text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Простой интерпретатор с нуля на Python #4
В предыдущих трех частях мы создали лексер, парсер и AST для нашего игрушечного языка IMP. Мы даже написали нашу собственную библиотеку парсеров комбинаторов. В этой, финальной статье мы напишем последний компонент интерпретатора — исполнитель.
**Содержание**[Простой интерпретатор с нуля на Python #1](http://habrahabr.ru/post/206320/)
[Простой интерпретатор с нуля на Python #2](http://habrahabr.ru/post/206454/)
[Простой интерпретатор с нуля на Python #3](http://habrahabr.ru/post/208872/)
**Простой интерпретатор с нуля на Python #4**
Давайте подумаем, как обычно исполняются программы. В любой момент времени есть некоторые «точки контроля», которые указывает на то, какое выражение программа собирается выполнить дальше. Когда следующее выражение исполняется, оно модифицирует состояние программы, путем улучшения «точки контроля» и изменения значений переменных.
Чтобы исполнить IMP-программу, нам нужны три вещи:
1. Точка контроля — мы должны знать следующее выражение для исполнения.
2. Среда — нам нужно смоделировать «изменение состояния программы».
3. Функции исполнения — нам нужно знать, как состояние и точка контроля должны быть модифицированы для каждого выражения.
Самое простое — точка контроля, по крайней мере для IMP. Мы устроили наше промежуточное представление в виде древовидной структуры. Мы будем просто вызывать функции исполнения (evaluation) для топ-левел выражений, которая будет рекурсивно вызывать функцию исполнения для выражений внутри. По сути, мы будем использовать точку контроля Python в качестве нашей собственной. Это не было бы так просто, для языков с более сложными структурами управления, как функций или исключений, но мы можем сохранить его простым для IMP.
Среда также проста. У IMP есть только глобальные переменные, так что мы можем смоделировать среду, использую стандартные питоновские словари. Когда значение изменяется, мы будем обновлять значение переменной в словаре.
Функции исполнения — единственная вещь, о которой мы должны думать. Каждый тип выражения будем иметь собственную функцию исполнения, которая использует актуальную среду и вернет значение. Арифметические выражения возвращают интеджеры, булевые — *true* или *false*. Выражения не имеют никаких побочных эффектов, так что среду не будет модифицирована. Каждый тип выражения также имеет функцию исполнения. Утверждения действуют путем модифицирования среды, так что никакого результата не вернется.
##### Определяем функции исполнения
Мы определим их как методы на наших AST-классах. Это даст прямой доступ каждой функции к структуре, которую она исполняет. Вот арифметические функции:
```
class IntAexp(Aexp):
...
def eval(self, env):
return self.i
class VarAexp(Aexp):
...
def eval(self, env):
if self.name in env:
return env[self.name]
else:
return 0
class BinopAexp(Aexp):
...
def eval(self, env):
left_value = self.left.eval(env)
right_value = self.right.eval(env)
if self.op == '+':
value = left_value + right_value
elif self.op == '-':
value = left_value - right_value
elif self.op == '*':
value = left_value * right_value
elif self.op == '/':
value = left_value / right_value
else:
raise RuntimeError('unknown operator: ' + self.op)
return value
```
Вы можете увидеть здесь немного экстра-логики в случае, где программист юзает переменную, которая не определена ранее (та, которая не определена в словаре среды). Для простоты и для того, чтобы избежать написание системы отлова ошибок, мы дадим всем неопределенным переменным **0**.
В **BinopAexp** мы обрабатываем случай «неизвестного оператора» путем выбрасывания **RuntimeError.** Парсер не может создать AST из неизвестных операторов, так что нам становится только легче. Но если кто-то делает свой собственный AST, там нужно будет учитывать и это.
Вот функции булевых операций:
```
class RelopBexp(Bexp):
...
def eval(self, env):
left_value = self.left.eval(env)
right_value = self.right.eval(env)
if self.op == '<':
value = left_value < right_value
elif self.op == '<=':
value = left_value <= right_value
elif self.op == '>':
value = left_value > right_value
elif self.op == '>=':
value = left_value >= right_value
elif self.op == '=':
value = left_value == right_value
elif self.op == '!=':
value = left_value != right_value
else:
raise RuntimeError('unknown operator: ' + self.op)
return value
class AndBexp(Bexp):
...
def eval(self, env):
left_value = self.left.eval(env)
right_value = self.right.eval(env)
return left_value and right_value
class OrBexp(Bexp):
...
def eval(self, env):
left_value = self.left.eval(env)
right_value = self.right.eval(env)
return left_value or right_value
class NotBexp(Bexp):
...
def eval(self, env):
value = self.exp.eval(env)
return not value
```
Это довольно просто. Мы используем питоньи реляционные и логические операторы.
А здесь функции исполнения для каждого типа выражений:
```
class AssignStatement(Statement):
...
def eval(self, env):
value = self.aexp.eval(env)
env[self.name] = value
class CompoundStatement(Statement):
...
def eval(self, env):
self.first.eval(env)
self.second.eval(env)
class IfStatement(Statement):
...
def eval(self, env):
condition_value = self.condition.eval(env)
if condition_value:
self.true_stmt.eval(env)
else:
if self.false_stmt:
self.false_stmt.eval(env)
class WhileStatement(Statement):
...
def eval(self, env):
condition_value = self.condition.eval(env)
while condition_value:
self.body.eval(env)
condition_value = self.condition.eval(env)
```
**AssignStatement:** мы просто исполняем арифметическое выражение на правой стороне, а затем обновляем среду с результирующим значением. Программист не ограничен в переопредлении переменных, которые уже были определены.
**CompoundStatement:** мы исполняем каждое выражение, одно за другим. Запомните, что CompoundStatement разрешен везде, где разрешено выражение, так что длинные цепи выражений раскодируются как вложенные.
**IfStatement:** сначала мы исполняем булевое условие выражения. Если true, мы исполняем true-выражение. Если false и false-выражение было определено, мы исполняем false-выражение.
**WhileStatement:** мы исполняем условие для проверки, должно ли тело цикла исполнится один раз. Условие исполняется каждую итерацию цикла, для проверки условия.
##### Собираем все в кучу
Ну что же, мы создали главные компоненты нашего интерпретатора и теперь остается только написать объединяющую программу:
```
#!/usr/bin/env python
import sys
from imp_parser import *
from imp_lexer import *
def usage():
sys.stderr.write('Usage: imp filename\n')
sys.exit(1)
if __name__ == '__main__':
if len(sys.argv) != 2:
usage()
filename = sys.argv[1]
text = open(filename).read()
tokens = imp_lex(text)
parse_result = imp_parse(tokens)
if not parse_result:
sys.stderr.write('Parse error!\n')
sys.exit(1)
ast = parse_result.value
env = {}
ast.eval(env)
sys.stdout.write('Final variable values:\n')
for name in env:
sys.stdout.write('%s: %s\n' % (name, env[name]))
```
В программу подается только один аргумент — имя для интерпретации. Она читает файл и отправляет его в лексер и парсер, рапортуя об ошибке (если таковая имеется). Затем мы извлекаем AST из результата парсера и исполняем его, используя пустую среду. Так как IMP не имеет никакого аутпута, мы просто выводим всю среду в терминал.
Каноничный пример вычисления факториала:
```
n := 5;
p := 1;
while n > 0 do
p := p * n;
n := n - 1
end
```
Само исполнение:
```
$ ./imp.py hello.imp
Final variable values:
p: 120
n: 0
```
##### Заключение
В последней статье мы написали интерпретатор для нашего простого языка с нуля. Сам язык мало полезен, но интерпретатор вполне расширяем и его главные компоненты могут быть использованы в чем-то другом.
Я надеюсь этот материал предоставит хороший старт для людей экспериментировать с дизайном языка. Немного идей:
* Сделать переменные локальными для неймспейса.
* Добавить цикл for.
* Добавить выражения для I/O (input/output).
* Добавить функции. | https://habr.com/ru/post/207662/ | null | ru | null |
# Проектирование на C# глазами первокурсника -NotePad++ №6
Всем привет, меня зовут Аркадий, я студент НИУ ВШЭ и в данной статье мы с вами поговорим о задании PeerReview №6 NotePad++, а именно об архитектурах, которые подойдут для данного задания и некоторых паттернов.
ЗаданиеВ данном задании основной задачей является реализация приложения с графическим интерфейсом. Предлагаю далеко не отходить от темы и сразу же посмотреть на то, что такое архитектуры и как они могут нам помочь в данном случае.
> *Информация из этого поста не покрывает всех существующих архитектур и паттернов, но является вполне достаточной для реализации задания №6*
>
>
Архитектуры приложений
----------------------
Под **архитектурой** мы понимаем архитектурный шаблон проектирования, охватывающий всё приложение или какую-то его часть. Часто такую часть называют модулем. Из этих модулей и строится приложение. Под модулями в данном случае понимаются не *C#* модули, а архитектурные модули. Им может являться, например, один экран приложения или несколько связанных между собой экранов.
Тема архитектур вызывает много споров. Во-первых, у каждого разработчика свое представление о том, какой должна быть хорошая архитектура. Во-вторых, даже если взять какую-то конкретную архитектуру, то вы сможете найти несколько различающихся между собой реализаций. Ну и третья причина заключается в том, что идеальных архитектур не существует. У каждой из них есть преимущества и недостатки. Поэтому при обсуждении архитектурных подходов всегда есть за что поругать любое из решений.
*Я расскажу лишь о трёх архитектурных решениях, которые считаю самыми подходящими для данного проекта, к тому же они имеют достаточно низкий порок вхождения*
1. Apple MVC
------------
Первая архитектура, которую мы разберем – MVC. Мы сразу сталкиваемся с тем, что под одним названием могут скрываться разные подходы. Например я предлагаю рассмотреть архитектуру Apple MVC, которая чуть ~~лучше~~ стандартной Classic MVC
Шаблон проектирования Apple MVCКак и во многих других архитектурах, название – это аббревиатура. Каждая буква обозначает один из компонентов. Рассмотрим их по порядку.
* **M – Model**. Роль модели могут играть как простые классы или структуры, так и сложные сущности, запрашивающие информацию из базы данных или из сети. Модель не знает о существовании UI *(user interface)*. Можно рассматривать ее как ядро приложения, которое можно переиспользовать с другим интерфейсом. Например, использовать одну и ту же модель для версии программы под разные устройства
* **V – View**. Вью – это представление. То, что пользователь видит и с чем взаимодействует. Ответственности вью – это отрисовка себя на экране и реагирование на действия пользователя, но оно не содержит логики и просто передает событие в Controller. В качестве представления в С#-приложениях используются Form и его наследники. Одну и ту же вью можно использовать на разных экранах приложения или даже перенести в другое.
* **C – Controller**. Это связующее звено между моделью и представлением. Его ответственность заключается в том, чтобы принимать действия пользователя от View, обрабатывать их и в случае необходимости обновлять модель, а при изменении модели обновлять вью. Т.к. контроллеры содержат логику, специфичную для приложения, то их сложно переиспользовать.
Один контроллер не всегда соответствует одному экрану. Их можно вкладывать друг в друга, разбив таким образом большой контроллер на несколько маленьких. Например, можно реализовать TabBarController который будет являться контейнером для нескольких контроллеров. При нажатии на вкладки он просто подменяет один на другой.
**MVC** – хороший выбор для данного приложения. Эта архитектура имеет очень низкий порог вхождения *(количество знаний и сил для её реализации).*Однако есть одна проблема в реализации MVC от Apple. Они наделили ViewController обязанностью следить за жизненным циклом View. Из-за этого они очень сильно связаны. В итоге контроллер содержит не только обработку модели, но и взаимодействие с вью.
Для решения этой проблемы во всех остальных архитектурах ViewController считается частью вью. В нем остается обработка жестов, анимации и прочее взаимодействие с View. А всю остальную логику переносят в другое место. Таким образом мы избегаем так называемого *«Massive View Controller»*
Еще одна важная проблема, которая решается таким образом – сложность тестирования. Если вы хотите проверить какую-то логику, находящуюся в ViewController, то вам придется иметь дело с жизненным циклом вью.
2. MVP
------
Очевидным развитием MVC является MVP. Раз ViewController – это часть вью, то вместо него нужно добавить какую-то другую сущность, никак не связанную с View, в результате получаем Presenter.
Шаблон проектирования MVPПолучившаяся схема очень похожа на MVC от Apple. Разница в том, что вся логика, не связанная с представлением, перемещается из ViewController в Presenter.
> *Обратите также внимание на то, что вью, как и в MVC, пассивная. Presenter передает в нее данные, но сама она их не запрашивает, хотя обращение к презентеру не запрещено. Оно может происходить, например, для вызова обработчика нажатия на кнопку.*
>
>
3. MVVM
-------
MVVM очень похоже на MVP. Разница в том, что вместо презентера в нем используется ViewModel. Вью модель хранит в себе состояние представления. Например, текст на экране или значение поля для ввода. Но в отличие от MVP, вью сама берет данные для отображения. Это можно реализовать разными способами, но часто используется data binding *(паттерн в следующей главе)*. Это подход, при котором один объект следит за состоянием другого. Т.е. вью будет следить за своим значением, хранящимся во ViewModel, и изменять свое отображение при его изменении.
Шаблон проектирования MVVMMVVM и MVP решают проблему большого контроллера и облегчают тестирование. Однако порог вхождения в проекты,
написанные на них, немного выше. Особенно это касается MVVM с биндингами, т.к. часто в таких проектах связывание данных используется не только между View и ViewModel. Такой код сложнее понять новичку, а еще сложнее отлаживать.
---
> *В данном проекте можно использовать эти или любые другие архитекрутрные решения. Лично я бы советовал использовать MVVM, так как он упростит реализацию настроек и вкладок.*
>
>
Паттерны
--------
Существует великое множество паттернов проектирования. Другое их название – шаблоны проектирования.
Паттерны – это многократно используемые решения часто встречающихся проблем при разработке. Они помогают писать код, который можно легко понять и использовать повторно. Паттерны помогают создавать слабо связанный код, в котором относительно легко и безболезненно можно заменять компоненты.
Мы рассмотрим самые распространенные паттерны, которые можно использовать в данном проекте. Давайте перечислим их:
1. Синглтон (Singleton)
2. Target-Action
3. Наблюдатель (Observer)
4. Команда (Command)
Я намеренно не включил в данные список Делегирование, т.к. считаю, что в данном проекте его использование будет излишним, в силу простоты программы.
> *В нескольких примерах кода буду использовать Swift, т.к. во-первых я его учу и надо практиковаться, а во-вторых \*\*\*\* я ваш C#, лучше \*\*\*\* \*\*\* \*\*\* \*\*\*\*\* \*\*\* \*\*\*\* , чем буду на нём писать не на оценку. Спасибо за понимание.*
>
>
1. Синглтон (Singleton)
-----------------------
Синглтон-паттерн широко используется при разработке программного обеспечения. Он гарантирует, что будет создан **только один экземпляр класса** и обеспечивает глобальную точку доступа для ресурсов, которые он предоставляет.
Применяется, когда нужно создать один и только один объект какого-либо класса на весь жизненный цикл приложения и доступ к которому необходимо получать из разных частей кода.
Примером применения этого паттерна является создания класса настроек приложения. Очевидно, что настройки приложения являются единственными в своём роде на всё приложение.
Другой пример применения данного паттерна – сервис GPS-навигации. Допустим, нам в приложении нужно отслеживать местоположение пользователя. В телефоне установлен единственный модуль GPS, и определять текущие координаты умеет только он. Ресурсы, которые предоставляет этот модуль, можно использовать совместно. В этом случае можно создать один глобальный синглтон-объект. И этот объект уже внутри себя будет использовать экземпляр класса LocationManager, предоставляющий единственную точку входа ко всем сервисам GPS-модуля.
```
class NetworkManager {
private(set) static var sharedInstance: NetworkManager = {
let manager = NetworkManager()
// additional setup code
return manager
}()
private init () {
}
func sendRequest() {
print("sending request")
}
}
// main program
let networkManager = NetworkManager.sharedInstance
networkManager.sendRequest() // sending request
```
2. Target-Action
----------------
Следующий паттерн, который мы рассмотрим, называется Target-Action. Обычно пользовательский интерфейс приложения состоит из нескольких графических объектов, и зачастую в роли таких объектов используются т.н. элементы управления. Это могут быть кнопки, переключатели, поля для ввода текста. Роль элемента управления в пользовательском интерфейсе довольно проста: он воспринимает намерение пользователя сделать какое-либо действие и дает указание другому объекту обработать этот запрос. Для связи между элементом управления и объектом, который может обработать запрос, и используется паттерн Target-Action. Target-Action – паттерн, в котором объект содержит информацию, необходимую для вызова метода у другого объекта при возникновении некоторого события, например, нажатия кнопки. Информация состоит из двух типов данных: селектора, который идентифицирует вызываемый метод (action), и объекта, чей метод вызывается (target). Остановимся чуть подробнее на том, что такое селекторы.
Фактически, селектор – это имя метода объекта или структуры, или уникальный идентификатор, который заменяет имя метода при компиляции исходного кода. Селектор сам по себе ничего не делает. Он просто идентифицирует какой-то метод.
Данный паттерн встроен в язык WindowsForm проект, так что в самостоятельной реализации не нуждается
3. Наблюдатель
--------------
В паттерне «Наблюдатель» один объект уведомляет другие объекты об изменениях своего состояния. Объектам, связанным таким образом, не нужно знать друг о друге – это и есть слабо связанный *(а значит, гибкий)* код. Этот паттерн чаще всего используют, когда надо уведомить «наблюдателя» об изменении свойств нашего объекта или о наступлении каких-либо событий в этом объекте. Обычно наблюдатель «регистрирует» свой интерес о состоянии другого объекта.
Когда состояние меняется, все объекты-наблюдатели будут уведомлены об изменении.
Уведомление – это сообщение, отправленное наблюдателям, чтобы оповестить их о каком-либо событии. Уведомления основаны на модели «подписка—публикация». Согласно ей, объект «издатель» (publisher) рассылает сообщения подписчикам (subscribers). Издатель ничего не должен знать о подписчиках.
```
interface IObservable {
void AddObserver(IObserver o);
void RemoveObserver(IObserver o);
void NotifyObservers();
}
class ConcreteObservable : IObservable {
private List observers;
public ConcreteObservable(){
observers = new List();
}
public void AddObserver(IObserver o){
observers.Add(o);
}
public void RemoveObserver(IObserver o){
observers.Remove(o);
}
public void NotifyObservers(){
foreach (IObserver observer in observers)
observer.Update();
}
}
interface IObserver {
void Update();
}
class ConcreteObserver :IObserver {
public void Update() {
// Some Action
}
}
```
*В данном примере ( к сожалению написанном на c#, т.к. реализация с другими языками отличается существенно ):*
* **IObservable**: представляет наблюдаемый объект. Определяет три метода: `AddObserver()` *(для добавления подписчика(наблюдателя))*, `RemoveObserver()` *(удаление набюдателя)* и `NotifyObservers()`*(уведомление наблюдателей)*
* **ConcreteObservable**: конкретная реализация интерфейса IObservable. Определяет коллекцию объектов наблюдателей.
* **IObserver**: представляет наблюдателя, который подписывается на все уведомления наблюдаемого объекта. Определяет метод `Update()`, который вызывается наблюдаемым объектом для уведомления наблюдателя.
* **ConcreteObserver**: конкретная реализация интерфейса IObserver
При этом наблюдаемому объекту не надо ничего знать о наблюдателе кроме того, что тот реализует метод `Update()`. С помощью отношения агрегации реализуется слабосвязанность обоих компонентов. Изменения в наблюдаемом объекте не виляют на наблюдателя и наоборот.
В определенный момент наблюдатель может прекратить наблюдение. И после этого оба объекта - наблюдатель и наблюдаемый могут продолжать существовать в системе независимо друг от друга.
Команда
-------
Команда — это поведенческий паттерн проектирования, который превращает запросы в объекты, позволяя передавать их как аргументы при вызове методов, ставить запросы в очередь, логировать их, а также поддерживать отмену операций......
> т.к. В WindowsForms уже есть реализация обработчиков, то этот паттерн нам особо не понадобится, но я всё же оставлю ссылку на него
>
> [https://refactoring.guru/ru/design-patterns/command](https://vk.com/away.php?to=https%3A%2F%2Frefactoring.guru%2Fru%2Fdesign-patterns%2Fcommand&cc_key=)
>
>
---
> подробная информация о паттернах :
>
> [https://refactoring.guru/ru/design-patterns/](https://vk.com/away.php?to=https%3A%2F%2Frefactoring.guru%2Fru%2Fdesign-patterns%2Fcommand&cc_key=)
>
>
Если вам есть что добавить или вы не поняли о чем пошла речь, можно указать это в комментариях, а не писать минус в рейтинг, всем спасибо.
*На этом я заканчиваю эту статью. Если она была вам полезна и поможет чем-нибудь, я буду очень рад.*
**Не игнорируйте паттерны и архитектуры, они вас спасут!** | https://habr.com/ru/post/542484/ | null | ru | null |
# Ночник с выключением по расписанию
С рождением ребёнка встал вопрос о ночнике. Где-то прочитали, что он необходим для спокойного сна. Быстро привыкли спать с тусклым светом. Очень удобно просыпаться от криков и воев среди ночи и видеть на что жалуется малыш (если удастся понять). Так же при тусклом свете можно укачать, перевернуть и продолжить спать.
Вначале был изготовлен тестовый образец светильника из куска жёлтой светодиодной ленты (12 вольт), который использовался 1,5 года.
Помимо хлипкости конструкции стало раздражать каждое утро вынимать блок питания светильника из розетки. Встаю я утром, с улицы в комнату поступает достаточно света. Таким образом, светильник работает впустую несколько часов каждый день. Ещё раз в пол года китайский контроллер RGB ленты забывал текущую настройку и нужно было искать пульт управления чтобы напомнить ему как нужно работать. Решил сделать новый светильник с автоматическим отключением, с регулировкой цвета как с помощью потенциометров, так и по радио.
Быстро собрал прототип на базе arduino nano. Отладил базовую функциональность.
Пользуясь случаем попробовал Fritzing. Не понравилось, но картинки получаются наглядные и «весёлые». Как видно ничего нового не изобрёл.
Заменил “nano” на малоизвестный, ардуино-совместимый модуль с встроенным радио приёмо-передатчиком (контроллер 8-ми битный, производительность и нафаршерованность сравнима с «наной»). Дома у меня уже есть одно устройство работающее на частоте 868 МГц, это будет второе. Краткие характеристики с сайта производителя:
**Краткие характеристики**
Не вижу больших проблем сделать тоже самое на ESP8266 (есть удобный онлайн сборщик прошивок для скриптов на LUA). Немного сложнее на Bluetooth (для перепрошивки модуля HM-10 нужен недорогой программатор, среда для разработки и понимание протокола). Хотя можно использовать Bluetooth модуль вместе с ардуиной. Но я использовал ZUNo, потому что уже давно лежит и ждёт меня, а также готова вся инфраструктура по соединению и управлению подобными устройствами в одну сеть (я про контроллер сети умного дома).
Для всех используемых ножек на ардуино нашлись аналоги в модуле.
Чтобы работать с модулем из Arduino IDE нужно её настроить (описание настройки есть на сайте производителя). Чуда не произошло. При попытке компиляции получил ошибку “doesn't support «for» statement with empty columns or without body!”. Я использовал библиотеку Adafruit\_NeoPixel. Залез в неё увидел сколько в ней циклов и закрыл. Пришлось опять идти на сайт производителя и искать в примерах работу со светодиодами (пример быстро нашёлся). Значит, я не первый, кто столкнулся с подобной проблемой.
Чтобы данный светильник управлялся по радио в код ардуино нужно добавить макрос и реализовать несколько функций:
```
ZUNO_SETUP_CHANNELS(
ZUNO_SWITCH_MULTILEVEL(getRed, setRed),
ZUNO_SWITCH_MULTILEVEL(getGreen, setGreen),
ZUNO_SWITCH_MULTILEVEL(getBlue, setBlue),
ZUNO_SWITCH_BINARY(switch_getter, switch_setter)
);
```
Данный макрос описывает устройство Z-Wave c тремя многоуровневыми переключателями (управление RGB) и одним простым переключателем (простое включение/выключение).
Реализация функций у меня простейшая (как в примерах на сайте производителя). Посмотреть можно в прикреплённом листинге.
### **Подбор корпуса**
Корпус у меня уже был. [Герметичный с прозрачной крышкой](http://gainta.ru/g203mf.html). Под крышкой поместилось 25 светодиодов. Испытания прошли успешно. Светильник имеет большой запас по яркости, для моей комнаты. Крышка у данного корпуса прозрачная, поэтому решил немного рассеять свет.
Набросал цветных бусинок и акриловых кубиков, залил прозрачной эпоксидкой. Краска с цветных бусинок под воздействием смолы растворилась.
Самое интересное, что крышка от герметичного корпуса протекла и почти вся смола вытекла. Не знаю где я успел ударить крышку, но после высыхания трещина отчётливо видна.
Печатную плату изготовил фоторезистивным методом.
После травления и механической обработки
Модуль с микроконтроллером заменил на его прототип, валявшийся в шкафу (потому что не жалко, а ZUNo нужно беречь). Первая версия ZUNo, но габариты больше и хуже антенна, да и не купишь уже. Испытания прошли более-менее успешно. Последний сегмент пришлось перепаять. Изначально был впаян не той стороной. И скорректировать количество светодиодов в прошивке.
Вот что получилось:
### **Управление по радио**
Главное окно с каналами управления светильника
Настройка яркости одного канала светодиодной ленты
Настройка утреннего отключения ночника
### **Заключение**
Устройство работает. Оно компактное и аккуратное. Питается от зарядки мобильного телефона.
Из замеченных проблем:
* во время сборки оторвал часть дорожек на переменных резисторах, поэтому в ручном режиме можно управлять только одним каналом.
* из 25 светодиодов нормально работают только 20. Мне и этого много, поэтому, скорее всего, оставлю до выявления более серьёзных недостатков
**Скетч ночника**
```
#include "ZUNO_NeoPixel.h"
#define MAX_PIXELS 20 // NB! Z-Uno can not control more than 25 WS2811 without harming RF communications
#define PIXEL_SIZE 3 // Three colors per pixel
#define BUFF_SIZE (MAX_PIXELS * PIXEL_SIZE)
byte pixel_buff[BUFF_SIZE];
NeoPixel pixels(pixel_buff, BUFF_SIZE);
#define B_PRESSED 1
#define BUTTON_PIN 1 // Digital IO pin connected to the button. This will be
#define DEF_RED 30
#define DEF_GREEN 20
byte red = DEF_RED;
byte green = DEF_GREEN;
byte blue = 0;
#define POWER_ON 1
#define POWER_OFF 0
byte light_power = POWER_ON;
byte last_light_power = POWER_OFF;
ZUNO_SETUP_CHANNELS(
ZUNO_SWITCH_MULTILEVEL(getRed, setRed),
ZUNO_SWITCH_MULTILEVEL(getGreen, setGreen),
ZUNO_SWITCH_MULTILEVEL(getBlue, setBlue),
ZUNO_SWITCH_BINARY(switch_getter, switch_setter)
);
void switch_setter(byte value)
{
Serial.println("switch");
Serial.print("value= ");
Serial.println(value);
if(value > 1)
light_power = POWER_ON;
else
light_power = POWER_OFF;
}
byte switch_getter()
{
return light_power;
}
int getRed() {
return red/2.56;
}
int getGreen() {
return green/2.56;
}
int getBlue() {
return blue/2.56;
}
void setRed(byte value) {
red = value * 2,56;
for(uint8_t i = 0; i < MAX_PIXELS; i++)
pixels.setPixelColor(i, pixels.Color(red, green, blue));
pixels.show();
Serial.print("set red = ");
Serial.println(value);
}
void setGreen(byte value) {
green = value * 2,56;
for(uint8_t i = 0; i < MAX_PIXELS; i++)
pixels.setPixelColor(i, pixels.Color(red, green, blue));
pixels.show();
Serial.print("set red = ");
Serial.println(value);
}
void setBlue(byte value) {
blue = value * 2,56;
for(uint8_t i = 0; i < MAX_PIXELS; i++)
pixels.setPixelColor(i, pixels.Color(red, green, blue));
pixels.show();
Serial.print("set red = ");
Serial.println(value);
}
void set_LEDS()
{
for(uint8_t i = 0; i < MAX_PIXELS; i++)
pixels.setPixelColor(i, pixels.Color(red, green, blue));
pixels.show();
}
void read_resistors()
{
red = (analogRead(A0) >> 2) & 0xff;
green = (analogRead(A1) >> 2) & 0xff;
blue = (analogRead(A3) >> 2) & 0xff;
Serial.print(red);
Serial.print(" ");
Serial.print(green);
Serial.print(" ");
Serial.print(blue);
Serial.print(" ");
Serial.println();
set_LEDS();
}
#define DEBOUNCE_ACK 10
byte check_button()
{
static bool oldState = HIGH;
byte debounce_cnt = 0;
static byte ret = 0;
if(digitalRead(BUTTON_PIN) == LOW)
{
if(ret != B_PRESSED)
while(digitalRead(BUTTON_PIN) == LOW)
{
if(debounce_cnt == DEBOUNCE_ACK)
{
ret = B_PRESSED;
break;
}
else
debounce_cnt++;
delay(10);
}
}
else
{
debounce_cnt = 0;
ret = 0;
}
return ret;
}
void setup() {
Serial.begin(9600);
pixels.begin();
pixels.clear();
pinMode(BUTTON_PIN, INPUT_PULLUP);
}
void loop()
{
if(check_button() == B_PRESSED)
read_resistors();
if(last_light_power != light_power)
{
Serial.println("set power");
if(light_power == POWER_OFF)
{
Serial.println("power off");
red = 0;
green = 0;
blue = 0;
}
else
{
Serial.println("power on");
red = DEF_RED;
green = DEF_GREEN;
blue = 0;
}
set_LEDS();
last_light_power = light_power;
}
}
``` | https://habr.com/ru/post/433194/ | null | ru | null |
# Воспроизведение звука в Java
#### Введение
Нормальной русскоязычной информации по теме просто нет. Java-tutorials тоже оставляют желать лучшего. А архитектура javax.sound.sampled хоть и проста, но далеко не тривиальна. Поэтому свой первый пост на Хабре я решил посвятить именно этой теме. Приступим:
#### Воспроизведение звука
Тут всё более-менее просто. Импортируем javax.sound.sampled и поехали:
```
try {
File soundFile = new File("snd.wav"); //Звуковой файл
//Получаем AudioInputStream
//Вот тут могут полететь IOException и UnsupportedAudioFileException
AudioInputStream ais = AudioSystem.getAudioInputStream(soundFile);
//Получаем реализацию интерфейса Clip
//Может выкинуть LineUnavailableException
Clip clip = AudioSystem.getClip();
//Загружаем наш звуковой поток в Clip
//Может выкинуть IOException и LineUnavailableException
clip.open(ais);
clip.setFramePosition(0); //устанавливаем указатель на старт
clip.start(); //Поехали!!!
//Если не запущено других потоков, то стоит подождать, пока клип не закончится
//В GUI-приложениях следующие 3 строчки не понадобятся
Thread.sleep(clip.getMicrosecondLength()/1000);
clip.stop(); //Останавливаем
clip.close(); //Закрываем
} catch (IOException | UnsupportedAudioFileException | LineUnavailableException exc) {
exc.printStackTrace();
} catch (InterruptedException exc) {}
```
##### Регулятор громкости
Поигравшись со звуками, вы наверняка захотите иметь возможность программно изменять громкость звука. Java Sound API предоставляет такую возможность с фирменной кривотой.
```
//Получаем контроллер громкости
FloatControl vc = (FloatControl) clip.getControl(FloatControl.Type.MASTER_GAIN);
//Устанавливаем значение
//Оно должно быть в пределах от vc.getMinimum() до vc.getMaximum()
vc.setValue(5); //Громче обычного
```
Этот код нужно поместить между строчками **clip.open(ais)** и **clip.setFramePosition(0)**.
#### Упрощаем процесс
Ну и наконец, чтобы вы не мучились, выкладываю класс для проигрывания звуков
```
import java.io.File;
import java.io.IOException;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.FloatControl;
import javax.sound.sampled.LineEvent;
import javax.sound.sampled.LineListener;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;
public class Sound implements AutoCloseable {
private boolean released = false;
private AudioInputStream stream = null;
private Clip clip = null;
private FloatControl volumeControl = null;
private boolean playing = false;
public Sound(File f) {
try {
stream = AudioSystem.getAudioInputStream(f);
clip = AudioSystem.getClip();
clip.open(stream);
clip.addLineListener(new Listener());
volumeControl = (FloatControl) clip.getControl(FloatControl.Type.MASTER_GAIN);
released = true;
} catch (IOException | UnsupportedAudioFileException | LineUnavailableException exc) {
exc.printStackTrace();
released = false;
close();
}
}
// true если звук успешно загружен, false если произошла ошибка
public boolean isReleased() {
return released;
}
// проигрывается ли звук в данный момент
public boolean isPlaying() {
return playing;
}
// Запуск
/*
breakOld определяет поведение, если звук уже играется
Если breakOld==true, о звук будет прерван и запущен заново
Иначе ничего не произойдёт
*/
public void play(boolean breakOld) {
if (released) {
if (breakOld) {
clip.stop();
clip.setFramePosition(0);
clip.start();
playing = true;
} else if (!isPlaying()) {
clip.setFramePosition(0);
clip.start();
playing = true;
}
}
}
// То же самое, что и play(true)
public void play() {
play(true);
}
// Останавливает воспроизведение
public void stop() {
if (playing) {
clip.stop();
}
}
public void close() {
if (clip != null)
clip.close();
if (stream != null)
try {
stream.close();
} catch (IOException exc) {
exc.printStackTrace();
}
}
// Установка громкости
/*
x долже быть в пределах от 0 до 1 (от самого тихого к самому громкому)
*/
public void setVolume(float x) {
if (x<0) x = 0;
if (x>1) x = 1;
float min = volumeControl.getMinimum();
float max = volumeControl.getMaximum();
volumeControl.setValue((max-min)*x+min);
}
// Возвращает текущую громкость (число от 0 до 1)
public float getVolume() {
float v = volumeControl.getValue();
float min = volumeControl.getMinimum();
float max = volumeControl.getMaximum();
return (v-min)/(max-min);
}
// Дожидается окончания проигрывания звука
public void join() {
if (!released) return;
synchronized(clip) {
try {
while (playing)
clip.wait();
} catch (InterruptedException exc) {}
}
}
// Статический метод, для удобства
public static Sound playSound(String path) {
File f = new File(path);
Sound snd = new Sound(f);
snd.play();
return snd;
}
private class Listener implements LineListener {
public void update(LineEvent ev) {
if (ev.getType() == LineEvent.Type.STOP) {
playing = false;
synchronized(clip) {
clip.notify();
}
}
}
}
}
```
Пользоваться очень просто, например:
```
Sound.playSound("sounds/hello.wav").join();
```
#### Форматы
Пару слов о поддержке форматов звуковых файлов: забудьте про mp3 и вспомните wav. Также поддерживаются au и aif. | https://habr.com/ru/post/191422/ | null | ru | null |
# Компактный сервер для Django приложений
#### **Введение**
Многие начинающие веб разработчики размышляют о том, где бы разместить свое творение. Обычно для этих целей применяются машины под управлением \*NIX подобных систем. Мой выбор остановился на Raspberry PI, поскольку малинка:
* работает под управлением полноценного Linux,
* долгое время лежит на столе и пылится.
Я хочу рассказать о том, как настроить сервер, работающий в сети с динамическим внешним IP адресом. Для запуска крупных проектов такое решение не годится, а для демонстрации своего портфолио и персонального применения вполне подойдет.
#### **Нам понадобятся**
1. Raspberry PI модели B, B+ или Raspberry PI 2 (поскольку на платах этих моделей имеется Ethernet) с установленной Raspbian и активированным SSH сервером. О настройке можно почитать [здесь](https://www.raspberrypi.org/documentation/installation/installing-images/README.md), [здесь](http://www.kaloshin.me/2014/02/install-os-raspberry-without-monitor-and-keyboard.html) или [здесь](http://habrahabr.ru/post/149890/). Помимо Raspian для малинки существует большое количество [альтернативных](http://habrahabr.ru/sandbox/66194/) [дистрибутивов](http://www.armlinux.ru/%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5-%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D1%8B-%D0%B4%D0%BB%D1%8F-raspberry-pi/). Тут, как говорится, «на любой вкус и цвет».
2. Рабочее Django приложение.
3. Роутер с поддержкой DDNS. Этот пункт не обязателен, поскольку DDNS можно настроить на самой малинке.
Я буду работать с малинкой модели B+.
#### **Подготовка**
На малинке установлена Raspbian 7.8.
Для начала необходимо найти малинку в сети, чтобы подключиться к ней по ssh.
`nmap -sP 192.168.1.1/24 | grep raspberry`
В моем случае в сети две малинки, одна из которых моя с IP адресом 192.168.1.100. В некоторых сетях nmap не показывает сетевые имена устройств.
В этом случае найти raspberry pi можно по MAC-адресу, который имеет префикс B8:27:EB.
`sudo nmap -sP -n 192.168.1.1/24 | grep -B 2 B8:27:EB`
Параметр -B для grep определяет какое количество предшествующих строк следует вывести.
Подключаемся к малинке по ssh.
`ssh pi@192.168.1.100`
Для начала разгоним малинку до 1 ГГц с помощью [raspi-config](https://www.raspberrypi.org/documentation/configuration/raspi-config.md).
Устанавливаем питоновский менеджер пакетов
`sudo apt-get install python-pip`
Переходим к установке необходимых пакетов. В моем web приложении используется СУБД MySQL. В качестве Frontend и Backend используется nginx и gunicorn соответственно.
`sudo apt-get install nginx gunicorn mysql-client mysql-server python-mysqldb`
В процессе установки mysql необходимо ввести данные для root пользователя СУБД. **python-mysqldb** — драйвер, необходимый при работе с моделями в Django. Django установим из питоновских репозиториев.
`sudo pip install django`
На момент написания статьи актуальные версии nginx и gunicorn в репозиториях для малинки 1.2.1 и 0.14.5 соответственно. Версия MySQL для малинки 5.5. Так же для работы с Django необходимо установить [SciPy](https://ru.wikipedia.org/wiki/SciPy).
`sudo apt-get install python-scipy`
nginx 1.2.1 устарел. Более новый можно [собрать из исходников](http://insalesclub.ru/other/2014/06/10/ustanovka-nginx-iz-ishodnikov-i-storonnimi-modulyami-na-debian-ubuntu-s-nulya.html). Свежий gunicorn можно установить из питоновских репозиториев.
#### **Настройка сервера**
Размещаем web-приложение на малинке (например в /home/pi).
Если у Вас есть рабочие конфиги, то достаточно их скопировать в соответствующие директории:
* для nginx /etc/nginx/sites-enabled/
* для gunicorn /etc/gunicorn.d/
C nginx ничего сложного нет. Я бы хотел обратить внимание на настройки для gunicorn.
```
CONFIG = {
'mode': 'wsgi',
'working_dir': '/home/pi/project',
#'working_dir': '/home/pi/project/project',
'user': 'www-data',
'group': 'www-data',
'python': '/usr/bin/python',
'args': (
'--bind=127.0.0.1:8081',
'--workers=5', # 5 достаточно для малинки
'--graceful-timeout=60',
'--timeout=60',
#'--debug',
#'wsgi:application',
'project.wsgi',
),
}
```
Если working\_dir (путь к файлу wsgy.py) указать `'/home/pi/project/project'`, а в args указать `'wsgi:application'`, то на малинке воркеры сначала стартуют, потом умирают без указания причины (под Ubuntu, например, gunicorn работает с обоими вариантами настроек).
#### **Перенос MySQL**
Дамп имеющейся БД можно сделать с помощью утилиты [mysqldump](https://dev.mysql.com/doc/refman/5.5/en/mysqldump.html).
`mysqldump -u root -p dbname > dbname.sql`
Полученный файл состоит из набора SQL-инструкций, которые восстанавливают структуру, а так же информацию, хранимую в базе данных.
На малинке создаем базу данных. Запускаем mysql shell.
`mysql -u root -p`
Добавляем новую базу данных.
```
mysql> create database dbname character set utf8 collate utf8_general_ci;
mysql> grant all privileges on dbname.* to someusr@localhost identified by 'somepassword';
```
Восстанавливаем данные с дампа. При размере дампа в 162 Мб время восстановления составило около 10 минут.
`mysql -u root -p dbname < dbname.sql`
Следует отметить, что базы данных лучше хранить на внешнем накопителе, иначе micro SD карта может быстро придти в негодность из-за частых операций записи. Как это сделать можно почитать [здесь](https://rusadmin.biz/bloknot/perenos-baz-dannyx-mysql-v-druguyu-papku-ili-razdel/). Конфиг mysql расположен по пути /etc/mysql/my.cnf
#### **Проверка**
Перезапускаем nginx и gunicorn. Если все настроено верно, можно открыть главную страницу.
Переходим к нагрузочному тестированию. Установим apache benchmark.
`sudo apt-get install apache2-utils`
Протестируем в 4 потока 1000 запросами Raspberry PI модель B+.
`ab -c 4 -n 1000 http://192.168.1.100/`
```
$ ab -c 4 -n 1000 http://192.168.1.100/
This is ApacheBench, Version 2.3 <$Revision: 1528965 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking 192.168.1.100 (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests
Server Software: nginx/1.8.0
Server Hostname: 192.168.1.100
Server Port: 80
Document Path: /
Document Length: 24839 bytes
Concurrency Level: 4
Time taken for tests: 1309.607 seconds
Complete requests: 1000
Failed requests: 0
Total transferred: 25018000 bytes
HTML transferred: 24839000 bytes
Requests per second: 0.76 [#/sec] (mean)
Time per request: 5238.429 [ms] (mean)
Time per request: 1309.607 [ms] (mean, across all concurrent requests)
Transfer rate: 18.66 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 1 0.1 1 1
Processing: 4924 5237 91.4 5227 6419
Waiting: 4919 5227 91.3 5217 6403
Total: 4925 5238 91.4 5228 6420
Percentage of the requests served within a certain time (ms)
50% 5228
66% 5245
75% 5255
80% 5265
90% 5296
95% 5335
98% 5382
99% 5667
100% 6420 (longest request)
```
Запросы идут медленно, поскольку большую часть времени запроса занимает работа с БД. Ко мне недавно пришла Raspberry PI 2 модель B. Посмотрим на что она способна c теми же настройками и данными.
```
$ ab -c 4 -n 1000 http://192.168.1.14/
This is ApacheBench, Version 2.3 <$Revision: 1528965 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking 192.168.1.14 (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests
Server Software: nginx/1.8.0
Server Hostname: 192.168.1.14
Server Port: 80
Document Path: /
Document Length: 24838 bytes
Concurrency Level: 4
Time taken for tests: 170.083 seconds
Complete requests: 1000
Failed requests: 0
Total transferred: 25017000 bytes
HTML transferred: 24838000 bytes
Requests per second: 5.88 [#/sec] (mean)
Time per request: 680.330 [ms] (mean)
Time per request: 170.083 [ms] (mean, across all concurrent requests)
Transfer rate: 143.64 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 1 0.1 1 1
Processing: 569 678 104.6 650 1338
Waiting: 567 676 104.1 647 1334
Total: 569 679 104.6 651 1338
Percentage of the requests served within a certain time (ms)
50% 651
66% 682
75% 708
80% 727
90% 796
95% 890
98% 1045
99% 1138
100% 1338 (longest request)
```
Raspberry PI 2 обрабатывает запросы в среднем в 6,16 раз быстрее. Разработчики малинки не обманули.
#### **Настройка DDNS**
Настроить DDNS можно на роутере или на самой малинке. Я выбираю [No IP](http://www.noip.com/), поскольку пользуюсь им несколько лет. Рассмотрим бесплатное использование.
**Регистрация хоста**
Если у вас есть учетная запись — проходим авторизацию, иначе [регистрируемся](https://www.noip.com/sign-up). После авторизации попадаем [сюда](http://www.noip.com/members/).
Кликаем AddHost и заполняем форму.
Внизу кликаем кнопку AddHost
Хост добавлен. Справа от имени хоста отображается внешний IP адрес Вашей сети.
##### **Настраиваем DDNS на роутере**
Для примера я настрою DDNS на ASUS RT-N56U с прошивкой от padavan версии 3.4.3.9-091. Открываем в страницу меню роутера
(например 192.168.1.1). WAN->DDNS.
Выбираем сервис no-ip.com, указываем регистрационные данные, а так же наш добавленный хост (technopark-test.ddns.net).
Остальные параметры выставляем по собственному желанию.
Теперь при смене внешнего IP адреса наше приложение остается доступным в сети.
###### **Настройка переадресации портов**
Нам нужно, чтобы при обращении к хосту малинка отдавала веб приложение. Роутер занимается перенаправлением входящих пакетов, пришедших из вне с порта X на внутренный порт Y. В меню роутера переходим WAN->Переадресация портов. Необходимо перенаправлять внешний 80 порт на 80 порт малинки. Добавим новое правило и применим изменения.
Теперь малинка обрабатывает все приходящие пакеты на 80 порту. Проверим, введя в адресной строке браузера хост, полученный в No IP.
Теперь наше веб приложение доступно для пользователей сети Интернет.
##### **Настраиваем DDNS на малинке**
Этот вариант не подходит, если малинка имеет [частный IP](https://ru.wikipedia.org/wiki/%D0%A7%D0%B0%D1%81%D1%82%D0%BD%D1%8B%D0%B9_IP-%D0%B0%D0%B4%D1%80%D0%B5%D1%81), поскольку она будет оправлять свой локальный IP адрес на на сервис No IP. ~~Это еще один способ узнать IP адрес малинки локальной сети.~~ Установим DDNS клиент.
`sudo apt-get install ddclient`
Во время установки необходимо выбрать сервис. Выбираем other и вводим dynupdate.no-ip.com, протокол dyndns2, имя пользователя, пароль, интерфейс — eth0, имя хоста.
Для проверки я выставил интервал обновления IP в 60 секунд. В файле /etc/default/ddclient необходимо выставить значение daemon\_interval=«60».
#### **Десерт**
Моя малинка давно лежала на столе и пылилась, вместе с tm1638 и [DHT11](http://geektimes.ru/post/257750/), выводя показания температуры и влажности в помещении и прочей информации.
Все же мне было интересно попробовать управлять GPIO Raspberry PI из django. Я разработал простое web приложение, которое объединило мои ранние наработки. Оно позволяет посмотреть температуру и влажность, измеренные с помощью DHT11, некоторую полезную информацию, управляет 8-ми релейным модулем (который может быть использован для управления электроприборами) и отправляет текст на tm1638.
Для управления GPIO необходимо запускать сервер с правами root. Это потенциальная уязвимость.
Полноценное использования web приложения предполагает работу сервера без прав суперпользователя, настройку https, добавление возможности администрирования учетных записей, ведение логов, разделение доступа к управляемым устройствам, работу электроприборов по расписанию и многое другое.
Впрочем это уже совсем другая ~~история~~ статья.
#### **Заключение**
Имея Raspberry PI моделей B, B+ или Raspberry PI 2, [power bank](http://www.mobile-review.com/accessories/review/xiaomi-powerbank.shtml), а так же «open» Ethernet jack получаем компактный сервер, который можно использовать для демонстрации своих наработок. Настройка сервера для Django приложений на Raspberry PI под управлением Raspbian мало чем отличится от любой другой сборки Linux. Пакеты в репозиториях могут быть устаревшими. Для работы с новыми версиями можно вручную собирать программы из исходников.
[Исходный код](https://github.com/bagrusss/pri-gpio) демо приложения.
P.S. Хочу поблагодарить коллег по Технопарку за помощь при подготовке материала.
P.S.S. Я готов выслушать дельные советы и комментарии, а затем поправить материал.
Статья создана в рамках конкурса статей Технопарка@Mail.Ru (park.mail.ru). | https://habr.com/ru/post/357950/ | null | ru | null |
# React hooks, как не выстрелить себе в ноги. Часть 3.2: useMemo, useCallback
Данная статья - продолжение [статьи](https://habr.com/ru/company/otus/blog/669962/) про мемоизацию, в которой мы разбирали, зачем нужно использовать memo и как правильно с ним работать. В этой статье разберем, как правильно использовать useMemo и useCallback, какое у них api и разберем пару трюков. В прошлой статье я писал, что в следующей будет информация про useRef, useImperativeHandle и прочее, но в итоге решил, что текущий материал можно объяснить проще. Только трюки подведут нас к использованию useRef и уже в следующей лекции мы разберемся с ним.
Проблема. Лишняя вычислительная работа
--------------------------------------
У функциональных компонентов есть проблема - весь код в теле выполняется при каждом обновлении. Изменили состояние компонента, обновился родительский компонент или же изменился пропс - постоянно будет выполняться в весь код внутри.
```
import React, { FC } from "react";
export type FuncComponentProps = {
data: Array
}
export const FuncComponent: FC = ({ data }) => {
// Совершаем какую-то вычислительную работу
const preparedData = prepareData(data); // (1)
return (
... какой-то контент
);
};
```
В компоненте выше, в метке 1 функция prepareData будет выполняться при любом обновлении компонента. Как думаете, какие варианты обновления тут существуют?
1. Если изменится data, и правда должен произойти пересчет.
2. Если появится новый пропс.
3. Если захотим добавить state в компонент, также prepareData будет выполняться при каждом изменении.
4. Если обновится родительский компонент, наш FuncComponent не завернут в memo, потому тоже обновится и опять же выполнится prepareData.
Когда мы точно знаем, что не появится новый state или props и уверены, что родительский компонент не обновится лишний раз - можно оставить как есть. Однако наш компонент получается хрупким, ведь спустя пару месяцев мы наверняка забудем о его особенностях, и шансы создавать дополнительную работу для устройства клиента повышаются.
Как использовать useMemo и решить проблему лишней работы
--------------------------------------------------------
useMemo - это хук, который сохраняет результат вызова функции (первый аргумент) и пересчитывает его только при изменении зависимостей (второй аргумент). useMemo возвращает результат вызова первого аргумента.
Выглядит использование так:
```
// Типизация
function useMemo(factory: () => T, deps: any[] | undefined): T;
// 1
const memoResult = useMemo(() => funcResult, []);
// 2
let testString = 'test';
const { data } = useMemo<{ data: string }>(() => ({ data: testString }), [testString]);
```
useMemo - это дженерик, и из него видно - то, что вернет первый аргумент, вернет и сам хук. В первом случае выполнится 1 раз, потому что массив зависимостей пустой. Во втором случае выполнится каждый раз при обновлении компонента и изменении testString из примера.
Обращаю внимание, если принудительно изменить что-то из массива зависимостей, в нашем случае, например: `testString = 'new test string'` - useMemo не будет изменен до тех пор, пока не обновится сам компонент. Ниже разберем подробнее это заблуждение, оно часто возникает у новичков.
А пока применим useMemo к нашей ситуации.
```
import React, { useMemo, FC } from "react";
export type FuncComponentProps = {
data: Array
}
export const FuncComponent: FC = ({ data }) => {
// Теперь вычислительная работа будет выполнена строго при изменении data
const preparedData = useMemo(() => prepareData(data), [data]); // (1)
return (
... какой-то контент
);
};
```
В useMemo первым аргументом мы передали функцию, которая вызовет prepareData(data) и вернет результат ее вызова. Вторым аргументом мы передали массив зависимостей, в нашем случае зависимость только одна - это data, ее и передаем.
Благодаря этому хуку наш компонент становится устойчивым, нам больше не нужно заботиться о том, чтобы родительский компонент не обновлялся лишний раз и не нужно оборачивать текущий компонент в memo. Также мы можем смело передавать дополнительные props в компонент или добавлять state - prepareData(data) будет вызвана только при изменении data.
Когда нужно использовать useMemo. Мемоизация тяжелых вычислений
---------------------------------------------------------------
useMemo предотвращает лишнюю вычислительную работу, однако его выполнение имеет свою цену. Посмотрите внимательно на этот код.
```
const memoResult = /* 1 */ useMemo(/* 2 */() => funcResult, /* 3 */ []);
```
Сам вызов useMemo запускает проверку под капотом react, был ли данный хук зарегистрирован. React регистрирует все хуки, вызываемые в конкретном компоненте, кстати, именно поэтому все хуки должны находиться до выполнения условий, таких как if, switch. Если не зарегистрирован - регистрирует, иначе ищет сохраненные данные хука. К тому же, useMemo клонирует функцию, что в него передали, и замыкание перестает работать, это по большей части нужно для корректной работы useEffect, однако useMemo также выполняет дополнительную работу по клонированию функции (первого аргумента). Также выделяется дополнительная память для создания первого аргумента (см 2 метку), то есть каждый раз перед вызовом useMemo создается новая функция, а также создается новый массив зависимостей (см 3 метку). Также useMemo сравнивает новый и предыдущий массив зависимостей и если произошло изменение, вызывает новую функцию, клонирует ее и сохраняет результат ее вызова, после чего возвращает результат.
Вызов useMemo имеет свою цену и это нужно понимать. Хорошо про цену рассказано [тут](https://youtu.be/i6DPqqbdIyw). Для себя я вывел следующее правило:
> Если сложность вычислений больше O(n), я использую useMemo. Если сложность вычислений постоянная или O(log n) - не использую. Про сложность хорошо рассказано [тут](https://tproger.ru/articles/computational-complexity-explained/).
>
>
Ниже примеры, когда цена useMemo выше цены вычислений.
```
const resBad1 = useMemo(() => arg1 === arg2, [arg1, arg2]); // Плохо
const resGood1 = arg1 === arg2; // Хорошо
const resBad2 = useMemo(() => arg1 + arg2 / arg3, [arg1, arg2, arg3]); // Плохо
const resGood2 = arg1 + arg2 / arg3; // Хорошо
const resBad3 = useMemo(() => {
if (loading) return
if (error) return
return
}, [loading, error]); // Плохо
const resGood3 = (() => {
if (loading) return
if (error) return
return
})(); // Хорошо. Это вызов анонимной самовызываемой функции
```
Заблуждение с обновлением зависимостей
--------------------------------------
```
import React, { useMemo, FC } from "react";
export type FuncComponentProps = {
data: Array
}
let dep1 = 'some string';
export const FuncComponent: FC = ({ data }) => {
const preparedData = useMemo(() => prepareData(dep1), [dep1]); // (1)
return (
(dep1 = 'other string')} /\* 2 \*/>
... какой-то контент
);
};
```
Часто допускают следующую ошибку: чтобы обновить useMemo обновляют значение какой-то зависимости. В примере выше директивно обновляют значение dep1 (см 2 метку). Однако обновления не происходит, как считаете почему, и как это исправить?
Само по себе изменение каких-либо переменных не запускает обновление компонента, соответственно в памяти переменная dep1 и правда изменилась, но компонент не обновился. Можно дождаться обновления компонента, а можно переменную использовать как состояние, тогда все будет работать, как и ожидалось.
```
import React, { useMemo, FC, useState } from "react";
export type FuncComponentProps = {
data: Array
}
export const FuncComponent: FC = ({ data }) => {
const [dep1, setDep1] = useState('some string');
const preparedData = useMemo(() => prepareData(dep1), [dep1]); // (1)
return (
setDep1('other string')} /\* 2 \*/>
... какой-то контент
);
};
```
### Когда нужно использовать useMemo. Мемоизация ссылочных типов данных
В прошлой статье мы разбирали, что memo проверяет все props и предотвращает лишние обновления компонента. Сравните два TargetComponent в метках 1 и 2. Мы используем один и тот же компонент и он обернут в memo. Как считаете какая между ними разница в поведении при обновлении родительского компонента?
```
import React, { useMemo, FC, memo } from "react";
export type TargetComponentProps = object
export const TargetComponent = memo(() => {
return (
... какой-то контент
);
});
export const FuncComponent: FC = () => {
return (
// 1
// 2
);
};
```
В первом случае TargetComponent никогда не будет обновляться при обновлении родителя. Во втором случае TargetComponent будет обновляться всегда при обновлении родителя. Почему так происходит?
Дело в том, что memo сравнивает по строгому равно пропсы, которые получает компонент. Соответственно в первом случае `"test" === "test" -> true` , а во втором случае `[] === [] -> false`.
Один из способов решения этой проблемы мы разбирали в прошлой [лекции](https://habr.com/ru/company/otus/blog/669962/). Второй способ - использовать useMemo
```
import React, { useMemo, FC, memo } from "react";
export type TargetComponentProps = object
export const TargetComponent = memo(() => {
return (
... какой-то контент
);
});
export const FuncComponent: FC = () => {
const testArray = useMemo(() => [], []);
const testObj = useMemo(() => ({}), []);
// 0
const testFunc = useMemo(() => (arg: number) => ({}), []);
return (
// 1
// 2
);
};
```
С помощью useMemo можно замемоизировать ссылочные типы данных и теперь второй компонент, так же как и первый, не будет обновляться никогда, несмотря на то, что в него переданы сразу три разных ссылочных типов данных.
Однако обратите внимание на метку номер 0.
```
const testFunc = useMemo(() => (arg: number) => ({}), []);
```
Мемоизация функции выглядит некрасиво, можно ли ее как-то упростить? Да, специально для мемоизации функций, в react существует хук useCallback.
useCallback
-----------
useCallback под капотом тот же useMemo и по сути является синтаксическим сахаром. Сравните два способа мемоизации функции с useMemo и с useCallback.
```
const testFunc = useMemo(() => (arg: number) => ({}), []);
const testFunc = useCallback((arg: number) => ({}), []);
```
А вот так выглядит типизация useCallback
```
function useCallback any>(callback: T, deps: any[]): T;
```
Это и все что нужно знать про useCallback. Далее, чтобы закрепить, поговорим про проблему замыканий в useCallback и разберем способ её решения. Также поговорим про мемоизацию нескольких функций с помощью одного useMemo.
Проблема замыкания в useCallback
--------------------------------
Посмотрите этот пример кода.
```
import React, { FC, useCallback, useState } from "react";
type NameValue = {
firstName: string;
lastName: string;
};
type NameInputProps = {
value: NameValue;
onChange: (value: NameValue) => void;
};
const NameInput: FC = ({ value, onChange }) => {
const onChangeFirstName = useCallback(
(e: React.ChangeEvent) => {
console.log(1, value); // 1
onChange({ ...value, firstName: e.target.value });
},
[onChange]
);
const onChangeLastName = useCallback(
(e: React.ChangeEvent) => {
console.log(2, value); // 2
onChange({ ...value, lastName: e.target.value });
},
[onChange]
);
return (
firstName
lastName
);
};
export const ClosureProblemExample = () => {
const [value, setValue] = useState({} as NameValue);
return (
{JSON.stringify(value)} // 3
);
};
```
Здесь написан компонент ввода имени, у его значения есть два поля firstName и lastName. Для каждого поля отдельный input и для каждого обработчика onChange инпута отдельный useCallback. Кстати, здесь можно не использовать useCallback, потому что , как и прочие html компоненты, будет обновляться всегда, независимо от просов, но для нашего примера мы все же используем useCallback, потому что для сложных компонентов ввода, аналогов input, нередко нужна мемоизация.
Обратите внимание на useCallback, на массив зависимостей. В нем содержится только onChange, но не содержится value. Можно ожидать, что value попадет в мемоизированную функцию через замыкание. Однако этого не происходит и в результате просто невозможно изменить оба поля. Вот здесь можно поэкспериментировать с этим примером [здесь](https://codesandbox.io/s/memoization-3-2-6yyn52?file=/src/ClosureProblemExample.tsx).
Помните, выше описывал цену useMemo и что под капотом он клонирует функцию вместе со всеми замыканиями. Это и приводит к данной проблеме. Как считаете, как можно починить?
Может показаться, что хорошее решение добавить value в массив зависимостей, тем более, что появляется подсказка eslint, требующая именно этого. И действительно, теперь значение изменяется как надо. Однако это плохое решение.
```
const onChangeFirstName = useCallback(
(e: React.ChangeEvent) => {
onChange({ ...value, firstName: e.target.value });
},
[onChange, value /\* <- добавить value - плохое решение \*/]
);
```
Мы хотим, чтобы когда изменяется одна составляющая value, например firstName, инпут ответственный за lastName не обновлялся. Однако value находится в зависимостях у onChangeLastName и эта функция будет обновляться. А так как функция - это ссылочный тип, то и наш input будет получать новую функцию и соответственно тоже будет обновляться. Когда мы использовали useCallback, то хотели улучшить производительность приложения, но добавив value в массив зависимостей мы только ухудшили, потому что по-прежнему оба инпута обновляются, так еще и каждый useCallback выполняет дополнительную работу под капотом.
### Пути решения проблемы замыкания - useRef
useCallback не работает с классическими замыканиями, но прекрасно работает с замыканиями, созданными с помощью useRef
```
const NameInput: FC = ({ value, onChange }) => {
const valueCopy = useRef(value);
valueCopy.current = value;
const onChangeFirstName = useCallback(
(e: React.ChangeEvent) => {
onChange({ ...valueCopy.current, firstName: e.target.value });
},
[onChange]
);
const onChangeLastName = useCallback(
(e: React.ChangeEvent) => {
onChange({ ...valueCopy.current, lastName: e.target.value });
},
[onChange]
);
return (
firstName
lastName
);
};
```
Мы используем useRef как стабильное хранилище данных. Его значение не будет изменяться при обновлении компонента, подробно про этот хук и его окружение читайте в следующей статье. Сейчас просто запомните - рефы в функциональных компонентах используются не только для доступа к dom элементам, но еще и как стабильное хранилище данных.
Пути решения проблемы замыкания - useEvent
------------------------------------------
useEvent - это кастомный хук, его еще нет в релизах react, однако его предложил сам Дэн Абрамов и, возможно, он появится в обозримом будущем, как официальный хук. На текущем моменте мы можем использовать свой, рукописный вариант, и он тоже будет работать. В нашей компании мы используем такой вариант.
```
export type Callback = (...args: unknown[]) => unknown;
export const useEvent = (callback: T): T => {
const copy = useRef();
copy.current = callback;
return useCallback(((...args) => copy.current(...args)) as T, []);
};
```
Более подробно про этот хук можно посмотреть [тут](https://youtu.be/qLQyjhU3fqg).
Этот хук также использует useRef, но не для хранения аргументов функции, а для хранения самой функции. Использование в нашем случае будет выглядеть вот так:
```
const NameInput: FC = ({ value, onChange }) => {
const onChangeFirstName = useEvent((e: React.ChangeEvent) => {
onChange({ ...valueCopy.current, firstName: e.target.value });
});
const onChangeLastName = useEvent((e: React.ChangeEvent) => {
onChange({ ...valueCopy.current, lastName: e.target.value });
});
return (
firstName
lastName
);
};
```
Код стал чище и работает ничуть не хуже.
Несколько useCallback превращайте в один useMemo
------------------------------------------------
Вернемся к нашему примеру с NameInput
```
const NameInput: FC = ({ value, onChange }) => {
const valueCopy = useRef(value);
valueCopy.current = value;
const onChangeFirstName = useCallback(
(e: React.ChangeEvent) => {
onChange({ ...valueCopy.current, firstName: e.target.value });
},
[onChange]
);
const onChangeLastName = useCallback(
(e: React.ChangeEvent) => {
onChange({ ...valueCopy.current, lastName: e.target.value });
},
[onChange]
);
return (
firstName
lastName
);
};
```
Когда у нас несколько useCallback их можно превратить в один useMemo
```
const NameInput: FC = ({ value, onChange }) => {
const valueCopy = useRef(value);
valueCopy.current = value;
const { onChangeFirstName, onChangeLastName } = useMemo(
() => ({
onChangeFirstName: (e: React.ChangeEvent) => {
onChange({ ...valueCopy.current, firstName: e.target.value });
},
onChangeLastName: (e: React.ChangeEvent) => {
onChange({ ...valueCopy.current, lastName: e.target.value });
}
}),
[onChange]
);
return (
firstName
lastName
);
};
```
Это производительнее, react под капотом выполняет меньше работы. Часто работать с такой конструкцией удобнее, потому что многие вспомогательные переменные можно хранить прямо внутри функции, что передаем в useMemo.
### Заключение
В этой статье разобрали, как работать с useMemo и useCallback.
useMemo стоит использовать в двух случаях:
1. Когда в компоненте выполняются сложные вычисления useMemo сохранит их и лишняя работа будет упразднена.
2. Когда нужно передать ссылочный тип данных в **мемоизированный** компонент.
useCallback - это синтаксический сахар, обертка на useMemo специально для функций.
И useMemo и useCallback под капотом клонируют функции, переданные первым аргументом вместе с замыканием, потому классическое замыкание перестает работать, но починить это можно с помощью useRef.
В следующей статье разберемся с reference и всеми инструментами для работы с ними: `useRef`, `createRef`, `forwardRef`, `useImperativeHandle`.
Также хочу пригласить вас на наш [курс по react.js](https://otus.pw/g3uR/) в нем помимо прочего разберем как кешировать функции с помощью useMemo и как это позволит нам создавать мемоизированные массивы инпутов. 7 ноября пройдет бесплатный урок курса по теме "Создание быстрых сайтов с Astro.build". Узнать подробнее о курсе и зарегистрироваться на [бесплатный урок](https://otus.pw/g3uR/) можно по ссылке ниже.
* [Зарегистрироваться на бесплатный урок](https://otus.pw/g3uR/) | https://habr.com/ru/post/696610/ | null | ru | null |
# Citrix Xen Center – Опыт работы с полностью бесплатной виртуализацией
*Сразу опишу главный плюс такого решения –* ***Это бесплатно!*** *Любой может более менее полноценно администрировать рабочие места(Windows машины/сервера, linux сервера, любые ОС), работать с бекапами и эффективно использовать мощность железа.*
*Так уж вышло, что профессиональные решения типа VM Ware стоят очень приличных денег.*
### Введение
Данная статья преследует цель упростить жизнь таким же энтузиастам, которые по какой-то причине, не являясь большими devOps специалистами, уже развернули визор Xen Server и запустили на нем продакшен проекты.
Как правило, сталкиваясь с проблемами и сложностями на уже запущенной системе, с проектами в продакшене право на ошибку нет.
Здесь мы рассмотрим свой опыт работы, проблемы и их решения, приходящие в процессе эксплуатации Xen Server в полностью бесплатном режиме и без какой-либо подготовки, в формате «разберемся в процессе».
### 1. Базовая настройка и нюансы установки
Начнем с установки. Процесс довольно прост: скачиваем iso, нарезаем на usb и устанавливаем на свой новоиспеченный сервер, который по нашему плану будет крутить на себе много разных виртуальных машин на разных ip-адресах, позволяя использовать ресурсы оборудования значительно эффективнее и предоставлять нам прекрасные возможности создания снепшотов и работы с ними.
Снепшоты – это образы системы, которые создаются моментально, запоминают точное состояние всей системы (виртуальной машины) на момент снятия и позволяют вернуться к этому состоянию в любой момент, буквально за несколько секунд, сохранив при этом текущее состояние.
Итак, в процессе установки, точнее при ее завершении, будет задан важный вопрос про объединенную файловую систему – **Enable thin provisioning (Optimised storage for XenDesktop)**. Суть всего этого глубже, но нам следует знать важную деталь: если мы ответим да, сможем в дальнейшем при подключении по ssh складывать файлы образов, используя пространство дисков, которые выбрали при установке. Стоит отметить, что в дальнейшем после установки мы сможем прицеплять сколько угодно новых дисков и инициализировать их в системе, но не в общем пространстве, о котором нас спрашивают при установке.
Почему важно иметь возможность использовать общее пространство? Это слегка упрощает разворачивание больших бекапов (снепшотов или образов). Если делать это через интерфейс, то при обрыве соединения весь процесс будет потерян. В случае передачи по sftp вы всегда сможете вернуться к тому же моменту и догрузить файл используя ftp клиент. Можно так же примонтировать сетевой диск и выполнить импорт с него, но здесь важна стабильность сетевого канала.
Есть важный нюанс: доступ к общему пространству, где по совместительству лежат все виртуальные машины основного раздела, происходит по адресу: **/run/sr-mount/**. Загружая туда файл, нам будет доступно все место из Local storage, но учтите, что в интерфейсе все, что мы займем своими бекапами, учитываться не будет и система в GUI будет говорить, что места больше (на самом деле нет). За этим необходимо следить.
**!Важно!** Если мы займем все место, а система будет думать, что оно есть, с виртуальными машинами начнет происходить страшная магия, и они начнут выключаться на ровном месте. Самое страшное в этой истории то, что не все машины запустятся после того как мы освободим место. С этим нужно быть предельно внимательными.
Все остальное в процессе установки на дальнейшую работу особо не влияет (по крайней мере в наших сценариях).
### 2. Запуск, подключение дисков, iso-образов и создание машин
После успешного запуска и подключение визора XenCenter из-под Windows (GUI работает только под ним) нам предоставляется возможность пользоваться благами виртуализации и создавать виртуальные машины.
При попытке создать машину нам сразу будет предложено использовать стандартный шаблон, загруженный через импорт снепшот (бекап) или снепшот от текущих машин. Есть так же Xen App, но в нашем бесплатном использовании он не актуален.
Как правило, стандартные шаблоны бесполезны и при создании новой машины, где мы будем устанавливаться с iso, нужно выбирать Other install media. В случае развертывания из снепшотов, разумеется, выбираем снепшот.
Важный момент: при развертывании снепшота системе требуется не только место на диске, на котором мы развертываем виртуальную машину, но и примерно столько же свободного места на основном диске, где лежит снепшот.
Из практических советов: в названии машины пишите ее полный ip-адрес, это упростит процесс администрирования, когда ваших виртуальных машин станет очень много.
### Подключение локального репозитория ISO
Для установки любой ОС (а, разумеется, мы захотим поставить всё и вся) необходимо создать репозиторий, куда мы будем складывать свои iso.
1. Создаем папку:
`$ mkdir -p /var/opt/xen/ISO_Store`
2. Создаем сам репозиторий, через Storage Manager(SR):
`$ xe sr-create name-label=LocalISO type=iso device-config:location=/var/opt/xen/ISO_Store device-config:legacy_mode=true content-type=iso`
*name-label – в данном случае имя репозитория*
Сразу после этого в GUI появится новое хранилище:
Чтобы загрузить туда iso нужно загрузить по sftp iso образ в **/var/opt/xen/ISO\_Store** или зайти по ssh в папку и вытянуть образ через wget.
`cd /var/opt/xen/ISO_Store`
`wget https://*address*/*file*.iso`
Для активации образов нужно перейти в LocalIso – Storage и нажать кнопку **Rescan**:
Образ появится в списке.
Так же в список загрузки виртуальной машины(Console – DVD Drive 1) добавится все что инициализировано в локальном репозитории.
Теперь можно выбрать загруженный образ и установить на новую виртуальную машину.
Далее идет обычный процесс установки и использование виртуальной машины. Обратите внимание на то, что лишние виртуальные сетевые карты лучше сразу удалять, чтобы не болтались в системе. По умолчанию там будут все карты сервера.
### Подключение дисков к уже настроенной системе
В какой-то момент после запуска и начала использования системы возникнет необходимость подключить новые диски. Сразу отмечу, что есть нюанс с дисками более 2 ТБ, они подключаются немного иначе, ниже это опишу.
**Процесс подключения:**
1. Нужно посмотреть список дисков:
`fdisk -l`
2. Далее нужно проверить, есть ли на диске какие-то разделы:
`ls -l /dev/disk/by-id/`
Если разделов нет, этот шаг можно пропустить.
Если разделы есть и нужно использовать весь диск под хранилище, все разделы нужно будет удалить. Делается это просто с помощью fdisk:
`fdisk /dev/sdb`
***\*sdb\**** тут идентификатор диска, полученный из **fdisk -l**
Далее нажимаете **d**, выбираете раздел, который хотите удалить и жмете **w**, чтобы сохранить изменения.
Если диск больше 2Tb, то следует воспользоваться программой gdisk. Работает так же, как fdisk (**gdisk /dev/sdb**).
Так как хранилище XenServer использует LVM для разделов, выполним инициализацию диска для работы с LVM:
`pvcreate /dev/sdb`
Если получаем ошибку
**Command not permitted while global/metadata\_read\_only is set**,
нужно выполнить ту же команду, но с дополнительным параметром:
`pvcreate /dev/sdb -ff --config global{metadata_read_only=0}`
Далее нам нужно получить UUID текущего хоста гипервизора:
`xe host-list`
Копируем полученный uuid и используем его в непосредственно команде по созданию локального хранилища XenServer:
`xe sr-create content-type=user host-uuid=27168638-2022-4dcb-aa1c-56de7d59f989 type=lvm device-config-device=/dev/sdb name-label="Local storage 1.5TB"`
**Здесь:**
* **host-uuid** – uuid гипервизора, полученный из xe host-list
* **type** – тип файловой системы
* **device-config-device** – подключаемый диск
* **name-label** – название диска после подключения (так он будет называться в визоре).
После выполненных манипуляций диск сразу станет виден в XenCenter, его можно использовать для создания виртуальных машин.
После подключения новое хранилище можно выставить как хранилище, используемое по умолчанию.
**Небольшое отступление на тему lvm:**
Lvm позволяет менять размеры диска на лету, даже если с этого диска запущена система. Это крайне полезная возможность.
**Процесс:**
**1.** Смотрим список томов:
`fdisk -l`
**2.** Создаем раздел на указанном диске:
`fdisk /dev/xvdb`
*В примере \*xvdb\* – выбранный диск*
**3.** Инициализируем lvm:
`pvcreate /dev/xvdb1`
В примере \**xvdb1\** – созданный на предыдущем этапе раздел
**4.** Отображаем список групп LVM:
`vgdisplay`
**5.** Включаем новый диск в нужную группу LVM :
`vgextend ubuntu-vg /dev/xvdb1` - включаем новый диск в группу LVM
*В примере \*ubuntu-vg\* – это выбранная группа LVM.*
**6.** Расширяем выбранную группу на указанный объем:
В данном примере мы увеличиваем объем на 10 ГБ:
`lvextend -L +10G /dev/mapper/ubuntu--vg-root`
В данном примере мы берем весь объем, который доступен, расширяем на максимум доступного пространства:
`lvextend -l +100%FREE /dev/mapper/ubuntu--vg-root`
**7.** Запускаем сам ресайз в реальном времени, группу нужно посмотреть в **/dev/mapper/**
`Cd /dev/mapper/; ls`
`resize2fs /dev/mapper/ubuntu--vg-root`
*В примере \*/dev/mapper/ubuntu--vg-root \* выбранная группа*
После выполнения команды resize2fs можете проверить доступное место, оно увеличится (df -h).
### Нюансы работы со снепшотами
Для создания и администрирования снепшотов требуется довольно много свободного места (больше чем в два раза от размера виртуальной машины).
Если получилось так, что мы создали машину на хранилище, у которого нет достаточного запаса свободного места и создали снепшот, он займет все место.
При попытке его удалить место не вернется назад, но снепшот пропадет (удалится).
### Как выйти из этой ситуации?
Есть встроенный механизм для очистки места после удаления снепшотов. Во вкладке Storage есть кнопка «Reclaim free space», но он может не дать желаемого эффекта. Так же стоит учесть, что данная функция создает нагрузку на контроллер и во время выполнения это операции его производительность может сильно упасть.
В этом случае нужно подключить второй диск большего размера, скопировать текущую машину на второй диск, затем удалить ее на первом диске. Virtual Allocated в этом случае исправится сразу, но занятое место не сразу, через некоторое время. На всякий случай можно выполнить команду **xe sr-scan uuid**
Далее мы копируем машину со второго диска на первый и стартуем ее.
### Импорт и экспорт бекапов
При сборке нового сервера стоит учитывать тот факт, что снепшоты снятые с более поздней версии Xen Server. Невозможно импортировать на сервер с более ранней версией Xen Server.
В обратном режиме все работает без проблем, т.е. снепшот, снятый с ранней версии Xen Server корректно импортируется в новую версию.
Также не рекомендуется большие бекапы снепшотов импортировать по сети через визор, надежнее загружать по sftp снепшот и выполнять команду:
`xe vm-import filename=/mnt/nfs/TestVM1-compress.xva`
**filename** – адрес расположения бекапа (снепшота)
### 3. Возможности Xen Server и работа с консолью
Сам по себе Xen Server имеет довольно большое количество функционала, почитать про которые можно [тут](https://docs.citrix.com/en-us/citrix-hypervisor/command-line-interface.html). Разумеется, полные возможности доступны только из консоли.
Здесь мы разберем буквально пару полезных примеров работы с функционалом Xen Server из консоли.
**Пример работы с консолью:**
**1.** Включить автозапуск виртуальной машины после запуска гипервизора:
Получаем uuid нужной виртуальной машины:
`xe vm-list`
Находим виртуальную машину и копируем uuid, далее включаем автозагрузку, подставляя в команду подходящий uuid:
`xe vm-param-set uuid=b23sfeefd-aee0-2def-8f15-55b3ef15ea77 other-config:auto_poweron=true`
После выполнения команды виртуальная машина будет запускаться вместе с запуском гипервизора.
**2.** Активировать все доступные ядра для виртуальной машины.
В Citrix XenCenter могут присутствовать некоторые ограничения на выделение количества процессорных ядер. Например, вы можете столкнуться с ограничением в 32 ядра на одну виртуальную машину.
Для того чтобы использовать все доступные ядра, мы так же прибегаем к помощи консоли:
Получаем uuid нужной виртуальной машины:
`xe vm-list`
Выполняем обе команды с указанием количества ядер:
`xe vm-param-set VCPUs-max=56 uuid=659795da-49cf-5071-27bd-6eab7b0f5951`
`xe vm-param-set VCPUs-at-startup=56 uuid=659795da-49cf-5071-27bd-6eab7b0f5951`
В итоге получаем виртуальную машину с указанным количеством ядер, точнее, потоков.
### 4. Удивительные, возможно полезные истории
Здесь я хочу рассказать несколько удивительных историй так или иначе связанных с виртуализацией.
**1.** История с нерабочим экраном консоли
Как-то раз при сборке и настройке нового сервера произошло следующее: Xen Server успешно установлен, успешно подключается от Xen Center, создает/редактирует виртуальные машины, все, казалось бы, отлично! Но при попытке запустить какую-либо из машин на вкладке консоли черный экран и потом ошибка, что-то вроде: «Невозможно создать изображение» (точную формулировку не помню).
Множество часов было потрачен на попытку решить эту проблему, подкидывались разные видео карты, отгуглен весь интернет. В процессе разбора было принято решение залезть в конфиги Xen, в которые залезать нельзя и ковыряться именно с настройками адаптера, т.к. все хоть как-то близкие темы вели именно туда.
После редактирования конфигов все закончилось плохо, и в итоге все пришлось устанавливать заново.
Проблема заключалась в закрытом порте у провайдера. Как только переключились на локальную сеть, все заработало. Если столкнетесь с похожей проблемой в первую очередь переключитесь на локальную сеть для проверки!
**2.** История с рейд массивами, которые спонтанно разлетались
На протяжении долгого времени на одной из машин мы страдали с непонятной проблемой: рейд разных типов периодически рассыпался. Мог отработать 3 месяца корректно и разбиться, мог отработать неделю корректно и рассыпаться.
Меняли:
* Материнскую плату (контроллер MegaRaid)
* Память
* SSD-диски
Создавалось впечатление, что это помогало, но потом все снова ломалось. В итоге проблема оказалась с корзиной, а, точнее, с бекплейтом. После ее замены проблема ушла.
**3.** Подключение удаленных hasp-ключей и других удаленных usb устройств:
При организации виртуальной инфраструктуры может возникнуть потребность в подключении hasp ключей или других устройств, которые проблематично вставлять в сервер в дата центре.
Для решения таких задач есть специальные решения. Например, ПО USB Redirector (бесплатно для Linux).
Эта схема позволяет развернуть сервер на физической машине в офисе и прокинуть на клиент в виртуальную машину любые usb устройства и настроить автоподключение.
Так мы легко прокидывали для решения задач клиентов всякого рода usb на виртуальные машины, хотя когда первый раз услышали про такую задачу в голову приходили дурацкие решения, вроде того, чтобы поехать в ДЦ и вставить usb ключ в сервер.
Тема не новая, но возможно кому то эта информация будет полезна. Очень удобная схема для установки программного обеспечения на виртуальные машины, требующего hasp ключи для работы.
### 5. Выводы
По моему скромному опыту, для организации полноценной работы с точки зрения обеспечения серверной инфраструктуры для мелко-средней веб-студии бесплатные решения на баз Xen Server отлично подходят.
Они позволяют сэкономить на стоимости Enterprise решений и решить большинство задачи, стоящих перед бизнесом.
Если есть в душе какой то интерес к devOps и организации собственной ИТ инфраструктуры, но нет опыта в этой области и хотелось бы войти в царство виртуализации без затрат, XenServer - отличный старт! | https://habr.com/ru/post/599213/ | null | ru | null |
# Качаем файлы в бэкграунде
Здравствуйте.
У меня на работе безлимитка, которой иногда хочется пользоваться. Например, закачивать много-много музыки, так, чтобы оставил, забыл на пару дней, вспомнил, а оно уже закачалось. Проблема в том, что безлимитка, все-таки, ограничена по скорости (30Kb/s), и если в наглую оставить закачку wget'ом, то никто этому рад не будет.
Я написал небольшой скриптик, который пингует яндекс, и на основании этого меняет скорость закачки:
> `#!/bin/bash
>
> limit=1
>
> delay=5
>
> num\_of\_pings=3
>
>
>
> while true
>
> do
>
> # Собственно, качаем. --limit-rate — это ограничение скорости. Обратите внимание на "&" в конце строки, он нужен, чтобы wget уходил в background
>
> wget -t0 -c --limit-rate=$limit -q хттп://адрес\_до\_файла&
>
> # Запоминаем номер работы, которую мы только что создали.
>
> jobnum=`jobs %% | mawk '{if (NR==1) print $1}' | perl -pe 's/\[//; s/\]\+//'`
>
> # Даем wget'у немного времени, чтобы поработать.
>
> sleep $delay`
>
>
Эта штука почти не мешает работе, разве что раз в пять минут на 20 секунд. И то, только если не повезет в этот момент освободить канал.
Но проблемы, все-таки, есть:
1. Когда канал свободен, он используется не на полную — теряются несколько секунд на простой, плюс, немного времени у wget'а на восстановление соединения.
2. Этот скрипт принципиально не сработает, если сервер, с которого качаем файлы, не поддерживает докачку.
3. Если скриптина таки зацапает себе канал, то придется ждать 20 секунд.
Собственно, теперь пара вопросов:
Кто-нибудь может подсказать более хороший и правильный способ для таких закачек?
Как можно улучшить этот скрипт, чтобы он стал хорошим и правильным способом?
UPD: Слегка подправил скрипт. Он теперь работает с конкретной работой (job) которую создает, и больше нет глобальных killall wget. Кроме того, пинг теперь не один, а столько, сколько захочется. | https://habr.com/ru/post/41969/ | null | ru | null |
# Префиксы в системе команд IA-32
Сегодня я хочу рассказать вам о префиксах в системе команд Intel IA-32 в 32- и 64-битных вариантах (также именуемых как x86 и x86\_64). Но для начала напомню вкратце общую структуру IA-32 инструкции:
* Префиксы. Могут отсутствовать. Может присутствовать сразу несколько.
* Опкод. Может состоять из одного, двух или трех байтов.
* Mod\_R/M байт. Используется для адресации операндов. Может отсутствовать в кодировке, если инструкция не имеет явных операндов.
* SIB (Scale Index Base) байт. Второй байт, использующийся для адресации операндов в памяти. Может отсутствовать.
* Байт смещения адреса (*англ.* displacement). 1, 2, 4 или ни одного байта.
* Константа (*англ.* immediate). 1, 2, 4 или ни одного байта.
Более подробное описание структуры инструкции можно найти в статье [«Дизассемблер своими руками»](http://habrahabr.ru/post/128042) и, конечно же, в [Intel 64 and IA-32 Architectures Software Development Manuals](http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html). В данной статью будет рассказываться об IA-32 префиксах, особенностях, связанных с их использованием, а также тенденций в их развитии.
#### Однобайтные префиксы
Практически с самых первых процессоров Intel в системе команд IA-32 начали использоваться однобайтные префиксы. О них уже было написано на [Хабре](http://habrahabr.ru/post/128042), по этой причине я про них рассказывать не буду.
#### Обязательные префиксы
С появлением расширения `SSE` часть однобайтных префиксов, а именно `0xf2`, `0xf3`, `0x66` в некоторых случаях стали иметь смысл части опкода. Появились так называемые обязательные префиксы (*англ.* mandatory prefixes). Примеры таких инструкций приведены ниже.
| Кодировка | Инструкция | Обязательный префикс |
| --- | --- | --- |
| `0x0f 0x10` | `MOVUPS` | - |
| `0xf2 0x0f 0x10` | `MOVSD` | `0xf2` |
| `0xf3 0x0f 0x10` | `MOVSS` | `0xf3` |
| `0x66 0x0f 0x10` | `MOVUPD` | `0x66` |
Не сложно заметить, что кодировки этих инструкций отличаются только префиксом. Опкод у них совпадает – `0x0f 0x10`. При этом семантика у этих инструкций различна. Например, `MOVSD` копирует из одного операнда в другой 64 бита, а `MOVUPD` – 128 бит.
#### Префикс REX
В определенный момент появилась необходимость в поддержке 64-битного адресного пространства и расширения числа адресуемых регистров. С этой задачей успешно справились разработчики AMD, добавив префикс, названный `REX`. Данный префикс также является однобайтным, и имеет вид `0x4*`. Его биты используются для расширения уже существующих полей, кодируемых в `Mod_R/M` байте, а также ширины операнда. На рисунке приведен пример использования `REX` префикса для адресации регистров.
Стоит отметить несколько особенностей, связанных с использованием этого префикса. Кодировка `0x4*` соответствует префиксу только в 64-битном режиме, во всех остальных режимах она соответствует вариантам инструкций `INC/DEC`. Интересным свойством данного префикса является то, что он должен быть расположен непосредственно перед байтом опкода, в противном случае он игнорируется. Если `REX` префикс используется вместе с инструкцией требующей присутствия другого обязательного префикса, он должен быть расположен между этим префиксом и байтом кода операции.
#### Префикс VEX
С введением расширения `AVX` в системе команд IA-32 появился новый префикс, названный `VEX`. Он уже не однобайтный. Он может состоять либо из двух, либо из трех байт в зависимости от первого байта префикса. `0xc4` и `0xc5` соответственно.
Поля `R`, `X`, `B`, `W` несут тот же смысл, что и соответствующие поля `REX` префикса. Поле pp предоставляет функциональность, эквивалентную обязательным `SIMD` префиксам (например, `b01` = `0x66`). А поле `m-mmmm` может соответствовать целым двум байтам опкода (например, `0b00011` = `0x0f 0x3a`). Поле `L` определяет длину вектора: 0 – 128 бит, 1 – 256 бит.
Использование `VEX` префикса предоставляет следующие преимущества:
* Поддержка до четырех операндов.
* Поддержка 128-битных `XMM` регистров и 256-битных `YMM` регистров.
* Сжатие кодировки уже введенных инструкций.
* Удаление необходимости использования `REX` префикса для адресации регистров общего назначения (`R8` – `R15`), векторных регистров `XMM8` – `XMM15` (`YMM8` – `YMM15`). `VEX` позволяет кодировать те же поля, что и `REX`, и, вдобавок, несколько новых.
Следуют отметить, что использование `VEX` префикса вместе с некоторыми однобайтными префиксами (`0xf0`, `0x66`, `0xf2`, `0xf3`, `REX`) запрещено и приводит к исключению `#UD`.
#### Префикс EVEX
Не так давно Intel анонсировал появление нового расширения набора команд с названием `AVX3` или `AVX512`. С появлением этого расширения также появился и новый префикс, получивший название `EVEX`. Его описание можно найти в [Intel Architecture Instruction Set Extensions Programming Reference](http://download-software.intel.com/sites/default/files/319433-015.pdf).
Он представляет собой усовершенствованный вариант `VEX` префикса, имеет длину уже в 4 байта и начинается с байта `0x62`, который во всех режимах, кроме 64-битного соответствует инструкции `BOUND`, редко используемой в современных программах.
Приведу некоторые, на мой взгляд, интересные особенности `EVEX` префикса:
* Два бита для длины вектора – `LL`` – необходимые для поддержки векторов размером 128, 256 и 512 бит.
* Поддержка адресации новых 512-битных регистров `ZMM8` — `ZMM31`.
* Поддержка регистров маски операндов (*англ.* opmask registers). Поле `EVEX.aaa`.
* `EVEX.mm` – эквивалент поля `VEX.m-mmmm`, но занимает два бита вместо пяти.
#### Заключение
В заключение хочется отметить некоторые причины появления настолько сложной и, местами, не логичной системы команд. История развития системы команд Intel IA-32 начинается в 70-х годах прошлого столетия, когда ни о каких 64-битных режимах не было и речи. Кроме Intel существенный вклад в эволюцию IA-32 внесла компания AMD. Много усилий было потрачено на поддержание обратной совместимости между различными моделями процессоров. Множество интересных фактов, связанных с развитием архитектуры IA-32 можно найти в статье [A. Fog’a](http://www.agner.org/optimize/blog/read.php?i=25).
Спасибо пользователю [Atakua](https://habr.com/ru/users/atakua/) за комментарии к черновикам этой статьи.
P.S. Все иллюстрации взяты из [Intel 64 and IA-32 Architectures Software Development Manuals](http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html). | https://habr.com/ru/post/200598/ | null | ru | null |
# Ищем коды уровней в Prehistorik-2
В игре [Prehistorik 2](http://en.wikipedia.org/wiki/Prehistorik_2) не предусмотрены сейвы, но на каждом уровне есть (болтается в воздухе в некотором месте уровня) код уровня. Есть два режима прохождения, Beginner и Expert, код также определяет режим. При старте игры можно начать с первого уровня, а можно ввести код и попасть сразу на соответствующий уровень. На одном и том же компьютере с неизменным окружением коды не меняются, но на разных компьютерах коды, вообще говоря, разные, так что коды, найденные при прохождении и тщательно выписанные на бумажку, станут совершенно бесполезны в другом окружении. Поэтому вместо бумажки лучше иметь программу, которая пишет коды для конкретного окружения. Готовый результат: [genpass.com](http://yadi.sk/d/0l5mlXpW72Uhc), представляет из себя DOS-программу, которая должна запускаться в том же окружении, что и игра. Альтернативный вариант попасть на нужный уровень из экрана ввода кода: ввести три кода ADDE C0DE F00D либо DEAD C0DE F00D, каждый из трёх кодов сам по себе неверен, но при вводе их в таком порядке четвёртый код — номер уровня от 1 до 10, плюс 10 для режима Expert, приводит сразу на запрошенный уровень.
Под катом — процесс исследования. Требуется знание ассемблера x86 хотя бы на уровне «читаю со [словарём](http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html)».
Инструменты
===========
Главный инструмент — дизассемблер [IDA Pro](http://www.idapro.ru). Для исследования DOS-программ вполне хватит [бесплатной версии 5.0](https://www.hex-rays.com/products/ida/support/download_freeware.shtml).
Много разных DOS-утилит есть здесь: <http://www.exetools.com/>, некоторые из них будут упомянуты далее в тексте.
Необязательный инструмент — отладчик. Можно использовать какой-нибудь из DOSовских отладчиков (выбор есть по ссылке выше), их общий недостаток — разделение ресурсов (как минимум, экрана) с отлаживаемой программой. Отдать все ресурсы программе, но при этом отлаживать её позволяет эмулятор [Bochs](http://bochs.sourceforge.net/) со встроенным отладчиком. Кроме того, можно обойтись и без отладчика.
Также не помешает hex-редактор. Из открытых, видимо, лучший — [beye](http://beye.sourceforge.net/) (бывший biew). Но можно обойтись и `hexdump` для просмотра и ````
echo -ne '\x..\x..' | dd of= seek= bs=1 conv=notrunc для изменения (без conv=notrunc для уменьшения размера).
Распаковка
==========
Будем анализировать версию, которую можно скачать с old-games.ru: pre2orig.exe размером 52190 байт. Над ней потрудилась (сняв защиту от копирования оригинальной версии) группа Hybrid, о чём игра настойчиво сообщает при старте.
В exe'шнике не обнаруживается связных текстовых строк, что наводит на мысли об упакованности файла: exe'шник на диске сжат с добавлением кода распаковщика, при загрузке сначала выполняется распаковщик, который распаковывает данные в памяти и передаёт управление на распакованный код. Естественно, перед исследованием кода придётся снять этот слой. File Scanner отсюда успешно идентифицирует упаковщик как LZEXE, для которого есть автоматический распаковщик unlzexe. Запустив unlzexe, получаем pre2_1.exe размером 63728 байт.
В pre2_1.exe осмысленные текстовые строки есть, первая из них "INTRO CODED BY CYBER". Смотрим внутрь:
seg002:5E48 start proc near
seg002:5E48 mov cs:pspSeg, ds
seg002:5E4D mov ax, cs
seg002:5E4F mov es, ax
seg002:5E51 assume es:seg002
seg002:5E51 mov cx, 20h
seg002:5E54 mov si, 80h
seg002:5E57 mov di, si
seg002:5E59 rep movsb
seg002:5E5B mov ds, ax
seg002:5E5D assume ds:seg002
seg002:5E5D call loc_19960
seg002:5E60 mov ax, pspSeg
seg002:5E63 add ax, 10h
seg002:5E66 add nextCS, ax
seg002:5E6A add nextSS, ax
seg002:5E6E sub ax, 10h
seg002:5E71 mov ds, ax
seg002:5E73 assume ds:nothing
seg002:5E73 mov es, ax
seg002:5E75 assume es:nothing
seg002:5E75 mov ax, cs:nextSS
seg002:5E79 mov ss, ax
seg002:5E7B assume ss:nothing
seg002:5E7B mov sp, cs:nextSP
seg002:5E80 mov bx, offset nextIP
seg002:5E83 jmp dword ptr cs:[bx]
seg002:5E83 start endp
seg002:5E83
seg002:5E83 ; ---------------------------------------------------------------------------
seg002:5E86 nextIP dw 3 ; DATA XREF: start+38o
seg002:5E88 nextCS dw 0 ; DATA XREF: start+1Ew
seg002:5E8A pspSeg dw 0 ; DATA XREF: startw
seg002:5E8A ; start+18r
seg002:5E8C nextSS dw 1681h ; DATA XREF: start+22w
seg002:5E8C ; start+2Dr
seg002:5E8E nextSP dw 80h ; DATA XREF: start+33r
```
DOS создаёт в памяти перед программой область [PSP](http://ru.wikipedia.org/wiki/Program_Segment_Prefix) размером 100h байт, самая интересная часть которой - командная строка по смещению 80h (в Pascal-стиле: первый байт - длина). Регистры ds и es при запуске программы указывают на сегмент PSP, приложение начинается с адреса ds:0+100h = (ds+10h):0. Первая команда сохраняет ds, следующие 7 (не считая assume - это не команды, а директивы ассемблера) копируют командную строку и настраивают ds, es, затем следует вызов какой-то процедуры loc_19960. После завершения процедуры следует последовательность действий, типичная для последней части кода, "навешенного" поверх готового бинарника, эмулирующая последние действия DOS перед началом выполнения программы: ds и es устанавливаются в сегмент PSP, ss:sp устанавливаются в значение, находящееся по фиксированному смещению относительно начала программы (сегмент pspSeg+10h), происходит прыжок на адрес, находящийся по фиксированному смещению относительно начала программы. Процедура loc_19960 начинает с трёх проверок, при нарушении которых немедленно выходит; о смысле проверок лучше всего говорят текстовые сообщения "This program requires an 80286 or higher", "This program requires a VGA card", "Intro skipped". Фрагмент кода последней проверки:
```
seg002:082F cmp al, '/'
seg002:0831 jnz short loc_1A08A
seg002:0833 lodsb
seg002:0834 and al, not 20h
seg002:0836 cmp al, 'N'
seg002:0838 jnz short loc_1A08B
seg002:083A lodsb
seg002:083B and al, not 20h
seg002:083D cmp al, 'I'
seg002:083F jnz short loc_1A08B
```
То есть, остаток процедуры loc_19960 не вызывается, если передать в командной строке параметр `/ni`. Пробуем, видим, что с этим параметром игра пропускает напоминание о доблестной команде Hybrid и сразу переходит к собственно игре. Делаем вывод, что весь seg002 - ненужная для игры заставка, навешенная на рабочий exe'шник. Переписываем в заголовке cs:ip на 0000:0003, ss:sp на 1681:0080, обрезаем последние 5E90h байт, соответственно скорректировав поля размера и дополнительной памяти в заголовке.
Получаем файл [pre2\_2.exe](http://yadi.sk/d/hbzp4GFz709m7) размером 39520 байт. В нём снова нет связных текстовых строк (все строки из pre2_1.exe оказались связаны с заставкой Hybrid), что снова наводит на мысли об упакованности. Тот же File Scanner показывает "Diet 1.00,1.20" в качестве упаковщика. Этот факт примечателен тем, что diet может работать в двух режимах: упаковка бинарников и упаковка данных. Попробовав распаковать файлы уровней (как самые интересные данные из всех) с помощью diet, убеждаемся, что, действительно, файлы уровней тоже упакованы diet, и, если нас заинтересует структура файлов уровней, один слой (упаковку) мы уже знаем.
Для снятия diet прибегнем к универсальному распаковщику [cup386](http://www.exetools.com/unpackers.htm). diet не содержит антиотладочных приёмов, запуск `cup386 pre2_2.exe pre2unp.exe /1` приводит к распакованному файлу [pre2unp.exe](http://yadi.sk/d/htZpsZTG70HaM) размером 91344 байт. Поиск текстовых строк показывает, что pre2unp.exe - то, что нам нужно.
Поиск кодов
===========
Прежде всего нужно найти место проверки и генерации кодов. Вариантов несколько. Можно прийти дизассемблером в точку входа программы и начать изучать всё подряд (если вы никуда не торопитесь; самый медленный способ, зато по дороге можно узнать много интересного). Можно зайти отладчиком, пройтись по коду без захода внутрь вызываемых процедур, отмечая, какие визуальные эффекты происходят во время выполнения процедур. Можно запустить под отладчиком, дойти до экрана выбора кода и прервать выполнение, посмотрев, где мы находимся (и заглянув в стек, чтобы выяснить, кто вызвал процедуру, где мы находимся). В данном случае самый простой способ - привязаться к текстовой строке "ENTER CODE", наличествующей на экране ввода кода. Поиск находит такую строку по адресу seg002:B171 (IDA любезно определила сегменты ещё при загрузке exe'шника), поиск значения 0B171h выводит на такую процедуру:
```
seg001:99C3 sub_19BC3 proc near ; DATA XREF: sub_1906F+A1o
seg001:99C3 call sub_19D1E
seg001:99C6 mov byte_251D7, 3
seg001:99CB mov bx, offset aEnterCode ; "ENTER CODE"
seg001:99CE mov word_251D2, 0AF2h
seg001:99D4 call sub_19AC4
seg001:99D7 mov byte_251D7, 4
seg001:99DC mov bx, offset levelCode ; "[[[["
seg001:99DF mov word_251D2, 12C9h
seg001:99E5 call sub_19AC4
```
Первую команду вызова `sub_19D1E` проигнорируем. Дальше следует два вызова одной и той же процедуры `sub_19AC4`, первый раз для строки "ENTER CODE", второй раз для строки из 4 символов, изменяемой далее в ходе процедуры; логично считать, что это вывод строки на экран, а вторая строка - вводимый код.
```
seg001:99E8 cmp byte_251D6, 1
seg001:99ED jnz short loc_19BF2
seg001:99EF jmp loc_19CF2
seg001:99F2 ; ---------------------------------------------------------------------------
seg001:99F2
seg001:99F2 loc_19BF2: ; CODE XREF: sub_19BC3+2Aj
seg001:99F2 cmp byte_251D6, 2
seg001:99F7 jnz short loc_19BFC
seg001:99F9 jmp loc_19D02
seg001:99FC ; ---------------------------------------------------------------------------
...
seg001:9AF2 ; ---------------------------------------------------------------------------
seg001:9AF2
seg001:9AF2 loc_19CF2: ; CODE XREF: sub_19BC3+2Cj
seg001:9AF2 inc word_251DC
seg001:9AF6 mov bx, word_251DC
seg001:9AFA sub bx, 8Ch
seg001:9AFE jb short locret_19D1D
seg001:9B00 jmp short loc_19D06
seg001:9B02 ; ---------------------------------------------------------------------------
seg001:9B02
seg001:9B02 loc_19D02: ; CODE XREF: sub_19BC3+36j
seg001:9B02 ; sub_19BC3+4Ej
seg001:9B02 inc byte_251DE
seg001:9B06
seg001:9B06 loc_19D06: ; CODE XREF: sub_19BC3+13Dj
seg001:9B06 mov bx, offset levelCode ; "[[[["
seg001:9B09 mov word ptr [bx], '[['
seg001:9B0D mov word ptr [bx+2], '[['
seg001:9B12 mov byte_251D6, 0
seg001:9B17 mov word_251D4, 0
seg001:9B1D
seg001:9B1D locret_19D1D: ; CODE XREF: sub_19BC3+42j
seg001:9B1D ; sub_19BC3+60j ...
seg001:9B1D retn
seg001:9B1D sub_19BC3 endp
```
В режиме `byte_251D6 == 1` увеличивается счётчик `word_251DC`, пока не достигнет значения 8Ch, после чего `byte_251D6` сбрасывается в 0, а введённый код очищается. Это как раз подходит под то, что после введения неправильного кода в игре он некоторое время остаётся на экране, после чего сбрасывается сам собой. В режиме `byte_251D6 == 2` происходит то же самое, но без паузы; это нам неинтересно.
```
seg001:99FC
seg001:99FC loc_19BFC: ; CODE XREF: sub_19BC3+34j
seg001:99FC mov bl, ScanCode
seg001:9A00 test bl, 80h
seg001:9A03 jz short loc_19C08
seg001:9A05 jmp locret_19D1D
seg001:9A08 ; ---------------------------------------------------------------------------
seg001:9A08
seg001:9A08 loc_19C08: ; CODE XREF: sub_19BC3+40j
seg001:9A08 mov al, KeysPressed+39h
seg001:9A0B or al, KeysPressed+1Ch
seg001:9A0F jz short loc_19C14
seg001:9A11 jmp loc_19D02
seg001:9A14 ; ---------------------------------------------------------------------------
seg001:9A14
```
Дальше читается переменная по адресу `seg002:2870`. Изучение ссылок на неё (найденных IDA) показывает, что ненулевое значение записывается только в одном месте, где оно берётся чтением из порта клавиатуры 60h. Делаем вывод, что эта переменная - последний обработанный сканкод клавиатуры, а записывающая процедура - обработчик прерывания клавиатуры; переименовываем переменную в `ScanCode`. Прокрутив обработчик прерывания до конца, понимаем значение ещё двух используемых переменных: массив `KeyPressed` (обновляемый в обработчике клавиатуры) содержит статусы кнопок (0 = кнопка не нажата, 0FFh = кнопка нажата). Возвращаемся в исследуемую процедуру: `KeyPressed[39h]` и `KeyPressed[1Ch]` - статусы пробела и Enter соответственно. При нажатии пробела или Enter (как показывает тест) игра возвращается из экрана ввода кода в экран с меню, это не то, что нам надо.
```
seg001:9A14 loc_19C14: ; CODE XREF: sub_19BC3+4Cj
seg001:9A14 mov ScanCode, 0
seg001:9A19 xor bh, bh
seg001:9A1B mov al, byte ptr a1234567890AEADfCB[bx] ; "--1234567890----A-E-----------A-DF-----"...
seg001:9A1F cmp al, '-'
seg001:9A21 jnz short loc_19C26
seg001:9A23 jmp locret_19D1D
seg001:9A26 ; ---------------------------------------------------------------------------
seg001:9A26
seg001:9A26 loc_19C26: ; CODE XREF: sub_19BC3+5Ej
seg001:9A26 mov ah, al
seg001:9A28 sub ah, '0'
seg001:9A2B cmp ah, 9
seg001:9A2E jbe short loc_19C33
seg001:9A30 sub ah, 7
seg001:9A33
seg001:9A33 loc_19C33: ; CODE XREF: sub_19BC3+6Bj
```
Здесь начинаются интересные действия. Сканкод подставляется как индекс в строку "--1234567890----A-E-----------A-DF------------C-B-...-", это преобразование в ASCII-код (заглянув в [список сканкодов](http://www.computer-engineering.org/ps2keyboard/scancodes1.html), обнаруживаем, что ASCII-код 'A' получается не только от клавиши A, но и от клавиши Q - надо полагать, чтобы игра работала также с раскладкой AZERTY). Если ASCII-код не является hex-цифрой, процедура игнорирует клавишу и выходит. Если является, то происходит преобразование в число от 0 до 0Fh.
```
seg001:9A33 mov dx, word_251E5
seg001:9A37 mov cl, 4
seg001:9A39 shl ah, cl
seg001:9A3B shl ah, 1
seg001:9A3D rcl dx, 1
seg001:9A3F shl ah, 1
seg001:9A41 rcl dx, 1
seg001:9A43 shl ah, 1
seg001:9A45 rcl dx, 1
seg001:9A47 shl ah, 1
seg001:9A49 rcl dx, 1
seg001:9A4B mov word_251E5, dx
seg001:9A4F mov bx, word_251D4
seg001:9A53 mov byte ptr levelCode[bx], al ; "[[[["
seg001:9A57 inc word_251D4
seg001:9A5B inc bl
seg001:9A5D cmp bl, 4
seg001:9A60 jnb short loc_19C65
seg001:9A62 jmp locret_19D1D
seg001:9A65 ; ---------------------------------------------------------------------------
```
Переменная `word_251E5` сдвигается на 4 бита влево, младшие биты заполняются числом, соответствующим введённому символу. Сам символ дописывается в строку со введённым кодом, число введённых символов `word_251D4` увеличивается на единицу. Если ещё нет 4 символов, на этом обработка заканчивается. После 4 символов `word_251E5` содержит 16-битное число, хранящее введённый код ("1234" -> 1234h), дальше следует ожидать проверок этого числа.
```
seg001:9A65
seg001:9A65 loc_19C65: ; CODE XREF: sub_19BC3+9Dj
seg001:9A65 push bp
seg001:9A66 mov word_251DC, 0
seg001:9A6C mov di, word_251DF
seg001:9A70 mov si, word_251E1
seg001:9A74 mov bp, word_251E3
seg001:9A78 mov ax, di
seg001:9A7A rol ax, 1
seg001:9A7C rol ax, 1
seg001:9A7E mul ah
seg001:9A80 xor ax, si
seg001:9A82 mul bp
seg001:9A84 mov bx, ax
seg001:9A86 add bx, si
seg001:9A88 ror bx, 1
seg001:9A8A rol bl, 1
seg001:9A8C xor bl, bh
seg001:9A8E xor bx, bp
seg001:9A90 pop bp
seg001:9A91 cmp ax, 36C8h
seg001:9A94 jnz short loc_19CAC
seg001:9A96 cmp bx, 8BD1h
seg001:9A9A jnz short loc_19CAC
seg001:9A9C cmp dx, 8E71h
seg001:9AA0 jnz short loc_19CAC
seg001:9AA2 mov dx, word_251E5
seg001:9AA6 dec dx
seg001:9AA7 cmp dx, 14h
seg001:9AAA jbe short loc_19CD9
seg001:9AAC
seg001:9AAC loc_19CAC: ; CODE XREF: sub_19BC3+D1j
seg001:9AAC ; sub_19BC3+D7j ...
```
Обнуление счётчика `word_251DC` и первая проверка. Если некоторые преобразования над тремя переменными, лежащими в памяти непосредственно перед `word_251E5`, приводят к некоторым фиксированным значениям и введённый код находится в диапазоне от 1 до 15h включительно, происходит переход на метку `loc_19CD9` с `dx`, равным введённому коду минус единица. Отложим пока выяснение, что же это за переменные.
```
seg001:9AAC xor dx, dx
seg001:9AAE
seg001:9AAE loc_19CAE: ; CODE XREF: sub_19BC3+FAj
seg001:9AAE mov ax, dx
seg001:9AB0 call sub_19559
seg001:9AB3 cmp word_251E5, ax
seg001:9AB7 jz short loc_19CD9
seg001:9AB9 inc dx
seg001:9ABA cmp dx, 14h
seg001:9ABD jbe short loc_19CAE
seg001:9ABF mov si, offset word_251E1
seg001:9AC2 mov ax, [si]
seg001:9AC4 mov [si-2], ax
seg001:9AC7 mov ax, [si+2]
seg001:9ACA mov [si], ax
seg001:9ACC mov ax, [si+4]
seg001:9ACF mov [si+2], ax
seg001:9AD2 mov byte_251D6, 1
seg001:9AD7 jmp short locret_19D1D
seg001:9AD9 ; ---------------------------------------------------------------------------
```
Основная проверка. `word_251E5` последовательно сравнивается с результатом работы функции `sub_19559`, вызываемой последовательно с `dx` от 0 до 14h. При равенстве происходит переход на метку `loc_19CD9` с `dx`, при котором `sub_19559` возвращает введённый код. Ясно, что `sub_19559` возвращает код заданного уровня.
Если совпадения нет, то `byte_251D6` устанавливается в 1 (как мы уже видели, это соответствует неверному коду), введённый код и две предшествующих ему переменных перемещаются на одну переменную назад. После трёх неправильных попыток три переменные, предшествующие введённому коду, будут хранить предыдущие варианты; теперь понятно, откуда берутся исходные данные для первой проверки.
```
seg001:9AD9
seg001:9AD9 loc_19CD9: ; CODE XREF: sub_19BC3+E7j
seg001:9AD9 ; sub_19BC3+F4j
seg001:9AD9 mov al, 0
seg001:9ADB cmp dl, 0Ah
seg001:9ADE jb short loc_19CE4
seg001:9AE0 sub dl, 0Ah
seg001:9AE3 inc ax
seg001:9AE4
seg001:9AE4 loc_19CE4: ; CODE XREF: sub_19BC3+11Bj
seg001:9AE4 mov byte_1CDB6, dl
seg001:9AE8 mov byte_251C3, al
seg001:9AEB mov byte_251D6, 2
seg001:9AF0 jmp short locret_19D1D
```
Завершение процедуры при правильном коде: если `dx` меньше 10, оно записывается как есть в `byte_1CDB6`, а `byte_251C3` становится нулём; иначе в `byte_1CDB6` записывается `dx-10`, а `byte_251C3` становится единицей. В любом случае `byte_251D6` становится равным 2, что означает конец процедуры.
Остаётся сделать генератор кодов, действующий так же, как `sub_19599`, и/или выяснить, как пройти первую проверку. Кратко о вычислении кодов: сначала вычисляется переменная `word_2435F` на основе последних 10h байт BIOS [F000:FFF0](http://www.about-pc.narod.ru/part5/bios2.html) (включающих дату BIOS) и первых 80h байт всех расширений BIOS в интервале от C000:0000 до F000:0000. Собственно код уровня вычисляется следующим образом:
```
; ax = zero-based level
seg001:93C6 xor ax, 55A3h
seg001:93C9 mul word_2435F
seg001:93CD mov cl, cs:ProcessorType ; always 3 for 386+
seg001:93D2 rol ax, cl
```
Процедура `sub_19599` достаточно независима от окружения (ей требуется только тип процессора - для 386+ он всегда равен 3), её можно просто скопировать из дизассемблированного кода, получив примерно такой генератор кодов: [genpass.asm](http://yadi.sk/d/few6G1L972UfS), [genpass.com](http://yadi.sk/d/0l5mlXpW72Uhc).
Немного сложнее выяснить "магические" значения для первой проверки: три кода, после введения которых можно просто ввести номер уровня (в hex и 1-based). Проверяются три значения, вычисляемые по трём кодам: пара `dx:ax` должна быть равна 8E7136C8h, значение `bx` должно быть 8BD1h. Анализ кода, приведённого выше, показывает, что `dx:ax` получается на выходе команды `mul bp` и 8E7136C8h - произведение двух 16-битных чисел: третьего кода и некоторого выражения с первыми двумя кодами. `bx` - некоторое выражение со вторым и третьим кодом. Разлагая 8E7136C8h на множители, получаем 23*7*4861*8779; чтобы получить два 16-битных сомножителя, 4861 и 8779 должны входить в разные сомножители, а оставшиеся множители 23*7 должны быть как-то разбиты на две части. Получается довольно мало вариантов (16 до отсеивания из-за 16-битности). Переберём каждый из вариантов; второй сомножитель - третий код, зная его, находим второй код из bx, после чего первый сомножитель даёт произведение двух 8-битных множителей. Не всякое 16-битное число можно представить в виде произведения двух 8-битных, здесь отсеиваются все варианты для третьего кода, кроме одного, который зато даёт два варианта для первого кода (отличающихся порядком 8-битных множителей). Код перебора: [getmagic.c](http://yadi.sk/d/ceMXWKyp72WFc), результаты: ADDE C0DE F00D и DEAD C0DE F00D.` | https://habr.com/ru/post/187072/ | null | ru | null |
# Azure Cloud Shell в Windows Terminal
Теперь вы можете подключаться к [Azure Cloud Shell](https://azure.microsoft.com/en-us/features/cloud-shell/) через Windows Terminal!
Для этого мы добавили новый профиль по умолчанию – Azure Cloud Shell, который позволяет получить доступ к каталогам/клиентам Azure через приложение Windows Terminal.
Если у вас уже установлен Windows Terminal
------------------------------------------
Ваши параметры Windows Terminal не будут автоматически обновляться до нового профиля (поскольку файл не обновляется каждый раз, когда вы открываете Windows Terminal), так что, вот как вы можете добавить его вручную:
1. Запустите Windows Terminal
2. Откройте Settings (используя выпадающий список)
3. Добавьте этот профиль в свой список профилей (пункт profiles):
```
{"acrylicOpacity" : 0.6,
"closeOnExit" : false,
"colorScheme" : "Vintage",
"commandline" : "Azure",
"connectionType" : "{d9fcfdfa-a479-412c-83b7-c5640e61cd62}",
"cursorColor" : "#FFFFFF",
"cursorShape" : "bar",
"fontFace" : "Consolas",
"fontSize" : 10,
"guid" : "{b453ae62-4e3d-5e58-b989-0a998ec441b8}",
"historySize" : 9001,
"icon" : "ms-appx:///ProfileIcons/{b453ae62-4e3d-5e58-b989-0a998ec441b8}.png",
"name" : "Azure Cloud Shell",
"padding" : "0, 0, 0, 0",
"snapOnInput" : true,
"startingDirectory" : "%USERPROFILE%",
"useAcrylic" : true}
```
Как только вы это сделаете, вам будет доступна вкладка Azure Cloud Shell.
Базовая настройка
-----------------
1. Откройте вкладку “Azure Cloud Shell”.
2. Вам будет предложено перейти на “microsoft.com/devicelogin” и ввести отображаемый код.
3. После ввода кода в браузере, вам будет необходимо войти в систему под своей учетной записью. Также, следует убедиться, что вход был произведен с учетной записи, которая имеет активный каталог/клиент Azure.
4. Вернитесь в терминал. Через несколько секунд вы увидите сообщение “Authenticated”.
5. *Только в некоторых случаях*: если в вашей учетной записи имеется несколько клиентов, то вам будет предложено выбрать один из них. Просто введите номер клиента, к которому вы хотите подключиться.
6. Затем вам будет предложено сохранить эти параметры подключения. Сохранение параметров подключения позволит в дальнейшем входить в систему, не проходя через шаги 1-5.
7. Затем приложение начнет устанавливать соединение с Cloud Shell (это может занять некоторое время, просто наберитесь терпения).
8. Теперь вы подключены к Azure Cloud Shell!
Вот как выглядит полный вывод входа в систему (я нажал ‘0’ для номера клиента и ‘y’ для выбора сохранения параметров подключения):
Теперь, когда я сохранил параметры подключения, вот как в дальнейшем будет выглядеть процесс входа в систему (я нажимаю ‘0’, чтобы получить доступ к сохраненным параметрам подключения):
Также можно войти в систему под другой учетной записью/клиентом, нажав ‘n’, или удалить сохраненные подключения, нажав ‘r’. Эти параметры будут сохраняться во время сеансов, поэтому даже если вы запустите терминал через несколько дней, то все равно сможете войти в систему с сохраненными параметрами подключения без необходимости вновь открывать браузер.
Надеюсь, вам понравится возможность иметь доступ к вашим ресурсам Azure через Windows Terminal. Также, как и всегда, пожалуйста, сообщайте о любых замеченных багах/проблемах в [наш репозиторий на Github](https://github.com/microsoft/terminal).
 | https://habr.com/ru/post/468341/ | null | ru | null |
# Machine Learning for your flat hunt. Part 2
Have you thought about the influence of the nearest metro to the price of your flat?
What about several kindergartens around your apartment? Are you ready to plunge in the world of geo-spatial data?
What is all about?
------------------
In the [previous part](https://habr.com/en/post/468053/), we had some data and tried to find a good enough offer on a real estate market in Yekaterinburg.
We had arrived at a point when we had an accuracy on cross-validation near 73%. However, every coin has 2 sides. And 73% accuracy it is 27% of error. How could we make that less? What is the next step?
Spatial data is coming to help
------------------------------
What about getting more data from the environment? We can use geo-context and some spatial data.
Rarely people spend their entire life at home. Sometimes they go to shops, take kids from daycare. Their children grow up and go to school, university, etc.
Or… sometimes they need medical help and they are looking for a hospital. And a very important thing is public transport, metro at least. In other words, there are many things near there, that have an impact on pricing.
Let me show you a list of them:
* Public transport stops
* Shops
* Kindergartens
* Hospitals/medical institutions
* Educational institutions
* Metro
### Visualization for new data
After getting that information from [different sources](https://bst.digital/), I made a visualisation.
There are some points on the map the most prestigious (and expensive) district of Yekaterinburg.
* **R**ed points - flats
* **O**range - stops
* **Y**ellow - shops
* **G**reen - kindergartens
* **B**lue - education
* **I**ndigo - medical
* **V**iolet - Metro
Yes, a rainbow is here.
### Overview
Now we have a dataset which is bounded with geodata and has some new information
```
df.head(10)
```
```
df.describe()
```
A good old model
----------------
Try the same way as before
```
y = df.cost
X = df.drop(columns=['cost'])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,random_state=42)
```
Then we train our model again, cross our fingers and try to predict the price of flat again.
```
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
model = regressor.fit(X_train, y_train)
do_cross_validation(X_test, y_test, model)
```
Hmm… it looks better than the previous result with 73% of accuracy.
What about trying of interpretation? Our previous model had a good enough ability to explain the flat price.
```
estimate_model(regressor)
```
Oops… Our new model works well with old features, but the behaviour with new ones seems odd.
For example, the bigger number of educational or medical institutions leads to a decrease in the price of flat. Accordingly, the number of stops nearby flat is an identical situation and it should gain an additional contribution to the flat price.
The new model is more accurate, but it does not fit with real life.
Something is broken
-------------------
Let consider what happened.
First of all — I want to remind you that key feature of our linear regression is… erm… linearity. Yes, Captain Obvious is here.
If your data is compatible with an idea "The bigger/lease is X the bigger/lease will Y" - linear regression will be a good tool. But geodata is more complex than we expected.
For instance:
* When near your flat is a bus stop it is good, but if the amount of them is around 5, it leads to a noisy street and people would like to avoid to buy a flat nearby.
* If there is a university, it should have a good influence on price,
at the same time a crowd of students near your home is not so pleased if you are not a very sociable person.
* Metro near your home is good, but if you live in one hour by foot
from the nearest metro - it should not make sense.
As you see - it depends on many factors and points of view. And the nature of our geodata is not linear, we can not extrapolate the impact of them.
At the same time, why does model with bizarre coefficients work better than the previous one?
```
plot.figure(figsize=(10,10))
corr = df.corr()*100.0
sns.heatmap(corr[['cost']],
cmap= sns.diverging_palette(220, 10),
center=0,
linewidths=1, cbar_kws={"shrink": .7}, annot=True,
fmt=".2f")
```
It looks interesting. We have seen the similar picture in the previous part.
There is a negative correlation between distance to the nearest metro and price. And this factor has an impact on accuracy more than some older ones.
**Meanwhile**, our model work messy and don not see dependencies between aggregated data and target variable. The simplicity of linear regression has its own limits.
The king is dead, long live the king!
-------------------------------------
And if a linear regression is not suitable for our case, what can be better? If only our model could be "smarter"…
Fortunately, we have an approach which should better because of it more… flexible and has a built-in mechanism "do if that do this else do that".
**Decision Tree** appears on the scene.
```
from sklearn.tree import DecisionTreeRegressor
A decision tree can have a different depth, usually, it works well when depth is 3 and bigger. And the parameter of max depth has the biggest influence on the result. Let's do some code for checking depth from 3 to 32
data = []
for x in range(3,32):
regressor = DecisionTreeRegressor(max_depth=x,random_state=42)
model = regressor.fit(X_train, y_train)
accuracy = do_cross_validation(X, y, model)
data.append({'max_depth':x,'accuracy':accuracy})
data = pd.DataFrame(data)
ax = sns.lineplot(x="max_depth", y="accuracy", data=data)
max_result = data.loc[data['accuracy'].idxmax()]
ax.set_title(f'Max accuracy-{max_result.accuracy}\nDepth {max_result.max_depth} ')
```
Well… for a situation when the max\_depth of a tree is equal 8 the accuracy is above 77.
And it would be a good achievement if we did not think about the limits of that approach. Let have a look at how it will work with *max\_depht=2*
```
from IPython.core.display import Image, SVG
from sklearn.tree import export_graphviz
from graphviz import Source
2_level_regressor = DecisionTreeRegressor(max_depth=2, random_state=42)
model = 2_level_regressor.fit(X_train, y_train)
graph = Source(export_graphviz(model, out_file=None
, feature_names=X.columns
, filled = True))
SVG(graph.pipe(format='svg'))
```
On this picture, we can see that there are only 4 variants of prediction. When you use *DecisionTreeRegressor*, it works differently than *Linear Regression*. Just differently. It does not use a contribution of factors (coefficients), instead of that *DecisionTreeRegressor* uses "likelihood". And the price of a flat will be the same as has the flat most similar on predicted.
We can show it by predicting our price with that tree.
```
y = two_level_regressor.predict(X_test)
errors = pd.DataFrame(data=y,columns=['errors'])
f, ax = plot.subplots(figsize=(12, 12))
sns.countplot(x="errors", data=errors)
```
And every your prediction will match with one of these values. And when we are using *max\_depth*=8 we can expect no more than 256 different variants for over than 2000 flats. Maybe it is good for classification's issues, but it is not flexible enough for our case.
Wisdom of crowd
---------------
If you try to predict the score on the final of World Cup - there is a big probability you will be mistaken. At the same time, if you ask for opinion all judges on Championship - you will have better chances to guess. If you ask independent experts, trainers, judges and then do some magic with answers - your chances will increase significantly. Looks like an election of a president.
An ensemble of several "primitive" trees can give more than each of them. And *RandomForestRegressor* is a tool which we will use
First of all, let's consider basic params - *max\_depth*, *max\_features* and a *number of trees* in the model.
### Number of trees
In accordance with ["How Many Trees in a Random Forest?"](https://www.researchgate.net/publication/230766603_How_Many_Trees_in_a_Random_Forest) the best choice will be **128 trees**. Further increasing of the number of trees does not lead to significant improvement in accuracy, but increase time for training.
### Maximal number of features
Right now our model has 12 features. Half of them is old ones which are related to with features of flat, other related to geo-context. So I decided to give a chance for each of them. Let it be **6 features** for a tree.
### Maximal depth of a tree
For that parameter, we can analyse a learning curve.
```
from sklearn.ensemble import RandomForestRegressor
data = []
for x in range(1,32):
regressor = RandomForestRegressor(random_state=42, max_depth=x,
n_estimators=128,max_features=6)
model = regressor.fit(X_train, y_train)
accuracy = do_cross_validation(X, y, model)
data.append({'max_depth':x,'accuracy':accuracy})
data = pd.DataFrame(data)
f, ax = plot.subplots(figsize=(10, 10))
sns.lineplot(x="max_depth", y="accuracy", data=data)
max_result = data.loc[data['accuracy'].idxmax()]
ax.set_title(f'Max accuracy-{max_result.accuracy}\nDepth {max_result.max_depth} ')
```
Whoa… over 86% accuracy on **max\_depth=16** against 77% on one design tree. It looks amazing, is not it?
Conclusion
----------
Well… now we have a better result in prediction than previous ones, 86% is near the finish line. The last step for checking - let look at feature importance. Did geodata give any benefit to our model?
```
feat_importances = model.feature_importances_
feat_importances = pd.Series(feat_importances, index=X.columns)
feat_importances.nlargest(5).plot(kind='barh')
```
Some old features still have affected on the result. At the same time distance to the nearest metro and kindergartens also has affected. And it sounds logical.
Without a doubt, geodata helped us to improve our model.
**Thanks for reading!**
P.S.
----
Our journey is not finished yet. 86% accuracy is a tremendous result for real data. Meanwhile, here is a small gap between 14% and 10% of mean error, which we expect. In the next chapter of our story, we will try to overcome this barrier or at least to decrease this error.
[There](https://github.com/VeeSot/flats/blob/master/part2.ipynb) is the IPython-notebook | https://habr.com/ru/post/470710/ | null | en | null |
# Как найти все битые ссылки на странице с помощью Selenium
Когда вам нужно проверить все ссылки в вашем проекте, вы можете сделать это с помощью Postman или любого другого инструмента тестирования API, но есть более простой способ. Когда вы используете инструменты тестирования API, вам нужно написать все соединения ссылок один за другим, а когда ссылки меняются, вам нужно снова редактировать все тесты один за другим.
Теперь с помощью этого java-кода вы можете проверить все ссылки. Эти ссылки могут быть ссылками pdf, изображения, видео или фотографии.
**Шаг 1:** В HTML мы связываем ссылки с помощью этого кода: это означает, что мы должны собрать все ссылки на веб-странице на основе . Для этого мы используем этот код:
```
List allLinks = driver.findElements(By.tagName(LINKS\_TAG));
```
`LINKS_TAG` - это "a". В конце страницы я добавлю весь код.
**Шаг 2:** Определение и проверка URL-адреса
```
String urlLink = link.getAttribute(LINKS_ATTRIBUTE);
```
`LINKS_ATTRIBUTE` - это "href"
**Шаг 3**: Отправка HTTP-запроса и считывание кодов HTTP-ответов
Мы создаем HttpConnection с параметром URL. Я добавил также Connection Timeout.
```
URL url = new URL(urlLink);
HttpURLConnection httpURLConnect=(HttpURLConnection)url.openConnection();
httpURLConnect.setConnectTimeout(5000);
httpURLConnect.connect();
```
* Информационные коды ответов: 100-199
* Коды успешного ответа: 200-299
* Редирект коды: 300-399
* Коды ошибок клиента: 400-499
* Коды ошибок сервера: 500-599
В принципе, мы можем сказать, что если код ответа больше или равен 400, то в этом случае соединение прервано.
```
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.List;
public class FindAllBrokenLinks {
public final String DRIVER_PATH = "Drivers/chromedriver";
public final String DRIVER_TYPE = "webdriver.chrome.driver";
public WebDriver driver;
public final String BASE_URL = "https://www.bbc.com/";
public final String LINKS_ATTRIBUTE = "href";
public final String LINKS_TAG = "a";
@BeforeTest
public void beforeTest(){
ChromeOptions options = new ChromeOptions();
options.addArguments("--disable-notifications","--ignore-certificate-errors","--disable-extensions");
System.setProperty(DRIVER_TYPE,DRIVER_PATH);
driver = new ChromeDriver(options);
driver.manage().window().maximize();
driver.get(BASE_URL);
}
@Test
public void FindAllBrokenLinks() throws Exception{
List allLinks = driver.findElements(By.tagName(LINKS\_TAG));
for(WebElement link:allLinks){
try {
String urlLink = link.getAttribute(LINKS\_ATTRIBUTE);
URL url = new URL(urlLink);
HttpURLConnection httpURLConnect=(HttpURLConnection)url.openConnection();
httpURLConnect.setConnectTimeout(5000);
httpURLConnect.connect();
if(httpURLConnect.getResponseCode()>=400)
{
System.out.println(urlLink+" - "+httpURLConnect.getResponseMessage()+"is a broken link");
}
else{
System.out.println(urlLink+" - "+httpURLConnect.getResponseMessage());
}
}catch (Exception e) {
}
}
}
@AfterClass
public void CloseDriver(){
driver.close();
}
}
```
Я использовал URL веб-страницы BBC в качестве базового URL, но запуск этого кода занял 1 минуту и 49 секунд. :) Возможно, вам стоит выбрать другой сайт.
Вот некоторые результаты тестов:
<https://www.bbc.com/sport> — OK
<https://www.bbc.com/reel> — OK
<https://www.bbc.com/worklife> — OK
<https://www.bbc.com/travel> — Временно приостановил работу
<https://www.bbc.com/future> — OK
<https://www.bbc.com/culture> — OK
<https://www.bbc.com/culture/music> — OK
<http://www.bbc.co.uk/worldserviceradio/> — Не доступен
<http://www.bbc.co.uk/programmes/p00wf2qw> — Не доступен
<https://www.bbc.com/news/world-europe-57039362> — OK
---
> Перевод подготовлен в рамках набора учащихся на курс [**"Java QA Automation Engineer"**](https://otus.pw/gYvl/). Если вам интересно узнать о курсе подробнее, а также познакомиться с преподавателем, приглашаем на [день открытых дверей](https://otus.pw/CJ11/) онлайн.
>
> | https://habr.com/ru/post/560170/ | null | ru | null |
# Введение в Spring Data JDBC
> **Для будущих студентов курса** [**"Java Developer. Professional"**](https://otus.pw/FUU0/) **подготовили перевод полезного материала.
>
> Также приглашаем принять участие в открытом уроке на тему** [**"Введение в Spring Data jdbc"**](https://otus.pw/z6ET/)
>
>
---
Spring Data JDBC был [анонсирован](https://spring.io/blog/2018/09/17/introducing-spring-data-jdbc) в 2018 году. Целью было предоставить разработчикам более простую альтернативу JPA, продолжая при этом следовать принципам Spring Data. Подробнее узнать о мотивах, лежащих в основе проекта, вы можете в [документации](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#jdbc.why).
В этой статье я покажу несколько примеров использования Spring Data JDBC. Здесь не будет подробного руководства, но, надеюсь, приведенной информации хватит, чтобы попробовать его самостоятельно. Очень хорошо, если вы уже знакомы со Spring Data JPA. Исходный код вы можете найти в [github](https://github.com/lumberjackdev/getting-started-spring-data-jdbc).
Для быстрого старта я использовал [этот шаблон](https://github.com/lumberjackdev/spring-boot-java-11-postgres-template).
#### Предварительная подготовка
Из зависимостей нам нужны `data-jdbc` — стартер, `flyway` для управления схемой и драйвер `postgres` для подключения к базе данных.
```
// build.gradle
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-data-jdbc'
implementation 'org.flywaydb:flyway-core'
runtimeOnly 'org.postgresql:postgresql'
}
```
Далее настраиваем приложение для подключения к базе данных:
```
# application.yml
spring:
application:
name: template-app
datasource:
url: jdbc:postgresql://localhost:5432/demo_app?currentSchema=app
username: app_user
password: change_me
driver-class-name: org.postgresql.Driver
```
#### Маппинг сущностей
Для этого примера будем использовать следующую таблицу:
```
create table book (
id varchar(32) not null,
title varchar(255) not null,
author varchar(255),
isbn varchar(15),
published_date date,
page_count integer,
primary key (id)
);
```
И соответствующий java-класс (обратите внимание, что `@Id` импортируется из `org.springframework.data.annotation.Id`):
```
// Book.java
public class Book {
@Id
private String id;
private String title;
private String author;
private String isbn;
private Instant publishedDate;
private Integer pageCount;
}
```
*Однако, если мы запустим* [*тест*](https://github.com/lumberjackdev/getting-started-spring-data-jdbc/blob/master/src/test/java/com/lumberjackdev/jdbcexample/repository/BookRepositoryTest.java)*:*
```
// BookRepositoryTest.java
@Test
void canSaveBook() {
var book = Book.builder().author("Steven Erikson").title("Gardens of the Moon").build();
var savedBook = bookRepository.save(book);
assertThat(savedBook.getId()).isNotBlank();
assertThat(savedBook.getAuthor()).isEqualTo(book.getAuthor());
assertThat(savedBook.getTitle()).isEqualTo(book.getTitle());
assertThat(savedBook).isEqualTo(bookRepository.findById(savedBook.getId()).get());
}
```
То увидим ошибку — ERROR: null value in column "id" violates not-null constraint. Это происходит, потому что мы не определили ни способ генерации id ни значение по умолчанию. Поведение Spring Data JDBC в части идентификаторов [немного отличается](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#jdbc.entity-persistence.id-generation) от Spring Data JPA. В нашем примере нужно определить `ApplicationListener` для `BeforeSaveEvent`:
```
// PersistenceConfig.java
@Bean
public ApplicationListener idGenerator() {
return event -> {
var entity = event.getEntity();
if (entity instanceof Book) {
((Book) entity).setId(UUID.randomUUID().toString());
}
};
}
```
Теперь тест пройдет, потому что поле Id заполняется. Полный список поддерживаемых событий жизненного цикла смотрите в [документации](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#jdbc.events).
### Методы запросов
Одной из особенностей проектов Spring Data является возможность определять методы запросов в репозиториях. Spring Data JDBC использует здесь несколько иной подход. Для демонстрации определим метод запроса в `BookRepository`:
```
Optional findByTitle(String title);
```
И если запустим соответствующий тест:
```
@Test
void canFindBookByTitle() {
var title = "Gardens of the Moon";
var book = Book.builder().author("Steven Erikson").title(title).build();
var savedBook = bookRepository.save(book);
assertThat(bookRepository.findByTitle(title).get()).isEqualTo(savedBook);
}
```
Получим ошибку — `Caused by: java.lang.IllegalStateException: No query specified on findByTitle`. В настоящее время Spring Data JDBC [поддерживает](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#jdbc.query-methods.at-query) только явные запросы, задаваемые через @Query. Напишем sql-запрос для нашего метода:
```
@Query("select * from Book b where b.title = :title")
Optional findByTitle(@Param("title") String title);
```
Тест пройден! Не забывайте об этом при создании репозиториев.
Примечание переводчика: в [Spring Data JDBC 2.0](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#new-features.2-0-0) появилась поддержка генерации запросов по [именам методов](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#jdbc.query-methods).
### Связи
Для работы со связями Spring Data JDBC также использует другой подход. Основное отличие в том, что отсутствует ленивая загрузка. Поэтому если вам не нужна связь в сущности, то просто не добавляйте ее туда. Такой подход основан на одной из концепций предметно-ориентированного проектирования (Domain Driven Design), согласно которой сущности, которые мы загружаем, являются корнями агрегатов, поэтому проектировать надо так, чтобы корни агрегатов тянули за собой загрузку других классов.
#### Один-к-одному
Для связей "один-к-одному" и "один-ко-многим" используется аннотация `@MappedCollection`. Сначала посмотрим на "один-к-одному". Класс `UserAccount` будет ссылаться на `Address`. Вот соответствующий sql:
```
create table address
(
id varchar(36) not null,
city varchar(255),
state varchar(255),
street varchar(255),
zipcode varchar(255),
primary key (id)
);
create table user_account
(
id varchar(36) not null,
name varchar(255) not null,
email varchar(255) not null,
address_id varchar(36),
primary key (id),
constraint fk_user_account_address_id foreign key (address_id) references address (id)
);
```
Класс `UserAccount` выглядит примерно так:
```
// UserAccount.java
public class UserAccount implements GeneratedId {
// ...other fields
@MappedCollection(idColumn = "id")
private Address address;
}
```
Здесь опущены другие поля, чтобы показать маппинг `address`. Значение в `idColumn` — это имя поля идентификатора класса `Address`. Обратите внимание, что в классе `Address` нет ссылки на класс `UserAccount`, поскольку агрегатом является `UserAccount`. Это продемонстрировано в тесте:
```
//UserAccountRepositoryTest.java
@Test
void canSaveUserWithAddress() {
var address = stubAddress();
var newUser = stubUser(address);
var savedUser = userAccountRepository.save(newUser);
assertThat(savedUser.getId()).isNotBlank();
assertThat(savedUser.getAddress().getId()).isNotBlank();
var foundUser = userAccountRepository.findById(savedUser.getId()).orElseThrow(IllegalStateException::new);
var foundAddress = addressRepository.findById(foundUser.getAddress().getId()).orElseThrow(IllegalStateException::new);
assertThat(foundUser).isEqualTo(savedUser);
assertThat(foundAddress).isEqualTo(savedUser.getAddress());
}
```
#### Один-ко-многим
Вот sql, который будем использовать для демонстрации связи "один-ко-многим":
```
create table warehouse
(
id varchar(36) not null,
location varchar(255),
primary key (id)
);
create table inventory_item
(
id varchar(36) not null,
name varchar(255),
count integer,
warehouse varchar(36),
primary key (id),
constraint fk_inventory_item_warehouse_id foreign key (warehouse) references warehouse (id)
);
```
В этом примере на складе (warehouse) есть много товаров/объектов (inventoryitems). Поэтому в классе `Warehouse` мы также будем использовать `@MappedCollection` для `InventoryItem`:
```
public class Warehouse {
// ...other fields
@MappedCollection
Set inventoryItems = new HashSet<>();
public void addInventoryItem(InventoryItem inventoryItem) {
var itemWithId = inventoryItem.toBuilder().id(UUID.randomUUID().toString()).build();
this.inventoryItems.add(itemWithId);
}
}
public class InventoryItem {
@Id
private String id;
private String name;
private int count;
}
```
В этом примере мы устанавливаем поле `id` во вспомогательном методе `addInventoryItem`. Можно также определить `ApplicationListener` для класса `Warehouse` с обработкой `BeforeSaveEvent`, в котором установить поле `id` для всех `InventoryItem`. Вам не обязательно делать в точности так, как сделано у меня. Посмотрите [тесты](https://github.com/lumberjackdev/getting-started-spring-data-jdbc/blob/master/src/test/java/com/lumberjackdev/jdbcexample/repository/WarehouseRepositoryTest.java) с демонстрацией некоторых особенностей поведения связи "один-ко-многим". Главное то, что сохранение или удаление экземпляра `Warehouse` влияет на соответствующие `InventoryItem`.
В нашем случае `InventoryItem` не должен знать о `Warehouse`. Таким образом, у этого класса есть только те поля, которые описывают его. В JPA принято делать двусторонние связи, но это может быть громоздким и провоцировать ошибки, если вы забудете поддерживать обе стороны связи. Spring Data JDBC способствует созданию только необходимых вам связей, поэтому обратная связь "многие-к-одному" здесь не используется.
#### Многие-к-одному и многие-ко-многим
В рамках этого руководства я не буду вдаваться в подробности о связях "многие-к-одному" или "многие ко многим". Я советую избегать связей "многие-ко-многим" и использовать их только в крайнем случае. Хотя иногда они могут быть неизбежны. Оба этих типа связей реализуются в Spring Data JDBC через ссылки на `Id` связанных сущностей. Поэтому имейте ввиду, что здесь вам предстоит еще немного потрудиться.
### Заключение
Если вы использовали Spring Data JPA, то большая часть из того, что я рассказал, должна быть вам знакома. Я уже упоминал ранее, что Spring Data JDBC стремится быть проще, и поэтому отсутствует ленивая загрузка. Помимо этого, отсутствует кеширование, отслеживание "грязных" объектов (dirty tracking) и сессии (session). Если в Spring Data JDBC вы загружаете объект, то он загружается полностью (включая связи) и сохраняется тогда, когда вы сохраняете его в репозиторий. Примеры, которые я показал, очень похожи на свои аналоги в JPA, но помните, что многие концепции Spring Data JPA отсутствуют в Spring Data JDBC.
В целом мне нравится Spring Data JDBC. Признаю, что это может быть не лучший выбор для всех приложений, однако я бы рекомендовал его попробовать. Как человек, который в прошлом боролся с ленивой загрузкой и dirty tracking, я ценю его простоту. Я думаю, что это хороший выбор для простых предметных областей, которые не требуют большого количества нестандартных запросов.
На этом пока все, спасибо за чтение! Надеюсь, вы нашли это руководство полезным и оно будет отправной точкой для использования Spring Data JDBC.
---
> [**Подробнее о курсе**](https://otus.pw/FUU0/) **"Java Developer. Professional"**
>
> [**Записаться на открытый урок**](https://otus.pw/z6ET/) **"Введение в Spring Data jdbc"**
>
> | https://habr.com/ru/post/531332/ | null | ru | null |
# Соглашения о вызовах
Что такое Calling Conventions?
------------------------------
Это стандартизированные методы реализации и вызова функций.
Соглашение о вызовах опредяют как функция вызывается, как функция управляет стеком и стековым кадром, как аргументы передаются в функцию, как функция возвращает значения.
Я разберу несколько наиболее часто используемых
stdcall (Standart Calling Convention)
-------------------------------------
STDCALL это стандартное соглашение для Win32 API. В данном соглашение, аргументы передаются справа налево и очистка стека ложится на вызываемую функцию. Для передачи аргументов используется стек, т.е. перед вызовом нужно положить аргументы на стек. Возвращаемое значение записывается в регистр eax.
Пример вызова абстрактной функции, которая принимает 3 4-байтовых аргумента.
```
PUSH 0x5
PUSH 0x4
PUSH 0x8
CALL _func@12
```
В вызываемой функции:
```
...
mov eax, 0x75 ; Записываем 0x75 в eax, т.е. в регистр, который отвечает за возвращаемое значение
...
ret 12 ; Очищаем стек на 12 байт (3 аргумента по 4 байта)
```
Давайте рассмотрим вызов функции MessageBox из Win32 API, используя NASM.
```
; Hello World with winapi messagebox using stdcall calling convention
extern _MessageBoxA@16
extern _ExitProcess@4
global _main
section .data
message db "Hello, Habr!", 0
title db "Habr!", 0
section .text
_main:
push dword 0x00
push dword title
push dword message
push dword 0
call _MessageBoxA@16
push 0
call _ExitProcess@4
```
Приведу пример вызова на языке программирования C.
```
MessageBox(0, message, title, MB_OK);
```
Разберем то, как мы передаем аргументы:
* Первые 4 строки - передача аргументов, согласно STDCALL, то есть справа налево.
Рассмотрим, какие аргументы требуются для вызова функции MessageBox:
```
int MessageBox(
[in, optional] HWND hWnd,
[in, optional] LPCTSTR lpText,
[in, optional] LPCTSTR lpCaption,
[in] UINT uType
);
```
MessageBox принимает 4 аргумента:
* HWND - Дескриптор родительского окна. Мы его оставляем 0, так как у нас его нет.
* lpText - Строка, которая будет выведена в окне. В нашем случае это "Hello, Habr!"
* lpCaption - Заголовок окна. В нашем случае это "Habr!"
* uType - Тип MessageBox'a. Мы указываем 0x00, то есть MESSAGEBOX\_OK. В окошке будет только одна кнопка - ОК.
> С другими типами MessageBox вы можете ознакомиться в [официальной документации](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-messagebox)
>
>
Мы видим в каком порядке принимаются параметры при вызове функции, но на стек мы кладем в обратном порядке, то есть первый аргумент, который мы кладем на стек - 0x00 - uType, второй ttl - lpCaption. Это и есть одна из особенностей данного соглашения о вызовах, вторая особенность - eax используется как регистр для возвращаемого значения.
Еще стоит упомянуть имена функций. Они начинаются с символа нижнего подчеркивания и заканчиваются на такую конструкцию "@[Количество байт, которые нужно выделить для аргументов.]"
cdecl (C calling convention)
----------------------------
Стандартное соглашение о вызовах для программ на C/C++.
В данном соглашение аргументы передаются справа налево и кладутся на стек, как и в [[#STDCALL Standart Calling Convention|stdcall]], возвращаемое значение кладется в регистр EAX. Но вот стек уже очищается функцией, которая вызывает. Имена функций начинаются с символа нижнего подчеркивания, без указания количества байт для аргументов к конце.
Пример:
```
push 18
push 19
call _add
add esp, 8
```
fastcall (Fast calling convention)
----------------------------------
Главным отличием от двух соглашениях выше является то, что аргументы кладутся в регистры, если это возможно, что позволяет увеличить скорость вызова функции, потому что обратиться к регистру быстрее, чем к стеку.
> Про память рекомендую посмотреть [это видео](https://www.youtube.com/watch?v=Wh22_O8jXVQ) от [AlekOs](https://www.youtube.com/c/AlekOS1)
>
>
Стоит указать, что в x86 только 2 регистра могут быть задействованы для передачи аргументов, остальные будут храниться в стеке.
Аргументы также передаются справа налево. Стек чистится вызываемой функцией.
Пример:
```
...
mov ecx, 0x3
mov edx, 0x1
call @sum@8
...
```
К названием функций добавляется @ в начале и следующая конструкция в конце "@[Количество байт, которые нужно выделить для аргументов.]"
thiscall
--------
Это соглашение о вызовах используется для вызова нестатических функций-членов C++.
Так как используется только для нестатических функций-членов, то у нас есть указатель this, который передается в ECX, стек очищается вызываемой функцией, аргументы передаются справа налево на стек, возвращаемое значение помещается в регистр EAX.
Пример:
```
mov ecx, SomeObj
push b
push a
call _MyMethod
```
vectorcall
----------
Это соглашение о вызовах, которое было выпущено для увеличения эффективности и скорости обработки, позволяя передавать векторные типы данных в регистры. (RCX/XMM0, RDX/XMM1, R8/XMM2, R9/XMM3 + XMM0-XMM5/YMM0-YMM5).
Стек очищается функцией, которая вызывает, аргументы передаются справа налево.
Итого
-----
Соглашение о вызове - описание правил вызова функций, в которое входит способы передачи аргументов, способы вызова, способы возврата значения, именования функций и очистки памяти после завершения работы функции.
В компиляторе от Microsoft (cl) их можно использовать вот так:
* stdcall (/Gz)
* fastcall (/Gr)
* cdecl (/Gd)
* vectorcall (/Gv) | https://habr.com/ru/post/675774/ | null | ru | null |
# Язык R для пользователей Excel (бесплатный видео курс)
В связи с карантином многие сейчас львиную долю времени проводят дома, и это время можно, и даже нужно провести с пользой.
В начале карантина я решил довести до ума некоторые проекты начатые несколько месяцев назад. Одним из таких проектов был видео курс "Язык R для пользователей Excel". Этим курсом я хотел снизить порог вхождения в R, и немного восполнить существующий дефицит обучающих материалов по данной теме на русском языке.
Если всю работу с данными в компании, в котороый вы работаете принято по-прежнему вести в Excel, то предлагаю вам познакомится с более современным, и при этом совершенно бесплатным инструментом анализа данных.
Содержание
==========
*Если вы интересуетесь анализом данных возможно вам будут интересны мои [telegram](https://t.me/R4marketing) и [youtube](https://www.youtube.com/R4marketing/?sub_confirmation=1) каналы. Большая часть контента которых посвящены языку R.*
1. [Ссылки](#ssylki)
2. [О курсе](#o-kurse)
3. [Для кого этот курс](#dlya-kogo-etot-kurs)
4. [Программа курса](#programma-kursa)
4.1. [Урок 1: Установка языка R и среды разработки RStudio](#urok-1-ustanovka-yazyka-r-i-sredy-razrabotki-rstudio)
4.2. [Урок 2: Основные структуры данных в R](#urok-2-osnovnye-struktury-dannyh-v-r)
4.3. [Урок 3: Чтение данных из TSV, CSV, Excel файлов и Google Таблиц](#urok-3-chtenie-dannyh-iz-tsv-csv-excel-faylov-i-google-tablic)
4.4. [Урок 4: Фильтрация строк, выбор и переименование столбцов, пайпланы в R](#urok-4-filtraciya-strok-vybor-i-pereimenovanie-stolbcov-payplany-v-r)
4.5. [Урок 5: Добавление вычисляемых столбцов в таблицу на языке R](#urok-5-dobavlenie-vychislyaemyh-stolbcov-v-tablicu-na-yazyke-r)
4.6. [Урок 6: Группировка и агрегация данных на языке R](#urok-6-gruppirovka-i-agregaciya-dannyh-na-yazyke-r)
4.7. [Урок 7: Вертикальное и горизонтальное объединение таблиц на языке R](#urok-7-vertikalnoe-i-gorizontalnoe-obedinenie-tablic-na-yazyke-r)
4.8. [Урок 8: Оконные функции в R](#urok-8-okonnye-funkcii-v-r)
4.9. [Урок 9: Вращение таблиц или аналог сводных таблиц в R](#urok-9-vraschenie-tablic-ili-analog-svodnyh-tablic-v-r)
4.10. [Урок 10: Загрузка JSON файлов в R и преобразование списков в таблицы](#urok-10-zagruzka-json-faylov-v-r-i-preobrazovanie-spiskov-v-tablicy)
4.11. [Урок 11: Быстрое построение графиков с помощью функции qplot()](#urok-11-bystroe-postroenie-grafikov-s-pomoschyu-funkcii-qplot)
4.12. [Урок 12: Построение графиков слой за слоем с помощью пакета ggplot2](#urok-12-postroenie-grafikov-sloy-za-sloem-s-pomoschyu-paketa-ggplot2)
4.13. [Урок 13: Изменение элементов графика и применение тем в ggplot2](#urok-13-izmenenie-elementov-grafika-i-primenenie-tem-v-ggplot2)
5. [Заключение](#zaklyuchenie)
Ссылки
======
* [Подписаться на YouTube канал](https://www.youtube.com/R4marketing/?sub_confirmation=1)
* [Плей лист курса на YouTube](https://www.youtube.com/playlist?list=PLD2LDq8edf4pgGg16wYMobvIYy_0MI0kF)
* [Репозиторйи с материалами](https://github.com/selesnow/r4excel_users/)
* [Страница курса](http://selesnow.github.io/r4excel_users)
О курсе
=======
Курс построен вокруг архитектуры `tidyverse`, и входящих в неё пакетов: `readr`, `vroom`, `dplyr`, `tidyr`, `ggplot2`. Конечно в R есть и другие хорошие пакеты выполняющие подобные операции, например `data.table`, но синтаксис `tidyverse` интуитивно понятен, его легко читать даже неподготовленному пользователю, поэтому я думаю, что начинать обучение языку R лучше именно с `tidyverse`.
Курс проведёт вас через все операции анализа данных, от загрузки до визуализации готового результата.
Почему именно язык R, а не Python? Потому, что R функциональный язык, пользователям Excel на него перейти легче, т.к. не надо вникать в традиционное объектно-ориентированное программирование.
На данный момент запланировано 13 видео уроков длительностью от 5 до 20 минут каждый.
Уроки будут открываться постепенно. Каждый понедельник я буду открывать доступ к новому уроку у себя на [YouTube канале](https://www.youtube.com/R4marketing/?sub_confirmation=1) в отдельном плей листе.
Для кого этот курс
==================
Думаю это понятно из названия, тем не менее опишу более подробно.
Курс ориентирован на тех, кто в работе активно использует Microsoft Excel и там же реализует всю работу с данными. В общем, если вы открываете приложение Microsoft Excel хотя бы раз в неделю то курс вам подойдёт.
Навыков программирования для прохождения курса от вас не требуется, т.к. курс ориентирован на начинающих.
Но, возможно начиная с 4 урока найдётся материал интересный и для активных пользователей R, т.к. основной функционал таких пакетов как `dplyr` и `tidyr` будет рассмотрен достаточно подробно.
Программа курса
===============
---
### Урок 1: Установка языка R и среды разработки RStudio
**Дата публикации:** 23 марта 2020
**Ссылки:**
* [Видео](https://www.youtube.com/watch?v=wFUoaeGEMmY&list=PLD2LDq8edf4pgGg16wYMobvIYy_0MI0kF&index=2&t=0s)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-1)
* [Скачать язык R](https://cran.r-project.org/)
* [Скачать RStudio](https://rstudio.com/products/rstudio/download/)
**Видео:**
**Описание:**
Вступительный урок в ходе которого мы скачаем и установим необходимое программное обеспечение, и немного разберём возможности и интерфейс среды разработки RStudio.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-1) на тест для проверки знаний.
---
### Урок 2: Основные структуры данных в R
**Дата публикации:** 30 марта 2020
**Ссылки:**
* [Видео](https://youtu.be/GwqoGHa8wjQ)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-2)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_2)
**Видео:**
**Описание:**
Этот урок поможет вам разобраться с тем, какие структуры данных есть в языке R. Мы подробно разберём векторы, дата фреймы и списки. Научимся их создавать и обращаться к их отдельным элементам.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-2) на тест для проверки знаний.
---
### Урок 3: Чтение данных из TSV, CSV, Excel файлов и Google Таблиц
**Дата публикации:** 6 апреля 2020
**Ссылки:**
* [Видео](https://youtu.be/vVFFtgcBp-w)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-3)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_3)
**Видео:**
**Описание:**
Работа с данными, не зависимо от инструмента, начинается с их добычи. В ходе урока используются пакеты `vroom`, `readxl`, `googlesheets4` для загрузки данных в среду R из csv, tsv, Excel файлов и Google Таблиц.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-3) на тест для проверки знаний.
---
### Урок 4: Фильтрация строк, выбор и переименование столбцов, пайпланы в R
**Дата публикации:** 13 апреля 2020
**Ссылки:**
* [Видео](https://youtu.be/uI0fc3foQQE)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-4)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_4)
**Видео:**
**Описание:**
Этот урок посвящён пакету `dplyr`. В нём мы разберёмся как фильтровать датафреймы, выбирать нужные столбцы и переименовывать их.
Также узнаем что такое пайпланы и как они помогают делать ваш код на языке R более читабельным.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-4) на тест для проверки знаний.
---
### Урок 5: Добавление вычисляемых столбцов в таблицу на языке R
**Дата публикации:** 20 апреля 2020
**Ссылки:**
* [Видео](https://youtu.be/lYYOKPcJ6Gc)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-5)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_5)
**Видео:**
**Описание:**
В этом видео мы продолжаем знакомство с библиотекой `tidyverse` и пакетом `dplyr`.
Разберём семейство функций `mutate()`, и научимся с их помощью добавлять в таблицу новые вычисляемые столбцы.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-5) на тест для проверки знаний.
---
### Урок 6: Группировка и агрегация данных на языке R
**Дата публикации:** 27 апреля 2020
**Ссылки:**
* [Видео](https://youtu.be/7zyL5apWm1M)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-6)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_6)
**Видео:**
**Описание:**
Данный урок посвящён одной из основных операций анализа данных, группировке и агрегации. В ходе урока мы будем использовать пакет `dplyr` и функции `group_by()` и `summarise()`.
Мы рассмотрим всё семейство функций `summarise()`, т.е. `summarise()`, `summarise_if()` и `summarise_at()`.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-6) на тест для проверки знаний.
---
### Урок 7: Вертикальное и горизонтальное объединение таблиц на языке R
**Дата публикации:** 4 мая 2020
**Ссылки:**
* [Видео](https://youtu.be/oCU30z-_qUQ)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-7)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_7)
**Видео:**
**Описание:**
Этот урок поможет вам разобраться с операциями вертикального и горизонтального объединения таблиц.
Вертикальное объединение является аналогом операции UNION в языке запросов SQL.
Горизонтальное объединение пользователям Excel более известно благодаря функции ВПР, в SQL такие операции осуществляются оператором JOIN.
В ходе урока мы решим практическую задачу, в ходе которой будем использовать пакеты `dplyr`, `readxl`, `tidyr` и `stringr`.
Основные функции которые мы рассмотрим:
* `bind_rows()` — вертикальное объединение таблиц
* `left_join()` — горизонтальное объединение таблиц
* `semi_join()` — включающее объединение таблиц
* `anti_join()` — исключающее объединение таблиц
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-7) на тест для проверки знаний.
---
### Урок 8: Оконные функции в R
**Дата публикации:** 11 мая 2020
**Ссылки:**
* [Видео](https://youtu.be/SS0LRdmyvvY)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-8)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_8)
**Видео:**
**Описание:**
Оконные функции по смыслу похожи на агрегирующие, они также принимают на вход массив значений и проводят над ними арифметические операции, но в исходящем результате не изменяют количество строк.
В этом уроке мы продолжаем изучать пакет `dplyr`, и функции `group_by()`, `mutate()`, а также новые `cumsum()`, `lag()`, `lead()` и `arrange()`.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-8) на тест для проверки знаний.
---
### Урок 9: Вращение таблиц или аналог сводных таблиц в R
**Дата публикации:** 18 мая 2020
**Ссылки:**
* [Видео](https://youtu.be/C72nlpBo9Cc)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-9)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_9)
**Видео:**
**Описание:**
Большинство пользователей Excel используют сводные таблицы, это удобный инструмент с помощью которого вы можете в считанные секунды превратить массив сырых данных в читабельные отчёты.
В этом уроке мы разберёмся с тем как вращать таблицы в R, и преобразовывать их из широко формата в длинный и наоборот.
Большая часть урока посвящена пакету `tidyr` и функциям `pivot_longer()` и `pivot_wider()`.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-9) на тест для проверки знаний.
---
### Урок 10: Загрузка JSON файлов в R и преобразование списков в таблицы
**Дата публикации:** 25 мая 2020
**Ссылки:**
* [Видео](https://youtu.be/jMTx34aGhw4)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-10)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_10)
**Видео:**
**Описание:**
JSON и XML являются чрезвычайно популярными форматами хранения и обмена информацией, как правило, за счёт своей компактности.
Но анализировать данные представленные в таких форматах сложно, поэтому их перед анализом необходимо привести к табличному виду, именно этому мы и научимся в данном видео.
Урок посвящён пакету `tidyr`, входящему в ядро библиотеки `tidyverse`, и функциям `unnest_longer()`, `unnest_wider()` и `hoist()`.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-10) на тест для проверки знаний.
---
### Урок 11: Быстрое построение графиков с помощью функции qplot()
**Дата публикации:** 1 июня 2020
**Ссылки:**
* [Видео](https://youtu.be/bWaYo5cU6rk)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-11)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_11)
**Видео:**
**Описание:**
Пакет `ggplot2` является одним из наиболее популярных средств визуализации данных не только в R.
В этом уроке мы научимся построению простейших графиков с помощью функции `qplot()`, и разберём все её аргументы.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-11) на тест для проверки знаний.
---
### Урок 12: Построение графиков слой за слоем с помощью пакета ggplot2
**Дата публикации:** 8 июня 2020
**Ссылки:**
* [Видео](https://www.youtube.com/watch?v=9CDDKaZOp7M)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-12)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_12)
**Видео:**
**Описание:**
В уроке продемонстрирована вся мощь пакета `ggplot2` и заложенной в него грамматики построения графиков слоями.
Мы разберём основные геометрии которые присутствуют в пакете и научимся накладывать слои для построения графика.
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-12) на тест для проверки знаний.
---
### Урок 13: Изменение элементов графика и применение тем в ggplot2
**Дата публикации:** 15 июня 2020
**Ссылки:**
* [Видео](https://youtu.be/8ZXzWx7gx4Q)
* [Тест](https://onlinetestpad.com/t/rlanguage4excelusers-13)
* [Материалы](https://github.com/selesnow/r4excel_users/tree/master/lesson_13)
**Описание:**
Заключительный урок курса посвящён приведению готовых графиков к корпоративному стилю, мы научимся применять готовые темы из пакетов `ggthemes` и `ggthemr`, и разберёмся со слоем `theme()`.
**Видео:**
**Тест**
[Ссылка](https://onlinetestpad.com/t/rlanguage4excelusers-13) на тест для проверки знаний.
---
Заключение
==========
Я старался подойти к формированию программы курса максимально лаконично, выделить только самую необходимую информацию которая понадобится вам для того, что бы сделать первые шаги в изучении такого мощного инструмента анализа данных как язык R.
Курс не является исчерпывающим руководством по анализу данных с помощью языка R, но поможет вам разобраться со всеми необходимыми для этого приёмами.
Пока программа курса рассчитана на 12 недель, каждую неделю, по понедельникам я буду открывать доступ к новым урокам, поэтому рекомендую [подписаться](https://www.youtube.com/R4marketing/?sub_confirmation=1) на YouTube канал, что бы не пропустить публикацию нового урока. | https://habr.com/ru/post/495438/ | null | ru | null |
# Асинхронное программирование на JavaScript — Остаться в живых
Программисты принимают некоторые особенности как должное — последовательное программирование, к примеру, при записи алгоритма, который делает один шаг только после другого.
Однако, если вы пишете код на JavaScript, который использует блокирующийся ввод/вывод или другие длительные операции, о последовательном кодировании не может быть и речи, так как блокирование единственного потока исполнения в системе является очень плохой идеей. Решение состоит в реализации алгоритмов с использованием асинхронных обратных вызовов, то есть, в разбиении последовательного кода на несколько обратных вызовов.
Это решает проблему, но означает, что мы теряем способность записывать последовательный алгоритм, а нетривиальный последовательный код преобразуется в граф функций обратного вызова.
Это становится ещё более критичным для приложений большого масштаба, которые широко используют асинхронность. Использование передачи функций обратного вызова для асинхронных действий не очень удобно и может создавать сложные процессы передачи обратных вызовов в связи с необходимостью обрабатывать возвращаемые значения.
Сообщество JavaScript в курсе этого, особенно сообщество Node.JS, так как Node.JS ставит акцент на асинхронном коде.
[Группа CommonJS](http://wiki.commonjs.org/wiki/CommonJS) ответила на этот вызов в форме [Promises](http://wiki.commonjs.org/wiki/Promises) (Обещаний), которые нацелены на обеспечение интерфейса для взаимодействия с объектом, который представляет собой результат действия, которое выполняется асинхронно, и может или не может быть закончено в любой данный момент времени.
Таким образом, различные компоненты могут вернуть обещания для асинхронных действий и потребители могут использовать обещания предсказуемым образом. Обещания можем также обеспечить фундаментальную сущность, чтобы быть использованными для более удобного синтаксически уровня расширений языка, которые помогают работать с асинхронностью.
[Stratified JavaScript](http://www.infoq.com/articles/stratifiedjs) — другой подход, предлагающий упростить программирование с помощью надмножества языка JavaScript. Но если вы не можете менять языки программирования, можно использовать гибкий API, который позволяет эмулировать последовательный код. Если этот API позволяет использовать краткие обозначения, его часто называют встроенным DSL.
InfoQ решил взглянуть на список этих API и DSL, и пообщаться с их создателями о том, как они подошли к проблеме, о принципах проектирования, о парадигмах, которым они следуют, и о многом другом. И, конечно, — об ограничениях этих решений.
В частности, InfoQ связался c:
* Tim Caswell из [Step](https://github.com/creationix/step),
* Will Conant из [Flow-js](https://github.com/willconant/flow-js),
* Kris Zyp из [node-promise](https://github.com/kriszyp/node-promise),
* Caolan McMahon из [Async](https://github.com/caolan/async),
* Fabian Jakobs из [Async.js](https://github.com/fjakobs/async.js),
* AJ O'Neal из [FuturesJS](https://github.com/coolaj86/futures) и
* Isaac Z. Schlueter из [slide-flow-control](https://github.com/isaacs/slide-flow-control)
**InfoQ: На решении каких проблем сосредоточена ваша библиотека? То есть, она сосредоточена главным образом на удалении шаблонного кода, уходе от ручной обработки асинхронного ввода/вывода, или же она также обеспечивает дирижирование или другой функционал (например, чтобы помочь с одновременной обработкой нескольких I/O-вызовов с ожиданием результатов их выполнения, и так далее).**
> **Tim (Step)**: Цели Step состоят как в удалении шаблонного кода, так и в большей читаемости асинхронного кода. Наша библиотека весьма минималистична, и не делает ничего, что вы не можете повторить вручную с обильным использованием блоков try..catch и переменных-счётчиков. Особенностью нашей библиотеки является простое формирование цепочек последовательных вызовов с опциональными группами параллельных вызовов на каждом шаге.
>
>
> **Will (Flow-js)**: Flow-JS предоставляет конструкцию JavaScript, которая похожа на continuation (преемственность) или fiber (волокно), существующие в других языках програмирования. Практически, она может быть использована для уничтожения так называемых «пирамид» из вашей многошаговой асинхронной логики. Вместо того, чтобы непосредственно использовать литералы вложенных функций обратного вызова, вы используете специальное значение «this» как функцию обратного вызова для следующей функции, указанной в определении потока исполнения.
>
>
> **Kris Zyp (node-promise)**: Проблема в том, что типичный стиль потока выполнения обратных вызовов (стиль передачи преемственности) объединяет усложнение интерфейса и смешивание функциональных параметров с обработчиками результатов. Promises (обещания) инкапсулируют событийное завершение вычисления, позволяя функциям/методам исполняться с чистыми входными параметрами, в то время, как возвращаемое значение, как обещание, хранит результат.
>
>
>
> Я объяснил эти принципы чуть подробнее [здесь](http://www.sitepen.com/blog/2010/05/03/robust-promises-with-dojo-deferred-1-5/) и [здесь](http://www.sitepen.com/blog/2010/09/20/promised-io/).
>
>
>
> Инкапсулируя событийное вычисление, обещания прекрасно работают для дирижирования параллельными и последовательными действиями, даже со сложной условной логикой. Библиотека node-promise включает функции, чтобы выполнять это просто (функции all() и step() в promised-io)
>
>
>
> Кстати, просто для информации, [promised-io](http://github.com/kriszyp/promised-io) фактически наследник node-promise. Она имеет тоже самое ядро, но promised-io также включает в себя функции ввода/вывода NodeJS в стиле обещаний, и в ней доступен слой нормализации платформы, который обеспечивает доступ к аналогичным функциям в браузере.
>
>
> **Caolan (Async)**: Да, основная задача состоит в удалении шаблонного кода. Код для вызова функций последовательно или параллельно, с последующим ожиданием обратных вызовов в JavaScript, довольно подробен, но очевиден. Вскоре после того, как node.js перешёл от обещаний к обратным вызовам в качестве базового механизма обработки асинхронности, я обнаружил, что я использую одни и те же шаблоны снова и снова. Казалось очевидным, что их нужно экстрагировать их в отдельную библиотеку.
>
>
>
> С тех пор она выросла, чтобы охватить более сложные возможности, которые позволяют дирижировать обратными вызовами на основе их зависимостей. По большей части, однако, это довольно низкоуровневая библиотека, которая оставляет общую структуру разработчикам. Тем не менее, я счёл, что JavaScript часто подходит для более функционального стиля программирования, и тут же добавил асинхронные версии map, reduce, filter и других обычных функций. Библиотека действительно проявляет свою силу, когда используется в таком стиле, и позволяет придерживаться обычных обратных вызовов без использования продолжений или объектов-обещаний.
>
>
> **Fabian (Async.js)**: Async.js пытается упростить стандартные асинхронные шаблоны в JavaScript. Её главное назначение — применить серию асинхронных функций к множеству однородных объектов. Она выросла из асинхронной функции forEach в набор обобщённых концепций. Это особенно удобно при асинхронной работе с файловой системой в node.js, хотя библиотека не привязана к node.js и может быть использована для любых других похожих случаев. Этот кусочек кода показывает применение async.js:
>
>
> ```
> async.readdir(__dirname)
> .stat()
> .filter(function(file) {
> return file.stat.isFile()
> })
> .readFile("utf8")
> .each(function(file) {
> console.log(file.data);
> })
> .end(function(err) {
> if (err)
> console.log("ERROR: ", err);
> else
> console.log("DONE");
> });
> ```
> Этот код оперирует всеми элементами текущего каталога. Это однородный набор объектов. Для каждого элемента в каталоге выполняется последовательность асинхронных операций. Сперва отфильтровываются все элементы, не являющиеся файлами, затем содержимое файлов читается с диска в кодировке utf-8 и печатается на консоль. После выполнения всех операций вызывается финальная функция обратного вызова с параметром-индикатором ошибки.
>
>
> **AJ (FuturesJS)**: Довольно сложно рассуждать об асинхронном и событийно-управляемом программировании.
>
>
>
> Я создал Futures в основном для:
>
>
>
> * предоставления одной библиотеки асинхронного потока управления как для браузера, так и для сервера (Node.JS);
> * публикации качественного шаблона обработки обратных вызовов и вызовов обработчиков ошибок;
> * контроля потока исполнения приложения, в котором события зависят друг от друга;
> * обработки обратных вызовов для множества ресурсов, таких, как мэш-апы;
> * поощрения использования передовых практик программирования, таких, как использование моделей и обработка ошибок.
>
>
>
>
>
> Futures.future и Futures.sequence просто сокращают количество шаблонного кода и предоставляют некоторую гибкость.
>
>
>
> Futures.join может подсоединять (в той же манере, как join работает для потоков исполнения операционной системы) или синхронизировать (для событий, которые случаются периодически) несколько объектов future.
>
>
>
> Futures.chainify делает простым создание асинхронных моделей, похоже на Twitter Anywhere API.
>
>
> **Isaac (slide-flow-control)**: Задача, решению которой посвящён slide, состоит в том, что мне было нужно что-то, о чём я бы мог рассказать на встрече OakJS, и не хотел придумывать какую-либо новую идею, так как я очень ленивый. В основном, я хотел не делать практически никакой работы, просто показать сделанное, выпить немного пива, полакомиться китайской кухней, пообщаться с интересными людьми, немного искупаться в положительном внимании, и затем вернуться домой. Соотношение объёма работы к полученному выигрышу очень важно для меня, как в программном обеспечении, так и в жизни. Таким образом, я просто скомпоновал вместе простые до ужаса вспомогательные асинхронные методы, которые я использую в npm, так, что они уместились в набор слайдов, назвал это «slide» из-за этой особенности, и представил эту библиотеку.
>
>
>
> Другая задача, которой посвящена эта библиотека, это показать, насколько легко написать свою собственную библиотеку управления потоком исполнения. Каждый считает, что его собственная библиотека — лучшая, так что важно просто дать людям несколько базовых шаблонов и позволить им созидать.
>
>
**InfoQ: Реализует ли библиотека идеи учёных компьютерной науки?**
> **Tim (Step)**: Напрямую — ничего.
>
>
> **Will (Flow-js)**: Не то, чтобы я знаю. Это был просто мой первый удар на создание бизнес-логики, которая упрощает выполнение множества синхронных вызовов внешних сервисов, управляемых из Node.js.
>
>
> **Kris Zyp (node-promise)**: Да, конечно. Большинство компьютерных научных исследований по асинхронному дизайну указывает на Promises (обещания) в различных формах, как наиболее подходящий механизм для функциональных потоков и правильного разделения интересов. Термин «promise» был первоначально предложен Daniel P. Friedman и David Wise, начиная с 1976 года. Вы можете узнать больше о богатой истории компьютерной науки относительно обещаний из [статьи на Википедии](http://en.wikipedia.org/wiki/Futures_and_promises).
>
>
> **Caolan (Async)**: У меня нет опыта в сфере компьютерной науки, и я реализовал библиотеку Async на чисто прагматической основе. Когда мне требовалась функция высшего порядка, чтобы вычистить немного асинхронности в JavaScript, и я использовал её неоднократно, она попадала в библиотеку.
>
>
> **Fabian (Async.js)**: Реализация async.js отдаленно напоминает [Монады Haskell](http://en.wikipedia.org/wiki/Monad_(functional_programming)), но это скорее случайно.
>
>
> **AJ (FuturesJS)**: Да. Наибольшее влияние оказали следующие материалы:
>
> * [Google's How to think about OO](http://googletesting.blogspot.com/2009/07/how-to-think-about-oo.html)
> * [Yahoo!s Crockford on JavaScript Act III](http://yuiblog.com/crockford/)
> * [Google's The Lazy Programmers Guide to Secure Computing](http://www.youtube.com/user/GoogleTechTalks#p/search/7/eL5o4PFuxTY)
>
>
>
> Лучшая вещь в асинхронном программировании, — это то, что оно естественным образом заставляет писать более модульный код, и если вы имеете асинхронные модели любого рода, то вы вынуждены следовать принципу всегда передавать параметры внутрь модели, и никогда не передавать данные, которые относятся к модели, за пределы этой модели.
>
>
> **Isaac (slide-flow-control)**: Она использует один из видов шаблона continuation. Множество исследований компьютерной науки упускают эту тему, я думаю. Это я тычу пальцем в Луну. Чтобы попасть туда, вам нужна ракета. Более длинные пальцы не помогут. Когда Вы осознаете это, более глубокие тайны проявят себя.
>
>
**InfoQ: Предлагает ли библиотека какие-либо стратегии обработки ошибок? Как она взаимодействует с выбрасыванием исключений?**
> **Tim (Step)**: Если исключение выбрасывается на любом шаге, оно ловится и передается следующему шагу как параметр-ошибка. Также любые не-неопределённые возвращаемые значения передаются на следующий шаг как параметр обратного вызова. Таким образом, шаги могут быть синхронными или асинхронными с использованием одного и того же синтаксиса.
>
>
> **Will (Flow-js)**: Flow-JS не имеет никакой встроенной обработки исключений, что определённо является её слабой стороной. Tim Caswell написал модуль, основанный на flow, под названием «Step», который обрамляет вызовы каждой из предоставленных функций в блоки try/catch и передаёт пойманные исключения следующей функции в последовательности.
>
>
> **Kris Zyp (node-promise)**: Да, promises спроектированы, чтобы предоставить асинхронный эквивалент синхронного потока выполнения. Как функция JavaScript может выбросить исключение или успешно вернуть значение, так и promise может быть разрешено к успешному значению или к состоянию ошибки. Обещания, возвращаемые вызывающим методам, могут распространять ошибки до тех пор, пока обработчик ошибок не «поймает» их, точно так же, как выброшенное исключение распространяется до тех пор, пока не будет поймано. Библиотека node-promise кроректно поддерживает эту концепцию, позволяя легко регистрировать обработчики ошибок или распространять ошибки до тех пор, пока они не будут пойманы (чтобы исключить ситуацию молчаливого проглатывания ошибок). Имея прямые синхронные эквиваленты обещаний, поток исполнения кода с использованием обещаний очень легко читать.
>
>
> **Caolan (Async)**: Обработка исключений с асинхронным кодом может быть немного сложнее, особенно если вы не знакомы с сильно асинхронными средами, такими, как node.js. Для меня, на самом деле, обработка ошибки важнее, чем стиль, который вы адаптируете для этой обработки. В браузере это особенно важно, поскольку в нём легко случайно поднять исключение до самого верхнего уровня, тем самым убив весь JavaScript на странице.
>
>
>
> Есть многое, что можно сказать по этому поводу. Обработка исключений должна быть прямой и желательно привычной, так чтобы было легко её реализовывать и становилось очевидно, если Вы забыли об этом. К сожалению, JavaScript в браузере не помогает нам в этом пока в достаточной мере, но node.js предоставил простую конвенцию, которая может быть легко использована в обеих средах.
>
>
>
> Библиотека Async приняла именно эту конвенцию, используя первый аргумент обратного вызова для передачи ошибки к следующему шагу в вашей программе. Если первый аргумент является null (или иным ложным значением), то его можно не учитывать, в противном случае оно рассматривается как исключение. Где это возможно, выполнение будет произведено библиотекой Async по сокращённой схеме, чтобы ускорить процесс. Если одна функция из выполняемой коллекции выполняется с ошибкой, то последующие функции в коллекции не будут выполнены.
>
>
> **Fabian (Async.js)**: Async.js построена с использованием конвенции обработки ошибок node.js. Первый аргумент любой функции обратного вызова зарезервирован за объектом ошибки. Если вычисление заканчивается ошибкой, или возникает исключение, ошибка/исключение передаются как первый аргумент в функцию обратного вызова. Async.js поддерживает две стратегии обработки ошибок, что может быть настроено через её API. В случае ошибки либо останавливается целиком операция над множеством, и вызывается обработчик ошибок, либо ошибочный элемент пропускается.
>
>
> **AJ (FuturesJS)**: Так как исключения не могут быть «выброшены» асинхронно, вместо этого пользователю предлагается передавать любые исключения как первый параметр в функцию обратного вызова.
>
>
>
> Основная идея, — выполнить try {} catch(e) {} для ошибки, и передать ошибку, вместо того, чтобы остановить приложение в какой-то неопределённый момент времени. Futures.asyncify() делает это для того, чтобы использовать синхронные функции в доминирующем асинхронном окружении.
>
>
>
> Здесь пример:
> ```
>
> (function () {
> "use strict";
>
> var Futures = require('futures'),
> doStuffSync,
> doStuff;
>
> doStuffSync = function () {
> if (2 % Math.floor(Math.random()*11)) {
> throw new Error("Some Error");
> }
>
> return "Some Data";
> };
>
> doStuff = Futures.asyncify(doStuffSync);
>
> doStuff.whenever(function (err, data) {
> if (err) {
> console.log(err);
> return;
> }
> console.log(data);
> });
>
> doStuff();
> doStuff();
> doStuff();
> doStuff();
> }());
>
> ```
>
>
>
> **Isaac (slide-flow-control)**: Никогда не бросайте исключения! Никогда! Выбрасывание исключения является злом. Не делайте этого. Когда вызывается функция обратного вызова, первым аргументом будет либо ошибка, либо null. Если это ошибка, обработайте её, или передайте функции обратного вызова для обработки. Передавайте ошибку первым параметром вашей функции обратного вызова, чтобы сигнализировать о появлении ошибки.
>
>
**InfoQ: Был ли вдохновитель или под каким влиянием была создана ваша библиотека (например, F# Workflows, Rx (версия для Javascript), или другие проекты)?**
> **Tim (Step)**: Да, стиль был заимствован напрямую из проекта [flow-js](https://github.com/willconant/flow-js).
>
>
> **Will (Flow-js)**: Не совсем. Это было просто первое решение, которое пришло мне в голову.
>
>
> **Kris Zyp (node-promise)**: На библиотеку node-promise повлияли язык программирования E от Mark Miller и использование обещаний в нём, библиотека ref\_send от Tyler Close, библиотека Q от Kris Kowal, библиотека NarrativeJS от Neil Mix, реализации Deferred в каркасах Twisted и Dojo, и многие другие библиотеки.
>
>
> **Caolan (Async)**: Я боюсь, что так как я не использовал F# или Rx, то я не могу выразить своё отношение к этим проектам. Однако, я черпал вдохновение из Underscore.js, отличной функциональной библиотеки для программирования на JavaScript. Большинство функций, которые используют итераторы, из Underscore были изменены, чтобы начать работать асинхронно с обратными вызовами, и внедрены в библиотеку Async.
>
>
> **Fabian (Async.js)**: Характерные цепочки вызовов в API были инспирированы jQuery. Одной из моих целей было предоставить jQuery-подобный API для модуля файловой системы node.js. Очень большое влияние также оказали [генераторы в стиле python](http://www.python.org/dev/peps/pep-0255/). Каждый элемент в цепочке генерирует значения, которые могут быть использованы последующими элементами цепочки. Вся операция вызывается последним элементов в цепочке, который «протягивает» значения через цепочку. С этой точки зрения async.js отличается от jQuery и Rx, где значения проталкиваются источником. Эта «тянущая» система делает возможным вычислять все значения лениво, а также позволяет создавать генераторы, которые возвращают бесконечное множество значений (к примеру, все чётные целые числа).
>
>
> **AJ (FuturesJS)**: Не сразу, нет.
>
>
>
> Я построил мэшап-сайт с использованием Facebook и Amazon, и моей первой попыткой стала мешанина, поскольку я просто не понимал, как работать с моделью, созданной из двух ресурсов (Я не был на самом деле хорошо знаком с JavaScript в то время; Я шёл путём проб и ошибок в стиле [«WTFJS»](http://wtfjs.com/) и использовал немного jQuery, чтобы упростить болезненную работу с DOM).
>
>
>
> Так я обнаружил, что легче всегда предполагать, что для получения любых данных может потребоваться некоторое время, чем когда-либо предпологать, что данные будут уже существовать при их необходимости, и затем понял, что нужно реорганизовать всю цепочку снизу вверх, чтобы любой конкретный набор данных мог быть обработан асинхронно.
>
>
>
> Я пробовал, терпел неудачи, и наполовину справился с использованием нескольких различных методов, и затем, к моей удаче, кто-то в рассылке [моей локальной группы пользователей JavaScript](https://groups.google.com/d/msg/ujsug/NBddMI5TV9M/14TI4HSYK2wJ) упомянул о [серии лекций Кроуфорда о JS](http://yuiblog.com/crockford). После просмотра всей серии (я смотрел третий раздел по крайней мере 3 раза) я, наконец, стал лучше понимать, как управлять «проблемами» (или, скорее, возможностями) асинхронного программирования. Далее я нашёл слайды Кроуфорда и начал с примера promises, который он привёл, как со своей стартовой точки.
>
>
>
> Позднее я начал играться с Node.JS, и вследствие этого изменил свою стратегию обработки ошибок (но документацию обновил только несколько дней назад). В Futures 2.0, которую я выпущу в ближайшее воскресенье, я также добавил EventEmitter из Node.JS для использования в браузере.
>
>
> **Isaac (slide-flow-control)**: Нет. Это было, я полагаю, вдохновлено шаблонами, к которым мы пришли в NodeJS для использования обратных вызовов. Я просто сторонник полноты, потому что я недостаточно умён, чтобы помнить более чем одного вида вещей (или, может быть двух, в хороший день, с большим количеством кофе) без того, чтобы запутываться и ходить в туалет, думая, что это ванная комната, а затем получив всю одежду пахнущей, как… Впрочем, Вы поняли идею.
>
>
>
> Использовать вещи одного типа, везде. Вот и все. Функции, которые принимают обратный вызов в качестве последнего аргумента. Функции обратного вызова, получающие сообщение об ошибке в качестве первого аргумента, или null/undefined, если все прошло успешно. Slide — это всего несколько вспомогательных функций, которые делают легче выполнение кучи вещей, используя эту схему.
>
>
**InfoQ: Существуют ли какие-либо новые возможности или изменения в языке JavaScript, которые могут сделать библиотеки лучше, например, позволят быть более кратким, и т.д.?**
> **Tim (Step)**: Возможно, но не без серьезных изменений в семантике языка. Может быть, препроцессор типа coffeescript может помочь с синтаксисом, но я думаю, что лучше придерживаться ванильного JavaScript большую часть времени.
>
>
> **Will (Flow-js)**: На мой взгляд, Javascript отчаянно нуждается в что-то вроде волокон из Ruby 1.9. Я провел много времени, работая с Node.js для моих будущих проектов, но в какой-то момент асинхронное программирование всегда заставляет мозг плавиться. Есть много инструментов для того, чтобы сделать его более управляемым, но я не могу доказать, но чувствую, что наличие столь большого числа библиотек, как Flow-js, является только свидетельством того, что Javascript на самом деле неудачен для параллельного программирования.
>
>
>
> Я знаю, что одной из целей Node было избежание модификаций в ядре JavaScript-движка V8, но, насколько я знаю, [ребята из Asana добавили волокна в ядро без особых проблем](http://asana.com/blog/?p=49).
>
>
> **Kris Zyp (node-promise)**: Да, недавно была [дискуссия вокруг одно-кадровых или мелких продолжений](https://mail.mozilla.org/pipermail/es-discuss/2010-March/010865.html), похожих на генераторы, которые могут помочь избежать необходимости обратного вызова, которые усложняют ветвление и циклы потоков. Это может быть использовано в сочетании с обещаниями для создания чрезвычайно простого и удобного для чтения асинхронного кода.
>
>
>
> Кстати, еще одно замечание, — библиотека node-promise также реализует спецификацию <http://wiki.commonjs.org/wiki/Promises/A>, то есть она может взаимодействовать с Dojo и, вероятно, с будущими JQuery promises.
>
>
> **Caolan (Async)**: библиотека Async была разработана, чтобы максимально использовать язык в его нынешнем виде. Для работы как есть, без попыток создать новый язык поверх JavaScript.
>
>
>
> Тем не менее, добавление yield в JavaScript 1.7 может иметь некоторые интересные приложения для будущих проектов. С использованием yield было бы возможно портировать некоторые Twisted-подобные функции на JavaScript для более синхронно-подобного стиля кодирования. Это то, что мой коллега изучает с [Whorl](https://github.com/Jc2k/whorl), хотя этот проект, похоже, перестал развиваться.
>
>
> **Fabian (Async.js)**: Стандартизация [генераторов и итераторов, поддерживаемых Mozilla](https://developer.mozilla.org/en/JavaScript/Guide/Iterators_and_Generators), может сделать код async.js более кратким и упростить проблемы асинхронности.
>
>
> **AJ (FuturesJS)**: Наиболее часто повторяющийся код в библиотеке, это тот, который делает одинаковой работу кода в браузере и в Node.JS. Я знаю, некоторые библиотеки (такие, как teleport) были созданы, чтобы попытаться решить этот вопрос, но я не игрался пока ни с одной из них. Это, конечно, было бы неплохо, если бы асинхронный require был встроен в язык.
>
>
>
> С моей точки зрения, язык с такой естественной асинхронностью, как JavaScript, должен иметь что-то похожее на фьючерсы, встроенным в ядро языка.
>
>
>
> Хотя CommonJS имеет [несколько предложений](http://wiki.commonjs.org/wiki/Promises) по стандартизации серверных promises, но в то время как их внимание больше уделено конфиденциальности данных, фьючерсы больше ориентированы на управление потоком, простоту использования конечными разработчиками и на совместимость с браузерами.
>
>
> **Isaac (slide-flow-control)**: Нет. Моя библиотека управления потоком лучшая. Она не может быть улучшена каким-либо иным способом, потому что эта лучшесть непосредственно связана с моей самостью, поэтому любое внешнее влияние сделало бы ее менее моей, и таким образом, менее лучшей. Если вы хотите получить опыт, я предлагаю вам написать свою библиотеку. Вы увидите, что она лучшая, сразу, как только вы её напишете. Если какой-либо другой библиотеке кажется, что что-то могло бы быть лучше, то вы можете торопиться обратно в редактор, скрывая свой стыд, и быстро переизобретать все свои идеи, но уже немного иначе, чем раньше, и тогда вы будете знать, в вашем сердце, что ваше новое сейчас лучшее.
>
> | https://habr.com/ru/post/111634/ | null | ru | null |
# К вопросу о сложении или как я нашел ошибку в gcc (на самом деле нет)
### Многие вещи нам непонятны не потому, что наши понятия слабы; но потому, что сии вещи не входят в круг наших понятий.
Вчера, просматривая новый комментарий к своему старому посту о реализации сдвигов компилятора gcc для МК, обратил внимание на интересную ссылку [godbolt.org/z/lW6rk8](https://godbolt.org/z/lW6rk8). На ней демонстрируется разница в коде, порождаемом компилятором для знаковых и без-знаковых кардинальных типов. Решил я немного поэкспериментировать с приведенным кодом и обнаружил интересные особенности компилятора, о которых и сообщаю сообществу.
Итак, мы видим две функции, которые сравнивают некую величину х и ее же, увеличенную на 1 и сообщают о том, какая из них больше. Подавляющее большинство читателей уже поняло, в чем дело, но для тех, кто забыл курс введения в программирование, напомню.
В обычной математике сама постановка задачи выглядит странно, если не вкладывать в понятие «больше» смысл, отличный от общепринятого. Естественно, что х+1>х, поскольку, если вычесть из обеих сторон неравенства х, получим тождество 1>0. При этом мы неявно постулируем, что для любого числа есть число, следующее за ним и количество возможных чисел бесконечно.
*Примечание на полях (Пнп): где-то я читал, что кто-то из великих (вроде как Гаусс) считал, что существует наибольшее целое число, но даже если это и так, наверняка он имел в виду что-то другое.*
Но в компьютерной математике не все так просто и проблема вытекает из ограниченности кардинальных типов, поскольку это означает конечное количество объектов, которые могут быть представлены конкретным типом при заданной кодировке. Среди них есть максимальное, в некотором смысле, число и попытка увеличить его приводит к парадоксу – требуется закодировать число, которое закодировать нельзя. Обычно такое явление называют переполнением разрядной сетки, или просто переполнением. Типичный пример: 255 для 8-битового числа.
*Пнп: В детстве у меня одной из любимых игрушек был арифмометр «Феликс» и постоянным развлечением было прибавление к «999999999» числа «000000001». Я завороженно наблюдал, как одна за другой девятки превращались в нули и завершался этот процесс звонком. Еще более мистическим было вычитание из результата все той же единицы и девятки чудесным способом возникали снова. На другой моей игрушке – счетах (моя мама была бухгалтером) происходили такие же процессы, но там я сам перекидывал костяшки, а на арифмометре это было своего рода мистикой.*
Так вот, для целых знаковых чисел парадокс разрешают простым способом – запрещают его возникновение, поэтому переполнение приводит к UB. И, поскольку относительно его результата справедливы любые предположения (в том числе и фантастические), компилятор вправе предположить, что х+1 всегда будет больше х и вернуть значение «истина», что он и делает в первой функции.
*Пнп: Существует другой подход, применяемый в ЦОС (импортозамещение для DSP)– операции с насыщением, при этом х+1 может быть равен х, но это все-таки экзотика.*
А вот для без-знаковых целых чисел результат прибавления 1 к максимальному числу определен и он равен нулю. Поэтому 0xFFFF+0x0001=0x0000 > 0xFFFF – неверно и компилятору приходится генерировать код для проверки данного случая, который мы и видим во второй функции.
Пока что я не написал ничего интересного для читателя «в теме», но вот оно начинается.
Для исследования ассемблерного кода я перешел к своим любимым AVR контроллерами (у них ассемблер проще и понятнее, чем у ARM).
Для начала обратим внимание на то, как gcc осуществляет заказанную нами проверку.
```
alwaysTrue_unsigned(unsigned int):
mov r18,r24
mov r19,r25
subi r18,lo8(-(1))
sbci r19,hi8(-(1))
ldi r20,lo8(1)
cp r24,r18
cpc r25,r19
brlo .L3
ldi r20,lo8(0)
.L3:
mov r24,r20
ret
```
Берем число х в буфер (строки 2,3), прибавляем к нему 1 (4,5), заготавливаем результат (6), сравниваем буфер с числом х (7,8), корректируем результат (9,10) и задача выполнена. Итого 9 команд и время выполнения 8+ тактов. Но это версия 5.4.0.
А вот выдача версии 9.2.0.:
```
alwaysTrue_unsigned(unsigned int):
mov r19,r25
mov r18,r24
ldi r24,lo8(1)
cpi r18,-1
sbci r19,-1
breq .L5
ret
.L5:
ldi r24,0
ret
```
и мы видим, что компилятор реализует совсем другую проверку.
Берем число х в буфер (2,3), заготавливаем результат (4), вычитаем из буфера 0xFFFF (5,6), корректируем результат. Итого 7 команд и время выполнения 6+ тактов. Если перевести этот код обратно на С, то мы получим что-то вроде:
```
return (x!=0xFF)
```
И такое преобразование абсолютно валидно, но у меня нет ни малейших мыслей по поводу того, как такие преобразования компилятор делает, просто сказка какая-то. Обратите еще внимание на код проверки для выражения (x+4)>x и так далее.
Дальше я решил поиграть с типами и попробовал (u)int16\_t – ничего не изменилось, (u)int32\_t – появились загадочные пересылки, но смысл проверки остался прежний, использовал (u)int8\_t и обалдел.
Совершенно неожиданно код для без-знакового аргумента редуцировался и функция стала выдавать жесткую единицу. Но ведь это откровенно неправильно и для случая x=0xFF условие (х+1)>х выполняться не будет. Ура, неужели я нашел ошибку в gcc (в части оптимизации) и смогу о ней сообщить и помочь развитию столь мощного продукта.
*Пнп: Когда лет 15 назад мои мальчишки приходили с фразой «Папа, я нашел баг в компиляторе» (речь шла о TurboPascal) я их отсылал с предложением внимательнее посмотреть на свой код и баг компилятора рассасывался сам собой, но ведь тут совсем другое дело — я не могу допустить неточность в интерпретации предельно ясного случая.*
Но счастье было недолгим. На самом деле надо внимательно читать стандарт языка С и покров тайны развеется (я не стал этого делать и просто догадался).
**Догадайтесь и Вы**
Выражение (х+1) в операторе сравнения имеет тип int (в данном случае uint16\_t), поэтому перед выполнением сложения тип uint8\_t приводится к типу uint16\_t приписыванием нулевого старшего байта, после чего переполнение становится невозможным и результат выполнения функции предрешен. Достаточно всего лишь явным образом обозначить свои намерения сравнивать именно байты следующим образом:
```
Return (uint8_t)(x+1)>x
```
и необходимая проверка возвращается в ассемблерный код.
Вариант
```
return (x+(unsigned char)1) > x;
```
не прокатывает, что характерно.
Наверняка есть прагма компилятора, которая сделает int по умолчанию 16-битным и позволит добиться возвращения проверки значения х, но это уже несколько замысловато.
Вот такая забавная пред-новогодняя история, которая лично мне дала в понимании приведения кардинальных типов в С больше (теперь я это никогда не забуду), чем возможное чтение стандартов (но это совершенно не означает, что их можно не читать). | https://habr.com/ru/post/535400/ | null | ru | null |
# Замыкания в C#
Перед прочтением статьи, ответьте на следующий вопрос — что будет напечатано, после исполнения следующего кода?
P p = Console.WriteLine; // P объявлен как delegate void P();
foreach (var i in new [] { 1, 2, 3, 4 }) {
p += () => Console.Write(i);
}
p();
(К сожалению, не хватает кармы для нормального оформления)
Я провел опрос среди своих коллег, и только три человека из десяти смогли ответить правильно, причем только двое точно знали, что происходит и почему. Я, к своему стыду, правильного ответа не знал.
Так вот, переведенный выше код покажет `4444`. Однако, если этот код слегка изменить:
P p = Console.WriteLine;
foreach (var i in new int[] { 1, 2, 3, 4 }) {
int j = i;
p += () => Console.Write(j);
}
p();
… то результат будет `1234`. Давайте разберемся, почему так происходит.
Наш анонимный метод (лямбда-выражение — это всего лишь «синтаксический сахар» для анонимных методов) использует в теле внешнюю переменную. Эта переменная становится *захваченной (captured)*, и ее время жизни увеличивается до времени жизни делегата, которые ее использует. Это позволяет методу в принципе использовать значения захваченных переменных.
Теперь в дело вступают *инстанциация (instantiation)* переменных и их *область видимости (scope)*. В первом случае, переменная `i` инстанциируется один раз перед `foreach`. Фактически код
foreach (var i in new[] { 1, 2, 3, 4 }) {
//…
}
эквивалентен
{
int i;
foreach (i in new[] { 1, 2, 3, 4 }) {
//…
}
}
Во втором случае переменная `j` создается и инстанциируется внутри цикла на каждой итерации. Переменные замыкаются в своей области видимости. Таким образом, в первом случае замкнутая переменная `i` будет изменятся при каждой итерации и к концу цикла будет равна четырем. Именно поэтому делегат выведет четыре четверки. Во втором случае, `j` будет замкнута внутри области видимости цикла и будет неизменна (фактически, будет созданно четыре экземпляра переменной `j`, каждая из которых получит свое значение), и делегат выведет `1234`.
Все это становится вполне очевидно, если мы заглянем внутрь сгенерированного компилятором кода, например, при помощи Reflector. Скомпилированный код первого примера (после некоторого причесываения) выглядит вот так:
class DecodedFoo {
private delegate void P();
class Anonim {
public int i;
public void p()
{
Console.Write(i);
}
}
public void Print() {
P p = Console.WriteLine;
var a = new Anonim();
var array = new[] { 1, 2, 3, 4 };
for (var i = 0; i < array.Length; i++) {
a.i = array[i];
p += a.p;
}
p();
}
}
Весьма интересно, что компилятор развернул цикл `foreach` в `for`.
Второй пример будет выглядеть вот так:
class DecodedBar {
private delegate void P();
class Anonim {
public int j;
public void p() {
Console.Write(j);
}
}
public void Print() {
P p = Console.WriteLine;
foreach (var i in new [] { 1, 2, 3, 4 }) {
var a = new Anonim();
a.j = i;
p += a.p;
}
p();
}
}
Ссылки по теме для заинтересовавшихся:
<http://blogs.msdn.com/abhinaba/archive/2005/10/18/482180.aspx>
<http://blogs.msdn.com/oldnewthing/archive/2006/08/02/686456.aspx>
<http://blogs.msdn.com/oldnewthing/archive/2006/08/03/687529.aspx>
<http://blogs.msdn.com/oldnewthing/archive/2006/08/04/688527.aspx>
P.S. Resharper 4.0 умеет определять такие вот случаи, и для первого примера он выдает предупреждение «Access to modified closure» и предлагает переделать первый пример во второй. Но, однако, он не умеет отделять случаи, когда делегат вызывается внутри цикла, от слчуаев, когда делегат вызывается вне цикла. | https://habr.com/ru/post/36601/ | null | ru | null |
# В поиске бесплатных билетов, исследование игры Аэрофлота
Началось все с того, что я получил ссылку на промо-сайт компании [Аэрофлот](http://www.aeroflotbonus15.ru/). Акция заключается в прохождении небольшой flash игры и получении бонусных миль. Главный приз в 150 000 миль получает игрок, занявший первую строчку в рейтинге. Собственно, принцип формирования рейтинга и вызвал мой интерес к этой акции.
Как всем хорошо известно, код flash приложений выполняется на стороне клиента, поэтому защита от нечестной игры представляет весьма сложную задачу. По сути, единственным верным решением является перенос всей игровой механики на сторону сервера, а flash приложение выполняет роль клиента к API.
Посмотрим, как с этой задачей справляются в Аэрофлот.
Для начала запускаем игру с открытой консолью разработчика в Google Chrome. И… видимо, все будет скучно. Как оказалось, запрос на сервер отправляется всего один раз в конце игры.
Данные в запросе подозрительно похожи на base64, но преобразование из этой кодировки приводит лишь к набору бинарных данных. Значит, запрос шифруется где-то в глубине клиента. К сожалению, или к счастью, swf файлы никогда не являлись стойкими к декомпиляции.
Буквально через 10 секунд после просмотра ActionScript кода обнаруживается вот такой фрагмент:
```
public static function prepareForSend(param1:Object, param2:String) : String {
return Xor64.encode(JSON.stringify(param1), "aef-game" + param2);
}
```
Да это же банальное XOR шифрование, значит, можно было не связываться с декомпиляцией, восстановить ключ такого шифра дело нескольких секунд. Но если все же разобраться до конца, то ключ здесь состоит из двух частей: первая захардкожена в функции, вторая часть получается из параметров инициализации SWF.
```
// main.as
this._token = stage.loaderInfo.parameters["token"];
// http://aeroflotbonus15.ru/media/js/aef.js
start : function( token, authState, connector, autoStart ){
. . .
this._token = token;
. . .
},
. . .
AEF.flashController.buildFlash({ token: this._token, connector: this._connector }, this._lang );
. . .
// http://aeroflotbonus15.ru/
AEF.start('c958c089505d321994578a12fabbe73d', true, "http://aeroflotbonus15.ru/api/", false, 'ru');
```
То есть полный ключ – **aef-gamec958c089505d321994578a12fabbe73d** почти весь лежит у всех на виду, прямо в коде страницы.
Кстати, судя по всему, разработчики даже поленились самостоятельно реализовывать алгоритм шифрования и воспользовались [готовым решением](http://flapps.ru/forum/topic861.html).
Результат дешифровки с озвученным ключом:
```
{
"result":{
"cities":11,
"miles":749.9018522566122,
"time":58356,
"bonuses":2,
"wins":6
},
"version":0.98,
"bytes":7205605,
"system":{
"cpuArchitecture":"x86",
"screenDPI":72,
"playerType":"PlugIn",
"isDebugger":false,
"version":"MAC 15,0,0,152",
"manufacturer":"Google Pepper"
},
"url":"http://aeroflotbonus15.ru/media/swf/game.swf?68"
}
```
Форматирование добавлено для удобства чтения.
В результате кто угодно может отправить какой угодно рейтинг. Не знаю, как организаторы планируют отделять честных участников от читеров, но лично у меня отпало всякое желание участвовать в этой акции.
P.S.
У меня нет карточки «Аэрофлот Бонус», поэтому результаты никак не повлияют на общий рейтинг. | https://habr.com/ru/post/238463/ | null | ru | null |
# Настройка ROS и работа со стереокамерой ZED на NVIDIA Jetson
Добрый день уважаемые читатели! В последних статьях я рассказывал о популярных методах SLAM и визуальной одометрии, которые имеют поддержку в ROS. В этой статье я немного отклонюсь от темы и расскажу о настройке и работе с ROS на микрокомпьютере [NVIDIA Jetson TK1](http://www.nvidia.com/object/jetson-tk1-embedded-dev-kit.html). После установки всего необходимого мы подключим и попробуем в деле [стереокамеру ZED от streolabs](https://www.stereolabs.com/). Кому интересно прошу под кат.
О NVIDIA Jetson
---------------
Для начала рассмотрим платформу NVIDIA Jetson TK1. NVIDIA Jetson TK1 это микрокомпьютер NVIDIA на основе [Tegra K1 SOC](https://elinux.org/Tegra/SoCs#Tegra124) (CPU+GPU на одном чипе с поддержкой CUDA). NVIDIA Jetson может похвастаться 4-х ядерным CPU ARM Cortex-A15 с 2.3 ГГц, имеет те же самые компоненты, что и Raspberry Pi (HDMI, USB 2.0 и 3.0, Ethernet), а также модули, свойственные ПК: SATA, mini-PCIe. Мобильный процессор [Tegra K1](http://www.nvidia.ru/object/tegra-k1-processor-ru.html) имеет очень близкие свойства и архитектуру к десктопным GPU, что позволяет выдерживать большие нагрузки с минимальным энергопотреблением. Как говорится на [официальной странице](http://www.nvidia.ru/object/tegra-k1-processor-ru.html) процессор позволяет запускать на плате любые ресурсоемкие графические задачи, такие как распознавание лиц, дополненная реальность и даже задачи компьютерного зрения для беспилотных автомобилей. Более подробнее о всех возможностях платформы можно прочитать [здесь](https://elinux.org/Jetson_TK1).
Встроенная память на NVIDIA Jetson TK1 представлена модулем eMMC размером 16 Гб. По умолчанию на NVIDIA Jetson TK1 предустановлена операционная система Ubuntu 14.04.
Для питания микрокомпьютера используется AC/DC адаптер на 12 В.
Стереокамера ZED
----------------
Стереокамера ZED является пассивной камерой глубины, состоящей из двух обычных RGB камер, удаленных на расстояние 12 см друг от друга, с обзором до 20 метров. В отличие от активных камер (таких как ASUS Xtion и Microsoft Kinect), стереокамера ZED не имеет ИК-лазера для измерения расстояния. Камера относительно недорогая (стоит 449$). Преимуществом камеры можно считать ее малые размеры (175 x 30 x 33 мм) и легковесность (159 г).
Камеру можно использовать для [построения карт местности вне помещения на дроне](https://developer.nvidia.com/embedded/learn/success-stories/stereolabs).
Подробнее о камере можно прочитать [на официальной странице](https://www.stereolabs.com/zed/).
Настройка Ubuntu на NVIDIA Jetson TK1
-------------------------------------
Подключим NVIDIA Jetson TK1 с помощью HDMI к монитору, провод Ethernet в соответствующий разъем и наконец с помощью AC/DC адаптера на 12 В к источнику питания.
Для установки системы на NVIDIA Jetson может понадобиться установить JetPack TK1 (инструкцию можно найти [здесь](https://www.stereolabs.com/blog/getting-started-with-jetson-tk1-and-zed/)). У меня на руках оказался NVIDIA Jetson с уже установленным JetPack и системой Ubuntu 14.04, поэтому здесь я не рассматриваю его установку.
Итак система Ubuntu 14.04 запустится автоматически. Для авторизации используем логин и пароль ubuntu.
Узнаем IP адрес хоста Jetson:
```
ifconfig
```
Получим аппаратные характеристики:
```
lscpu
```
Вывод будем таким:
```
Architecture: armv7l
Byte Order: Little Endian
CPU(s): 4
On-line CPU(s) list: 0-3
Thread(s) per core: 1
Core(s) per socket: 4
Socket(s): 1
```
Возможна проблема с подключением к Jetson по SSH: ifconfig отображает IP адрес, но подключиться к Jetson по этому адресу не удается. Чтобы решить проблему откроем файл /etc/network/interface из-под рута:
```
sudo nano /etc/network/interface
```
и добавим строки:
```
auto eth0
iface eth0 inet dhcp
```
Мы сделали динамическое назначение IP адреса. Сохраним изменения и выполним:
```
sudo ifup eth0
```
Теперь все должно работать. Данное решение было взято [отсюда](https://devtalk.nvidia.com/default/topic/753039/ethernet-not-working-at-all-on-my-jetson/?offset=8).
Теперь подключимся к Jetson по SSH:
```
ssh -X ubuntu@
```
### Установка CUDA
Для работы с камерой ZED нам нужен ZED SDK, который требует установленной CUDA версии 6.5. Скачаем deb файл для CUDA Toolkit 6.5 for L4T[отсюда](https://developer.nvidia.com/cuda-toolkit-65) (инструкция взята [отсюда](https://elinux.org/Jetson/Installing_CUDA)):
```
wget http://developer.download.nvidia.com/compute/cuda/6_5/rel/installers/cuda-repo-l4t-r21.1-6-5-prod_6.5-14_armhf.deb
```
Установим метаданные репозитория для CUDA for L4T, который только что скачали:
```
sudo dpkg -i cuda-repo-l4t-r21.1-6-5-prod_6.5-14_armhf.deb
```
Скачаем и установим сам CUDA Toolkit включая OpenGL toolkit для NVIDIA:
```
sudo apt-get update
```
Установим cuda-toolkit-6-5:
```
sudo apt-get install cuda-toolkit-6-5
```
Добавим пользователя ubuntu в группу «video» для обеспечения доступа к GPU:
```
sudo usermod -a -G video $USER
```
Здесь $USER это ubuntu.
Добавим пути до папки установки CUDA в скрипт .bashrc и выполним его в текущем терминале:
```
echo "export PATH=/usr/local/cuda-6.5/bin:$PATH" >> ~/.bashrc
echo "export $PATH=/usr/local/cuda-6.5/bin:$PATH" >> ~/.bashrc
source ~/.bashrc
```
Проверим, что CUDA Toolkit установлен на устройстве:
```
nvcc -V
```
### Настройка USB 3.0 на Jetson TK1
По умолчанию порт USB 3.0 настроен системой на Jetson TK1 как USB 2.0. Нам необходимо его сконфигурировать как USB 3.0. Для этого откроем файл /boot/extlinux/extlinux.conf под рутом:
```
sudo vi /boot/extlinux/extlinux.conf
```
Найдем строку ‘usb\_port\_owner\_info=0‘. Если эта строка встречается два раза, то изменим последнее включение. Перепишем ‘usb\_port\_owner\_info=0‘ на ‘usb\_port\_owner\_info=2‘.
### Установка ZED SDK
Процедура установки выглядит подобным образом как и на десктопной Linux. Стоит только отметить, что OpenCV уже установлен при установке JetPack для того, чтобы можно было для него использовать оптимизацию Tegra. Поэтому ручная установка OpenCV не требуется.
Для использования стереокамеры ZED нам нужно установить ZED SDK 1.2. В качестве установщика используется специальный для Jetson TK1 .run файл. Скачаем установщик:
```
wget https://www.stereolabs.com/developers/downloads/archives/ZED_SDK_Linux_JTK1_v1.2.0.run
```
Установим для файла права на исполнение и запустим его в терминале:
```
sudo chmod +x ZED_SDK_Linux_JTK1_v1.2.0.run
./ZED_SDK_Linux_JTK1_v1.2.0.run
```
Примем условия лицензионного соглашения, нажмем ‘q’ и затем ‘Y’. Далее выполним процедуру следуя инструкциям.
Запустим ZED Explorer на самом Jetson (не работает при подключении удаленно через SSH):
```
/usr/local/zed/tools/ZED\ Explorer
```
Установка ROS драйвера для стереокамеры ZED
-------------------------------------------
Я использовал в своих экспериментах ROS Indigo. Установим зависимости для ROS драйвера:
```
sudo apt-get install ros-indigo-tf2-ros ros-indigo-image-transport ros-indigo-dynamic-reconfigure ros-indigo-urdf
```
Установим ROS враппер для ZED камеры:
```
cd ~/catkin_ws/src
git clone https://github.com/zastrix/zed-ros-wrapper.git
git checkout ef3ad46f14cf62ff21083829a1fa6879d20246de
cd ~/catkin_ws
catkin_make
```
Запустим zed\_wrapper выполнив следующие команды в разных окнах терминала:
```
roscore
roslaunch zed_wrapper zed.launch
```
Покажем активные топики:
```
rostopic list
```
В списке помимо стандартных топиков увидим топики с префиксом /zed:
```
/zed/depth/camera_info
/zed/depth/depth_registered
/zed/joint_states
/zed/left/camera_info
/zed/left/image_raw_color
/zed/left/image_rect_color
/zed/odom
/zed/point_cloud/cloud_registered
/zed/rgb/camera_info
/zed/rgb/image_raw_color
/zed/rgb/image_rect_color
/zed/right/camera_info
/zed/right/image_raw_color
/zed/right/image_rect_color
```
Запустим rqt\_image\_view:
```
rosrun rqt_image_view rqt_image_view
```
При выборе топика /zed/depth/depth\_registered получим карту глубины:
RGB изображение с левой камеры (/zed/left/image\_raw\_color):
И наконец RGB изображение с правой камеры (/zed/right/image\_raw\_color):
Данные с камеры публикуются в топики /zed/rgb/image\_raw\_color и /zed/depth/depth\_registered с частотой 15Hz.
Узнаем частоту публикации облака точек в топик /zed/point\_cloud/cloud\_registered:
```
rostopic hz /zed/point_cloud/cloud_registered
```
```
average rate: 4.146
min: 0.202s max: 0.371s std dev: 0.04798s window: 11
average rate: 4.178
min: 0.191s max: 0.371s std dev: 0.04306s window: 16
```
Запустим rviz на самом Jetson (мне не удалось успешно запустить его при подключении через ssh с опцией -x):
```
rosrun rviz rviz
```
SLAM На NVIDIA Jetson со стереокамерой ZED
------------------------------------------
Давайте теперь попробуем камеру ZED на практической задаче. На NVIDIA Jetson можно без проблем запустить алгоритм SLAM RTAB-MAP. Для начала установим враппер ROS для RTAB-MAP:
```
sudo apt-get install ros-indigo-rtabmap-ros
```
Теперь запустим rtabmap с использованием камеры ZED. Если у нас не запущен zed\_wrapper, то запускаем его:
```
rosrun zed_wrapper zed_wrapper_node
```
Запустим rtabmap:
```
rtabmap
```
Выберем камеру ZED в окне rtabmap в качестве источника:
Я не проводил испытания RTAB-MAP на NVIDIA Jetson, поэтому оставляю вам, дорогие читатели, возможность испытать этот алгоритм SLAM. Об использовании RTAB-MAP можно прочитать в двух моих последних статьях ([здесь](https://geektimes.ru/post/291917/) и [здесь](https://geektimes.ru/post/292889/)).
Надеюсь эта статья станет для вас хорошей стартовой точкой для использования стереокамеры ZED и микрокомпьютера NVIDIA Jetson. Желаю вам удачи в экспериментах и до новых встреч!
PS: Интересно ваше мнение по поводу выбора недорогой стереокамеры для экспериментов. Поддержка ROS не имеет большого значения, главное цена. Свои варианты пожалуйста пишите в комментариях к статье.
PS (Upd): Хотелось бы попробовать пассивные стереокамеры типа ZED. Желательно способные работать с Raspberry Pi 3. | https://habr.com/ru/post/409259/ | null | ru | null |
# Префиксные деревья в Python
Доделал на днях питонью библиотеку [datrie](https://github.com/kmike/datrie), реализующую префиксное дерево (см. [википедию](http://en.wikipedia.org/wiki/Trie) или [хабр](http://habrahabr.ru/post/111874/)), спешу поделиться.
Если вкратце, то можно считать, что datrie.Trie — это замена стандартному питоньему dict, которая при определенных условиях (ключи — строки) занимает меньше памяти, имеет сравнимую скорость получения отдельного элемента и поддерживает дополнительные операции (получение всех префиксов данной строки, получение всех строк, начинающихся с данной строки и др.), которые работают примерно так же быстро, как и «словарные» операции.
Работает под Python 2.6-3.3, поддерживает юникод, лицензия LGPL.
[datrie](https://github.com/kmike/datrie) — это Cython-обертка над библиотекой [libdatrie](http://linux.thai.net/~thep/datrie/datrie.html). В libdatrie реализован вариант префиксного дерева, в котором конечный автомат переходов между узлами хранится в специальных 2 массивах + реализовано сжатие суффиксов (ветки, которые не ветвятся, хранятся еще в одном отдельном массиве «хвостов»). Это не совсем «state of art» вариант trie (HAT-trie и тд вроде должны быть быстрее), но вариант достаточно быстрый/эффективный и с хорошей готовой реализацией (а реализация может на практике убить любой алгоритм).
Существующие варианты trie-образных структур для питона меня не устраивали. Чисто питоньи реализации неизбежно будут потреблять очень много памяти, они отметаются сразу. Другие реализации trie-образных структур для питона:
* trie.c в biopython. Не поддерживает юникод (хотя это ОК), не работает под 3.х (и чтоб заставить работать под 3.х, нужно хорошенько переписывать обертку, т.к. библиотека реализована как «голое» C-расширение);
* [github.com/buriy/python-chartrie](https://github.com/buriy/python-chartrie) от [buriy](https://habrahabr.ru/users/buriy/) — довольно быстрая (на \_\_getitem\_\_ быстрее, чем datrie в итоге), занимает много памяти (чтоб это поправить, нужно, видимо, структуру данных менять, т.е. основу библиотеки), мало функционала, не поддерживает юникод (хотя это ОК);
* [www.dalkescientific.com/Python/PyJudy.html](http://www.dalkescientific.com/Python/PyJudy.html) — старая, сложная, непонятно, работает ли (написано, что поддерживает 2.3 и 2.4)
Может еще что-то и есть, но, в любом случае, варианта «поставил — заработало — всем устраивает!» не нашел, поэтому считаю, что желание вспомнить C и поразбираться получше в Cython и Python C-API вполне успешно удалось прикрыть отсутствием нормальной реализации trie для питона.
Установка (как это обычно бывает при установке расширений, потребуется компилятор):
`pip install datrie`
Создание:
```
import string
import datrie
trie = datrie.Trie(string.ascii_lowercase)
```
При создании нужно сразу сказать, какие ключи можно будет с этим trie использовать (явно указывать алфавит или диапазоны). Это ограничение libdatrie, которое позволяет эффективно хранить автомат состояний и поддерживать юникод — сначала указываются допустимые диапазоны unicode-символов, потом unicode-ключи транслируются в более компактное внутреннее представление.
*Мне кажется, что можно было бы на практике обойтись однобайтовыми кодировками вроде cp1251 и иметь примерно тот же функционал и эффективность, но подход с диапазонами символов тоже работает неплохо, уж сделано так в libdatrie и ладно. Я поэтому пишу, что «не поддерживает юникод — это ОК» — в случае с trie однобайтовая кодировка может быть удобным вариантом.*
Потом с trie можно работать как со словарем:
```
>>> trie[u'foo'] = 5
>>> trie[u'foobar'] = 10
>>> trie[u'bar'] = 'bar value'
>>> trie.setdefault(u'foobar', 15)
10
>>> u'foo' in trie
True
>>> trie[u'foo']
5
```
Ключи должны быть юникодными :) В питоне 3.х это вполне естественно, в 2.x в примерах приходится ставить букву u, уж простите. Значения могут быть любыми питоньими объектами, что нетипично для C-реализаций trie (обычно там целые число в качестве значений). На самом деле «внутри» значения и правда представляют собой целые числа, но datrie.Trie использует их как индексы в массиве «настоящих» значений. Для тех, кому эта фича не нужна (например, значения не интересуют совсем), в datrie есть datrie.BaseTrie, который немного быстрее и умеет хранить только числа.
Немного о скорости. Все замеры проводил на trie.Trie с сотней тысяч уникальных русский и английских слов (50/50) и int-значениями «1», другие замеры (на миллионе url'ов) можно глянуть [тут](http://stackoverflow.com/a/5479374/114795) или (еще лучше) проводить самим на своих данных. Замеры скорости я проводил только для того, чтоб иметь какое-то общее представление о порядке величин, и чтоб отслеживать регрессии в библиотеке, так что принимайте их соответственно; весь исходный код и данные есть в репозитории. Кроме того, нигде не буду писать об асимптотической сложности различных операций, т.к. не исследовал ее. В теории должно быть как у trie из википедии (например, получение элемента или поиск по префиксу — O(m), где m — длина ключа), но детали реализации (как libdatrie, так и моей обертки) могут все менять; если кто-нибудь построит соответствующие графики, буду, конечно же, благодарен.
Операции получения элемента, проверки in, обновления элемента работают в среднем раза в 2-3 медленнее, чем у стандартного словаря (т.е. быстро, на моем буке это от 1 до 3 млн операций в секунду для вышеупомянутого trie). Исключение — это вставка нового значения в trie, она работает значительно медленнее (порядка 50тыс операций в секунду для того же trie с русскими и английскими словами). При этом trie на таких данных занимает значительно меньше места в оперативной памяти: 3-5M (в зависимости от интерпретатора) vs 20M+ у обычного словаря *(замеры памяти проводил коряво и за конкретные цифры не ручаюсь)*.
Т.е. datrie.Trie можно использовать как замену dict, если есть большое количество не очень длинных строк (например, слов или url'ов), данные в основном используются в режиме read-only (или «update-only») и хочется сэкономить оперативную память память ценой 2-3 кратного снижения скорости доступа.
Чтоб этот псевдо-read-only не очень смущал, trie можно сохранять в файл и загружать из файла:
```
>>> trie.save('my.trie')
>>> trie2 = datrie.Trie.load('my.trie')
```
Еще одна особенность trie — это то, что некоторые операции, которые в dict (и любой другой хэш-таблице) потребовали бы полного перебора или большого объема памяти для построения дополнительных индексов, в префиксном дереве работают почти так же быстро (а некоторые даже быстрее), как и простое получение значения.
Можно проверить, есть ли в trie элементы, ключи у которых начинаются с данного префикса (это даже быстрее, чем простая проверка in):
```
>>> trie.has_keys_with_prefix(u'fo')
True
```
Можно найти все префиксы данной строки, которые есть в данном trie (это медленнее, по тестам — 500-600тыс операций/сек):
```
>>> trie.prefixes(u'foobarbaz')
[u'foo', u'foobar']
>>> trie.prefix_items(u'foobarbaz')
[(u'foo', 5), (u'foobar', 10)]
```
Можно найти все элементы, у которых ключи начинаются с данной строки:
```
>>> trie.keys(u'fo')
[u'foo', u'foobar']
>>> trie.items(u'fo')
[(u'foo', 5), (u'foobar', 10)]
>>> trie.values(u'foob')
[10]
```
В последнем примере основное время сейчас тратится на построение результатов, а не на поиск, это можно оптимизировать; сейчас скорость была где-то порядка 150-300 тыс. значений/сек (например, при префиксе длиной 7 и в среднем 3 значениями это 70тыс операций/сек).
У datrie.Trie есть еще различные методы, справку по ним и дополнительные результаты замеров скорости можно посмотреть в README в репозитории.
Под pypy у меня все завелось на дебиане (раз в 10 медленнее, чем под cpython); на маке под pypy не завелось (с обычным питоном должно работать и на маке, и на линуксе, и под windows). C API — расширения в pypy всегда будут медленные, т.к. работают через костыль cpyext, а cython генерирует именно C API расширения. Можно было написать обертку на ctypes, но она была бы медленной под обычным питоном (и не факт что быстрой под pypy) + распространять ctypes-расширения неудобно. Ребята из pypy пилят сейчас [cffi](https://bitbucket.org/cffi/cffi), обещают, что он быстрый будет (и под cpython, и под pypy). Плюс, возможно, cython научится когда-нибудь генерировать не C API расширения, а cffi-расширения. Вот тогда, возможно, и наступит счастье) А пока что с pypy делать — не знаю. Ничего не буду, наверное; как-то работает все под линуксом и ладно.
В процессе реализации столкнулся с тормознутым кодеком utf\_32\_le в питоне. На это есть баг с патчем ( [bugs.python.org/issue15027](http://bugs.python.org/issue15027) ), но патч еще не закоммитили. Изначально все операции в datrie работали в 10 раз медленнее, но потом удалось в одном месте обойтись без кодирования строки стандартным питоньим utf\_32\_le и все заработало получше. Этот кодек используется еще в паре «горячих» мест, так что, думаю, если его ускорят, некоторые операции в datrie могут заработать еще до 2 раз быстрее.
Итерация по дереву сейчас тоже не самая эффективная, это связано с особенностями интерфейса libdatrie. Но автор libdatrie — отличный чел и собирается все поправить, так что перспективы неплохие.
Как обычно, патчи, баг-репорты, идеи, бенчмарки, пулл-реквесты и тд приветствуются!
[github](https://github.com/kmike/datrie) / [bitbucket](https://bitbucket.org/kmike/datrie), кому что удобнее. | https://habr.com/ru/post/147963/ | null | ru | null |
# Повышаем стабильность сессии в CakePHP 2.x
*От переводчика: при разработке [Web-payment.ru](http://web-payment.ru/) на фреймворке [CakePHP](http://cakephp.org/) мы сталкивались с самого начала с тем, что логаут пользователей происходил каждые несколько часов, а это слишком короткий промежуток времени. При этом сколь большие значения timeout и cookieTimeout мы бы не выставляли в настройках ядра, ничего не менялось. Данная статья решила для нас эту проблему.*
В прошлом году я обращался к этому вопросу как минимум дважды, но практически безрезультатно. После длительных поисков решения я снова отложил его на неопределенное время. Здесь также следует сказать, что когда дело касается отлаживания session/cookie вещей (в данном случае — аутентификации), процесс поиска багов никогда не отличался простотой, поскольку он зависит от множества факторов, которые складываясь вместе, усложняют обнаружение проблемы.
В документации Cake также не говорится, что для длительной работы php-сессий необходимо увеличить значение внутренней переменной max\_lifetime. Я вообще наткнулся на нее случайно, потому что всегда думал, что об этом позаботился сам фреймворк, однако даже после того, как я сделал базу данных контейнером сессий, я не заметил каких-либо улучшений. Поэтому я подумал, что чистка памяти на стороне сервера здесь, видимо, вообще не причем, ну или по крайней мере, влияет не только она одна.
Итак, в итоге мы имеем следующее:
* Выставление таймаутов было пустой тратой времени, также, как и изменение Security level, который я выставил на *low*.
* Переезд с php/cake на БД тоже не сработал, хотя он, конечно, предоставляет немного больше контроля.
* Увеличение значения gc\_maxlifetime в php.ini опять же, не дало особого эффекта.
После всех этих действий, логауты продолжались через совершенно разные промежутки времени — иногда через несколько минут, иногда — несколько часов, но не более того. Эта проблема имеет важное значение не только для создания социальных сетей, но и для других сайтов, работающих на Cake.
Я несколько раз пытался добавить зашифрованные cookie, такие, как *RememberMe* для быстрого повторного логина в тот момент логаута, однако из-за [бага PHP](http://www.adayinthelifeof.nl/2010/12/13/php-srand-problems-with-suhosin/), связанного с srand/mt\_srand и suhosin это решение не работало. Благодаря [посту Miles’a](http://milesj.me/blog/read/security-cipher-suhosin) о баге, я решил взяться за проблему всерьез и что-нибудь с этим поделать (многие пользователи жаловались на необъяснимые логауты за последние несколько месяцев).
Есть также другая отдаленно связанная с этой ситуацией проблема, суть которой заключается в том, что PHP (Саке) хранит сессионные cookie, определяя для них фиксированный срок жизни, однако срок их жизни при этом не обновляется во время запросов и таким образом получается, что в определенный момент сессионные cookie становятся недействительны. В настоящее время [с этим ничего нельзя поделать](http://stackoverflow.com/questions/11304390/cakephp-session-updates-but-cookie-expiry-doesnt/11506630)…
#### Автоматический возврат логина как вариант решения проблемы
Прошло несколько лет, и вот, наконец, я все-таки воспользовался черновыми работами Miles’a и настроил его компонент [AutoLogin](http://milesj.me/code/cakephp/auto-login) для работы с моими приложениями.
Суть работы компонента заключается в том, что он сохраняет данные пользователя в cookie во время логина, а как только сессия по неизвестной причине теряется снова, компонент восстанавливает ее. Это происходит тихо и никак не мешает работе пользователя.
Код компонента вы можете найти в в моем [плагине Tools](https://github.com/dereuromark/tools/blob/master/Controller/Component/AutoLoginComponent.php) (пользуйтесь именно этим репозиторием).
##### Особенности использования
Успешно проверив его в нескольких Cake2.x приложениях, я хочу поделиться с вами простым руководством по его использованию. Для его подключения вам нужно просто добавить компонент глобально в AppController:
```
public $components = array('Session', 'RequestHandler', 'AutoLogin', 'Auth', ...);
```
Важно объявить его подключение до подключения компонента авторизации, чтобы избежать возникновения любых ошибочных сообщений об “отсутствии авторизации”.
Вы можете использовать /Config/configs.php (или любой другую директорию конфигурации) для определения его настроек:
```
$config['AutoLogin'] = array(
'controller' => 'account',
'username' => 'login',
'requirePrompt' => false
... //для ознакомления с другими параметрами смотрите описание компонента
);
```
Я прошу вас соблюдать осторожность при использовании последнего параметра — *requirePrompt*. При его отключении, AutoLogin будет использоваться для всех попыток залогиниться. Это требует от пользователей постоянно делать правильный выход из аккаунтов во время использования сайта в общественных сетях (особенно опасно для интернет-кафе, где посторонние люди могут завладеть аккаунтом пользователя даже спустя несколько дней после последнего использования). Поэтому вы должны убедиться, что компонент используется только на сайтах, где все пользователи предупреждены и знают об этом.
То есть в обычном случае вам нужно добавить чекбокс в форму авторизации:
```
if (Configure::read('AutoLogin.active')) {
echo $this->Form->input('auto_login', array('type'=>'checkbox', 'label'=>__('Запомнить меня')));
}
```
Вот и все. Компонент можно с легкостью протестировать, сохраняя сессии в БД и обрезая таблицу сессий после логина. Компонент вернет пользователя обратно, а также создаст новую строку для сессии в таблице базы. Если все сделано как надо, пользователь даже не заметит, что на какую-то долю секунды потерял авторизацию.
Приведенную выше конструкцию if можно опустить. Я использую ее для динамического включения/выключения компонента в зависимости от среды, в которой он работает, однако если вы собираетесь ее использовать, убедитесь, что вы присвоили active значение *true* в Configure.
Теперь об исправлении бага suhosin. Согласно объяснению Miles по ссылкам выше, большинство линуксовых апач-сред по умолчанию поставляются с патчем suhosin, который изменяет принцип работы srand. В случае с моим WAMP-сервером это не так, поэтому на нем все работает сразу, однако для того, чтобы компонент заработал в линукс-среде, вам нужно всего лишь добавить в конец */etc/php5/apache2/php.ini* вот эту строчку:
```
suhosin.srand.ignore = Off
```
И не забудьте перезагрузить апач или сделать force-reload для */etc/init.d/apache2*.
Совет: Я добавил пример для проверки наличия этого бага (смотрите файл для проверки в репозитории). Если вы не уверены, если ли у вас эта проблема, запустите его в своей среде.
Другие советы: Если вы хотите отключить AutoLogin для конкретного сайта, вам достаточно просто изменить значение *active* на *false* в конфиге сайта или сделать это динамически в конструкторе контроллеров. Всегда помните: вы не сможете добавлять его в список компонентов динамически, поскольку вам нужно включать его перед Auth-частью, однако вы всегда сможете отключить компонент, если тот уже был добавлен туда заранее.
Дебаг-режимом по умолчанию является auto-detect. В процессе разработки (debug > 0) он включен изначально, однако вы, конечно же, можете перезаписать это значение в своих конфигах.
Другим важным параметром является *expires* — по умолчанию оно равно двум неделям и легко поддается изменению.
#### Альтернативы
В 2.x теперь также есть альтернативные варианты решения проблемы. Один из них — использовать специальный адаптер [CookieAuthenticate](https://github.com/ceeram/Authenticate/blob/master/Controller/Component/Auth/CookieAuthenticate.php).
#### Разбор механизма работы с сессиями в Cake
Мне потребовалось немало времени, чтобы детально разобраться в принципе работы сессий. Теперь я наконец-то понял. Я хочу обратить особое внимание на то, что использование приведенного выше кода без глубокого его понимания скорее всего просто замаскирует проблему… ну или вылечит только симптомы болезни, если хотите. Да, этот способ будет работать, однако я думаю, что вам больше понравилось бы, если бы все работало и без применения описанных выше трюков с запоминаниями сессии.
Для начала нам надо понять, как сессии создаются, проходят валидацию и обновляются при переходе по клику:
* Пользователь приходит в первый раз, сессионные cookie генерируются (и действуют x секунд), значение таймаута сессии сохраняется в них (y секунд)
* Юзер снова кликает: Конечно же мы увеличиваем срок действия сессии (определенные y секунд + еще z секунд), сохраняя его в cookie в виде значения
* Однако cookie, сами по себе, не получают новый срок жизни (все те же x секунд). Это ограничение в обработке cookie, время их таймаута фиксировано.
Выяснив это, становиться совершенно ясно, что когда срок действия cookie, заданный при ее создании истечет, сессия будет уничтожена, даже если вы увеличеки срок ее жизни до нескольких лет. Таким образом, крайне важно понимать, что для того, чтобы эти настройки имели смысл, вам нужно задать большое значение для длительности сессии и еще большее — для времени жизни cookie:
```
Configure::write('Session', array(
'defaults' => 'php',
'timeout' => 14400, // 4 часа, обращается к 'session.gc_maxlifetime' в //настройках PHP
'cookieTimeout' => 10 * 14400, // 20 часов, обращается к 'session.cookie_lifetime' в //настройках PHP
// ...
));
```
Оба значения выставлены в минутах в конфиге CakePHP.
С учетом этих изменений, юзер выходит из сессии, если он:
* не произвел никакой сессионной активности (клики, ajax) в течении 4 часов
* достиг 20-ти часового cookie таймаута (независимо от активности)
А поскольку такие настройки будут устраивать ему логаут каждые 20 часов, имеет смысл сделать значения побольше (несколько месяцев, например) или использовать его в сочетании с описанным выше компонентом для запоминания сессии.
Итак, повторим снова:
```
'session.gc_maxlifetime' => относительная величина, увеличивается при активности
'session.cookie_lifetime' => абсолютное значение, может быть присвоено только в //начале сессии
```
И не забудьте проверить свои ini-параметры, которые относятся к *session.gc\_divisor* и *andsession.gc\_probability* чтобы убедиться, что очистка памяти работает и проводиться в нужное время.
[](http://web-payment.ru/) | https://habr.com/ru/post/244645/ | null | ru | null |
# Паяльная станция своими руками на базе Arduino
Всем привет! Как-то я затронул тему паяльной станции на Arduino и сразу меня завалили вопросами (как/где/когда). Учитывая массовость запросов, я решил написать обзор простой паяльной станции (только паяльник) на базе Arduino.
Почему Arduino? Ведь существует уйма контроллеров быстрее и дешевле. В таких случаях я обычно отвечаю: *— Дёшево, практично, быстро.*
Действительно, ведь Arduino Pro Mini сейчас стоит 1,63$ за 1 шт (недавно прислали), а atmega8 стоит 1$ (оптовая цена). Получается, что плата Pro Mini с обвесом (кварц, конденсаторы, стабилизаторы) стоит не так-то и дорого, плюс ко всему экономит время. Также время очень сильно экономит IDE-оболочка для Arduino, легко и быстро в ней справляется даже школьник. Учитывая популярность и дешевизну я решил собрать именно на Arduino.
Для создания паяльной станции нам первым делом нужна ручка паяльной станции, зачастую это китайские станции типа 907 A1322 939.
**Начнём**
**Характеристики ручки:**
Напряжение: 24V DC
Мощность: 50W (60W)
Температура: 200℃~ 480℃
Для управления ручкой паяльника нам первым делом нужно снимать данные с датчика температуры, в этом нам поможет **LM358N**. Эта схема уже работает у меня почти 2 года.
Далее нам нужно управлять(включать и выключать) нагревательный элемент паяльника, в этом на поможет импульсный транзистор **IRFZ44**. Его подключение очень простое:
Хочу обратить Ваше внимание на будущий режим работы нагревательного элемента. Его мы будем включать в три этапа путём ШИМ-модуляции. При старте программы будет включаться почти максимальная мощность (скважность 90%), при приближении к заданной температуре мощность понижается (скважность 35-45%), и при минимальной разнице между текущей и заданной температуры мощность держится на минимуме (скважность 30-35%). Таким образом мы устраняем инерцию перегрева. Повторюсь, паяльная станция стабильно работает почти 2 года, и термоэлемент не находится в постоянной предельной нагрузке (что продлевает его жизнь). Все настройки в программе можно отредактировать.
Подключать ручку нужно по схеме:
**Обратите внимание, разъём на панели станции, а не на ручке.**
**Очень настаиваю**: проверяйте ручки перед пуском, раскрутите и проверьте целостность нагревательного элемента, а также правильность распайки проводов на разъёме.
Далее нам нужен контроллер. Для демонстрации я выбрал Arduino Uno – как самый популярный и удобный. Заметьте, что паяльную станцию я делаю блочной и это даёт возможность самому выбрать контроллер. Также нам нужны две кнопки подтянутые к +5В сопротивлениям 10кОм и 7-ми сегментный индикатор на три разряда. Выводы сегментов я подключил через сопротивления 100 Ом.
**ANODES:**
D0 — a
D1 — b
D2 — c
D3 — d
D4 — e
D5 — f
D6 — g
D7 — dp (точка)
**CATHODES:**
D8 — cathode 3
D9 — cathode 2
D10 — cathode 1
Хочу также заметить, что кнопки мы сажаем на аналоговые пины 3 и 2. И в программе я их опрашиваю как аналог. Сделал я это для того, чтобы не вводить в заблуждение молодое поколение. Не каждый знает где найти пин 14, 15 и 16. А учитывая, что скорости достаточно и памяти в контроллере много, то так будет проще.
Давайте посмотри что получилось:
Вы можете заметить пустую панельку возле индикатора, это заготовка под LM358N, просто аналог KA358 показал плохие результаты в работе. Поэтому я воспользовался блоком термодатчиков на LM358N для паяльной станции с феном.
Далее необходимо выбрать источник питания. Я взял блок питания от какого-то ноутбука на 22V 3А, его хватает с запасом. Потребление при старте паяльника 1,5 А а при поддержке температуры 0,5А. Поэтому выбирайте себе подходящий блок питания, желательно 24V DC 2A.
На фото выше видно жмут проводов и многих это пугает. Поймите, это демо, вариант под любой контроллер, станцию можно собрать и компактно, к примеру:
Это наглядный пример для реализации Вашего проекта паяльной станции. Видео, которое наглядно поможет понять Вам как собрать самому:
Вот тест программы, писал под версией IDE 1.5.2. Учтите всё вышесказанное и сильно не критикуйте (программу пытался написать просто и доступно).
```
/*
// Пины подключения индикаторов
ANODES:
D0 - a
D1 - b
D2 - c
D3 - d
D4 - e
D5 - f
D6 - g
D7 - dp (digital point)
a
********
* *
f * * b
* g *
********
* *
e * * c
* d *
******** # dp
CATHODES:
D8 - cathode 3
D9 - cathode 2
D10 - cathode 1
*/
// -------------------------------------------------- не изменять, это для Сегментов -----------------------------------------------
byte const digits[] = {
B00111111,B00000110,B01011011,B01001111,B01100110,B01101101,B01111101,B00000111,B01111111,B01101111};
int digit_common_pins[]={8,9,10}; // пины для разрядов сегментов(при изменении убедитесь что Ваш порт не используется)
int refresh_delay = 5;
int count_delay = 300; // COUNTING SECONDS IF count_delay = 1000
long actual_count_delay = 0;
long actual_refresh_delay = 0;
int increment = 0; //Стартовое значение на сегментах
int max_digits =3; // Кол-во знаков
int current_digit=max_digits-1;
int increment_max = pow(10,max_digits);
// -------------------------------------------------- не изменять, это для Сегментов -----------------------------------------------
//--------------------- переменные паяльника -----------------------------
int knup = 3; //Пин кнопки вверх in(красный светодиод)
int kndn = 2; //Пин кнопки вниз in(синий светодиод)
int nagr = 11; // пин вывода нагревательного элемента(через транзистор)
int tin = 0; // Пин Датчика температуры IN Analog через LM358N
int tdat = 0; //Переменная Датчика температура
int ustt = 210; // Выставленная температура по умолчанию (+ увеличение и уменьшение при нажатии кнопок)
int mintemp = 140; // Минимальная температура
int maxtemp = 310; // Максимальная температура
int nshim = 0; // Начальное значение шим для нагрузки
void setup(){
pinMode(nagr,OUTPUT); // Порт нагрузки (паяльника) настраиваем на выход
analogWrite(nagr, nshim); //Вывод шим в нагрузку паяльника (выводим 0 - старт с выключенным паяльником - пока не определим состояние температуры)
// -------------------------------------------------- не изменять, это для Сегментов -----------------------------------------------
DDRD = B11111111;
for (int y=0;y 6 ) // Проверяем разницу между установленной температурой и текущей паяльника,
// Если разница меньше 10 градусов, то
{
nshim = 99; // Понижаем мощность нагрева (шим 0-255, мы делаем 99) - таким образом мы убираем инерцию перегрева
}
else if ((ustt - tdat) < 7 & (ustt - tdat) > 3)
{
nshim = 80; // Понижаем мощность нагрева (шим 0-255, мы делаем 99) - таким образом мы убираем инерцию перегрева
}
else if ((ustt - tdat) < 4 )
{
nshim = 45; // Понижаем мощность нагрева (шим 0-255, мы делаем 99) - таким образом мы убираем инерцию перегрева
}
else {
nshim = 230; // Иначе поднимаем мощность нагрева (шим 0-255, мы делаем 230) на максимум для быстрого нагрева до нужной температуры
}
analogWrite(nagr, nshim); //Вывод в шим порт (на транзистор) значение мощности
}
else { //Иначе (если температура паяльника равняется или выше установленной)
nshim = 0; // Выключаем мощность нагрева (шим 0-255 мы делаем 0) - таким образом мы отключаем паяльник
analogWrite(nagr, nshim); //Вывод в шим порт (на транзистор) значение мощности
}
if(millis() - actual\_count\_delay > count\_delay) // это для сегментов
{
actual\_count\_delay = millis();
// Здесь мы пишем нашу прогу по считыванию состояния кнопок (это место в счетчик не будет тормозить вывод на сегменты)
tdat = analogRead(tin); // Считать состояние датчика температуры и присвоить tdat
tdat =map(tdat,0,430,25,310); // калибровка п умолчанию 0,430,25,310
increment = tdat; // присвоить текущее значение температуры переменной сегмента
if (analogRead(kndn) < 1) // Если нажата синяя кнопка, то понизить температуру на 5
{
if( ustt <= mintemp || (ustt-5) <= mintemp )
{
ustt= mintemp;
increment = ustt;
}
else {
ustt=ustt-5;
increment = ustt;
}
}
else if (analogRead(knup) < 1) // Если нажата красная кнопка, то повысить температуру на 5
{
ustt=ustt+5;
if( ustt >=maxtemp)
{
ustt= maxtemp;
}
increment = ustt;
}
}
}
void show(int value) { //------------------------------- подпрограмма для вывода на сегменты - лучше не изменять ---------------------------------------------
int digits\_array[]={};
int y=0;
boolean empty\_most\_significant = true;
if(millis() - actual\_refresh\_delay >= refresh\_delay)
{
for (int z=max\_digits-1;z>=0;z--)
{
digits\_array[z] = value / pow(10,z); //rounding down by converting from float to int
if(digits\_array[z] != 0 ) empty\_most\_significant = false; // DON'T SHOW LEADING ZEROS
value = value - digits\_array[z] \* pow(10,z);
if(z==current\_digit)
{
if(!empty\_most\_significant || z==0){ // DON'T SHOW LEADING ZEROS EXCEPT FOR THE LEAST SIGNIFICANT
PORTD = digits[digits\_array[z]];
}
else
{
PORTD = B00000000;
}
digitalWrite(digit\_common\_pins[z], LOW);
}else{
digitalWrite(digit\_common\_pins[z], HIGH);
}
}
current\_digit--;
if(current\_digit < 0)
{
current\_digit= max\_digits; // NEED AN EXTRA REFRESH CYCLE TO CLEAR ALL DIGITS
}
actual\_refresh\_delay = millis();
}
}
```
Очень надеюсь, что Вам это как-то поможет в создании своего проекта. | https://habr.com/ru/post/248959/ | null | ru | null |
# Прокачиваем производительность C# с Федерико Луисом
Сегодня мы поговорим о производительности в C#, о способах прокачать её до неузнаваемости. Задача этой статьи — продемонстрировать такие способы повышения производительности, которые, при необходимости, вы смогли бы использовать самостоятельно. Однако эти методики не являются универсальными — вы не сможете использовать их в качестве общего решения любой задачи. Они хороши при наличии вполне конкретных сценариев использования, о которых пойдет речь ниже.
В качестве прототипа статьи был выбран доклад Федерико Луиса, основателя компании Corvalius (они занимаются R&D). Работая над движком базы данных для одного из клиентов, они посвятили около четырёх лет задачам оптимизации. Такое количество времени требуется для того, чтобы применить разного рода техники и достичь хороших показателей оптимизации. Требуется выявить все проблемы и узкие места, проследить поведение софта в соответствии со всеми имеющимися метриками и так далее. Примеры из этой статьи основаны на работе над RavenDB 4.0 (известная NoSQL база для .NET), которую компания Федерико тюнила до уровня наносекунд во всевозможных сложных кейсах.
Все примеры, которые встретятся вам в ходе рассказа (плюс некоторые дополнительные), доступны [в специальном репозитории на GitHub](https://github.com/redknightlois/performance-course).
> Осторожно, трафик! В этом посте присутствует огромное количество картинок — слайдов и скриншотов с видео в формате 720p. На слайдах присутствует важный для понимания статьи код.
Немного математики
==================
Представьте, что вы вернулись с очередного DotNext или обчитались Хабры в рабочее время, и ваш босс, полагая, что вы качественно прокачались в вопросах производительности, предлагает разработать систему, которая бы выполняла 20 миллиардов операций в день. Вдумайтесь в это число! Очевидно, идея безумная — реализовать нереально. Однако попробуем копнуть глубже и поймём одну важную вещь: 20 миллиардов операций должны выполняться в течение 24 часов *непрерывной работы* узла. Высокая или нет, но наша производительность обязательным образом будет устойчивой. Этот факт позволяет нам перейти к другим цифрам: 20000000000 / 24 = 833333333 операций в час. Легче ли нам? По правде, нет. Но мы можем продолжить разбивать наш показатель и далее. Получим, что требуемое количество операций в минуту: 833333333 / 60 = 13888888. Такое число уже более-менее поддаётся счёту. На следующем шаге получим количество операций в секунду — 13888888 / 60 = 231481. На практике, дальнейшее решение задачи, как правило, очень простое: мы берем, скажем, 40 серверов, каждый из которых обладал бы производительностью 231481 / 40 = 5787 операций в секунду. А ещё лучше, если возьмём 1500 серверов производительностью 231481 / 1500 = 154 операций в секунду. С такими цифрами уже можно работать. Получается, что число, вначале казавшееся нам неимоверно большим, уже не производит такого ужаса. На выполнение одной операции будет предоставлен целый узел и целых 5 миллисекунд его работы. Более того, в данном случае мы с уверенностью можем говорить о быстродействии нашей системы. Для сравнения, компьютерные игры выпускаются на рынок с отметкой в 13 миллисекунд.
Порядок чисел
=============
Большинство продаваемых высокопроизводительных систем характеризуется способностью одного узла обрабатывать около 600 запросов в секунду в непрерывном режиме. Как такое возможно? Разумеется, показатель во многом зависит от того бенчмарка, который предъявлен системе: выполняем ли мы попросту серию повторяющихся операций, возвращающих каждый раз одно и то же, или же мы рассылаем сообщения по всему миру и вообще делаем невесть что. Но дело в том, что если наша цель — добиться выполнения узлом 600 запросов в секунду в непрерывном режиме, то в изначальный проект системы мы должны закладывать показатель в 10 раз больший и ориентироваться на него. А 6000 запросов — задача, требующая иного рода усилий с инженерной точки зрения. 6000 операций в секунду — показатель, требующий планирования. Необходимо, чтобы кто-то постоянно контролировал свежий код, который дописывают в кодовую базу, и не пропускал бы ничего, что ставит показатель в 6000 операций под удар. И в конечном счёте вы добьетесь этой цели. А вот чтобы достигнуть производительности, которая была бы выше не на один, а на два порядка, то есть 60000 операций в секунду, те же самые методики уже не подойдут. Здесь нам потребуются серьёзные изощрения. Сегодня я хотел бы поделиться с вами теми секретами, которые используем в работе мы.
Обсуждать не будем, но примем за аксиомы
========================================
* Интероп — постоянный источник накладных расходов ресурсов:
+ Перфоманс убивает высокая частота маршалинга;
* Сборка мусора — основной источник проблем с производительностью;
* Нельзя использовать try-catch и LINQ:
+ [Эпилог и пролог](https://docs.microsoft.com/en-us/cpp/build/prolog-and-epilog) для исключений — не бесплатные;
+ Вызовы методов LINQ ведут к выделению памяти;
+ При высокой частоте выполнения коротких операций — всё пропало;
* Любой доступ до значений через интерфейсы приводит к выделению памяти в куче (иначе говоря, будет боксинг;
* Типы-значения нужно оптимизировать особым образом;
* `unsafe` называется небезопасным не просто так;
* GC pinning (явная блокировка объектов, запрещающая их перемещение в памяти сборщиком мусора) обходится очень дорого.
Всё, что нужно знать об инлайнинге
==================================
* Директивы компилятора — не более чем подсказки;
* Применяя инлайнинг, мы снижаем:
+ количество промахов кэша инструкций;
+ количество операций Push/Pop и обработку параметров;
+ количество переключений контекста на уровне процессора;
* Применяя инлайнинг, мы увеличиваем:
+ размер (в байтах) вызывающей функции;
+ область локальности ссылки;
* Связанные эффекты:
+ Dead Code Elimination;
+ Constant propagation;
+ Код может ускориться или замедлиться (нужно всё измерять!).
Даже зная обо всём этом, всё равно можно находить оптимизирующие решения. То, что будет дальше, полностью основано на нашем рабочем опыте. Никаких публикаций, отчетов об этом вы не найдёте. Выводы сделаны нами скорее эмпирически, на основе наших собственных наблюдений.
Порядковая оценка и Парето-классификация узких мест
===================================================
Знаменитый закон Парето говорит нам о том, что 20% кода использует 80% ресурсов. Оценка, как мы считаем, вполне реалистичная. Возведем эту пропорцию в квадрат и уменьшим масштаб значений в 100 раз. Получим квадрат закона Парето: 4.0% кода использует 64% (около ⅔) ресурсов. Если же возведем пропорцию в куб и уменьшим масштаб в 10000 раз, получим куб закона Парето: 0.8% кода использует приблизительно 51% (около половины) ресурсов. То есть имея кодовую базу в 1 миллион строк, мы вынуждены отвести примерно половину ресурсов на выполнение всего 5000 строк. Закон Парето первого, второго и третьего порядка — это то, что поможет нам классифицировать техники оптимизации. Проведём любимую работу программиста и разложим наши техники по группам:
1. В первую группу поместим техники оптимизации, работающие по закону Парето I порядка. Это техники про архитектуру системы, сетевое окружение, порядковую сложность используемых алгоритмов (пока что в терминах «большого О»).
2. Во вторую группу пойдут техники, для которых применим закон Парето II порядка. Они подразумевают работу над оптимизацией времени исполнения алгоритмов. Возможно ли, например, не допустить многократное выполнение того алгоритма, который может быть выполнен однократно?
3. Третья группа — это закон Парето III порядка, и здесь мы сталкиваемся с поистине непростыми вещами, требующими настоящей изобретательности. Это так называемые техники микрооптимизации.
Надо сказать, что, как правило, исходная производительность вашей системы будет требовать применения техник первой группы. Если уровень оптимизированности системы находится ниже некоторого порогового значения, то задумываться о техниках второй и третьей группы вам пока рано.
Работая над RavenDB
===================
Сейчас я продемонстрирую вам те проблемы, с которыми мы имели дело в работе над продуктом RavenDB пару версий назад. RavenDB — полностью управляемая документо-ориентированная база данных. Во времена версии RavenDB 2.0 мы использовали систему хранения Microsoft ESE (известную также как Esent). Продукт хороший. Но скоро выявилась проблема: каждый раз при сохранении данных выполнялся вызов интероп, который, как мы знаем, является достаточно ресурсозатратным. Другие проблемы производительности возникали, в частности, из-за использования криптографического хеширования, из-за обработки JSON. Также мы выполняли недостаточно батчинга и теряли производительность, используя Write Locks при записи данных. Итак, мы решили оптимизировать кодовую базу RavenDB 2.0. Мы создали своё собственное хранилище, которое было призвано решить проблему с интеропами. И что же, взамен мы получили две новых дыры! Точно так же мы обнаружили новые проблемы после того, как оптимизировали обработку JSON и стали выполнять больше батчинга. Устраняя имеющиеся узкие места, мы получали взамен всё новые и новые. Но уже к тому моменту предпринятые нами действия дали десятикратное увеличение производительности на критических ответвлениях кода, что само по себе достаточно существенно.
На пути от версии 3.0 к версии 4.0 RavenDB мы решили использовать кардинально другой подход — «Performance first». Мы отнесли клиентские требования на второй план, а во главу угла поставили производительность. Мы принялись работать с локальным распределением памяти, создали свой собственный строковый тип. Чтобы избежать копирования данных и добиться полного контроля над памятью, мы создали свой собственный формат бинарной сериализации. Мы разрабатывали собственные алгоритмы сжатия, заточенные специально под виды хранимых данных. Также мы бросили усилия на то, чтобы обеспечить полный контроль доступа к IO и памяти (к примеру, необходимо было иметь возможность напрямую указывать ядру, какие страницы выгружать и подгружать). Крайне важно было попытаться очистить код от виртуальных вызовов. Об эффективности такого рода методик заранее судить невозможно, они оцениваются лишь на практике. А каждая удачная оптимизация —это не просто величина, это новый множитель в формуле. Увеличение производительности — это всегда её умножение. Из всех тех ботлнеков, которые присутствовали в RavenDB 3.0, я бы хотел рассмотреть с вами три:
* проблему обработки JSON;
* проблемы управления памятью;
* большое число виртуальных вызовов.
Работа с памятью
================
Так или иначе, мы всё время имеем дело с запросами. Запрос некоторым образом начинается и завершается. Выделение памяти — это тоже запрос. Вначале память необходимо предоставить, а по окончании использования её необходимо вернуть. Как показала наша практика, приблизительно 90% случаев выделение памяти происходит для строк (такова специфика баз данных, ведь они в основном хранят строки). Далее в порядке убывания идут коллекции, объекты поколения Gen0, попадающие под сборку мусора (так называемые объекты «fire & forget»), асинхронные операции, объекты Context лямбда-функций. Если вы разрабатываете высокопроизводительный софт, от использования сборщика мусора вам придётся отказаться. А значит, освобождение памяти вы также будете осуществлять вручную. Мы создали такие строки, которыми бы управляла не среда, а мы лично (в буквальном смысле обращаясь к диску). Для краткости будем называть такие строки «неуправляемыми».
Теперь мы будем иметь дело с вопросами типа: кому принадлежит тот или иной участок памяти, как быстро может быть выделена память, возможно ли обеспечить высокую скорость выделения памяти, если речь идет о короткой строке? Если в ходе работы нам понадобится (в рамках того же потока) выполнить ещё один запрос на память, то, поскольку свободный сегмент будет располагаться по соседству с уже используемыми, он с большой долей вероятности окажется уже подгруженным в кэш. Но наличие в вашем коде ботлнеков может не дать вам возможности вести подобную ювелирную работу. Чтобы вы могли успешно заниматься таким видом оптимизации, ваш код должен быть скроен уже в достаточной мере бережливо. Тем не менее, данный подход относится к методикам закона Парето I порядка, поскольку пронизывает всю архитектуру системы. Решиться на подобные преобразования, как правило, нелегко. Вы должны быть готовы практически начать с чистого листа. Ваши версии не будут обладать двоичной программной совместимостью, что проблематично.
Анатомия ByteString
===================
Что такое `ByteString`? Его реализация выглядит примерно так:
Несколько флагов, длина `ByteString`, указатель на сегмент памяти, в котором он хранится, а также размер этого сегмента (на тот случай, если мы решим освободить его с возможностью переиспользования кем-то другим). Не сильно отличается от строкового типа плюсов, верно? Данная реализация `ByteString` напоминает нам и кое-что другое — Span библиотеки CoreCLR.
Span был впервые представлен в начале 2016 года, а сейчас вошел в мейнстрим. Внутри себя Span хранит ссылку на тип. А что такое ссылка? Это не что иное, как указатель, тщательно скрытый от нас за своей прекрасной реализацией. Второе поле Span хранит длину. Сам по себе Span нам не подойдёт, поскольку не поддерживает работы с неуправляемой памятью. Итак, `ByteString` — структура по типу Span, притом вполне законная для C#. Она прекрасно решает проблему управления памятью. Однако `ByteString` имеет одну большую проблему — она занимает целых 36 байт. Размер регистра данных позволяет нам хранить всего 8 байт, в лучшем случае — 32 байта. Передавать такую структуру в качестве параметра или возвращаемого значения будет крайне проблематично. И вся та производительность, которую мы выиграли за счёт концепции `ByteString`, будет потеряна при его передаче. Но такого рода проблема, как правило, находит решение в сообществе любого языка. Решат её так же, как и любую другую проблему в информатике: добавлением ещё одного уровня косвенности.
Создадим указатель на наш `ByteString`.
И теперь наш `ByteString` занимает 8 байт. Круто ведь! Но хочется задать вопрос: и всё же, как дорого нам обходится передача ByteString в качестве параметра *на самом деле*? Лучший способ выяснить — провести эксперимент. Экспериментировать специалист по производительности вынужден постоянно.
Пусть `ByteString` `"a"` задан внутри метода `UsingByteString`. Не будем выполнять никаких операций, метод должен просто вернуть `"а"`. Компилятору необходимо указать, что метод «холодный». «Горячий» метод всегда отработает быстрее — чистота эксперимента будет нарушена, показатель производительности окажется искажен в лучшую сторону. Напомню, что `ByteString`, в соответствии с нашей реализацией, должен занимать 8 байт. Ниже реализуем метод `UsingLong`, который выполнит те же самые действия (возврат значения) над 8-байтной переменной типа `long`. Если упраление `ByteString` через указатель окажется не сложней, чем управление переменной типа long, то методы `UsingByteString` и `UsingLong` отработают за равное время. В качестве реализации `ByteString` возьмём такую:
Реализация упрощена до минимума, но вполне подходит для нашего эксперимента. Создавая экземпляр структуры, мы выполняем присваивание значения именно указателю. Итак, сначала протестируем на переменной `long`. Отправная точка нашей программы:
Значение переменной long добудем из статической глобальной переменной. Затем запустим наш метод, возвращенное значение сохраним в переменную `"a"`. И, чтобы не дать компилятору вмешаться и оптимизировать здесь что-либо (а он делает это только тогда, когда все действия кода строго детерминированы, в частности, в нем отсутствуют побочные эффекты), добавим операцию с побочным эффектом — выполним вывод `"a"` в консоль. Запустим программу и получим такой результат:
Итак, первая операция mov перемещает в регистр `RCX` первый параметр метода. Далее следует операция call — вызов функции, после чего происходит копирование значения из регистра `RAX` в регистр `RCX` — запись значения, которое вернула функция, в переменную `"a"`. Следующий далее call — это вызов метода `WriteLine`. Теперь повторим то же самое, но с `ByteString`. Код для запуска:
Объявляем статическую глобальную переменную-указатель. Код `Main` аналогичен: инициализируем новый `ByteString`, вызываем метод `UsingByteString`, возвращенное значение сохраняем в переменную `"a"` и выводим её значение в консоль; во избежание каких-либо проблем с `Console.WriteLine`, добавим сюда явное приведение к типу `long`. Результаты выполнения программы:
Точно так же выполняется сохранение в регистр `RCX`, точно так же выполняется вызов метода, точно так же полученное значение копируется из регистра `RAX` в регистр `RCX`, и точно так же происходит вызов `WriteLine`. Результаты одинаковы!
Получается, что, несмотря на явное семантические отличие, на уровне JIT-компилятора эти два куска кода отрабатывают идентично. Возможно, вы кое о чём догадываетесь. Однако потерпите немного, вторая часть истории впереди.
Ликвидация ветвлений
====================
Втихаря от нас JIT-компилятор кое-что оптимизировал. Проиллюстрируем на другом примере:
Предположим, у нас есть пустой интерфейс `IMarker` и две его реализации — `MarkerI` и `MarkerJ`. Однако, что важно, объявим `MarkerI` и `MarkerJ` структурами, а не классами, как обычно. Ниже определим метод `Method`, для которого: — параметр типа, принадлежащий интерфейсу `IMarker`; `i` и `j` — входные параметры типа `int`. Внутри метода выполним простую операцию: если `T` равен `MarkerI`, то вернём значение `i`; если же `T` равен `MarkerJ` — вернём `j`. Запустим метод с параметром `MarkerI`.
Как именно будет обрабатывать такой вызов JIT-компилятор? Он увидит метод Method и параметр `MarkerI`, который ему передан. Затем он выполнит проверку принадлежности `MarkerI` интерфейсу `IMarker`, и, посчитав, что условие выполнено, приступит к выполнению тела метода. И далее, анализируя условие оператора if, компилятор выполнит довольно интересную операцию: он проверит, равен ли тип `MarkerI` типу `MarkerI` и, разумеется, получит значение `true`. Однако, поскольку `MarkerI` является структурой, а не классом, компилятор сочтет, что `true` в данном случае является константой и решит изъять из кода оператор if (а заодно и то, что следует после него), оставив только команды тела if. Код примет такой вид:
Теперь запустим метод с параметром `MarkerJ`.
В этот раз анализ условия оператора if даст значение `false` (переданный тип `MarkerJ` не равен типу `MarkerI`). Точно так же компилятор посчитает, что в данном случае `false` является константой, а значит можно изъять конструкцию if целиком вместе с содержимым. Таким образом, мы наблюдали генерацию JIT-компилятором кода для двух различных ветвей.
Зачем нам нужно обобщённое метапрограммирование?
================================================
Для программистов на C++ скажу: по тем же самым причинам, что и у вас. Для всех остальных оно позволяет:
* избегать частых виртуальных вызовов;
* адаптировать алгоритмы с учётом того, как именно мы планируем их использовать (например, того как часто);
* использовать возможности JIT-компилятора (определение значений констант и простых выражений) — получать улучшенный, «уплотненный» код;
* избегать инвариантных условий (мы не можем предугадывать ветвь исполнения, но мы можем свести к минимуму количество ветвлений).
Для более наглядного представления я приведу вам пример применения обобщенного метапрограммирования. Поговорим об пулах объектов.
Объектные пулы
==============
В сущности, мы имеем некоторый тип и имеем набор объектов этого типа — получается пул. Но объект ведь имеет жизненный цикл: однажды он создаётся, а рано или поздно нам нужно будет удалить его из памяти (связавшись с неуправляемой памятью, удаление мы вынуждены делать буквально руками). Есть и другой нюанс. Возможно, мы хотим сделать объект специально заточенным под тот или иной процессор. Если в последний раз некоторый объект был получен нами от процессора №1, то нам бы хотелось, чтобы дальнейшая работа с этим объектом произошла как можно скорее и на том же самом процессоре №1. Типичная реализация аллокатора на сегодняшний день выглядит примерно так:
Имеем объектный пул с NonThreadAwareBehavior. На вход конструктору мы передаем функцию factory, которая умеет создавать нужный нам объект. Фокус же состоит в том, что мы будем корректировать типы данных.
Сравним две реализации:
Первая использует классический подход, представленный только что. Во второй использован явный аллокатор, представленный обыкновенной структурой. Для создания же нового объекта пула, в данном случае нам достаточно использовать оператор New. Теперь протестируем и сравним эти две реализации.
Мы можем видеть, что реализация с factory задействовала 84 ассемблерные команды, а реализация с New — всего 57. То есть вариант с использованием New оказывается эффективнее в 1.7 раз. Насколько существенно для нас такое различие? Попробуем кое-что более интересное — реализуем ассоциативный массив (Dictionary).
Вдобавок к привычным двум аргументам ключа и значения, объявим третий — компаратор. Классическая реализация, соответствующая нашим пожеланиям, будет выглядеть примерно так:
В качестве компаратора указываем интерфейс `IEqualityComparer`. Реализация `NumericEqualityComparer` достаточно проста:
В данном случае `NumericEqualityComparer` представляет собой структуру, реализующую интерфейс `IEqualityComparer` для типа `long`. Метод `Equals` попросту возвращает результат проверки на равенство двух переданных ему значений типа `long`. Обратите внимание на особое указание к реализации метода — `AgressiveInlining`, увидев которое, JIT-компилятор будет по возможности выполнять метод как встроенный. Тестировать будем три разных варианта реализаций:
В первом случае осуществляем типичное для .NET использование ассоциативного массива с применением интерфейса. Во втором случае, минуя использование интерфейса, пробуем передать наш `NumericEqualityComparer` непосредственно в качестве типа. Третий вариант нужен нам для полноты картины. Здесь мы выполним то же самое с использованием ассоциативного массива CoreCLR. Результаты тестирования дают:
Очевидно, что алгоритмы `FastDictionary` работают быстрее. Но кроме того, мы видим, что прямое использование типа `NumericEqualityComparer` эффективнее использования интерфейса более чем в два раза. Я представил вам несколько примеров. Объективно ли использовать их в качестве бенчмарков? Ответ: нет. Нам необходимо провести реальное тестирование.
Отсюда мы видим, что на самом деле компараторы встроены не были: они оказались слишком большими. И тем не менее, использование `FastDictionary` уже повышает нашу производительность в 3,25 раз. Не любое использование `FastDictionary` даст нам подобный результат, поэтому важно разобраться в том, что же обусловило его в данном конкретном случае. Оптимизации, проводимые JIT-компиляторами, далеко не так просты, как кажутся.
Константы
=========
Ещё один пример:
Флагу doDispose присваивается некоторое вычисляемое значение. В момент реализации JIT-компилятор не может определить, является ли это значение константным (напомню, если в качестве параметра будет передана, например, структура, то выражение будет расценено как константа). Однако, в силу неопределённости, скомпилированный ассемблерный код будет вынужден хранить две возможные ветви. Попробуем ввести упрощения. Тот тип техники, который я вам покажу, важно применять с большой осторожностью, иначе он может иметь неожиданный эффект на клиентской стороне. Упрощать будем следующее:
*(На слайде ошибка: вместо `TEvictionStrategy` нужно использовать `TEviction`)*
Реализован метод `Clear`, который умеет очищать память от того или иного объекта. Но как нам определять какой объект удалить, а какой оставить? Можно назначить условия искусственно: пусть объект удаляется по прошествии определенного периода времени с момента последнего использования (скажем, 15 минут или часа). Но сейчас я воспользуюсь другим подходом.
Пусть `IEviction` — интерфейс критерия. А реализующие его `AlwaysEvictStrategy` и `NeverEvictStrategy`, предлагают две противоположные стратегии соответственно: «удалять можно» и «удалять нельзя». Технически, и `AlwaysEvictStrategy`, и `NeverEvictStrategy` содержат метод под названием `CanEvict`, который просто возвращает `true` и `false` соответственно. Код `Clear` будет выглядеть так:
В bucket хранятся некоторые объекты. Если имеется хоть один, мы бы хотели использовать `CanEvict`, чтобы понять, можно ли его удалить или нет. Нужно только указать используемую стратегию. А в зависимости от выбора (удалять или нет), скомпилированный код будет иметь разный вид. Если будет использована `AlwaysEvictStrategy`, компилятор видит следующее:
Обратите внимание на то, что теперь параметр типа при методе отсутствует, а в качестве второго параметра мы теперь имеем ссылку на `AlwaysEvictStrategy`.
Вызов CanEvict вернет значение true и будет заменен на константу. Конструкция if будет упрощена следующим образом:
В случае, если будет использована `NeverEvictStrategy`, наблюдаемая компилятором картина:
В условие оператора if попадёт константа `false`, возвращенная `CanEvict`.
Компилятор сочтет, что данная ветвь не будет исполнена никогда, а значит, if-конструкция будет полностью удалена:
А зачем в таком случае добывать значение `inst`? Компилятор не станет этого делать и удалит строку:
А зачем нужен вызов пустого метода?
Компилятор удалит вызов `Clear` из кода. У такого кода есть очевидная проблема:
Компилятор должен удалить цикл for, однако пока что он не может этого сделать.
Zero Cost Façade
================
Поговорим о другой реализации тех же самых техник. Предположим, у нас есть интерфейс `ILimitedOutputDirective`, реализованный структурами `NotLimited` и `LimitedOutput`. Также объявим интерфейс `ITableTypeDirective` и реализуем его структурами `ByU32` и `ByU16`.
Так будет выглядеть сигнатура метода:
Тело метода:
Если в качестве типа сжатия был указан `ByU16`, то выполнится первая ветвь if. Если был указан `ByU32` — выполнится вторая ветвь if. Если же указанный тип не является ни `ByU32`, ни `ByU16`, то бросим исключение. Можно адаптировать код под различные варианты использования. А можно применить методику, называемую «Zero Cost Façade». Её и рассмотрим.
Мы создали интерфейс `IUnmanagedWriteBuffer` и две его реализации: структура `UnmanagedStreamBuffer` (для потоков, которые, как правило, работают медленно, так как оперируют большим числом виртуальных вызовов) и структура `UnmanagedWriteBuffer` (для агрегирования и вывода данных). Что интересно, теперь вы можете конструировать новые типы путем надстройки над имеющимися. Сами структуры генерируются на лету.
Если необходимо, например, параметризировать создание `BlittableWriter` — вы просто добавите конструктор с соответствующими параметрами, внутри которого будет вызываться конструктор `TWriter`. Теперь мы можем написать, к примеру, такой код:
Это реализация метода `WriteNumber`, уже подверженная ряду оптимизаций. Обратите внимание на указание к `AgressiveInlining`. Причём неважно, добываем ли мы данные, выполняя виртуальный вызов или собирая по частям байты памяти — данный код абстрагирован от такой информации. JIT-компилятор поймет, что ему предложен эффективный код, и выполнит его. Как это использовать? При помощи такого подхода мы можем, к примеру, маскировать указатели и ссылки структурами.
Мы можем индексировать множество объектов пула, сопоставив каждому из них структуру, которая будет содержать две вещи: ссылку на пул и индекс на соответствующий объект.
Стоит ли вложиться во всё это?
==============================
Около 6 месяцев назад мы занимались микрооптимизацией JSON-парсера, исходные скорости которого были уже не так-то плохи. На тот момент для одного из наших тестов общее время парсинга составило 500 секунд (около 8 минут). Совершив первый двухнедельный заход и применив ряд озвученных сегодня методик оптимизации, мы достигли исполнения того же теста за 3 минуты. Спустя неделю мы приблизились к отметке в 2 минуты, а через пару дней тратили на тест уже менее 2-х минут. Таким образом, имея продукт далеко не низкой исходной производительности, мы сумели достичь дополнительной оптимизации его работы в 6,6 раз. А теперь представьте, что мы запускаем такое ПО на устройстве с маломощным процессором, таком как, например, Raspberry Pi. В данном случае оптимизация окажется абсолютно спасительной. Подумайте обо всех тех ресурсах, которые вы сэкономите, запуская такое ПО на огромном кластере из 1000 машин. Когда речь идёт о суперкомпьютерах, отказ от оптимизации производительности означает финансовый расход — реальный и при том каждодневный.
Подводя итог
============
Что подразумевать под оптимизацией? Во-первых, это обобщенное метапрограммирование, использующее упаковку типов в структуры. Это мощнейшее средство, открывающее большой простор для оптимизации.
В частности, обобщённое программирование позволяет:
* специализировать обобщённый код под конкретные условия;
* бесплатно делать фасады:
+ создаем интерфейсные структуры над типами;
+ создаем в интерфейсных типах обобщенные методы;
+ профит!
+ (как говорят в Rust, это «трейты для бедных» — другими словами, бесплатные абстракции);
+ (а в C# это похоже на [shapes and extensions](http://github.com/dotnet/csharplang/issues/164));
* избавляться от виртуальных методов (даже в сложных ситуациях).
Сообщество C#-программистов постоянно ищет новые решения. К примеру, они пробуют определить кое-что, именуемое идиомой «shapes & extensions». Реализации напоминают то, что я продемонстрировал вам сегодня, при этом код становится всё меньше похож на привычный C#.
* Cокрытие указателей и ссылок за структурами:
+ позволяет иметь бесплатные дженерики над указателями;
+ дает использовать структуры вместо последовательностей заранее подготовленных данных:
- позволяет относиться к ним как к прозрачным индексам;
- улучшает локализацию памяти;
- дает возможность работать с управляемой и неуправляемой памятью одинаковым способом;
+ помогает избежать расходования лишней памяти при захвате контекста в лямбдах.
Методика скрытия за структурами открывает много возможностей. Но вы должны иметь в виду, что она делает код более сложным для понимания. Есть риск, что программисты, читающие ваш код спустя полгода, не смогут понять вашего подхода (мы сталкивались с подобной проблемой в Corvalius).
Заключительная мысль
====================
Любой специалист по производительности должен понимать одну важную вещь: узкие места не могут исчезнуть, вместо этого они видоизменяются, становясь всё более трудноустранимыми. В борьбе с такими проблемами мы постепенно дошли до проблем уровня элементарной нехватки процессорного кэша. А ведь наша система способна за 6 минут загрузить в базу данных 64 Гб, используя при этом всего 17% ресурса процессора. То есть чем глубже залегают раскапываемые вами ботлнеки, чем сложнее задачи, для которых вы ищете решения — тем большей производительности вы *уже достигли*. К чему мы в итоге приходим? К необходимости оптимизации работы с I/O, к вопросам того, как обеспечить наличие свободной памяти каждый раз, когда она нам нужна. Работы много! Я думаю, что мы с вами ещё встретимся в будущем и обсудим найденные решения.
Что дальше?
===========
Смело знакомьтесь материалами моего репозитория, а также с моей подборкой лучших учебных материалов!
* Исходники RavenDB 4.0: [коммиты автора этой статьи, Federico Lois](https://github.com/ravendb/ravendb/search?o=desc&q=author%3Aredknightlois&s=author-date&type=Commits);
* [Local (arena) Memory Allocators — John Lakos [ACCU 2017]](https://www.youtube.com/watch?v=d1DpVR0tw0U);
* [Carl Cook «When a Microsecond Is an Eternity: High Performance Trading Systems in C++»](https://www.youtube.com/watch?v=NH1Tta7purM);
* [An Overview of Program Optimization Techniques — Mathias Gaunard [ACCU 2017]](https://www.youtube.com/watch?v=pEvm5NNc6ko);
* [MIT 6.172 Performance Engineering of Software Systems, Fall 2010 — BTree Write Cliff](https://www.youtube.com/watch?v=9Rb85cOXTKU);
* [Understanding Flash: The Write Cliff](https://flashdba.com/2014/11/24/understanding-flash-the-write-cliff/) (SSD);
* Блог [Oren Eini](https://ayende.com/blog/) — технические статьи о базах данных (Federico Lois иногда пишет туда статьи);
* [Баги CoreCLR по темам перформанса и оптимизаций](https://github.com/dotnet/coreclr/issues?q=label%3Atenet-performance%20%20label%3Aoptimization%20);
* [BenchmarkDotNet](https://github.com/dotnet/benchmarkdotnet).
> Минутка рекламы. Как вы, наверное, знаете, мы делаем конференции. Ближайшая конференция по .NET — [DotNext 2018 Piter](https://dotnext-piter.ru/). Она пройдет 22-23 апреля 2018 года в Санкт-Петербурге. Какие доклады там бывают — можно посмотреть в [нашем архиве на YouTube](https://www.youtube.com/watch?v=MpFEkVPbgiU&list=PLtWrKx3nUGBeYn-pSCjEgBPL90SvpylZL). На конференции можно будет вживую пообщаться с докладчиками и лучшими экспертами по .NET в специальных дискуссионных зонах после каждого доклада. Короче, заходите, мы вас ждём. | https://habr.com/ru/post/352362/ | null | ru | null |
# Высокопроизводительная сборка мусора для C++
[Мы](https://v8.dev/blog/trash-talk) [уже](https://v8.dev/blog/concurrent-marking) [писали](https://v8.dev/blog/tracing-js-dom) о сборке мусора для JavaScript, о DOM, и о том, как всё это реализовано и оптимизировано в JS-движке V8. Правда, Chromium — это не только JavaScript. Большая часть браузера и движок рендеринга Blink, куда встроен V8, написаны на C++. JavaScript можно использовать для работы с DOM, а на экран изменения выводятся с использованием конвейера рендеринга.
Так как граф C++-объектов, имеющих отношение к DOM, тесно связан с JavaScript-объектами, команда разработчиков Chromium пару лет назад начала использовать для управления памятью, в которой хранятся эти объекты, сборщик мусора, названный [Oilpan](https://www.youtube.com/watch?v=_uxmEyd6uxo). Oilpan — это сборщик мусора, написанный на C++ и предназначенный для управления C++-памятью, которая может быть подключена к V8. Управление памятью осуществляется с использованием технологии [кросс-компонентной сборки мусора](https://research.google/pubs/pub47359/). В рамках этой технологии граф связанных C++/JavaScript-объектов рассматривается как единая куча.
[](https://habr.com/ru/company/ruvds/blog/507516/)
Этот материал является первой публикацией, посвящённой Oilpan. Здесь будет сделан обзор основных принципов, лежащих в основе данного сборщика мусора, а также — C++-API Oilpan. Мы рассмотрим некоторые возможности, поддерживаемые Oilpan, расскажем о том, как устроена работа различных подсистемам сборщика мусора. Тут же мы разберём процесс конкурентного освобождения памяти, занятой объектами.
Самое интересное здесь то, что система Oilpan является частью Blink, но сейчас осуществляется её перевод в V8, где она будет представлена в форме [библиотеки для сборки мусора](https://chromium.googlesource.com/v8/v8.git/+/HEAD/include/cppgc/). Цель этого всего заключается в том, чтобы облегчить доступ к C++-механизмам сборки мусора всем тем, кто встраивает в свои платформы движок V8. Кроме того, то, что Oilpan станет библиотекой, позволит пользоваться этой системой абсолютно всем заинтересованным в ней C++-программистам.
Общие сведения
--------------
В Oilpan применяется система сборки мусора, в которой используется алгоритм пометок ([Mark and Sweep](https://en.wikipedia.org/wiki/Tracing_garbage_collection)). Этот алгоритм предусматривает разделение процесса сборки мусора на две фазы. Первая фаза заключается в исследовании кучи, и в пометке (mark) «живых» объектов, которые нельзя удалять из памяти. Вторая фаза — это очистка (sweep) памяти кучи, которую занимают ненужные («мёртвые») объекты.
О фазе mark нашей реализации алгоритма мы [уже писали](https://v8.dev/blog/concurrent-marking). Если вспомнить основные идеи того материала, то окажется, что поиск «живых» объектов может рассматриваться как обход графа, в котором объекты — это узлы, а указатели, с помощью которых объекты ссылаются друг на друга, это рёбра графа. Обход начинается с [корневых сущностей](https://v8.dev/blog/concurrent-marking#background), которыми являются объекты, о которых заранее известно то, что они — «живые». Это, например, глобальный объект и активные функции.
В этом плане C++ от JavaScript не отличается. Правда, в отличие от JavaScript-объектов, C++-объекты статически типизированы. Они, в результате, не могут менять собственное представление во время выполнения программы. При работе с C++-объектами с применением Oilpan этот факт учитывается и предоставляется описание указателей на другие объекты (рёбра графа) с использованием паттерна «Посетитель» (Visitor). Базовый паттерн используемый для описания Oilpan-объектов, выглядит так:
```
class LinkedNode final : public GarbageCollected {
public:
LinkedNode(LinkedNode\* next, int value) : next\_(next), value\_(value) {}
void Trace(Visitor\* visitor) const {
visitor->Trace(next\_);
}
private:
Member next\_;
int value\_;
};
LinkedNode\* CreateNodes() {
LinkedNode\* first\_node = MakeGarbageCollected(nullptr, 1);
LinkedNode\* second\_node = MakeGarbageCollected(first\_node, 2);
return second\_node;
}
```
В этом примере Oilpan управляет `LinkedNode`, на что указывает то, что класс `LinkedNode` является наследником `GarbageCollected`. Когда сборщик мусора обрабатывает объект, он находит указатели на другие объекты, вызывая метод объекта `Trace`. Тип `Member` — это интеллектуальный указатель, который, с синтаксической точки зрения, похож, например, на `std::shared_ptr`, который предоставляется Oilpan и используется для поддержания единообразного состояния при обходе графа объектов во время выполнения маркировки объектов. Всё это позволяет Oilpan точно знать о том, где именно находятся указатели, с которыми работает эта система.
Тот, кто внимательно прочитал вышеприведённый код, возможно, заметил (и, может быть, его это испугало) то, что `first_node` и `second_node` хранятся в стеке в виде обычных C++-указателей. Oilpan не задействует дополнительные абстракции для работы со стеком. Сборщик мусора, обрабатывая корневые объекты в куче, которой управляет, полагается исключительно на консервативное сканирование стека при поиске указателей. Всё это работает путём пословного перебора стека и благодаря интерпретации слов в виде указателей на сущности, находящиеся в управляемой куче. Это означает, что использование Oilpan не приводит к ухудшению производительности при доступе к объектам, размещаемым в стеке. Вместо этого нагрузка переносится на этап сборки мусора, когда осуществляется консервативное сканирование стека. Oilpan интегрирован в подсистему рендеринга и пытается откладывать запуск процедуры сборки мусора до тех пор, пока система не достигнет состояния, когда в стеке, точно, не будет ничего интересного. Так как работа веб основана на событиях, а выполнение кода производится путём обработки задач в циклах событий, в распоряжении Oilpan оказывается достаточно удобных моментов для запуска сборки мусора.
Oilpan используется в Blink, а это — большая кодовая база, написанная на C++, в которой содержатся значительные объёмы зрелого кода. Благодаря этому Oilpan, кроме прочего, отличается следующими возможностями:
* Множественное наследование с помощью миксинов и ссылок на подобные миксины (внутренние указатели).
* Поддержка вызова сборки мусора при выполнении конструкторов.
* Поддержание объектов из неуправляемой памяти в «живом» состоянии с помощью интеллектуальных указателей `Persistent`, которые рассматриваются как корневые сущности.
* Коллекции, представляющие собой последовательные (например — vector) и ассоциативные (например — set и map) контейнеры. Возможность уплотнения данных, лежащих в основе коллекций.
* Слабые ссылки, слабые функции и [эфемерные структур данных](https://en.wikipedia.org/wiki/Ephemeron).
* Финализаторы — методы, выполняемые перед удалением из памяти отдельных объектов.
Очистка памяти для C++
----------------------
О том, как осуществляется пометка объектов в ходе работы Oilpan, мы поговорим в другой раз. Сейчас же будем исходить из предположения о том, что пометка объектов уже выполнена и Oilpan уже обнаружил все достижимые объекты, используя метод объектов `Trace`. После того, как фаза пометки завершена, у достижимых объектов оказывается установленным соответствующий бит.
Очистка — это та фаза работы Oilpan, когда уничтожаются «мёртвые» объекты (те, которых не удалось достичь на фазе пометки объектов). Память, которую они занимают, либо возвращается операционной системе, либо становится доступной для выделения под другие объекты. Ниже мы поговорим о том, как Oilpan выполняет очистку памяти, рассмотрим особенности выполнения этого процесса и его ограничения. Мы, кроме того, поговорим о том, как механизму очистки памяти Oilpan удаётся достигать высоких скоростей при уничтожении «мёртвых» объектов.
Система очистки памяти находит «мёртвые» объекты, перебирая память кучи и проверяя соответствующие биты объектов. Для того чтобы сохранить семантику C++, системе очистки памяти нужно вызывать деструктор каждого из «мёртвых» объектов перед освобождением занимаемой им памяти. Нетривиальные деструкторы реализуются в виде финализаторов.
Здесь, с точки зрения программиста, нет заранее заданного порядка, в котором вызываются деструкторы, так как механизм перебора, используемый системой очистки памяти, не принимает во внимание порядок создания уничтожаемых объектов. Это накладывает на финализаторы ограничения, в соответствии с которым они не могут обращаться к другим объектам, находящимся в куче. Перед нами встаёт задача, встречающаяся достаточно часто. Она заключается в следующем: есть платформа, которая не поддерживает указание порядка финализации объектов (вроде Java), но при этом для данной платформы нужно писать код, требующий определённого порядка вызова финализаторов. Oilpan использует плагин Clang, который, в статическом режиме, обеспечивает запрет доступа к объектам кучи в процессе уничтожения объектов (это — лишь одна из многих возможностей Clang):
```
class GCed : public GarbageCollected {
public:
void DoSomething();
void Trace(Visitor\* visitor) {
visitor->Trace(other\_);
}
~GCed() {
other\_->DoSomething(); // error: Finalizer '~GCed' accesses
// potentially finalized field 'other\_'.
}
private:
Member other\_;
};
```
В этом коде происходит ошибка при попытке обращения к объекту из кучи в ходе уничтожения другого объекта.
Если вас интересует вопрос уничтожения объектов, то знайте, что Oilpan даёт в распоряжение программиста коллбэки, вызываемые перед финализатором. Это позволяет реализовывать сложные схемы уничтожения объектов, когда объекту, перед уничтожением, нужен доступ к другим объектам. Подобные коллбэки создают немалую дополнительную нагрузку на систему в ходе сборки мусора. Эта нагрузка больше той, которую способны создать деструкторы. Поэтому такие коллбэки используются в Blink относительно редко.
Инкрементальная и конкурентная очистка памяти
---------------------------------------------
Теперь, когда мы поговорили об ограничениях деструкторов в управляемом C++-окружении, пришло время более подробно остановиться на том, как в Oilpan реализована и оптимизирована очистка памяти.
Но, прежде чем переходить к этому разговору, важно вспомнить о том, как программы выполняются в веб-среде. Выполнение кода, а именно — JavaScript-кода, равно и как очистка мусора, инициируются главным потоком путём помещения задач в [цикл событий](https://en.wikipedia.org/wiki/Event_loop). Система рендеринга, как и другие среды для выполнения кода, поддерживает фоновые задачи, которые, вместе с главным потоком, выполняются в конкурентном режиме. Это позволяет снять часть нагрузки с главного потока.
В самом начале в Oilpan использовался механизм очистки памяти, реализованный по схеме «stop-the-world». Это означало, что выполнение приложения в главном потоке приостанавливалось во время проведения процедуры очистки памяти.
*Приостановка выполнения кода в ходе очистки памяти*
Для приложений, на которые не накладывается слишком сильных ограничений, касающихся их работы в режиме реального времени, определяющим фактором при использовании сборщика мусора являются задержки. Очистка памяти с использованием механизма, работающего по принципу stop-the-world, может приводить к тому, что выполнение программы будет приостанавливаться на значительные промежутки времени, что приводит к задержкам, заметным пользователям. Для сокращения времени этих задержек сборку мусора улучшили, реализовав в ней инкрементальную очистку памяти.
*Инкрементальная очистка памяти*
При использовании инкрементального подхода фазы пометки и уничтожения объектов отделены друг от друга. При этом процедура очистки памяти разбита на несколько частей, представленных отдельными задачами, выполняющимися в главном потоке. В лучшем случае подобные задачи выполняются только во время [простоя](https://research.google/pubs/pub45361/) системы, что позволяет избежать их конфликта с задачами, представляющими обычные механизмы приложения. Внутренние механизмы сборщика мусора разделяют одну большую задачу по очистке памяти на небольшие задачи, это разделение основано на понятии «страница». Страницы могут пребывать в двух состояниях. Одни страницы находятся в состоянии ожидания очистки (to-be-swept), а другие уже являются очищенными (already-swept). Механизмы выделения памяти учитывают только страницы, которые уже очищены, и пополняют локальные буферы выделения памяти (Local Allocation Buffer, LAB) из списка свободной памяти, в котором хранится список доступных фрагментов памяти. Для того чтобы получить память, сведения о которой есть в списке свободной памяти, приложение сначала попытается найти память, которая относится к уже очищенным страницам. Затем приложение попытается помочь системе в обработке страниц, которые ожидают очистки, воспользовавшись там, где оно пытается выделить память, системой очистки памяти. Новая память у операционной системы будет запрошена лишь в том случае, если вышеприведённые действия не привели к тому, что приложение получило нужную ему память.
В Oilpan механизм инкрементальной очистки памяти использовался несколько лет. Но, по мере того, как приложения, а значит и графы их объектов, становились всё больше и больше, очистка памяти начала влиять на производительность приложений. Ради улучшения механизмов сборки мусора, мы, для реализации конкурентной очистки памяти, начали использовать фоновые задачи. Для того чтобы исключить «гонку данных» между фоновыми задачами, выполняющими очистку памяти, и приложением, выделяющим память под новые объекты, существуют два правила:
* Система очистки памяти обрабатывает только память «мёртвых» объектов, которые, по определению, недостижимы из приложения.
* Приложение выделяет память, используя только ту память, которая принадлежит очищенным страницам. Такие страницы уже не интересуют систему очистки памяти.
Оба правила позволяют обеспечить то, что несколько сущностей не станут бороться друг с другом за один и тот же объект и его память. К сожалению, C++ сильно полагается на деструкторы, которые реализованы как финализаторы. Oilpan запускает финализаторы в главном потоке для того чтобы помочь разработчикам и исключить гонку данных в самом коде приложения. Для решения этой проблемы Oilpan планирует отложенное выполнение финализатора объекта в главном потоке. А если точнее, то всякий раз, когда конкурентная система очистки памяти сталкивается с объектом, у которого есть финализатор (деструктор), она помещает его в очередь финализации, которая будет обработана на особом этапе финализации. Код на этом этапе всегда выполняется в главном потоке, в котором, кроме того, выполняется и код приложения. Вот как, в общих чертах, выглядит схема конкурентной очистки памяти.
*Конкурентная очистка памяти с использованием фоновых задач*
Так как финализаторам может понадобиться доступ ко всему тому, что содержится в объектах, добавление соответствующей памяти в список свободной памяти откладывается до момента завершения выполнения финализатора. Если у объекта нет финализатора, то механизм очистки памяти, выполняющийся в фоновом потоке, сразу же добавляет освобождённую память в список свободной памяти.
Результаты
----------
Механизм фоновой очистки памяти был выпущен в сборке Chrome M78. Наш [фреймворк](https://v8.dev/blog/real-world-performance) для тестирования Chrome в условиях, приближенных к реальным, показал уменьшение времени, уходящего в главном потоке на операции, связанные с очисткой памяти, на 25-50% (в среднем — на 42%). Ниже показаны результаты испытаний некоторых популярных веб-проектов.
*Время в миллисекундах, затрачиваемое на выполнение операций по очистке памяти. Синим цветом выделены результаты, полученные в M77 без использования конкурентной очистки памяти. Красным представлены результаты M78, где конкурентная очистка памяти используется*
То время, которое всё ещё уходит в главном потоке на очистку памяти, требуется для выполнения финализаторов. В настоящее время идёт работа по оптимизации финализаторов для типов объектов, которые часто используются в Blink. Примечательно здесь то, что все такие оптимизации проводятся за пределами кода системы очистки памяти, так как эта система, в её текущем виде, автоматически подстраивается под ситуацию при отсутствии финализаторов.
Сталкивались ли вы с проблемами производительности веб-проектов, которые вызваны системой сборки мусора Chrome?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=sborka-musora-c)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=sborka-musora-c#order) | https://habr.com/ru/post/507516/ | null | ru | null |
# Опять про пустые перечисления в C#
На этот пост мня вдохновила свежая [статья на Хабре](https://habrahabr.ru/post/349852/) отсылающая к уже давней проблеме (и [советующей статье](https://habrahabr.ru/post/97464/)) о том, как же проверить, что **IEnumerable** является пустым. Однако в оригинальных статьях, авторы больше сфокусировались на том как оформить проверку, предположив, что проверки вида:
```
public static bool IsNullOrEmpty(this IEnumerable items)
{
return items == null || !items.Any();
}
```
будет достаточно, но на мой взгляд, подобный подход применим далеко не всегда.
Дело в том, что **IEnumerable** – это, по сути, фабрика для **IIterator**, но с точки зрения вызывающего кода, затраты на создание итератора совершено непредсказуемы. Ситуацию усложняет тот факт, что в C# и для списков, и для массивов, и для **IEnumerable** можно использовать один и тот же оператор **foreach** и одни и те же методы LINQ, которые скрывают создание **IIterator** и делают в сознании многих разработчиков неразличимыми списки, массивы, и **IEnumerable**. Однако же разница может быть колоссальной — при вызове с виду безобидного кода **items.Any()** могут происходить разные ресурсоемкие операций такие как: создание подключения и запрос к базе данных, вызов REST Api или просто множество тяжелых вычислений:
```
private IEnumerable GetItemsDb()
{
using (var connection = new SqlConnection("connection string"))
{
connection.Open();
using (var command = new SqlCommand("SELECT Id FROM Table"))
{
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
yield return reader.GetInt32(0);
}
}
}
}
}
```
```
private IEnumerable GetItemsLinq()
{
return Enumerable
.Range(0, 100)
.Reverse()
.Select(
i =>
{
Thread.Sleep(100);
return i;
})
.Where(i => i < 10);
}
```
Но что же делать в том случае, если необходимо узнать вернет ли подобный итератор какие-нибудь элементы или нет? Например, нам нужно написать код суммирующий все элементы возвращаемые **GetItemsLinq()**, но если элементов нет, то код должен вернуть **null**:
```
int? result = GetSum(GetItemsLinq());
...
private static int? GetSum(IEnumerable items)
{
...
}
```
Думаю, что многие бы реализовали метод GetSum следующим образом:
```
private static int? GetSum(IEnumerable items)
{
return items != null && items.Any() ? (int?)items.Sum() : null;
}
```
и… столкнулись бы с ситуаций, что **GetSum(GetItemsLinq())** выполняется в течении 19,1 секунд вместо ожидаемых десяти. Дело в том, что для **items.Any()** необходимо перебрать 91 оригинальный элемент для того что бы понять, что на выходе что-то есть, а на каждый элемент мы тратим по 100 миллисекунд. Давайте попробуем чуть оптимизировать метод **GetSum**:
```
private static int? GetSumm(IEnumerable items)
{
var list = items as IReadOnlyCollection ?? items?.ToList();
return list != null && list.Count > 0 ? (int?)list.Sum() : null;
}
```
Теперь код выполняется за ожидаемые 10 секунд, но ценой выделения в памяти промежуточного буфера. А если элементов будет гораздо больше чем 10? В общем, можно еще оптимизировать:
```
private static int? GetSum(IEnumerable items)
{
if (items == null) return null;
using (var enumerator = items.GetEnumerator())
{
if (enumerator.MoveNext())
{
int result = enumerator.Current;
while (enumerator.MoveNext())
{
result += enumerator.Current;
}
return result;
}
return null;
}
}
```
Теперь код выполняется за 10 секунд и не потребляет лишней памяти, но… писать подобный код каждый раз, когда нужно проверить наличие элементов в **IEnumerable** мне бы не хотелось. Можно ли этот код как-то переиспользовать? Мое предложение, это создать extension метод который бы принимал в качестве аргумента функцию, в которую мы передадим заведомо непустой **IEnumerable**. Предполагается что эта функция вернет результат обработки этого **IEnumerable**. “Заведомо непустой IEnumerable” это обертка над уже открытом итератором которая при запросе первого элемента вернет первый уже полученный элемент и затем продолжит перечисление:
```
public static class EnumerableHelper
{
public static TRes ProcessIfNotEmpty(
this IEnumerable source,
Func, TRes> handler,
Func defaultValue)
{
switch (source)
{
case null: return defaultValue();
case IReadOnlyCollection collection:
return collection.Count > 0 ? handler(collection) : defaultValue();
default:
using (var enumerator = new DisposeGuardWrapper(source.GetEnumerator()))
{
if (enumerator.MoveNext())
{
return handler(Continue(enumerator.Current, enumerator));
}
}
return defaultValue();
}
}
private static IEnumerable Continue(T first, IEnumerator startedEnumerator)
{
yield return first;
while (startedEnumerator.MoveNext())
{
yield return startedEnumerator.Current;
}
}
private class DisposeGuardWrapper : IEnumerator
{
...
}
}
```
*[Полный исходный код тут](https://github.com/0x1000000/ProcessIfNotEmpty)*
Используя этот вспомогательный метод, мы сможем решить нашу задачу следующим образом:
```
int? result = GetItemsLinq().ProcessIfNotEmpty(items=> items.Sum(), () => (int?)null);
```
К сожалению, у этого подхода есть один существенный недостаток, мы не можем вынести работу с **items** за пределы **ProcessIfNotEmpty**, поскольку итератор созданный для проверки наличия элементов не будет должным образом закрыт. Для предотвращения подобных случав создан класс **DisposeGuardWrapper** и следующий код будет выдавать исключение:
```
int? result = GetItemsLinq().ProcessIfNotEmpty(items=> items, () => null).Sum();
```
Неприятно конечно, но на мой взгляд, всяко лучше, чем тратить лишние ресурсы или каждый раз писать шаблонный код. Возможно кто-то предложит лучший вариант. | https://habr.com/ru/post/349920/ | null | ru | null |
# Анализ кода CUBA Platform с помощью PVS-Studio
Для Java программистов существуют полезные инструменты, помогающие писать качественный код, например, мощная среда разработки IntelliJ IDEA, бесплатные анализаторы SpotBugs, PMD и другие. Всё это уже используется в разработке проекта CUBA Platform, и в этом обзоре найденных дефектов кода я расскажу, как ещё можно улучшить качество проекта, используя статический анализатор кода PVS-Studio.
О проекте и анализаторе
-----------------------
[CUBA Platform](https://www.cuba-platform.ru/) — это высокоуровневый Java-фреймворк для быстрого создания корпоративных приложений с полноценным веб-интерфейсом. Платформа абстрагирует разработчика от разнородных технологий, чтобы вы могли сфокусироваться на решении задач бизнеса, в то же время, не лишая возможности работать с ними напрямую. Исходный код взят из репозитория на [GitHub](https://github.com/cuba-platform/cuba).
[PVS-Studio](https://www.viva64.com/ru/pvs-studio/) — это инструмент для выявления ошибок и потенциальных уязвимостей в исходном коде программ, написанных на языках C, C++, C# и Java. Работает в 64-битных системах на Windows, Linux и macOS. Для удобства Java-программистов мы разработали плагины для Maven, Gradle и IntelliJ IDEA. Проект CUBA Platform легко проверился с помощью плагина для Gradle.
Ошибки в условиях
-----------------
**Предупреждение 1**
[V6007](https://www.viva64.com/ru/w/v6007/) Expression 'StringUtils.isNotEmpty(«handleTabKey»)' is always true. SourceCodeEditorLoader.java(60)
```
@Override
public void loadComponent() {
....
String handleTabKey = element.attributeValue("handleTabKey");
if (StringUtils.isNotEmpty("handleTabKey")) {
resultComponent.setHandleTabKey(Boolean.parseBoolean(handleTabKey));
}
....
}
```
После извлечения значения атрибута из некого элемента не выполняется проверка этого значения. Вместо этого в функцию *isNotEmpty* передаётся константная строка, а надо было передать переменную *handleTabKey*.
Есть ещё одна аналогичная ошибка в файле AbstractTableLoader.java:
* V6007 Expression 'StringUtils.isNotEmpty(«editable»)' is always true. AbstractTableLoader.java(596)
**Предупреждение 2**
[V6007](https://www.viva64.com/ru/w/v6007/) Expression 'previousMenuItemFlatIndex >= 0' is always true. CubaSideMenuWidget.java(328)
```
protected MenuItemWidget findNextMenuItem(MenuItemWidget currentItem) {
List menuTree = buildVisibleTree(this);
List menuItemWidgets = menuTreeToList(menuTree);
int menuItemFlatIndex = menuItemWidgets.indexOf(currentItem);
int previousMenuItemFlatIndex = menuItemFlatIndex + 1;
if (previousMenuItemFlatIndex >= 0) {
return menuItemWidgets.get(previousMenuItemFlatIndex);
}
return null;
}
```
Функция *indexOf* может вернуть значение *-1*, если в списке не будет найден элемент. Затем к индексу прибавляется единица, скрывая таким образом ситуацию, когда нужный элемент отсутствует. Другой потенциальной проблемой может стать тот факт, что переменная *previousMenuItemFlatIndex* будет всегда больше или равна нулю. Если, например, список *menuItemWidgets* будет пустым, то становится возможным выход за границу массива.
**Предупреждение 3**
[V6009](https://www.viva64.com/ru/w/v6009/) The 'delete' function could receive the '-1' value while non-negative value is expected. Inspect argument: 1. AbstractCollectionDatasource.java(556)
```
protected DataLoadContextQuery createDataQuery(....) {
....
StringBuilder orderBy = new StringBuilder();
....
if (orderBy.length() > 0) {
orderBy.delete(orderBy.length() - 2, orderBy.length());
orderBy.insert(0, " order by ");
}
....
}
```
В буфере символов *orderBy* удаляют последние 2 символа, если их общее количество больше нуля, т.е. строка содержит один символ или больше. Но стартовую позицию удаления символов задали со смещением на 2 символа. Таким образом, если вдруг *orderBy* будет состоять из 1 символа, попытка удаления приведёт к исключению *StringIndexOutOfBoundsException*.
**Предупреждение 4**
[V6013](https://www.viva64.com/ru/w/v6013/) Objects 'masterCollection' and 'entities' are compared by reference. Possibly an equality comparison was intended. CollectionPropertyContainerImpl.java(81)
```
@Override
public void setItems(@Nullable Collection entities) {
super.setItems(entities);
Entity masterItem = master.getItemOrNull();
if (masterItem != null) {
MetaProperty masterProperty = getMasterProperty();
Collection masterCollection = masterItem.getValue(masterProperty.getName());
if (masterCollection != entities) {
updateMasterCollection(masterProperty, masterCollection, entities);
}
}
}
```
В функции *updateMasterCollection* значения из *entities* копируются в *masterCollection*. Перед этим коллекции сравнили по ссылке, но, возможно, их планировали сравнивать по значению.
**Предупреждение 5**
[V6013](https://www.viva64.com/ru/w/v6013/) Objects 'value' and 'oldValue' are compared by reference. Possibly an equality comparison was intended. WebOptionsList.java(278)
```
protected boolean isCollectionValuesChanged(Collection *value,
Collection *oldValue) {
return value != oldValue;
}**
```
Этот пример похож на предыдущий. Здесь *isCollectionValuesChanged* предназначена для сравнения коллекций. Возможно, сравнение по ссылке тоже не тот способ, который ожидался.
Избыточные условия
------------------
**Предупреждение 1**
[V6007](https://www.viva64.com/ru/w/v6007/) Expression 'mask.charAt(i + offset) != placeHolder' is always true. DatePickerDocument.java(238)
```
private String calculateFormattedString(int offset, String text) .... {
....
if ((mask.charAt(i + offset) == placeHolder)) { // <=
....
} else if ((mask.charAt(i + offset) != placeHolder) && // <=
(Character.isDigit(text.charAt(i)))) {
....
}
....
}
```
Во втором сравнении проверяется выражение, которое противоположно первому. Вторую проверку можно удалить, что упростит код.
[V6007](https://www.viva64.com/ru/w/v6007/) Expression 'connector == null' is always false. HTML5Support.java(169)
```
private boolean validate(NativeEvent event) {
....
while (connector == null) {
widget = widget.getParent();
connector = Util.findConnectorFor(widget);
}
if (this.connector == connector) {
return true;
} else if (connector == null) { // <=
return false;
} else if (connector.getWidget() instanceof VDDHasDropHandler) {
return false;
}
return true;
}
```
После завершения цикла *while*, значение переменной *connector* не будет равняться *null*, следовательно, избыточную проверку можно удалить.
Ещё одно подозрительное место, на которое стоит обратить внимание разработчикам:
* V6007 Expression 'StringUtils.isBlank(strValue)' is always true. Param.java(818)
Недостижимый код в тестах
-------------------------
[V6019](https://www.viva64.com/ru/w/v6019/) Unreachable code detected. It is possible that an error is present. TransactionTest.java(283)
```
private void throwException() {
throw new RuntimeException(TEST_EXCEPTION_MSG);
}
@Test
public void testSuspendRollback() {
Transaction tx = cont.persistence().createTransaction();
try {
....
Transaction tx1 = cont.persistence().createTransaction();
try {
EntityManager em1 = cont.persistence().getEntityManager();
assertTrue(em != em1);
Server server1 = em1.find(Server.class, server.getId());
assertNull(server1);
throwException(); // <=
tx1.commit(); // <=
} catch (Exception e) {
//
} finally {
tx1.end();
}
tx.commit();
} finally {
tx.end();
}
}
```
Функция *throwException* бросает исключение, из-за которого не выполняется вызов функции *tx1.commit.* Возможно, эти строки стоит поменять местами.
Ещё несколько похожих мест в других тестах:
* V6019 Unreachable code detected. It is possible that an error is present. TransactionTest.java(218)
* V6019 Unreachable code detected. It is possible that an error is present. TransactionTest.java(163)
* V6019 Unreachable code detected. It is possible that an error is present. TransactionTest.java(203)
* V6019 Unreachable code detected. It is possible that an error is present. TransactionTest.java(137)
* V6019 Unreachable code detected. It is possible that an error is present. UpdateDetachedTest.java(153)
* V6019 Unreachable code detected. It is possible that an error is present. EclipseLinkDetachedTest.java(132)
* V6019 Unreachable code detected. It is possible that an error is present. PersistenceTest.java(223)
Подозрительные аргументы функций
--------------------------------
**Предупреждение 1**
[V6023](https://www.viva64.com/ru/w/v6023/) Parameter 'salt' is always rewritten in method body before being used. BCryptEncryptionModule.java(47)
```
@Override
public String getHash(String content, String salt) {
salt = BCrypt.gensalt();
return BCrypt.hashpw(content, salt);
}
```
В криптографии *salt* — строка данных, которая передаётся хеш-функции вместе с паролем. Главным образом используется для защиты от перебора по словарю и атак с использованием радужных таблиц, а также сокрытия одинаковых паролей. Подробнее: [Соль (криптография)](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BB%D1%8C_(%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%8F)).
В этой функции строка перетирается сразу при входе в функцию. Возможно, игнорирование переданного значения является потенциальной уязвимостью.
**Предупреждение 2**
Для рассматриваемой функции анализатор выдаёт сразу два предупреждения:
* [V6023](https://www.viva64.com/ru/w/v6023/) Parameter 'offsetWidth' is always rewritten in method body before being used. CubaSuggestionFieldWidget.java(433)
* [V6023](https://www.viva64.com/ru/w/v6023/) Parameter 'offsetHeight' is always rewritten in method body before being used. CubaSuggestionFieldWidget.java(433)
```
@Override
public void setPosition(int offsetWidth, int offsetHeight) {
offsetHeight = getOffsetHeight();
....
if (offsetHeight + getPopupTop() > ....)) {
....
}
....
offsetWidth = containerFirstChild.getOffsetWidth();
if (offsetWidth + getPopupLeft() > ....)) {
....
} else {
left = getPopupLeft();
}
setPopupPosition(left, top);
}
```
Занятный код. Функция принимает всего две переменных: *offsetWidth* и *offsetHeight*, обе перезаписываются перед использованием.
**Предупреждение 3**
[V6022](https://www.viva64.com/ru/w/v6022/) Parameter 'shortcut' is not used inside constructor body. DeclarativeTrackingAction.java(47)
```
public DeclarativeTrackingAction(String id, String caption, String description,
String icon, String enable, String visible,
String methodName, @Nullable String shortcut,
ActionsHolder holder) {
super(id);
this.caption = caption;
this.description = description;
this.icon = icon;
setEnabled(enable == null || Boolean.parseBoolean(enable));
setVisible(visible == null || Boolean.parseBoolean(visible));
this.methodName = methodName;
checkActionsHolder(holder);
}
```
Значение параметра *shortcut* не используется в функции. Возможно, интерфейс функции устарел или это предупреждение не является ошибкой.
Ещё несколько подобных мест:
* V6022 Parameter 'type' is not used inside constructor body. QueryNode.java(36)
* V6022 Parameter 'text2' is not used inside constructor body. MarkerAddition.java(22)
* V6022 Parameter 'selection' is not used inside constructor body. AceEditor.java(114)
* V6022 Parameter 'options' is not used inside constructor body. EntitySerialization.java(379)
Разные функции с одинаковым кодом
---------------------------------
**Предупреждение 1**
[V6032](https://www.viva64.com/ru/w/v6032/) It is odd that the body of method 'firstItemId' is fully equivalent to the body of another method 'lastItemId'. ContainerTableItems.java(213), ContainerTableItems.java(219)
```
@Override
public Object firstItemId() {
List items = container.getItems();
return items.isEmpty() ? null : items.get(0).getId();
}
@Override
public Object lastItemId() {
List items = container.getItems();
return items.isEmpty() ? null : items.get(0).getId();
}
```
Функции *firstItemId* и *lastItemId* имеют одинаковую реализацию. Скорее всего, в последней необходимо было получать элемент не с индексом *0*, а вычислять индекс последнего элемента.
**Предупреждение 2**
[V6032](https://www.viva64.com/ru/w/v6032/) It is odd that the body of method is fully equivalent to the body of another method. SearchComboBoxPainter.java(495), SearchComboBoxPainter.java(501)
```
private void paintBackgroundDisabledAndEditable(Graphics2D g) {
rect = decodeRect1();
g.setPaint(color53);
g.fill(rect);
}
private void paintBackgroundEnabledAndEditable(Graphics2D g) {
rect = decodeRect1();
g.setPaint(color53);
g.fill(rect);
}
```
Ещё две функции с подозрительно одинаковой реализацией. Рискну предположить, что в одной из них нужно было использовать другой цвет, отличный от *color53*.
Обращение по нулевой ссылке
---------------------------
**Предупреждение 1**
[V6060](https://www.viva64.com/ru/w/v6060/) The 'descriptionPopup' reference was utilized before it was verified against null. SuggestPopup.java(252), SuggestPopup.java(251)
```
protected void updateDescriptionPopupPosition() {
int x = getAbsoluteLeft() + WIDTH;
int y = getAbsoluteTop();
descriptionPopup.setPopupPosition(x, y);
if (descriptionPopup!=null) {
descriptionPopup.setPopupPosition(x, y);
}
}
```
Всего в двух строчках автору удалось написать очень подозрительный код. Сначала у объекта *descriptionPopup* вызывается метод *setPopupPosition*, а потом объект сравнивается с *null*. Скорее всего, первый вызов функции *setPopupPosition* является лишним и опасным. Похоже на последствия неудачного рефакторинга.
**Предупреждения 2**
[V6060](https://www.viva64.com/ru/w/v6060/) The 'tableModel' reference was utilized before it was verified against null. DesktopAbstractTable.java(1580), DesktopAbstractTable.java(1564)
```
protected Column addRuntimeGeneratedColumn(String columnId) {
// store old cell editors / renderers
TableCellEditor[] cellEditors =
new TableCellEditor[tableModel.getColumnCount() + 1]; // <=
TableCellRenderer[] cellRenderers =
new TableCellRenderer[tableModel.getColumnCount() + 1]; // <=
for (int i = 0; i < tableModel.getColumnCount(); i++) { // <=
Column tableModelColumn = tableModel.getColumn(i);
if (tableModel.isGeneratedColumn(tableModelColumn)) { // <=
TableColumn tableColumn = getColumn(tableModelColumn);
cellEditors[i] = tableColumn.getCellEditor();
cellRenderers[i] = tableColumn.getCellRenderer();
}
}
Column col = new Column(columnId, columnId);
col.setEditable(false);
columns.put(col.getId(), col);
if (tableModel != null) { // <=
tableModel.addColumn(col);
}
....
}
```
Похожая ситуация и в этой функции. После многочисленных обращений к объекту *tableModel* выполняется проверка, равен он *null* или нет.
Ещё один пример:
* V6060 The 'tableModel' reference was utilized before it was verified against null. DesktopAbstractTable.java(596), DesktopAbstractTable.java(579)
Возможно, логическая ошибка
---------------------------
[V6026](https://www.viva64.com/ru/w/v6026/) This value is already assigned to the 'sortAscending' variable. CubaScrollTableWidget.java(488)
```
@Override
protected void sortColumn() {
....
if (sortAscending) {
if (sortClickCounter < 2) {
// special case for initial revert sorting instead of reset sort order
if (sortClickCounter == 0) {
client.updateVariable(paintableId, "sortascending", false, false);
} else {
reloadDataFromServer = false;
sortClickCounter = 0;
sortColumn = null;
sortAscending = true; // <=
client.updateVariable(paintableId, "resetsortorder", "", true);
}
} else {
client.updateVariable(paintableId, "sortascending", false, false);
}
} else {
if (sortClickCounter < 2) {
// special case for initial revert sorting instead of reset sort order
if (sortClickCounter == 0) {
client.updateVariable(paintableId, "sortascending", true, false);
} else {
reloadDataFromServer = false;
sortClickCounter = 0;
sortColumn = null;
sortAscending = true;
client.updateVariable(paintableId, "resetsortorder", "", true);
}
} else {
reloadDataFromServer = false;
sortClickCounter = 0;
sortColumn = null;
sortAscending = true;
client.updateVariable(paintableId, "resetsortorder", "", true);
}
}
....
}
```
В первом условии переменная *sortAscending* и так равна *true*, но ей всё равно присваивают то же самое значение. Возможно, это является ошибкой и хотели присвоить *false*.
Похожий пример из другого файла:
* V6026 This value is already assigned to the 'sortAscending' variable. CubaTreeTableWidget.java(444)
Странные возвращаемые значения функций
--------------------------------------
**Предупреждение 1**
[V6037](https://www.viva64.com/ru/w/v6037/) An unconditional 'return' within a loop. QueryCacheManager.java(128)
```
public T getSingleResultFromCache(QueryKey queryKey, List views) {
....
for (Object id : queryResult.getResult()) {
return (T) em.find(metaClass.getJavaClass(), id, views.toArray(....));
}
....
}
```
Анализатор обнаружил безусловный вызов оператора *return* на первой же итерации цикла *for*. Возможно, тут ошибка, или нужно переписать код на использование оператора *if*.
**Предупреждение 2**
[V6014](https://www.viva64.com/ru/w/v6014/) It's odd that this method always returns one and the same value. DefaultExceptionHandler.java(40)
```
@Override
public boolean handle(ErrorEvent event, App app) {
Throwable t = event.getThrowable();
if (t instanceof SocketException
|| ExceptionUtils.getRootCause(t) instanceof SocketException) {
return true;
}
if (ExceptionUtils.getThrowableList(t).stream()
.anyMatch(o -> o.getClass().getName().equals("...."))) {
return true;
}
if (StringUtils.contains(ExceptionUtils.getMessage(t), "....")) {
return true;
}
AppUI ui = AppUI.getCurrent();
if (ui == null) {
return true;
}
if (t != null) {
if (app.getConnection().getSession() != null) {
showDialog(app, t);
} else {
showNotification(app, t);
}
}
return true;
}
```
Эта функция во всех случаях возвращает значение *true*. Но вот в самой последней строчке напрашивается возврат значения *false*. Возможно, тут допущена ошибка.
Весь список подозрительных функций с похожим кодом:
* V6014 It's odd that this method always returns one and the same value. ErrorNodesFinder.java(31)
* V6014 It's odd that this method always returns one and the same value. FileDownloadController.java(69)
* V6014 It's odd that this method always returns one and the same value. IdVarSelector.java(73)
* V6014 It's odd that this method always returns one and the same value. IdVarSelector.java(48)
* V6014 It's odd that this method always returns one and the same value. IdVarSelector.java(67)
* V6014 It's odd that this method always returns one and the same value. IdVarSelector.java(46)
* V6014 It's odd that this method always returns one and the same value. JoinVariableNode.java(57)
**Предупреждение 3**
[V6007](https://www.viva64.com/ru/w/v6007/) Expression 'needReload' is always false. WebAbstractTable.java(2702)
```
protected boolean handleSpecificVariables(Map variables) {
boolean needReload = false;
if (isUsePresentations() && presentations != null) {
Presentations p = getPresentations();
if (p.getCurrent() != null && p.isAutoSave(p.getCurrent())
&& needUpdatePresentation(variables)) {
Element e = p.getSettings(p.getCurrent());
saveSettings(e);
p.setSettings(p.getCurrent(), e);
}
}
return needReload;
}
```
Функция возвращает переменную *needReload*, значение которой всегда равно *false*. Скорее всего, в одном из условий забыли добавить код изменения значения переменной.
**Предупреждение 4**
[V6062](https://www.viva64.com/ru/w/v6062/) Possible infinite recursion inside the 'isFocused' method. GwtAceEditor.java(189), GwtAceEditor.java(190)
```
public final native void focus() /*-{
this.focus();
}-*/;
public final boolean isFocused() {
return this.isFocused();
}
```
Анализатор обнаружил функцию, которая вызывается рекурсивно без условия остановки рекурсии. В этом файле много функций, которые помечены ключевым словом *native* и содержат закомментированный код. Скорее всего, файл в данный момент переписывается и вскоре разработчики обратят внимание и на функцию *isFocused*.
Разные предупреждения
---------------------
**Предупреждение 1**
[V6002](https://www.viva64.com/ru/w/v6002/) The switch statement does not cover all values of the 'Operation' enum: ADD. DesktopAbstractTable.java(665)
```
/**
* Operation which caused the datasource change.
*/
enum Operation {
REFRESH,
CLEAR,
ADD,
REMOVE,
UPDATE
}
@Override
public void setDatasource(final CollectionDatasource datasource) {
....
collectionChangeListener = e -> {
switch (e.getOperation()) {
case CLEAR:
case REFRESH:
fieldDatasources.clear();
break;
case UPDATE:
case REMOVE:
for (Object entity : e.getItems()) {
fieldDatasources.remove(entity);
}
break;
}
};
....
}
```
В операторе *switch* не рассмотрено значение *ADD*. Оно является единственным нерассмотренным, поэтому стоит проверить, ошибка это или нет.
**Предупреждение 2**
[V6021](https://www.viva64.com/ru/w/v6021/) Variable 'source' is not used. DefaultHorizontalLayoutDropHandler.java(177)
```
@Override
protected void handleHTML5Drop(DragAndDropEvent event) {
LayoutBoundTransferable transferable = (LayoutBoundTransferable) event
.getTransferable();
HorizontalLayoutTargetDetails details = (HorizontalLayoutTargetDetails) event
.getTargetDetails();
AbstractOrderedLayout layout = (AbstractOrderedLayout) details
.getTarget();
Component source = event.getTransferable().getSourceComponent(); // <=
int idx = (details).getOverIndex();
HorizontalDropLocation loc = (details).getDropLocation();
if (loc == HorizontalDropLocation.CENTER
|| loc == HorizontalDropLocation.RIGHT) {
idx++;
}
Component comp = resolveComponentFromHTML5Drop(event);
if (idx >= 0) {
layout.addComponent(comp, idx);
} else {
layout.addComponent(comp);
}
if (dropAlignment != null) {
layout.setComponentAlignment(comp, dropAlignment);
}
}
```
В коде объявляется и не используется переменная *source*. Возможно, как и другую переменную *comp* этого же типа, *source* забыли добавить в *layout*.
Ещё функции с неиспользуемыми переменными:
* V6021 Variable 'source' is not used. DefaultHorizontalLayoutDropHandler.java(175)
* V6021 The value is assigned to the 'r' variable but is not used. ExcelExporter.java(262)
* V6021 Variable 'over' is not used. DefaultCssLayoutDropHandler.java(49)
* V6021 Variable 'transferable' is not used. DefaultHorizontalLayoutDropHandler.java(171)
* V6021 Variable 'transferable' is not used. DefaultHorizontalLayoutDropHandler.java(169)
* V6021 Variable 'beanLocator' is not used. ScreenEventMixin.java(28)
**Предупреждение 3**
[V6054](https://www.viva64.com/ru/w/v6054/) Classes should not be compared by their name. MessageTools.java(283)
```
public boolean hasPropertyCaption(MetaProperty property) {
Class declaringClass = property.getDeclaringClass();
if (declaringClass == null)
return false;
String caption = getPropertyCaption(property);
int i = caption.indexOf('.');
if (i > 0 && declaringClass.getSimpleName().equals(caption.substring(0, i)))
return false;
else
return true;
}
```
Анализатор обнаружил ситуацию, когда сравнение классов осуществляется по имени. Такое сравнение является некорректным, т.к., согласно спецификации, JVM классы имеют уникальное имя только внутри пакета. Это может стать причиной некорректного сравнения и выполнения не того кода, который планировался.
Отзыв разработчиков CUBA Platform
---------------------------------
*Безусловно, в любом крупном проекте бывают баги. Именно поэтому мы с радостью согласились на предложение команды PVS-Studio проверить наш проект. В репозиторий CUBA включены форки некоторых сторонних OSS библиотек под лицензией Apache 2 и, кажется, нам нужно уделить этому коду больше внимания, анализатор нашёл довольно много проблем в этих исходниках. Сейчас мы используем SpotBugs в качестве основного анализатора, и он не находит некоторые существенные проблемы, найденные PVS-Studio. Самое время пойти и написать дополнительные проверки самим. Большое спасибо команде PVS-Studio за проделанную работу.*
Также разработчики отметили, что предупреждения V6013 и V6054 являются ложными. Код был написан таким намеренно. Статический анализатор предназначен для выявления подозрительных фрагментов кода и вероятность нахождения ошибки у всех инспекций разная. Тем не менее, работать с такими предупреждениями легко, используя удобный механизм [массового подавления предупреждений анализатора](https://www.viva64.com/ru/m/0032/) без модификации файлов исходного кода.
Ещё команда PVS-Studio не может пройти мимо фразы «самое время пойти и написать дополнительные проверки самим» и не оставить эту картинку :)
Заключение
----------
PVS-Studio будет отличным дополнением для вашего проекта к уже существующим инструментам улучшения качества кода. Особенно, если в штате десятки, сотни и тысячи сотрудников. PVS-Studio предназначен не только для нахождения ошибок, но и для их исправления. Причём речь не об автоматическом редактировании кода, а о надёжном контроле качества кода. В большой компании невозможно представить ситуацию, когда абсолютно все разработчики будут самостоятельно проверять свой код различными инструментами, поэтому таким компаниям больше подходят инструменты типа PVS-Studio, где предусмотрен контроль качества кода на всех этапах разработки, не только у рядового программиста.
[](https://habr.com/en/company/pvs-studio/blog/449020/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [Analyzing the Code of CUBA Platform with PVS-Studio](https://habr.com/en/company/pvs-studio/blog/449020/) | https://habr.com/ru/post/449022/ | null | ru | null |
# Arduino и Processing. Как управлять микроконтроллером по COM порту. Двустороннее общение
Всем привет! В интернете бытует заблуждение, что для управления компьютером при помощи самодельной электроники нужны только специальные платы, которые могут распознаваться как USB HID устройства. А касаемо Arduino все только и говорят о *Arduino Leanardo*. Такие популярные библиотеки как **Keyboard** и **Mouse**, которые позволяют создавать эмуляцию работы мыши или клавиатуры посредством микроконтроллера предназначены только для пары плат Arduino, Leonardo в их числе.
Я расскажу о том, как наладить связь любого микроконтроллера Arduino (для примера взята *Arduino Uno*) и своей программы на Processing. Добавив ко всему прочему знания о Java, на котором основывается Processing, можно будет дописать проект под управление всем компьютером, а не только собственным приложением. Тема управления компьютером программой на Java не есть чем то секретным, погуглите и все найдете, уверяю вас.
### Скачиваем среды для разработки (IDE)
Существует много интегрированных сред разработки для программирования микроконтроллеров на чистом Си. Из них можно отметить самые удобные: Atollic, Eclipse, Keil.
Однако для простоты и доступности данного руководства я буду использовать редактор Arduino IDE и писать на Ардуино Си. Скачать такой редактор можно с [официального сайта Arduino](https://www.arduino.cc/en/Main/Software).
Среду разработки для программирования на Procrssing так же можно скачать с [официального сайта](https://processing.org/download/).
Стоит отметить, приличия ради, что данные IDE очень похожи, потому что написаны на одном движке. И когда создавался Arduino основатели старались как можно больше упростить свой редактор кода, как это и было сделано в Processing редакторе.
### Arduino. Собираем схему и пишем код
В данном примере я буду использовать Arduino Uno. К ней будет подключена кнопка, потенциометр и светодиод. Соответственно я могу выдавать логический 0 или 1. Читать логический 0 или 1. И проводить [Аналого-цифровое преобразование](https://habr.com/ru/post/112913/)(ADC или АЦП), получая числа от 0 до 1023 (в Arduino Uno 10-ми разрядный АЦП) в зависимости от положения потенциометра. Большего для примера и не нужно, так как это основные функции, которые может делать микроконтроллер.
Схема подключения:
На схеме светодиод анодом подключен к 5V через ограничивающий резистор ( минимум 220 Ом, желательно 500 Ом), катодом к пину D11. Кнопка замыкает землю и пин D2. Потенциометр меняет потенциал на пине A1.
Задача микроконтроллера следующая: Если по последовательному интерфейсу (Serial COM port) приходит сообщение «LED — H» — засветить светодиод. Если приходит сообщение «LED — L» — затушить светодиод. Каждые 250мс отправлять сообщение в последовательный порт (в данном случае на экран компьютера) сообщение «Pot — » и число, полученное аналоговым чтением пина A1. При нажатии кнопки единожды отсылать сообщение «Button is pressed!».
Вот мое предложение решения данной задачи (не пример для подражания):
**Прошивка для Arduino Uno**````
#define pinPot A1
#define pinLed 11
#define pinBtn 2
void setup() {
pinMode(pinPot, INPUT);
pinMode(pinLed, OUTPUT);
pinMode(pinBtn, INPUT_PULLUP);
Serial.begin(9600);
Serial.println("The program starts.\n\n");
}
void loop() {
/* INITIAL VARIABLES. Segment 1 */
static char potMes[] = "Pot - ";
static char btnMes[] = "Button is pressed!";
static char passLight[] = "Led - ";
static int passLength = sizeof(passLight) - 1;
static int sizepm = sizeof(potMes) - 1;
static int sizebtn = sizeof(btnMes) - 1;
static bool flagLedState = LOW;
static bool flagBtnPress = false;
static long int curTime = 0;
static const int period = 200;
static bool flagEnableRead = false;
/* INITIAL VARIABLES. Segment 1 */
/* FUNCTIONS CALL. Segment 2 */
/*
* Led is attached to HIGH voltage from one side
* And to pin on the other side
* By that the inverting logic
*/
ReadSerialForLed(passLight, passLength, &flagLedState);
digitalWrite(pinLed, !flagLedState);
/*
* Button pin always is pulled to the HIGH voltage
* And only when button is pressed - Voltage on pin goes to GROUND
* So it is need to invert logic when read pins
*/
if(!Bounce(pinBtn) && flagBtnPress == false){
for(int i = 0; i < sizebtn; i++){
Serial.write(btnMes[i]);
}
Serial.print("\n");
flagBtnPress = true;
if(!flagEnableRead){
curTime = millis();
flagEnableRead = true;
}
}else if(Bounce(pinBtn)){
flagBtnPress = false;
}
/*
* Read and send Info "Pot - " + var Only after first press on button
* Every 'period'ms
*/
if(millis() - curTime > period && flagEnableRead){
SendData(pinPot, potMes, sizepm);
curTime = millis();
}
/* FUNCTIONS CALL. Segment 2 */
}
/*
* Pot - pin with potentiometer
* pMes - Array with message before Pot value
* sp - size of potentiometer message
*/
void SendData(int Pot, char* pMes, int sp){
static int varP[2];
varP[0] = analogRead(Pot);
varP[1] = varP[0]/256; // 0 - 3 (256 - 1024)
varP[0] = varP[0]%256; // 0 - 255
//Send Message
for(int i = 0; i < sp; i++){
Serial.write(char(pMes[i]));
}
//Send 2 bits of data
//Serial.write(varP[0]);
//Serial.write(varP[1]);
Serial.print(analogRead(Pot));
Serial.print("\n");
}
/*
* Function, which is reads button pin with the bounce
*/
bool Bounce(int btn){
if(digitalRead(btn) == true){
delay(15);
if(digitalRead(btn) == true){
return true;
}else{
return false;
}
}else{
return false;
}
}
/*
* If Message from Serial port, which you read will be the same to passLight
* So look at the next symbol after Pass Message. If it is symbol 'H' - make LED to light
* If it is 'L' - make LED off.
*/
void ReadSerialForLed(char *passLight_f, int passLength_f, bool* flagLedState_f){
static char sym;
static int cntPass = 0;
static bool readyGetLed = LOW;
while (Serial.available() > 0) {
sym = Serial.read();
if(sym == passLight_f[cntPass] && !readyGetLed){
cntPass++;
}else if (!readyGetLed){
cntPass = 0;
}else if(readyGetLed){
if(sym == 'H'){
*flagLedState_f = HIGH;
}else if(sym == 'L'){
*flagLedState_f = LOW;
}
}
if(cntPass == passLength_f){
readyGetLed = HIGH;
}
}
}
````
*Комментарий: Светодиод подключен анодом к питаю. Это инвертирует логику состояния светодиода и больше никакой пользы не приносит. Кнопка не обвязана подтягивающим резистором из соображений экономии, так как в Arduino Uno имеются встроенные подтягивающие резисторы, которые включаются в схему при инициализации пина в режим INPUT\_PULLUP.
Так же в прошивке сообщения о значении снятого с потенциометра отсылаются только после первого нажатия на кнопку!*
Что бы залить прошивку в плату не забывайте выбрать порт и плату.
Если вы не знаете какой COM порт у вас отведен для платы Arduino, то на Windows заходим в
Панель управления -> Диспетчер устройств и нажимаем на вкладку «Порты COM»
Если у вас COM порт не подписан как у меня — всегда можно отсоединить Arduino и посмотреть который порт пропадет. А вот если никакой не пропал и Ардуина вовсе не распознается компьютером — значит пора поискать решение в интернете. Но начните с обновления драйверов или смены платы.
Когда все получится — попробуйте открыть монитор порта и ввести «Led — H», «Led — L», по нажимайте на кнопку, покрутите потенциометр и смотрите на экран, все ли правильно выводится.
Наигрались — поменяйте слегка код.
Замените последнюю строку кодом из комментария.
```
//Send 2 bits of data
//Serial.write(varP[0]);
//Serial.write(varP[1]);
Serial.print(analogRead(Pot));
```
Теперь значения с потенциометра не будут выглядеть читабельными, но такой маневр требуется для программы на Processing.
### Processing. Пишем программу, которая взаимодействует с микроконтроллером
Суть связи программы на Processing и микроконтроллера очень проста. Для этого языка программирования существует библиотека Serial, которая позволяет принимать сообщения, отправленные как `Serial.write();`, а так же позволяет отправлять сообщения как `Serial.print();`. Важно отметить, что при подобной отправке сообщения оно будет записано в буфер порта, а значит будет прочитано микроконтроллером. Так что нам осталось только подключиться к нужному Serial порту и принимать/отправлять на него сообщения.
Следующая программа подключит библиотеку Serial и напишет в консоли редактора список всех COM портов, к которым можно подключиться.
```
import processing.serial.*;
void setup()
{
String[] port = Serial.list();
for(int i = 0; i < port.length; i++){
print("Port number #" + i + " ");
println(Serial.list()[0]);
}
}
void draw() {}
```
Когда вы напишете код в редактор и нажмете на кнопку «Пуск» (стрелочка 1 на картинке), то появится окно приложения(2) и в консоли(3) выведется список COM портов.
У меня только один такой COM порт и в листе, как в массиве, он будет находиться под номером 0. Из этих соображений объекту класса Serial: `Serial port;` при его создании будет указан именно первый элемент списка портов `port = new Serial(this, Serial.list()[0], 9600);`
Залейте в Ардуину нашу последнюю прошивку с изменением. После чего напишите вот эту программу и запустите ее. В ней Каждые 500 миллисекунд отправляется сообщение в COM порт потушить или зажечь светодиод. И если все у вас сделано правильно, то после запуска приложения светодиод должен мигать.
```
import processing.serial.*;
Serial port; // Create object from Serial class
void setup(){
port = new Serial(this, Serial.list()[0], 9600);
}
void draw(){
delay(500);
port.write("Led - H");
delay(500);
port.write("Led - L");
}
```
Или вот другой пример. Светодиод будет менять свое состояние после любого нажатия на окно приложения (размеры которого 800х800px) кнопкой мыши.
```
import processing.serial.*;
Serial port; // Create object from Serial class
int cnt = 0;
void setup(){
size(800, 800);
port = new Serial(this, Serial.list()[0], 9600);
}
void draw(){}
void mousePressed() {
cnt++;
if(cnt % 2 == 1){
port.write("Led - H");
}else{
port.write("Led - L");
}
}
```
### Processing. Пример многофункционального приложения
Данное элементарное приложение симулирует «полет в космосе», если это можно так назвать. Значение с потенциометра изменяет скорость полета, нажатие на кнопку меняет направление полета. А любое нажатие кнопки мыши на окно приложения — меняет состояние светодиода (да, ничего оригинальнее я не придумал).
Мой код далек от совершенства, не принимайте его как хороший пример. Это просто пример, который работает. Вот, собственно, он.
**Пример многофункциональной программы**
```
import processing.serial.*;
Serial port; // Create object from Serial class
int val; // Data received from the serial port (symbol)
int pot; // Data from potentiometer
String potMes = "Pot - ";
String btnMes = "Button is pressed!";
int cntPM = 0; // Counter Potentiometer Message.
// When it equals to length of Pot Mess - get value.
int cntBM = 0;
int cntBtnPress = 0;
int cntMousePress = 0;
Star[] stars = new Star[1000];
float speed;
int dir = 1;
void setup(){
size(800, 800);
for(int i = 0; i < stars.length; i++){
stars[i] = new Star();
}
frameRate(60); // 60 Frames per second
port = new Serial(this, Serial.list()[0], 9600);
// Wait for first message from Arduino
delay(2000);
while (port.available() > 0) {
val = port.read();
print(char(val));
}
}
void draw(){
if (port.available() > 0) {
val = port.read();
cntPM = CheckSymbol(potMes, cntPM, char(val), cntPM);
cntBM = CheckSymbol(btnMes, cntBM, char(val), cntBM);
}
DrawRain(pot, 0, 1023);
}
void DrawRain(int speed_f, int min, int max){
background(0);
translate(width/2,height/2);
speed = dir*map(speed_f, min, max, 0, 50);
for(int i = 0; i < stars.length; i++){
stars[i].go();
stars[i].update();
stars[i].show();
}
}
int CheckSymbol(String mes, int index, char sym, int ret_val){
if(mes.charAt(index) == sym && ret_val < (mes.length() - 1)){
return (ret_val + 1);
}else if( ret_val == (mes.length() - 1) && mes.equals(potMes) ){
if(port.available() > 0){
pot = port.read(); // First 0-255 value
}
if(port.available() > 0){
pot += 256*port.read(); // Last 2 bits 256 - 1024
}
}else if( ret_val == (mes.length() - 1) && mes.equals(btnMes) ){
cntBtnPress++;
dir = -dir;
}
return 0;
}
void mousePressed() {
cntMousePress++;
if(cntMousePress % 2 == 1){
port.write("Led - H");
}else{
port.write("Led - L");
}
}
```
### Заключение
Думаю, нужно написать, что идею последней программы я подцепил у одного программиста — [Daniel Shiffman](https://thecodingtrain.com/), который снимает ролики, понятные даже детям, о программировании на Processing ([решено более 140 визуальных задач](https://www.youtube.com/user/shiffman)).
Когда я пытался сам разобраться в том что и как нужно делать для связи Processing и Arduino мне очень помогли вот эти сайты:
1. [developer.alexanderklimov.ru/arduino/processing.php](http://developer.alexanderklimov.ru/arduino/processing.php)
2. [arduino-diy.com/arduino-processing-osnovi](http://arduino-diy.com/arduino-processing-osnovi) | https://habr.com/ru/post/450518/ | null | ru | null |
# Старт в музыкальном программировании — для начинающих достаточно и простого браузера
Продолжаем нашу [серию](https://www.audiomania.ru/content/art-7405.html) постов о [музыкальном программировании](https://www.audiomania.ru/content/art-6815.html). В ней мы говорим о языках, утилитах и других инструментах, превращающих функции и атрибуты в мелодичные [в зависимости от уровня автора] композиции. Сегодня рассказываем о виртуальной среде Klangmeister. Она не требует установки специализированного программного обеспечения.
Фотография: Brandon Erlinger-Ford. Источник: Unsplash.comМузыкальное программирование — это процесс написания треков с использованием специализированного ПО, синтезаторов и секвенсоров. Есть огромное количество сервисов, позволяющих «влиться» в эту тему. О некоторых из них мы уже рассказывали — например, [OpenMusic](https://www.audiomania.ru/content/art-6802.html) и [ORCA](https://www.audiomania.ru/content/art-6815.html). С их помощью можно писать музыку в разных жанрах, однако они требуют установки и настройки на компьютере. Композитор и разработчик [Крис Форд](https://twitter.com/ctford) посчитал, этот факт ограничивающим творчество начинающих музыкантов и решил исправить ситуацию.
Он разработал инструмент, позволяющий творить «без заморочек». Так появился [Klangmeister](https://ctford.github.io/klangmeister/) — с немецкого переводится как «*мастер звука*» — работающий **прямо из браузера**.
Что под капотом
---------------
Для написания музыки Klangmeister предлагает использовать Clojurescript. Это — реализация языка LISP с компиляцией в JavaScript. Необходимые для работы функции хранятся в библиотеке [Leipzig](https://github.com/ctford/leipzig), которую написал автор проекта. Он также подготовил достаточно подробную [документацию](https://ctford.github.io/leipzig/). Для воспроизведения треков приложение использует Web Audio API.
Интерфейс позволяет компилировать программы на лету — фактически писать и воспроизводить музыку в реальном времени. Ряд возможностей Крис Форд [продемонстрировал](https://vimeo.com/165917501) на технологической конференции flatMap в Осло несколько лет назад. Например, чтобы написать мелодию, нужно составить массив, включающий продолжительность звучания и высоту тона для каждой отдельной ноты.
```
(phrase [3/3 3/3 2/3 1/3 3/3]
[ 72 72 72 74 76])
```
Klangmeister также позволяет объединять несколько мелодий в одну:
```
(->>
(phrase [3/3 3/3 2/3 1/3 3/3]
[ 72 72 72 74 76])
(then
(phrase [2/3 1/3 2/3 1/3 3/3]
[ 76 74 76 77 79])))
```
На официальном сайте [есть руководство](https://ctford.github.io/klangmeister/composition) с примерами кода для реализации более сложных техник написания музыки — зацикливанием треков и настройкой BPM.
В целом инструмент Klangmeister довольно прост, что является как его достоинством, так и недостатком. Он позволяет взять легкий старт в музыкальном программировании, но задействованный в работе Web Audio API плохо подходит для написания глубоких и комплексных композиций. Также автор [отмечает](https://ctford.github.io/klangmeister/), что Klangmeister лучше всего работает в Chrome. Функции синтеза, которые он использует, могут не поддерживаться в других браузерах (или поддерживаться плохо). Все желающие могут оценить «внутренности» проекта самостоятельно — его исходный код выложен в [репозиторий на GitHub](https://github.com/ctford/klangmeister).
Какие есть альтернативы
-----------------------
Одна из известных виртуальных сред для аудиосинтеза в реальном времени — это [SuperCollider](https://supercollider.github.io/download). Мы кратко упоминали её в одном [из предыдущих материалов](https://www.audiomania.ru/content/art-7405.html). Она существует с 1996 года, и за это время вокруг неё сформировалось обширное сообщество поклонников. SuperCollider более сложный инструмент, чем Klangmeister и на его освоение может уйти длительное время, однако и возможности он предлагает более широкие.
С инструментом работает композитор [Крис Браун](https://www.discogs.com/ru/artist/140370-Chris-Brown-2) (не путать [с певцом и актером](https://ru.wikipedia.org/wiki/%D0%91%D1%80%D0%B0%D1%83%D0%BD,_%D0%9A%D1%80%D0%B8%D1%81)) из Сан-Франциско. С его помощью он написал альбом [Branches](https://www.discogs.com/ru/Chris-Brown-Branches/release/196653). Эли Филдстил (Eli Fieldsteel), преподающий теорию музыкальной композиции в Университете Иллинойса, [использует](https://www.youtube.com/watch?v=qSPQcc97Qcg&list=PLPYzvS8A_rTbW5J9t-gj6NqAE0XGgUD2V&index=1) SuperCollider для анализа отдельных произведений на лекциях.
Фотография: Valentin Müller. Источник: Unsplash.comЕще одним аналогом Klangmeister, который упоминает сам Крис Форд, является платформа [Extempore](https://extemporelang.github.io/). Она включает в себя два языка программирования — Scheme и одноименный Extempore. Объединяет их возможности компилятор на базе LLVM, позволяющий обрабатывать цифровые сигналы в реальном времени. Как это работает, автор системы [рассказывал](https://youtu.be/yY1FSsUV-8c) на конференции OSCON, посвященной открытому ПО.
---
**О чем еще мы пишем в «Мире Hi-Fi»:**
* [Как устроен Sporth — ЯП для музыкальных live-сессий](https://www.audiomania.ru/content/art-7140.html)
* [Что такое музыкальное программирование — кто и почему им занимается](https://www.audiomania.ru/content/art-6815.html)
* [Влиться в музыкальное программирование — языки, которые помогут это сделать](https://www.audiomania.ru/content/art-7405.html)
---
**Наши обзоры в блоге на Хабре:**
* [Arslab, DALI и Monitor Audio —](https://habr.com/ru/company/audiomania/blog/557886/) «[напольники](https://habr.com/ru/company/audiomania/blog/557886/)» [в диапазоне 60-80 тысяч рублей](https://habr.com/ru/company/audiomania/blog/557886/)
* [Обзоры аудиотехники и тематические гайды из «Мира Hi-Fi»](https://habr.com/ru/company/audiomania/blog/556220/)
* [Полочная акустика в районе 50 тысяч рублей](https://habr.com/ru/company/audiomania/blog/554178/)
--- | https://habr.com/ru/post/555562/ | null | ru | null |
# Разбор перформансных задач с JBreak (часть 3)
Публикую предпоследнюю часть разбора с третьей задачей. До этого выходил разбор [первой задачи](https://habrahabr.ru/post/350800/) и [второй задачи](https://habrahabr.ru/post/351300/).
Код к третьей задаче:
```
public static double compute(
double x1, double y1, double z1,
double x2, double y2, double z2) {
double x = y1 * z2 - z1 * y2;
double y = z1 * x2 - x1 * z2;
double z = x1 * y2 - y1 * x2;
return x * x + y * y + z * z;
}
public static double compute(
double x1, double y1, double z1,
double x2, double y2, double z2) {
Vector v1 = new Vector(x1, y1, z1);
Vector v2 = new Vector(x2, y2, z2);
return v1.crossProduct(v2).squared();
}
public final static class Vector {
private final double x, y, z;
public Vector(double x, double y, double z) {
this.x = x; this.y = y; this.z = z;
}
public double squared() {
return x * x + y * y + z * z;
}
public Vector crossProduct(Vector v) {
return new Vector(
y * v.z - z * v.y,
z * v.x - x * v.z,
x * v.y - y * v.x);
}
}
```
Условие (упрощённо):
> Определить, какие методы быстрые, а какие — медленные (JRE 1.8.0\_161).
В обоих случаях реализована одна и та же математика: сперва вычисляем векторное произведение двух векторов в трёхмерном пространстве, затем для получившегося вектора считаем квадрат его длины (или скалярное произведение вектора самого на себя, кому как больше нравится).
#### Очевидный неправильный ответ
> Первый способ быстрее, так как не тратится время на создание объектов `Vector`.
Сюда же можно добавить рассуждения о том, что первый алгоритм, в отличие от второго, garbage-free, поэтому нет дополнительной нагрузки на работу GC.
Решение
-------
Традиционно начнём с небольшого бенчмарка (полный код доступен на [github](https://github.com/gnkoshelev/jbreak2018-vector-perf-tests)):
```
@Fork(value = 5, warmups = 0)
@Warmup(iterations = 5, time = 1_000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1_000, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Benchmark)
public class ComputationOnlyBenchmark {
private double x1, y1, z1;
private double x2, y2, z2;
@Setup(value = Level.Iteration)
public void setup() {
x1 = 123.4;
y1 = 234.5;
z1 = 345.6;
x2 = 456.7;
y2 = 567.8;
z2 = 678.9;
}
@Benchmark
public void computeWithRawScalars(Blackhole bh) {
bh.consume(VectorAlgebra.computeWithRawScalars(x1, y1, z1, x2, y2, z2));
}
@Benchmark
public void computeWithVectors(Blackhole bh) {
bh.consume(VectorAlgebra.computeWithVectors(x1, y1, z1, x2, y2, z2));
}
}
```
Полученный результат довольно-таки интересен:
```
Benchmark Mode Cnt Score Error Units
ComputationOnly...computeWithRawScalars avgt 50 4,783 ± 0,031 ns/op
ComputationOnly...computeWithVectors avgt 50 4,785 ± 0,040 ns/op
```
**Результат бенчмарка целиком**
```
# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.ComputationOnlyBenchmark.computeWithRawScalars
# Run progress: 0,00% complete, ETA 00:02:30
# Fork: 1 of 5
# Warmup Iteration 1: 5,236 ns/op
# Warmup Iteration 2: 4,710 ns/op
# Warmup Iteration 3: 4,779 ns/op
# Warmup Iteration 4: 5,481 ns/op
# Warmup Iteration 5: 4,908 ns/op
Iteration 1: 4,785 ns/op
Iteration 2: 4,886 ns/op
Iteration 3: 4,888 ns/op
Iteration 4: 4,739 ns/op
Iteration 5: 4,738 ns/op
Iteration 6: 4,749 ns/op
Iteration 7: 4,737 ns/op
Iteration 8: 4,739 ns/op
Iteration 9: 4,749 ns/op
Iteration 10: 4,745 ns/op
# Run progress: 10,00% complete, ETA 00:02:17
# Fork: 2 of 5
# Warmup Iteration 1: 5,108 ns/op
# Warmup Iteration 2: 4,692 ns/op
# Warmup Iteration 3: 4,746 ns/op
# Warmup Iteration 4: 4,738 ns/op
# Warmup Iteration 5: 4,750 ns/op
Iteration 1: 4,888 ns/op
Iteration 2: 4,753 ns/op
Iteration 3: 4,741 ns/op
Iteration 4: 4,734 ns/op
Iteration 5: 4,741 ns/op
Iteration 6: 4,789 ns/op
Iteration 7: 4,880 ns/op
Iteration 8: 4,771 ns/op
Iteration 9: 4,746 ns/op
Iteration 10: 4,742 ns/op
# Run progress: 20,00% complete, ETA 00:02:02
# Fork: 3 of 5
# Warmup Iteration 1: 5,129 ns/op
# Warmup Iteration 2: 4,733 ns/op
# Warmup Iteration 3: 4,760 ns/op
# Warmup Iteration 4: 5,021 ns/op
# Warmup Iteration 5: 4,834 ns/op
Iteration 1: 4,787 ns/op
Iteration 2: 4,818 ns/op
Iteration 3: 4,773 ns/op
Iteration 4: 4,735 ns/op
Iteration 5: 4,742 ns/op
Iteration 6: 4,758 ns/op
Iteration 7: 4,749 ns/op
Iteration 8: 4,741 ns/op
Iteration 9: 4,794 ns/op
Iteration 10: 4,937 ns/op
# Run progress: 30,00% complete, ETA 00:01:47
# Fork: 4 of 5
# Warmup Iteration 1: 5,158 ns/op
# Warmup Iteration 2: 4,889 ns/op
# Warmup Iteration 3: 4,823 ns/op
# Warmup Iteration 4: 4,994 ns/op
# Warmup Iteration 5: 4,847 ns/op
Iteration 1: 4,779 ns/op
Iteration 2: 4,818 ns/op
Iteration 3: 4,804 ns/op
Iteration 4: 4,900 ns/op
Iteration 5: 5,045 ns/op
Iteration 6: 4,841 ns/op
Iteration 7: 4,773 ns/op
Iteration 8: 4,738 ns/op
Iteration 9: 4,770 ns/op
Iteration 10: 4,745 ns/op
# Run progress: 40,00% complete, ETA 00:01:31
# Fork: 5 of 5
# Warmup Iteration 1: 5,215 ns/op
# Warmup Iteration 2: 4,731 ns/op
# Warmup Iteration 3: 5,088 ns/op
# Warmup Iteration 4: 4,776 ns/op
# Warmup Iteration 5: 4,769 ns/op
Iteration 1: 4,750 ns/op
Iteration 2: 4,775 ns/op
Iteration 3: 4,759 ns/op
Iteration 4: 4,759 ns/op
Iteration 5: 4,731 ns/op
Iteration 6: 4,737 ns/op
Iteration 7: 4,764 ns/op
Iteration 8: 4,751 ns/op
Iteration 9: 4,755 ns/op
Iteration 10: 4,763 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.ComputationOnlyBenchmark.computeWithRawScalars":
4,783 ±(99.9%) 0,031 ns/op [Average]
(min, avg, max) = (4,731, 4,783, 5,045), stdev = 0,063
CI (99.9%): [4,751, 4,814] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.ComputationOnlyBenchmark.computeWithVectors
# Run progress: 50,00% complete, ETA 00:01:16
# Fork: 1 of 5
# Warmup Iteration 1: 5,246 ns/op
# Warmup Iteration 2: 4,695 ns/op
# Warmup Iteration 3: 4,713 ns/op
# Warmup Iteration 4: 4,693 ns/op
# Warmup Iteration 5: 4,705 ns/op
Iteration 1: 4,717 ns/op
Iteration 2: 4,705 ns/op
Iteration 3: 4,718 ns/op
Iteration 4: 4,720 ns/op
Iteration 5: 4,697 ns/op
Iteration 6: 4,739 ns/op
Iteration 7: 4,714 ns/op
Iteration 8: 4,718 ns/op
Iteration 9: 4,711 ns/op
Iteration 10: 4,818 ns/op
# Run progress: 60,00% complete, ETA 00:01:01
# Fork: 2 of 5
# Warmup Iteration 1: 5,253 ns/op
# Warmup Iteration 2: 4,827 ns/op
# Warmup Iteration 3: 4,850 ns/op
# Warmup Iteration 4: 4,745 ns/op
# Warmup Iteration 5: 4,912 ns/op
Iteration 1: 4,889 ns/op
Iteration 2: 4,732 ns/op
Iteration 3: 5,133 ns/op
Iteration 4: 5,010 ns/op
Iteration 5: 4,820 ns/op
Iteration 6: 4,748 ns/op
Iteration 7: 4,762 ns/op
Iteration 8: 4,831 ns/op
Iteration 9: 4,797 ns/op
Iteration 10: 4,826 ns/op
# Run progress: 70,00% complete, ETA 00:00:45
# Fork: 3 of 5
# Warmup Iteration 1: 5,227 ns/op
# Warmup Iteration 2: 4,750 ns/op
# Warmup Iteration 3: 4,811 ns/op
# Warmup Iteration 4: 4,769 ns/op
# Warmup Iteration 5: 4,792 ns/op
Iteration 1: 4,783 ns/op
Iteration 2: 4,780 ns/op
Iteration 3: 4,754 ns/op
Iteration 4: 4,747 ns/op
Iteration 5: 4,753 ns/op
Iteration 6: 4,807 ns/op
Iteration 7: 4,773 ns/op
Iteration 8: 4,786 ns/op
Iteration 9: 4,770 ns/op
Iteration 10: 4,772 ns/op
# Run progress: 80,00% complete, ETA 00:00:30
# Fork: 4 of 5
# Warmup Iteration 1: 5,190 ns/op
# Warmup Iteration 2: 4,780 ns/op
# Warmup Iteration 3: 4,704 ns/op
# Warmup Iteration 4: 4,762 ns/op
# Warmup Iteration 5: 4,725 ns/op
Iteration 1: 4,745 ns/op
Iteration 2: 4,753 ns/op
Iteration 3: 4,775 ns/op
Iteration 4: 4,804 ns/op
Iteration 5: 4,771 ns/op
Iteration 6: 4,737 ns/op
Iteration 7: 4,875 ns/op
Iteration 8: 4,834 ns/op
Iteration 9: 4,833 ns/op
Iteration 10: 5,000 ns/op
# Run progress: 90,00% complete, ETA 00:00:15
# Fork: 5 of 5
# Warmup Iteration 1: 5,220 ns/op
# Warmup Iteration 2: 4,766 ns/op
# Warmup Iteration 3: 5,140 ns/op
# Warmup Iteration 4: 4,835 ns/op
# Warmup Iteration 5: 4,963 ns/op
Iteration 1: 4,743 ns/op
Iteration 2: 4,738 ns/op
Iteration 3: 4,780 ns/op
Iteration 4: 4,749 ns/op
Iteration 5: 4,716 ns/op
Iteration 6: 4,791 ns/op
Iteration 7: 4,759 ns/op
Iteration 8: 4,772 ns/op
Iteration 9: 4,797 ns/op
Iteration 10: 4,768 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.ComputationOnlyBenchmark.computeWithVectors":
4,785 ±(99.9%) 0,040 ns/op [Average]
(min, avg, max) = (4,697, 4,785, 5,133), stdev = 0,081
CI (99.9%): [4,746, 4,825] (assumes normal distribution)
# Run complete. Total time: 00:02:33
Benchmark Mode Cnt Score Error Units
ComputationOnlyBenchmark.computeWithRawScalars avgt 50 4,783 ± 0,031 ns/op
ComputationOnlyBenchmark.computeWithVectors avgt 50 4,785 ± 0,040 ns/op
```
В коде нашего примера помимо арифметических действий есть создание трёх объектов `Vector` (а это вызов двух конструкторов `Vector` и `Object` на каждое создание) и вызов двух методов `Vector.crossProduct()` и `Vector.squared()`, но на производительность метода `VectorAlgebra.computeWithVectors()` это никак не сказалось. Ну, не может же создание этих объектов быть таким дешёвым и пропасть в погрешности измерения!
Справедливо можно заметить, что JIT без проблем умеет инлайнить простые методы, что он и сделал:
```
@ 25 ru.gnkoshelev.jbreak2018.perf_tests.vector.VectorAlgebra::computeWithVectors (39 bytes) 3 inline (hot)
@ 8 ru.gnkoshelev.jbreak2018.perf_tests.vector.VectorAlgebra$Vector:: (21 bytes) inline (hot)
@ 1 java.lang.Object:: (1 bytes) inline (hot)
@ 23 ru.gnkoshelev.jbreak2018.perf\_tests.vector.VectorAlgebra$Vector:: (21 bytes) inline (hot)
@ 1 java.lang.Object:: (1 bytes) inline (hot)
@ 32 ru.gnkoshelev.jbreak2018.perf\_tests.vector.VectorAlgebra$Vector::crossProduct (65 bytes) inline (hot)
@ 61 ru.gnkoshelev.jbreak2018.perf\_tests.vector.VectorAlgebra$Vector:: (21 bytes) inline (hot)
@ 1 java.lang.Object:: (1 bytes) inline (hot)
@ 35 ru.gnkoshelev.jbreak2018.perf\_tests.vector.VectorAlgebra$Vector::squared (30 bytes) inline (hot)
```
Но inlining лишь встраивает тело вызываемой функции внутрь вызываемого кода, то есть исполняемого кода по-прежнему остаётся объективно много.
Попробуем проверить затраты на создание объектов и оценить оверхед JMH:
```
@Fork(value = 5, warmups = 0)
@Warmup(iterations = 5, time = 1_000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1_000, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Benchmark)
public class CreateAndConsumeBenchmark {
private double x1, y1, z1;
private double x2, y2, z2;
@Setup(value = Level.Iteration)
public void setup() {
x1 = 123.4;
y1 = 234.5;
z1 = 345.6;
x2 = 456.7;
y2 = 567.8;
z2 = 678.9;
}
@Benchmark
public void consumeDouble(Blackhole bh) {
bh.consume(x1);
}
@Benchmark
public void consumeObject(Blackhole bh) {
bh.consume(new Object());
}
@Benchmark
public void createAndConsumeSingleVector(Blackhole bh) {
bh.consume(new VectorAlgebra.Vector(x1, y1, z1));
}
@Benchmark
public void createAndConsumeTwoVectors(Blackhole bh) {
bh.consume(new VectorAlgebra.Vector(x1, y1, z1));
bh.consume(new VectorAlgebra.Vector(x2, y2, z2));
}
@Benchmark
public void createAndConsumeThreeVectors(Blackhole bh) {
bh.consume(new VectorAlgebra.Vector(x1, y1, z1));
bh.consume(new VectorAlgebra.Vector(x2, y2, z2));
bh.consume(new VectorAlgebra.Vector(x1, y2, z1));
}
}
```
Ниже результат прогона нашего бенчмарка:
```
Benchmark Mode Cnt Score Error Units
CreateAndConsume...consumeDouble avgt 50 2,762 ± 0,103 ns/op
CreateAndConsume...consumeObject avgt 50 3,084 ± 0,036 ns/op
CreateAndConsume...createAndConsumeObject avgt 50 4,233 ± 0,081 ns/op
CreateAndConsume...createAndConsumeSingleVector avgt 50 7,010 ± 0,147 ns/op
CreateAndConsume...createAndConsumeThreeVectors avgt 50 20,710 ± 0,654 ns/op
CreateAndConsume...createAndConsumeTwoVectors avgt 50 13,702 ± 0,276 ns/op
```
**Результат бенчмарка целиком**
```
# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.consumeDouble
# Run progress: 0,00% complete, ETA 00:07:30
# Fork: 1 of 5
# Warmup Iteration 1: 2,888 ns/op
# Warmup Iteration 2: 2,949 ns/op
# Warmup Iteration 3: 2,716 ns/op
# Warmup Iteration 4: 2,635 ns/op
# Warmup Iteration 5: 2,674 ns/op
Iteration 1: 2,710 ns/op
Iteration 2: 2,622 ns/op
Iteration 3: 2,651 ns/op
Iteration 4: 2,628 ns/op
Iteration 5: 2,620 ns/op
Iteration 6: 2,623 ns/op
Iteration 7: 2,613 ns/op
Iteration 8: 2,613 ns/op
Iteration 9: 2,618 ns/op
Iteration 10: 2,621 ns/op
# Run progress: 3,33% complete, ETA 00:07:24
# Fork: 2 of 5
# Warmup Iteration 1: 2,828 ns/op
# Warmup Iteration 2: 2,762 ns/op
# Warmup Iteration 3: 2,612 ns/op
# Warmup Iteration 4: 2,640 ns/op
# Warmup Iteration 5: 2,620 ns/op
Iteration 1: 2,665 ns/op
Iteration 2: 2,637 ns/op
Iteration 3: 2,622 ns/op
Iteration 4: 2,623 ns/op
Iteration 5: 2,654 ns/op
Iteration 6: 2,628 ns/op
Iteration 7: 2,634 ns/op
Iteration 8: 2,658 ns/op
Iteration 9: 2,630 ns/op
Iteration 10: 2,626 ns/op
# Run progress: 6,67% complete, ETA 00:07:08
# Fork: 3 of 5
# Warmup Iteration 1: 2,886 ns/op
# Warmup Iteration 2: 2,755 ns/op
# Warmup Iteration 3: 2,627 ns/op
# Warmup Iteration 4: 2,662 ns/op
# Warmup Iteration 5: 2,726 ns/op
Iteration 1: 2,691 ns/op
Iteration 2: 2,642 ns/op
Iteration 3: 2,675 ns/op
Iteration 4: 2,687 ns/op
Iteration 5: 2,663 ns/op
Iteration 6: 2,717 ns/op
Iteration 7: 2,624 ns/op
Iteration 8: 2,692 ns/op
Iteration 9: 2,706 ns/op
Iteration 10: 2,659 ns/op
# Run progress: 10,00% complete, ETA 00:06:53
# Fork: 4 of 5
# Warmup Iteration 1: 3,347 ns/op
# Warmup Iteration 2: 2,833 ns/op
# Warmup Iteration 3: 3,462 ns/op
# Warmup Iteration 4: 3,186 ns/op
# Warmup Iteration 5: 3,187 ns/op
Iteration 1: 3,143 ns/op
Iteration 2: 3,144 ns/op
Iteration 3: 3,189 ns/op
Iteration 4: 3,171 ns/op
Iteration 5: 3,178 ns/op
Iteration 6: 3,199 ns/op
Iteration 7: 3,137 ns/op
Iteration 8: 3,180 ns/op
Iteration 9: 3,133 ns/op
Iteration 10: 3,204 ns/op
# Run progress: 13,33% complete, ETA 00:06:37
# Fork: 5 of 5
# Warmup Iteration 1: 2,881 ns/op
# Warmup Iteration 2: 2,792 ns/op
# Warmup Iteration 3: 2,629 ns/op
# Warmup Iteration 4: 2,656 ns/op
# Warmup Iteration 5: 2,709 ns/op
Iteration 1: 2,630 ns/op
Iteration 2: 2,731 ns/op
Iteration 3: 2,674 ns/op
Iteration 4: 2,781 ns/op
Iteration 5: 2,667 ns/op
Iteration 6: 2,736 ns/op
Iteration 7: 2,657 ns/op
Iteration 8: 2,737 ns/op
Iteration 9: 2,692 ns/op
Iteration 10: 2,659 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.consumeDouble":
2,762 ±(99.9%) 0,103 ns/op [Average]
(min, avg, max) = (2,613, 2,762, 3,204), stdev = 0,209
CI (99.9%): [2,659, 2,865] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.consumeObject
# Run progress: 16,67% complete, ETA 00:06:22
# Fork: 1 of 5
# Warmup Iteration 1: 3,251 ns/op
# Warmup Iteration 2: 3,207 ns/op
# Warmup Iteration 3: 3,434 ns/op
# Warmup Iteration 4: 3,136 ns/op
# Warmup Iteration 5: 3,108 ns/op
Iteration 1: 3,113 ns/op
Iteration 2: 3,126 ns/op
Iteration 3: 3,111 ns/op
Iteration 4: 3,072 ns/op
Iteration 5: 3,048 ns/op
Iteration 6: 3,484 ns/op
Iteration 7: 3,138 ns/op
Iteration 8: 3,052 ns/op
Iteration 9: 3,119 ns/op
Iteration 10: 3,071 ns/op
# Run progress: 20,00% complete, ETA 00:06:07
# Fork: 2 of 5
# Warmup Iteration 1: 3,283 ns/op
# Warmup Iteration 2: 3,129 ns/op
# Warmup Iteration 3: 3,124 ns/op
# Warmup Iteration 4: 3,119 ns/op
# Warmup Iteration 5: 3,092 ns/op
Iteration 1: 3,123 ns/op
Iteration 2: 3,101 ns/op
Iteration 3: 3,121 ns/op
Iteration 4: 3,112 ns/op
Iteration 5: 3,141 ns/op
Iteration 6: 3,142 ns/op
Iteration 7: 3,045 ns/op
Iteration 8: 3,090 ns/op
Iteration 9: 3,145 ns/op
Iteration 10: 3,094 ns/op
# Run progress: 23,33% complete, ETA 00:05:51
# Fork: 3 of 5
# Warmup Iteration 1: 3,232 ns/op
# Warmup Iteration 2: 3,160 ns/op
# Warmup Iteration 3: 3,092 ns/op
# Warmup Iteration 4: 3,090 ns/op
# Warmup Iteration 5: 3,101 ns/op
Iteration 1: 3,077 ns/op
Iteration 2: 3,027 ns/op
Iteration 3: 3,039 ns/op
Iteration 4: 3,086 ns/op
Iteration 5: 3,043 ns/op
Iteration 6: 3,073 ns/op
Iteration 7: 3,078 ns/op
Iteration 8: 3,054 ns/op
Iteration 9: 3,040 ns/op
Iteration 10: 3,042 ns/op
# Run progress: 26,67% complete, ETA 00:05:36
# Fork: 4 of 5
# Warmup Iteration 1: 3,272 ns/op
# Warmup Iteration 2: 3,215 ns/op
# Warmup Iteration 3: 3,053 ns/op
# Warmup Iteration 4: 3,074 ns/op
# Warmup Iteration 5: 3,056 ns/op
Iteration 1: 3,236 ns/op
Iteration 2: 3,036 ns/op
Iteration 3: 3,060 ns/op
Iteration 4: 3,067 ns/op
Iteration 5: 3,061 ns/op
Iteration 6: 3,083 ns/op
Iteration 7: 3,045 ns/op
Iteration 8: 3,031 ns/op
Iteration 9: 3,070 ns/op
Iteration 10: 3,099 ns/op
# Run progress: 30,00% complete, ETA 00:05:21
# Fork: 5 of 5
# Warmup Iteration 1: 3,314 ns/op
# Warmup Iteration 2: 3,134 ns/op
# Warmup Iteration 3: 3,055 ns/op
# Warmup Iteration 4: 3,065 ns/op
# Warmup Iteration 5: 3,058 ns/op
Iteration 1: 3,064 ns/op
Iteration 2: 3,048 ns/op
Iteration 3: 3,022 ns/op
Iteration 4: 3,034 ns/op
Iteration 5: 3,049 ns/op
Iteration 6: 3,008 ns/op
Iteration 7: 3,022 ns/op
Iteration 8: 3,053 ns/op
Iteration 9: 3,047 ns/op
Iteration 10: 3,036 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.consumeObject":
3,084 ±(99.9%) 0,036 ns/op [Average]
(min, avg, max) = (3,008, 3,084, 3,484), stdev = 0,072
CI (99.9%): [3,048, 3,119] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.createAndConsumeObject
# Run progress: 33,33% complete, ETA 00:05:05
# Fork: 1 of 5
# Warmup Iteration 1: 6,357 ns/op
# Warmup Iteration 2: 6,220 ns/op
# Warmup Iteration 3: 4,057 ns/op
# Warmup Iteration 4: 3,996 ns/op
# Warmup Iteration 5: 4,095 ns/op
Iteration 1: 4,189 ns/op
Iteration 2: 4,137 ns/op
Iteration 3: 4,176 ns/op
Iteration 4: 4,212 ns/op
Iteration 5: 4,114 ns/op
Iteration 6: 4,216 ns/op
Iteration 7: 4,214 ns/op
Iteration 8: 4,158 ns/op
Iteration 9: 4,159 ns/op
Iteration 10: 4,132 ns/op
# Run progress: 36,67% complete, ETA 00:04:50
# Fork: 2 of 5
# Warmup Iteration 1: 6,585 ns/op
# Warmup Iteration 2: 6,339 ns/op
# Warmup Iteration 3: 4,486 ns/op
# Warmup Iteration 4: 4,182 ns/op
# Warmup Iteration 5: 4,234 ns/op
Iteration 1: 4,196 ns/op
Iteration 2: 4,119 ns/op
Iteration 3: 4,221 ns/op
Iteration 4: 4,350 ns/op
Iteration 5: 4,268 ns/op
Iteration 6: 4,422 ns/op
Iteration 7: 4,856 ns/op
Iteration 8: 4,463 ns/op
Iteration 9: 4,387 ns/op
Iteration 10: 4,666 ns/op
# Run progress: 40,00% complete, ETA 00:04:35
# Fork: 3 of 5
# Warmup Iteration 1: 6,676 ns/op
# Warmup Iteration 2: 5,895 ns/op
# Warmup Iteration 3: 4,275 ns/op
# Warmup Iteration 4: 4,967 ns/op
# Warmup Iteration 5: 4,296 ns/op
Iteration 1: 3,988 ns/op
Iteration 2: 4,229 ns/op
Iteration 3: 4,043 ns/op
Iteration 4: 4,176 ns/op
Iteration 5: 4,132 ns/op
Iteration 6: 4,116 ns/op
Iteration 7: 4,112 ns/op
Iteration 8: 4,141 ns/op
Iteration 9: 4,376 ns/op
Iteration 10: 4,046 ns/op
# Run progress: 43,33% complete, ETA 00:04:20
# Fork: 4 of 5
# Warmup Iteration 1: 6,594 ns/op
# Warmup Iteration 2: 6,165 ns/op
# Warmup Iteration 3: 4,236 ns/op
# Warmup Iteration 4: 4,239 ns/op
# Warmup Iteration 5: 4,261 ns/op
Iteration 1: 4,410 ns/op
Iteration 2: 4,354 ns/op
Iteration 3: 4,389 ns/op
Iteration 4: 4,404 ns/op
Iteration 5: 4,372 ns/op
Iteration 6: 4,383 ns/op
Iteration 7: 4,339 ns/op
Iteration 8: 4,262 ns/op
Iteration 9: 4,225 ns/op
Iteration 10: 4,263 ns/op
# Run progress: 46,67% complete, ETA 00:04:05
# Fork: 5 of 5
# Warmup Iteration 1: 6,359 ns/op
# Warmup Iteration 2: 5,736 ns/op
# Warmup Iteration 3: 4,054 ns/op
# Warmup Iteration 4: 4,209 ns/op
# Warmup Iteration 5: 4,989 ns/op
Iteration 1: 4,128 ns/op
Iteration 2: 4,111 ns/op
Iteration 3: 4,050 ns/op
Iteration 4: 4,145 ns/op
Iteration 5: 3,997 ns/op
Iteration 6: 4,055 ns/op
Iteration 7: 4,131 ns/op
Iteration 8: 4,109 ns/op
Iteration 9: 4,258 ns/op
Iteration 10: 4,259 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.createAndConsumeObject":
4,233 ±(99.9%) 0,081 ns/op [Average]
(min, avg, max) = (3,988, 4,233, 4,856), stdev = 0,163
CI (99.9%): [4,152, 4,314] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.createAndConsumeSingleVector
# Run progress: 50,00% complete, ETA 00:03:50
# Fork: 1 of 5
# Warmup Iteration 1: 9,465 ns/op
# Warmup Iteration 2: 8,339 ns/op
# Warmup Iteration 3: 6,843 ns/op
# Warmup Iteration 4: 6,870 ns/op
# Warmup Iteration 5: 7,000 ns/op
Iteration 1: 6,830 ns/op
Iteration 2: 6,889 ns/op
Iteration 3: 6,719 ns/op
Iteration 4: 6,963 ns/op
Iteration 5: 7,735 ns/op
Iteration 6: 6,903 ns/op
Iteration 7: 7,118 ns/op
Iteration 8: 6,859 ns/op
Iteration 9: 7,087 ns/op
Iteration 10: 7,379 ns/op
# Run progress: 53,33% complete, ETA 00:03:34
# Fork: 2 of 5
# Warmup Iteration 1: 9,744 ns/op
# Warmup Iteration 2: 9,466 ns/op
# Warmup Iteration 3: 6,871 ns/op
# Warmup Iteration 4: 6,820 ns/op
# Warmup Iteration 5: 6,858 ns/op
Iteration 1: 6,869 ns/op
Iteration 2: 6,898 ns/op
Iteration 3: 7,045 ns/op
Iteration 4: 6,835 ns/op
Iteration 5: 6,868 ns/op
Iteration 6: 6,941 ns/op
Iteration 7: 6,998 ns/op
Iteration 8: 6,807 ns/op
Iteration 9: 7,175 ns/op
Iteration 10: 6,743 ns/op
# Run progress: 56,67% complete, ETA 00:03:19
# Fork: 3 of 5
# Warmup Iteration 1: 10,032 ns/op
# Warmup Iteration 2: 8,211 ns/op
# Warmup Iteration 3: 6,765 ns/op
# Warmup Iteration 4: 6,623 ns/op
# Warmup Iteration 5: 6,686 ns/op
Iteration 1: 6,888 ns/op
Iteration 2: 6,890 ns/op
Iteration 3: 6,801 ns/op
Iteration 4: 6,948 ns/op
Iteration 5: 6,917 ns/op
Iteration 6: 6,983 ns/op
Iteration 7: 7,424 ns/op
Iteration 8: 6,883 ns/op
Iteration 9: 6,852 ns/op
Iteration 10: 7,131 ns/op
# Run progress: 60,00% complete, ETA 00:03:04
# Fork: 4 of 5
# Warmup Iteration 1: 9,733 ns/op
# Warmup Iteration 2: 9,382 ns/op
# Warmup Iteration 3: 7,941 ns/op
# Warmup Iteration 4: 6,613 ns/op
# Warmup Iteration 5: 6,822 ns/op
Iteration 1: 6,882 ns/op
Iteration 2: 6,867 ns/op
Iteration 3: 6,746 ns/op
Iteration 4: 6,705 ns/op
Iteration 5: 6,797 ns/op
Iteration 6: 6,912 ns/op
Iteration 7: 6,829 ns/op
Iteration 8: 6,918 ns/op
Iteration 9: 6,794 ns/op
Iteration 10: 6,676 ns/op
# Run progress: 63,33% complete, ETA 00:02:48
# Fork: 5 of 5
# Warmup Iteration 1: 9,569 ns/op
# Warmup Iteration 2: 8,417 ns/op
# Warmup Iteration 3: 7,498 ns/op
# Warmup Iteration 4: 6,733 ns/op
# Warmup Iteration 5: 7,604 ns/op
Iteration 1: 7,897 ns/op
Iteration 2: 7,120 ns/op
Iteration 3: 7,500 ns/op
Iteration 4: 6,625 ns/op
Iteration 5: 6,770 ns/op
Iteration 6: 7,269 ns/op
Iteration 7: 7,241 ns/op
Iteration 8: 7,620 ns/op
Iteration 9: 7,856 ns/op
Iteration 10: 7,113 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.createAndConsumeSingleVector":
7,010 ±(99.9%) 0,147 ns/op [Average]
(min, avg, max) = (6,625, 7,010, 7,897), stdev = 0,296
CI (99.9%): [6,864, 7,157] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.createAndConsumeThreeVectors
# Run progress: 66,67% complete, ETA 00:02:33
# Fork: 1 of 5
# Warmup Iteration 1: 31,232 ns/op
# Warmup Iteration 2: 24,643 ns/op
# Warmup Iteration 3: 20,248 ns/op
# Warmup Iteration 4: 20,570 ns/op
# Warmup Iteration 5: 20,308 ns/op
Iteration 1: 19,842 ns/op
Iteration 2: 20,232 ns/op
Iteration 3: 20,029 ns/op
Iteration 4: 20,176 ns/op
Iteration 5: 20,115 ns/op
Iteration 6: 19,805 ns/op
Iteration 7: 21,714 ns/op
Iteration 8: 22,290 ns/op
Iteration 9: 19,326 ns/op
Iteration 10: 20,043 ns/op
# Run progress: 70,00% complete, ETA 00:02:18
# Fork: 2 of 5
# Warmup Iteration 1: 26,737 ns/op
# Warmup Iteration 2: 23,298 ns/op
# Warmup Iteration 3: 19,492 ns/op
# Warmup Iteration 4: 20,015 ns/op
# Warmup Iteration 5: 19,786 ns/op
Iteration 1: 20,654 ns/op
Iteration 2: 24,989 ns/op
Iteration 3: 23,062 ns/op
Iteration 4: 20,066 ns/op
Iteration 5: 19,356 ns/op
Iteration 6: 20,228 ns/op
Iteration 7: 21,509 ns/op
Iteration 8: 22,263 ns/op
Iteration 9: 21,233 ns/op
Iteration 10: 19,880 ns/op
# Run progress: 73,33% complete, ETA 00:02:02
# Fork: 3 of 5
# Warmup Iteration 1: 26,036 ns/op
# Warmup Iteration 2: 23,763 ns/op
# Warmup Iteration 3: 20,667 ns/op
# Warmup Iteration 4: 21,922 ns/op
# Warmup Iteration 5: 21,267 ns/op
Iteration 1: 23,255 ns/op
Iteration 2: 19,302 ns/op
Iteration 3: 18,863 ns/op
Iteration 4: 19,233 ns/op
Iteration 5: 19,925 ns/op
Iteration 6: 20,173 ns/op
Iteration 7: 21,392 ns/op
Iteration 8: 20,636 ns/op
Iteration 9: 20,912 ns/op
Iteration 10: 24,070 ns/op
# Run progress: 76,67% complete, ETA 00:01:47
# Fork: 4 of 5
# Warmup Iteration 1: 29,365 ns/op
# Warmup Iteration 2: 27,052 ns/op
# Warmup Iteration 3: 21,789 ns/op
# Warmup Iteration 4: 19,787 ns/op
# Warmup Iteration 5: 20,056 ns/op
Iteration 1: 21,602 ns/op
Iteration 2: 22,444 ns/op
Iteration 3: 20,305 ns/op
Iteration 4: 21,075 ns/op
Iteration 5: 19,933 ns/op
Iteration 6: 22,111 ns/op
Iteration 7: 22,645 ns/op
Iteration 8: 19,873 ns/op
Iteration 9: 19,664 ns/op
Iteration 10: 19,952 ns/op
# Run progress: 80,00% complete, ETA 00:01:32
# Fork: 5 of 5
# Warmup Iteration 1: 30,277 ns/op
# Warmup Iteration 2: 25,022 ns/op
# Warmup Iteration 3: 20,405 ns/op
# Warmup Iteration 4: 19,999 ns/op
# Warmup Iteration 5: 20,755 ns/op
Iteration 1: 20,470 ns/op
Iteration 2: 21,499 ns/op
Iteration 3: 20,766 ns/op
Iteration 4: 19,998 ns/op
Iteration 5: 19,515 ns/op
Iteration 6: 20,064 ns/op
Iteration 7: 19,542 ns/op
Iteration 8: 20,014 ns/op
Iteration 9: 19,758 ns/op
Iteration 10: 19,717 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.createAndConsumeThreeVectors":
20,710 ±(99.9%) 0,654 ns/op [Average]
(min, avg, max) = (18,863, 20,710, 24,989), stdev = 1,320
CI (99.9%): [20,057, 21,364] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.createAndConsumeTwoVectors
# Run progress: 83,33% complete, ETA 00:01:16
# Fork: 1 of 5
# Warmup Iteration 1: 18,072 ns/op
# Warmup Iteration 2: 25,260 ns/op
# Warmup Iteration 3: 15,438 ns/op
# Warmup Iteration 4: 13,649 ns/op
# Warmup Iteration 5: 13,361 ns/op
Iteration 1: 13,433 ns/op
Iteration 2: 13,303 ns/op
Iteration 3: 13,019 ns/op
Iteration 4: 13,528 ns/op
Iteration 5: 14,091 ns/op
Iteration 6: 13,546 ns/op
Iteration 7: 13,573 ns/op
Iteration 8: 13,638 ns/op
Iteration 9: 14,691 ns/op
Iteration 10: 13,792 ns/op
# Run progress: 86,67% complete, ETA 00:01:01
# Fork: 2 of 5
# Warmup Iteration 1: 18,286 ns/op
# Warmup Iteration 2: 17,930 ns/op
# Warmup Iteration 3: 14,022 ns/op
# Warmup Iteration 4: 13,687 ns/op
# Warmup Iteration 5: 13,751 ns/op
Iteration 1: 14,289 ns/op
Iteration 2: 15,563 ns/op
Iteration 3: 14,257 ns/op
Iteration 4: 13,320 ns/op
Iteration 5: 13,521 ns/op
Iteration 6: 13,466 ns/op
Iteration 7: 13,302 ns/op
Iteration 8: 14,263 ns/op
Iteration 9: 14,169 ns/op
Iteration 10: 13,351 ns/op
# Run progress: 90,00% complete, ETA 00:00:46
# Fork: 3 of 5
# Warmup Iteration 1: 18,666 ns/op
# Warmup Iteration 2: 16,649 ns/op
# Warmup Iteration 3: 14,153 ns/op
# Warmup Iteration 4: 13,350 ns/op
# Warmup Iteration 5: 13,531 ns/op
Iteration 1: 13,186 ns/op
Iteration 2: 13,436 ns/op
Iteration 3: 14,136 ns/op
Iteration 4: 14,686 ns/op
Iteration 5: 13,111 ns/op
Iteration 6: 13,267 ns/op
Iteration 7: 13,264 ns/op
Iteration 8: 15,579 ns/op
Iteration 9: 13,763 ns/op
Iteration 10: 13,015 ns/op
# Run progress: 93,33% complete, ETA 00:00:30
# Fork: 4 of 5
# Warmup Iteration 1: 17,933 ns/op
# Warmup Iteration 2: 17,535 ns/op
# Warmup Iteration 3: 12,788 ns/op
# Warmup Iteration 4: 13,409 ns/op
# Warmup Iteration 5: 13,425 ns/op
Iteration 1: 13,695 ns/op
Iteration 2: 13,744 ns/op
Iteration 3: 13,878 ns/op
Iteration 4: 13,978 ns/op
Iteration 5: 13,653 ns/op
Iteration 6: 13,535 ns/op
Iteration 7: 13,110 ns/op
Iteration 8: 14,358 ns/op
Iteration 9: 13,280 ns/op
Iteration 10: 13,538 ns/op
# Run progress: 96,67% complete, ETA 00:00:15
# Fork: 5 of 5
# Warmup Iteration 1: 18,142 ns/op
# Warmup Iteration 2: 16,007 ns/op
# Warmup Iteration 3: 15,354 ns/op
# Warmup Iteration 4: 14,272 ns/op
# Warmup Iteration 5: 13,961 ns/op
Iteration 1: 13,698 ns/op
Iteration 2: 13,758 ns/op
Iteration 3: 13,508 ns/op
Iteration 4: 13,410 ns/op
Iteration 5: 13,533 ns/op
Iteration 6: 13,457 ns/op
Iteration 7: 13,454 ns/op
Iteration 8: 13,197 ns/op
Iteration 9: 13,234 ns/op
Iteration 10: 13,514 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.CreateAndConsumeBenchmark.createAndConsumeTwoVectors":
13,702 ±(99.9%) 0,276 ns/op [Average]
(min, avg, max) = (13,015, 13,702, 15,579), stdev = 0,557
CI (99.9%): [13,426, 13,978] (assumes normal distribution)
# Run complete. Total time: 00:07:41
Benchmark Mode Cnt Score Error Units
CreateAndConsumeBenchmark.consumeDouble avgt 50 2,762 ± 0,103 ns/op
CreateAndConsumeBenchmark.consumeObject avgt 50 3,084 ± 0,036 ns/op
CreateAndConsumeBenchmark.createAndConsumeObject avgt 50 4,233 ± 0,081 ns/op
CreateAndConsumeBenchmark.createAndConsumeSingleVector avgt 50 7,010 ± 0,147 ns/op
CreateAndConsumeBenchmark.createAndConsumeThreeVectors avgt 50 20,710 ± 0,654 ns/op
CreateAndConsumeBenchmark.createAndConsumeTwoVectors avgt 50 13,702 ± 0,276 ns/op
```
Ещё несколько выводов по результатам этого бенчмарка:
1. `Blackhole.consume(double)` — дорогой в сравнении с нашей арифметикой (это плохо)
2. `Blackhole.consume(Object)` немного дороже `Blackhole.consume(double)` (это тоже плохо)
3. Каких-то существенных выбросов в измерениях нет (это ни о чём не говорит)
4. Важный вывод — цена создания объекта сопоставима с арифметикой выше
Можно долго спекулировать на тему полученных результатов, менять `double` на `int` и наоборот — *данный бенчмарк показал несущественную разницу для двух алгоритмов*. Честно признаться, на таких тестах (единицы наносекунд) существенное влияние может оказать всё вплоть до железа, но нам повезло. А ещё… Мы так и не разобрались, куда пропали затраты на создание объектов из первого бенчмарка.
### Куда делись объекты `Vector`
Если внимательно посмотреть на код, можно заметить, что создаваемые объекты Vector локальны для метода `VectorAlgebra.computeWithVectors()` (скоуп объектов ограничен указанным методом), а всё действие с объектами ограничивается арифметикой над их полями. Это значит, что JIT-компилятор в теории мог бы не создавать эти объекты, а заменить код каким-то таким образом (помним, что методы были заинлайнены):
```
public static double computeJittedPseudocode(
double x1, double y1, double z1,
double x2, double y2, double z2) {
final double v1_x = x1, v1_y = y1, v1_z = z1;// new Vector(x1, y1, z1);
final double v2_x = x2, v2_y = y2, v2_z = z2;// new Vector(x2, y2, z2);
double x = v1_y * v2_z - v1_z * v2_y; // inline crossProduct
double y = v1_z * v2_x - v1_x * v2_z; // inline crossProduct
double z = v1_x * v2_y - v1_y * v2_x; // inline crossProduct
// new Vector(x, y, z);
return x * x + y * y + z * z;// inline squared
}
```
Каковы преимущества такой оптимизации? Во-первых, выделение памяти не в куче, а на стеке (если повезёт, то все вычисления ограничатся использованием регистров процессора). Во-вторых, нет объекта — нет нагрузки на GC.
Написанное выше можно формализовать в виде двух действий:
1. Обнаружить, какие объекты имеют ограниченный скоуп (определение области достижимости объекта). Это называется Escape analysis.
2. Заменить операции над полями объекта операциями над локальными переменными (а значит, не создавать сами объекты за ненадобностью). Данная оптимизация называется Scalar replacement или скаляризация.
Подробнее об этом можно почитать в статье [Escape analysis и скаляризация: Пусть GC отдохнет](https://habrahabr.ru/company/jugru/blog/322348/) (по ссылке доклад Руслана [cheremin](https://habr.com/users/cheremin/) с конференции JPoint и его текстовая расшифровка). Оригинальная статья Brian Goetz, вышедшая в 2005 году, [Urban performance legends, revisited](https://www.ibm.com/developerworks/java/library/j-jtp09275/index.html), в которой рассказывается о нововведении в Java 6. По умолчанию Escape-анализ включен начиная с 6u23.
В качестве подтверждения попробуем прогнать первый бенчмарк с отключенным Escape-анализом `-XX:-DoEscapeAnalysis`:
```
Benchmark Mode Cnt Score Error Units
ComputationOnly...computeWithRawScalars avgt 50 4,977 ± 0,122 ns/op
ComputationOnly...computeWithVectors avgt 50 20,335 ± 1,005 ns/op
```
**Результат бенчмарка целиком**
```
# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0_161\bin\java.exe
# VM options: -XX:-DoEscapeAnalysis
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.vector.ComputationOnlyBenchmark.computeWithRawScalars
# Run progress: 0,00% complete, ETA 00:02:30
# Fork: 1 of 5
# Warmup Iteration 1: 6,116 ns/op
# Warmup Iteration 2: 5,668 ns/op
# Warmup Iteration 3: 5,795 ns/op
# Warmup Iteration 4: 5,484 ns/op
# Warmup Iteration 5: 5,185 ns/op
Iteration 1: 4,794 ns/op
Iteration 2: 4,919 ns/op
Iteration 3: 5,092 ns/op
Iteration 4: 5,231 ns/op
Iteration 5: 5,187 ns/op
Iteration 6: 4,912 ns/op
Iteration 7: 4,899 ns/op
Iteration 8: 5,254 ns/op
Iteration 9: 5,218 ns/op
Iteration 10: 5,095 ns/op
# Run progress: 10,00% complete, ETA 00:02:19
# Fork: 2 of 5
# Warmup Iteration 1: 6,257 ns/op
# Warmup Iteration 2: 5,560 ns/op
# Warmup Iteration 3: 6,078 ns/op
# Warmup Iteration 4: 5,831 ns/op
# Warmup Iteration 5: 6,079 ns/op
Iteration 1: 5,250 ns/op
Iteration 2: 5,434 ns/op
Iteration 3: 5,472 ns/op
Iteration 4: 5,099 ns/op
Iteration 5: 5,204 ns/op
Iteration 6: 5,217 ns/op
Iteration 7: 5,628 ns/op
Iteration 8: 5,152 ns/op
Iteration 9: 5,273 ns/op
Iteration 10: 5,126 ns/op
# Run progress: 20,00% complete, ETA 00:02:03
# Fork: 3 of 5
# Warmup Iteration 1: 5,595 ns/op
# Warmup Iteration 2: 5,203 ns/op
# Warmup Iteration 3: 5,247 ns/op
# Warmup Iteration 4: 5,157 ns/op
# Warmup Iteration 5: 5,184 ns/op
Iteration 1: 4,924 ns/op
Iteration 2: 4,831 ns/op
Iteration 3: 4,816 ns/op
Iteration 4: 4,787 ns/op
Iteration 5: 4,843 ns/op
Iteration 6: 4,758 ns/op
Iteration 7: 4,788 ns/op
Iteration 8: 4,771 ns/op
Iteration 9: 5,051 ns/op
Iteration 10: 4,767 ns/op
# Run progress: 30,00% complete, ETA 00:01:47
# Fork: 4 of 5
# Warmup Iteration 1: 5,296 ns/op
# Warmup Iteration 2: 4,822 ns/op
# Warmup Iteration 3: 4,827 ns/op
# Warmup Iteration 4: 4,884 ns/op
# Warmup Iteration 5: 4,863 ns/op
Iteration 1: 4,807 ns/op
Iteration 2: 4,880 ns/op
Iteration 3: 5,747 ns/op
Iteration 4: 4,862 ns/op
Iteration 5: 4,800 ns/op
Iteration 6: 4,802 ns/op
Iteration 7: 4,843 ns/op
Iteration 8: 4,858 ns/op
Iteration 9: 4,864 ns/op
Iteration 10: 4,837 ns/op
# Run progress: 40,00% complete, ETA 00:01:32
# Fork: 5 of 5
# Warmup Iteration 1: 5,158 ns/op
# Warmup Iteration 2: 4,728 ns/op
# Warmup Iteration 3: 4,759 ns/op
# Warmup Iteration 4: 4,751 ns/op
# Warmup Iteration 5: 4,753 ns/op
Iteration 1: 4,758 ns/op
Iteration 2: 4,793 ns/op
Iteration 3: 4,773 ns/op
Iteration 4: 4,755 ns/op
Iteration 5: 4,771 ns/op
Iteration 6: 4,759 ns/op
Iteration 7: 4,811 ns/op
Iteration 8: 4,763 ns/op
Iteration 9: 4,768 ns/op
Iteration 10: 4,822 ns/op
Result "ru.gnkoshelev.jbreak2018.perf_tests.vector.ComputationOnlyBenchmark.computeWithRawScalars":
4,977 ±(99.9%) 0,122 ns/op [Average]
(min, avg, max) = (4,755, 4,977, 5,747), stdev = 0,247
CI (99.9%): [4,855, 5,100] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0_161\bin\java.exe
# VM options: -XX:-DoEscapeAnalysis
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.vector.ComputationOnlyBenchmark.computeWithVectors
# Run progress: 50,00% complete, ETA 00:01:16
# Fork: 1 of 5
# Warmup Iteration 1: 27,236 ns/op
# Warmup Iteration 2: 19,767 ns/op
# Warmup Iteration 3: 17,886 ns/op
# Warmup Iteration 4: 18,233 ns/op
# Warmup Iteration 5: 19,181 ns/op
Iteration 1: 18,941 ns/op
Iteration 2: 19,268 ns/op
Iteration 3: 19,248 ns/op
Iteration 4: 18,410 ns/op
Iteration 5: 18,542 ns/op
Iteration 6: 18,864 ns/op
Iteration 7: 19,185 ns/op
Iteration 8: 19,991 ns/op
Iteration 9: 20,165 ns/op
Iteration 10: 23,206 ns/op
# Run progress: 60,00% complete, ETA 00:01:01
# Fork: 2 of 5
# Warmup Iteration 1: 25,746 ns/op
# Warmup Iteration 2: 22,360 ns/op
# Warmup Iteration 3: 21,799 ns/op
# Warmup Iteration 4: 20,638 ns/op
# Warmup Iteration 5: 19,795 ns/op
Iteration 1: 19,828 ns/op
Iteration 2: 19,245 ns/op
Iteration 3: 19,671 ns/op
Iteration 4: 19,241 ns/op
Iteration 5: 20,262 ns/op
Iteration 6: 23,844 ns/op
Iteration 7: 21,305 ns/op
Iteration 8: 19,938 ns/op
Iteration 9: 24,120 ns/op
Iteration 10: 22,911 ns/op
# Run progress: 70,00% complete, ETA 00:00:46
# Fork: 3 of 5
# Warmup Iteration 1: 28,404 ns/op
# Warmup Iteration 2: 25,285 ns/op
# Warmup Iteration 3: 20,809 ns/op
# Warmup Iteration 4: 20,383 ns/op
# Warmup Iteration 5: 20,395 ns/op
Iteration 1: 21,113 ns/op
Iteration 2: 21,447 ns/op
Iteration 3: 21,666 ns/op
Iteration 4: 20,485 ns/op
Iteration 5: 21,662 ns/op
Iteration 6: 20,139 ns/op
Iteration 7: 21,567 ns/op
Iteration 8: 20,834 ns/op
Iteration 9: 21,712 ns/op
Iteration 10: 20,869 ns/op
# Run progress: 80,00% complete, ETA 00:00:30
# Fork: 4 of 5
# Warmup Iteration 1: 30,493 ns/op
# Warmup Iteration 2: 24,889 ns/op
# Warmup Iteration 3: 21,871 ns/op
# Warmup Iteration 4: 19,788 ns/op
# Warmup Iteration 5: 18,893 ns/op
Iteration 1: 18,813 ns/op
Iteration 2: 18,546 ns/op
Iteration 3: 19,503 ns/op
Iteration 4: 20,699 ns/op
Iteration 5: 27,849 ns/op
Iteration 6: 19,529 ns/op
Iteration 7: 26,412 ns/op
Iteration 8: 20,032 ns/op
Iteration 9: 19,040 ns/op
Iteration 10: 19,013 ns/op
# Run progress: 90,00% complete, ETA 00:00:15
# Fork: 5 of 5
# Warmup Iteration 1: 25,171 ns/op
# Warmup Iteration 2: 23,385 ns/op
# Warmup Iteration 3: 19,782 ns/op
# Warmup Iteration 4: 21,491 ns/op
# Warmup Iteration 5: 20,863 ns/op
Iteration 1: 20,694 ns/op
Iteration 2: 18,793 ns/op
Iteration 3: 17,919 ns/op
Iteration 4: 18,117 ns/op
Iteration 5: 18,309 ns/op
Iteration 6: 20,848 ns/op
Iteration 7: 18,970 ns/op
Iteration 8: 18,359 ns/op
Iteration 9: 18,688 ns/op
Iteration 10: 18,948 ns/op
Result "ru.gnkoshelev.jbreak2018.perf_tests.vector.ComputationOnlyBenchmark.computeWithVectors":
20,335 ±(99.9%) 1,005 ns/op [Average]
(min, avg, max) = (17,919, 20,335, 27,849), stdev = 2,030
CI (99.9%): [19,331, 21,340] (assumes normal distribution)
# Run complete. Total time: 00:02:34
Benchmark Mode Cnt Score Error Units
ComputationOnly...computeWithRawScalars avgt 50 4,977 ± 0,122 ns/op
ComputationOnly...computeWithVectors avgt 50 20,335 ± 1,005 ns/op
```
Escape-анализ не является оптимизацией сам по себе — он лишь собирает сведения для последующего применения Scalar Replacement. Для отключения оптимизации можно воспользоваться ключом `-XX:-EliminateAllocations`.
#### Правильный ответ?
> Оба алгоритма дают одинаковый результат по производительности, т.к. благодаря Escape Analysis и Scalar Replacement не будут создаваться объекты Vector
### Второе дно
На конференции у нашего стенда Владимир [vladimirsitnikov](https://habr.com/users/vladimirsitnikov/) Ситников и Никита Коваль обсуждали эту задачу. Они верно определили, что здесь имеет место быть Escape-анализ. Однако, Вова высказал сомнение, что здесь может быть не всё так просто и у задачи вполне может оказаться *второе дно*.
Вернёмся к тому, что один-единственный вызов нашего метода столкнулся с side-эффектами окружения. В частности, метод `Blackhole.consume()` требовал сопоставимое с алгоритмом время на выполнение. Доработаем бенчмарк, чтобы снизить эффект от этого:
```
@Fork(value = 5, warmups = 0)
@Warmup(iterations = 5, time = 1_000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1_000, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Benchmark)
public class ComputationBatchBenchmark {
private double x1, y1, z1;
private double x2, y2, z2;
@Setup(value = Level.Iteration)
public void setup() {
x1 = 123.4;
y1 = 234.5;
z1 = 345.6;
x2 = 456.7;
y2 = 567.8;
z2 = 678.9;
}
@Benchmark
@OperationsPerInvocation(10_000)
public void computeWithRawScalars(Blackhole bh) {
double sum = 0;
for (int i = 0; i < 10_000; i++) {
sum += VectorAlgebra.computeWithRawScalars(x1, y1, z1, x2, y2, z2);
}
bh.consume(sum);
}
@Benchmark
@OperationsPerInvocation(10_000)
public void computeWithVectors(Blackhole bh) {
double sum = 0;
for (int i = 0; i < 10_000; i++) {
sum += VectorAlgebra.computeWithVectors(x1, y1, z1, x2, y2, z2);
}
bh.consume(sum);
}
}
```
Внезапно:
```
Benchmark Mode Cnt Score Error Units
ComputationBatch...computeWithRawScalars avgt 50 0,921 ± 0,004 ns/op
ComputationBatch...computeWithVectors avgt 50 2,609 ± 0,029 ns/op
```
**Результат бенчмарка целиком**
```
# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.ComputationBatchBenchmark.computeWithRawScalars
# Run progress: 0,00% complete, ETA 00:02:30
# Fork: 1 of 5
# Warmup Iteration 1: 1,003 ns/op
# Warmup Iteration 2: 0,936 ns/op
# Warmup Iteration 3: 0,918 ns/op
# Warmup Iteration 4: 0,929 ns/op
# Warmup Iteration 5: 0,919 ns/op
Iteration 1: 0,923 ns/op
Iteration 2: 0,936 ns/op
Iteration 3: 0,914 ns/op
Iteration 4: 0,913 ns/op
Iteration 5: 0,914 ns/op
Iteration 6: 0,914 ns/op
Iteration 7: 0,916 ns/op
Iteration 8: 0,913 ns/op
Iteration 9: 0,919 ns/op
Iteration 10: 0,923 ns/op
# Run progress: 10,00% complete, ETA 00:02:18
# Fork: 2 of 5
# Warmup Iteration 1: 0,941 ns/op
# Warmup Iteration 2: 0,926 ns/op
# Warmup Iteration 3: 0,931 ns/op
# Warmup Iteration 4: 0,927 ns/op
# Warmup Iteration 5: 0,927 ns/op
Iteration 1: 0,940 ns/op
Iteration 2: 0,918 ns/op
Iteration 3: 0,919 ns/op
Iteration 4: 0,915 ns/op
Iteration 5: 0,915 ns/op
Iteration 6: 0,914 ns/op
Iteration 7: 0,918 ns/op
Iteration 8: 0,912 ns/op
Iteration 9: 0,916 ns/op
Iteration 10: 0,918 ns/op
# Run progress: 20,00% complete, ETA 00:02:02
# Fork: 3 of 5
# Warmup Iteration 1: 0,923 ns/op
# Warmup Iteration 2: 0,912 ns/op
# Warmup Iteration 3: 0,916 ns/op
# Warmup Iteration 4: 0,930 ns/op
# Warmup Iteration 5: 0,916 ns/op
Iteration 1: 0,921 ns/op
Iteration 2: 0,932 ns/op
Iteration 3: 0,931 ns/op
Iteration 4: 0,919 ns/op
Iteration 5: 0,918 ns/op
Iteration 6: 0,915 ns/op
Iteration 7: 0,914 ns/op
Iteration 8: 0,918 ns/op
Iteration 9: 0,917 ns/op
Iteration 10: 0,917 ns/op
# Run progress: 30,00% complete, ETA 00:01:47
# Fork: 4 of 5
# Warmup Iteration 1: 0,926 ns/op
# Warmup Iteration 2: 0,915 ns/op
# Warmup Iteration 3: 0,912 ns/op
# Warmup Iteration 4: 0,917 ns/op
# Warmup Iteration 5: 0,915 ns/op
Iteration 1: 0,917 ns/op
Iteration 2: 0,915 ns/op
Iteration 3: 0,915 ns/op
Iteration 4: 0,929 ns/op
Iteration 5: 0,939 ns/op
Iteration 6: 0,919 ns/op
Iteration 7: 0,919 ns/op
Iteration 8: 0,936 ns/op
Iteration 9: 0,929 ns/op
Iteration 10: 0,939 ns/op
# Run progress: 40,00% complete, ETA 00:01:31
# Fork: 5 of 5
# Warmup Iteration 1: 0,939 ns/op
# Warmup Iteration 2: 0,928 ns/op
# Warmup Iteration 3: 0,947 ns/op
# Warmup Iteration 4: 0,930 ns/op
# Warmup Iteration 5: 0,948 ns/op
Iteration 1: 0,925 ns/op
Iteration 2: 0,930 ns/op
Iteration 3: 0,914 ns/op
Iteration 4: 0,918 ns/op
Iteration 5: 0,914 ns/op
Iteration 6: 0,918 ns/op
Iteration 7: 0,928 ns/op
Iteration 8: 0,923 ns/op
Iteration 9: 0,924 ns/op
Iteration 10: 0,920 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.ComputationBatchBenchmark.computeWithRawScalars":
0,921 ±(99.9%) 0,004 ns/op [Average]
(min, avg, max) = (0,912, 0,921, 0,940), stdev = 0,008
CI (99.9%): [0,917, 0,925] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.ComputationBatchBenchmark.computeWithVectors
# Run progress: 50,00% complete, ETA 00:01:16
# Fork: 1 of 5
# Warmup Iteration 1: 2,489 ns/op
# Warmup Iteration 2: 2,493 ns/op
# Warmup Iteration 3: 2,457 ns/op
# Warmup Iteration 4: 2,688 ns/op
# Warmup Iteration 5: 2,699 ns/op
Iteration 1: 2,647 ns/op
Iteration 2: 2,631 ns/op
Iteration 3: 2,637 ns/op
Iteration 4: 2,653 ns/op
Iteration 5: 2,724 ns/op
Iteration 6: 2,601 ns/op
Iteration 7: 2,590 ns/op
Iteration 8: 2,600 ns/op
Iteration 9: 2,589 ns/op
Iteration 10: 2,617 ns/op
# Run progress: 60,00% complete, ETA 00:01:01
# Fork: 2 of 5
# Warmup Iteration 1: 2,500 ns/op
# Warmup Iteration 2: 2,461 ns/op
# Warmup Iteration 3: 2,478 ns/op
# Warmup Iteration 4: 2,870 ns/op
# Warmup Iteration 5: 2,695 ns/op
Iteration 1: 2,576 ns/op
Iteration 2: 2,558 ns/op
Iteration 3: 2,594 ns/op
Iteration 4: 2,587 ns/op
Iteration 5: 2,654 ns/op
Iteration 6: 2,605 ns/op
Iteration 7: 2,631 ns/op
Iteration 8: 2,573 ns/op
Iteration 9: 2,574 ns/op
Iteration 10: 2,595 ns/op
# Run progress: 70,00% complete, ETA 00:00:45
# Fork: 3 of 5
# Warmup Iteration 1: 2,499 ns/op
# Warmup Iteration 2: 2,463 ns/op
# Warmup Iteration 3: 2,465 ns/op
# Warmup Iteration 4: 2,596 ns/op
# Warmup Iteration 5: 2,686 ns/op
Iteration 1: 2,695 ns/op
Iteration 2: 2,665 ns/op
Iteration 3: 2,573 ns/op
Iteration 4: 2,827 ns/op
Iteration 5: 2,620 ns/op
Iteration 6: 2,654 ns/op
Iteration 7: 2,641 ns/op
Iteration 8: 2,636 ns/op
Iteration 9: 2,642 ns/op
Iteration 10: 2,805 ns/op
# Run progress: 80,00% complete, ETA 00:00:30
# Fork: 4 of 5
# Warmup Iteration 1: 2,710 ns/op
# Warmup Iteration 2: 2,549 ns/op
# Warmup Iteration 3: 2,713 ns/op
# Warmup Iteration 4: 2,616 ns/op
# Warmup Iteration 5: 2,566 ns/op
Iteration 1: 2,577 ns/op
Iteration 2: 2,569 ns/op
Iteration 3: 2,562 ns/op
Iteration 4: 2,563 ns/op
Iteration 5: 2,559 ns/op
Iteration 6: 2,570 ns/op
Iteration 7: 2,560 ns/op
Iteration 8: 2,558 ns/op
Iteration 9: 2,552 ns/op
Iteration 10: 2,580 ns/op
# Run progress: 90,00% complete, ETA 00:00:15
# Fork: 5 of 5
# Warmup Iteration 1: 2,461 ns/op
# Warmup Iteration 2: 2,443 ns/op
# Warmup Iteration 3: 2,465 ns/op
# Warmup Iteration 4: 2,558 ns/op
# Warmup Iteration 5: 2,554 ns/op
Iteration 1: 2,547 ns/op
Iteration 2: 2,636 ns/op
Iteration 3: 2,553 ns/op
Iteration 4: 2,568 ns/op
Iteration 5: 2,582 ns/op
Iteration 6: 2,586 ns/op
Iteration 7: 2,559 ns/op
Iteration 8: 2,657 ns/op
Iteration 9: 2,567 ns/op
Iteration 10: 2,565 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.ComputationBatchBenchmark.computeWithVectors":
2,609 ±(99.9%) 0,029 ns/op [Average]
(min, avg, max) = (2,547, 2,609, 2,827), stdev = 0,059
CI (99.9%): [2,580, 2,639] (assumes normal distribution)
# Run complete. Total time: 00:02:33
Benchmark Mode Cnt Score Error Units
ComputationBatch...computeWithRawScalars avgt 50 0,921 ± 0,004 ns/op
ComputationBatch...computeWithVectors avgt 50 2,609 ± 0,029 ns/op
```
Почти 3-кратное различие. И это в условиях, когда объекты реально не создаются (что происходит, если не работает ScalarReplacement мы могли заметить по бенчмаркам выше).
#### Что вообще происходит?
Ключом к разгадке является ключевое слово `final` в классе `VectorAlgebra.Vector`.
Прогоним ещё один бенчмарк, в котором будем сравнивать результаты `computeWithVector()` для двух классов: `FinalVector` и `NonFinalVector`:
```
public final static class FinalVector {
private final double x, y, z;
public FinalVector(double x, double y, double z) {
this.x = x; this.y = y; this.z = z;
}
public double squared() {
return x * x + y * y + z * z;
}
public FinalVector crossProduct(FinalVector v) {
return new FinalVector(
y * v.z - z * v.y,
z * v.x - x * v.z,
x * v.y - y * v.x);
}
}
public final static class NonFinalVector {
private double x, y, z;
public NonFinalVector(double x, double y, double z) {
this.x = x; this.y = y; this.z = z;
}
public double squared() {
return x * x + y * y + z * z;
}
public NonFinalVector crossProduct(NonFinalVector v) {
return new NonFinalVector(
y * v.z - z * v.y,
z * v.x - x * v.z,
x * v.y - y * v.x);
}
}
```
**Код бенчмарка целиком**
```
package ru.gnkoshelev.jbreak2018.perf_tests.vector;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OperationsPerInvocation;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.infra.Blackhole;
import java.util.concurrent.TimeUnit;
/**
* Created by kgn on 20.03.2018.
*/
@Fork(value = 5, warmups = 0)
@Warmup(iterations = 5, time = 1_000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1_000, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Benchmark)
public class FinalOrNotFinalBenchmark {
private double x1, y1, z1;
private double x2, y2, z2;
@Setup(value = Level.Iteration)
public void setup() {
x1 = 123.4;
y1 = 234.5;
z1 = 345.6;
x2 = 456.7;
y2 = 567.8;
z2 = 678.9;
}
@Benchmark
@OperationsPerInvocation(10_000)
public void computeWithFinalsBenchmark(Blackhole bh) {
double sum = 0;
for (int i = 0; i < 100_000; i++) {
sum += computeWithFinals(x1, y1, z1, x2, y2, z2);
}
bh.consume(sum);
}
@Benchmark
@OperationsPerInvocation(10_000)
public void computeWithNonFinalsBenchmark(Blackhole bh) {
double sum = 0;
for (int i = 0; i < 100_000; i++) {
sum += computeWithNonFinals(x1, y1, z1, x2, y2, z2);
}
bh.consume(sum);
}
public static double computeWithFinals(
double x1, double y1, double z1,
double x2, double y2, double z2) {
FinalVector v1 = new FinalVector(x1, y1, z1);
FinalVector v2 = new FinalVector(x2, y2, z2);
return v1.crossProduct(v2).squared();
}
public static double computeWithNonFinals(
double x1, double y1, double z1,
double x2, double y2, double z2) {
NonFinalVector v1 = new NonFinalVector(x1, y1, z1);
NonFinalVector v2 = new NonFinalVector(x2, y2, z2);
return v1.crossProduct(v2).squared();
}
public final static class FinalVector {
private final double x, y, z;
public FinalVector(double x, double y, double z) {
this.x = x; this.y = y; this.z = z;
}
public double squared() {
return x * x + y * y + z * z;
}
public FinalVector crossProduct(FinalVector v) {
return new FinalVector(
y * v.z - z * v.y,
z * v.x - x * v.z,
x * v.y - y * v.x);
}
}
public final static class NonFinalVector {
private double x, y, z;
public NonFinalVector(double x, double y, double z) {
this.x = x; this.y = y; this.z = z;
}
public double squared() {
return x * x + y * y + z * z;
}
public NonFinalVector crossProduct(NonFinalVector v) {
return new NonFinalVector(
y * v.z - z * v.y,
z * v.x - x * v.z,
x * v.y - y * v.x);
}
}
}
```
Результат:
```
Benchmark Mode Cnt Score Error Units
FinalOrNotFinal...computeWithFinalsBenchmark avgt 50 2,618 ± 0,075 ns/op
FinalOrNotFinal...computeWithNonFinalsBenchmark avgt 50 0,929 ± 0,005 ns/op
```
**Результат бенчмарка целиком**
```
# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.FinalOrNotFinalBenchmark.computeWithFinalsBenchmark
# Run progress: 0,00% complete, ETA 00:02:30
# Fork: 1 of 5
# Warmup Iteration 1: 2,461 ns/op
# Warmup Iteration 2: 2,434 ns/op
# Warmup Iteration 3: 2,428 ns/op
# Warmup Iteration 4: 2,543 ns/op
# Warmup Iteration 5: 2,546 ns/op
Iteration 1: 2,546 ns/op
Iteration 2: 2,545 ns/op
Iteration 3: 2,546 ns/op
Iteration 4: 2,545 ns/op
Iteration 5: 2,541 ns/op
Iteration 6: 2,543 ns/op
Iteration 7: 2,543 ns/op
Iteration 8: 2,673 ns/op
Iteration 9: 2,686 ns/op
Iteration 10: 2,637 ns/op
# Run progress: 10,00% complete, ETA 00:02:18
# Fork: 2 of 5
# Warmup Iteration 1: 2,487 ns/op
# Warmup Iteration 2: 2,436 ns/op
# Warmup Iteration 3: 2,431 ns/op
# Warmup Iteration 4: 2,574 ns/op
# Warmup Iteration 5: 2,560 ns/op
Iteration 1: 2,581 ns/op
Iteration 2: 2,575 ns/op
Iteration 3: 2,600 ns/op
Iteration 4: 2,633 ns/op
Iteration 5: 2,573 ns/op
Iteration 6: 2,628 ns/op
Iteration 7: 2,568 ns/op
Iteration 8: 2,553 ns/op
Iteration 9: 2,582 ns/op
Iteration 10: 2,603 ns/op
# Run progress: 20,00% complete, ETA 00:02:02
# Fork: 3 of 5
# Warmup Iteration 1: 2,499 ns/op
# Warmup Iteration 2: 2,570 ns/op
# Warmup Iteration 3: 2,564 ns/op
# Warmup Iteration 4: 2,655 ns/op
# Warmup Iteration 5: 2,544 ns/op
Iteration 1: 2,537 ns/op
Iteration 2: 2,541 ns/op
Iteration 3: 2,543 ns/op
Iteration 4: 2,548 ns/op
Iteration 5: 2,547 ns/op
Iteration 6: 2,543 ns/op
Iteration 7: 2,540 ns/op
Iteration 8: 2,584 ns/op
Iteration 9: 2,590 ns/op
Iteration 10: 2,615 ns/op
# Run progress: 30,00% complete, ETA 00:01:47
# Fork: 4 of 5
# Warmup Iteration 1: 2,474 ns/op
# Warmup Iteration 2: 2,524 ns/op
# Warmup Iteration 3: 2,457 ns/op
# Warmup Iteration 4: 2,607 ns/op
# Warmup Iteration 5: 2,573 ns/op
Iteration 1: 2,574 ns/op
Iteration 2: 2,569 ns/op
Iteration 3: 2,806 ns/op
Iteration 4: 2,735 ns/op
Iteration 5: 2,570 ns/op
Iteration 6: 2,709 ns/op
Iteration 7: 2,556 ns/op
Iteration 8: 2,551 ns/op
Iteration 9: 2,561 ns/op
Iteration 10: 2,569 ns/op
# Run progress: 40,00% complete, ETA 00:01:31
# Fork: 5 of 5
# Warmup Iteration 1: 2,464 ns/op
# Warmup Iteration 2: 2,537 ns/op
# Warmup Iteration 3: 2,568 ns/op
# Warmup Iteration 4: 2,766 ns/op
# Warmup Iteration 5: 2,607 ns/op
Iteration 1: 2,687 ns/op
Iteration 2: 2,573 ns/op
Iteration 3: 2,553 ns/op
Iteration 4: 2,527 ns/op
Iteration 5: 2,608 ns/op
Iteration 6: 2,550 ns/op
Iteration 7: 2,775 ns/op
Iteration 8: 2,570 ns/op
Iteration 9: 3,349 ns/op
Iteration 10: 3,218 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.FinalOrNotFinalBenchmark.computeWithFinalsBenchmark":
2,618 ±(99.9%) 0,075 ns/op [Average]
(min, avg, max) = (2,527, 2,618, 3,349), stdev = 0,152
CI (99.9%): [2,543, 2,693] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1000 ms each
# Measurement: 10 iterations, 1000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.vector.FinalOrNotFinalBenchmark.computeWithNonFinalsBenchmark
# Run progress: 50,00% complete, ETA 00:01:16
# Fork: 1 of 5
# Warmup Iteration 1: 0,966 ns/op
# Warmup Iteration 2: 0,920 ns/op
# Warmup Iteration 3: 0,967 ns/op
# Warmup Iteration 4: 0,910 ns/op
# Warmup Iteration 5: 0,932 ns/op
Iteration 1: 0,917 ns/op
Iteration 2: 0,919 ns/op
Iteration 3: 0,926 ns/op
Iteration 4: 0,917 ns/op
Iteration 5: 0,915 ns/op
Iteration 6: 0,908 ns/op
Iteration 7: 0,924 ns/op
Iteration 8: 0,923 ns/op
Iteration 9: 0,927 ns/op
Iteration 10: 0,925 ns/op
# Run progress: 60,00% complete, ETA 00:01:01
# Fork: 2 of 5
# Warmup Iteration 1: 0,947 ns/op
# Warmup Iteration 2: 0,929 ns/op
# Warmup Iteration 3: 0,945 ns/op
# Warmup Iteration 4: 0,926 ns/op
# Warmup Iteration 5: 0,931 ns/op
Iteration 1: 0,924 ns/op
Iteration 2: 0,925 ns/op
Iteration 3: 0,925 ns/op
Iteration 4: 0,930 ns/op
Iteration 5: 0,929 ns/op
Iteration 6: 0,934 ns/op
Iteration 7: 0,927 ns/op
Iteration 8: 0,942 ns/op
Iteration 9: 0,947 ns/op
Iteration 10: 0,932 ns/op
# Run progress: 70,00% complete, ETA 00:00:46
# Fork: 3 of 5
# Warmup Iteration 1: 0,940 ns/op
# Warmup Iteration 2: 0,930 ns/op
# Warmup Iteration 3: 0,929 ns/op
# Warmup Iteration 4: 0,928 ns/op
# Warmup Iteration 5: 0,930 ns/op
Iteration 1: 0,925 ns/op
Iteration 2: 0,928 ns/op
Iteration 3: 0,933 ns/op
Iteration 4: 0,931 ns/op
Iteration 5: 0,928 ns/op
Iteration 6: 0,932 ns/op
Iteration 7: 0,928 ns/op
Iteration 8: 0,932 ns/op
Iteration 9: 0,936 ns/op
Iteration 10: 0,930 ns/op
# Run progress: 80,00% complete, ETA 00:00:30
# Fork: 4 of 5
# Warmup Iteration 1: 0,944 ns/op
# Warmup Iteration 2: 0,931 ns/op
# Warmup Iteration 3: 0,925 ns/op
# Warmup Iteration 4: 0,963 ns/op
# Warmup Iteration 5: 0,929 ns/op
Iteration 1: 0,930 ns/op
Iteration 2: 0,926 ns/op
Iteration 3: 0,923 ns/op
Iteration 4: 0,929 ns/op
Iteration 5: 0,929 ns/op
Iteration 6: 0,933 ns/op
Iteration 7: 0,927 ns/op
Iteration 8: 0,931 ns/op
Iteration 9: 0,926 ns/op
Iteration 10: 0,934 ns/op
# Run progress: 90,00% complete, ETA 00:00:15
# Fork: 5 of 5
# Warmup Iteration 1: 0,939 ns/op
# Warmup Iteration 2: 0,931 ns/op
# Warmup Iteration 3: 0,935 ns/op
# Warmup Iteration 4: 0,928 ns/op
# Warmup Iteration 5: 0,932 ns/op
Iteration 1: 0,985 ns/op
Iteration 2: 0,931 ns/op
Iteration 3: 0,930 ns/op
Iteration 4: 0,928 ns/op
Iteration 5: 0,932 ns/op
Iteration 6: 0,926 ns/op
Iteration 7: 0,929 ns/op
Iteration 8: 0,932 ns/op
Iteration 9: 0,926 ns/op
Iteration 10: 0,923 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.vector.FinalOrNotFinalBenchmark.computeWithNonFinalsBenchmark":
0,929 ±(99.9%) 0,005 ns/op [Average]
(min, avg, max) = (0,908, 0,929, 0,985), stdev = 0,010
CI (99.9%): [0,924, 0,934] (assumes normal distribution)
# Run complete. Total time: 00:02:33
Benchmark Mode Cnt Score Error Units
FinalOrNotFinalBenchmark.computeWithFinalsBenchmark avgt 50 2,618 ± 0,075 ns/op
FinalOrNotFinalBenchmark.computeWithNonFinalsBenchmark avgt 50 0,929 ± 0,005 ns/op
```
**Почему так?** Есть *гипотеза*, что семантика `final`-полей, описанная в спецификации ([JLS 17.5.1](https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.5.1): Semantics of `final` Fields) в части `freeze` action оказывает влияние на применение Scalar Replacement и результат JIT-компиляции метода.
Если у кого-то есть строгое объяснение (например, со ссылкой на спецификацию), почему JIT-компилятор ведёт себя таким образом — *пишите в комментариях*.
**UPD.** Отправил баг в Oracle, было получено подтверждение — [JDK-8200412](https://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8200412).
**UPD от 2 октября 2018г.** Баг был закрыт с резолюцией Won't fix:
> Original issue [JDK-8139758](http://bugs.java.com/view_bug.do?bug_id=JDK-8139758) is performance enhancement.
>
> We will not be fixing this in 8.
>
>
>
> Closing as wnf
Заключение
----------
На интересный результат работы с `final` наткнулся совершенно случайно в ходе подготовки задач. Разумеется, такие или более глубокие погружения не требовались для *правильного* ответа на задачу:
> Оба алгоритма дают одинаковый результат по производительности, т.к. благодаря Escape Analysis и Scalar Replacement не будут создаваться объекты Vector
### Статистика
Среди 32 сданных вариантов было 4 верных ответа (EA/SR) и ещё 3 частично правильных ответа.
### Java 9
Стало любопытно, как эти же бенчмарки отработают в JRE 9 (jre 9.0.4) — ниже результаты прогона бенчмарков:
```
Benchmark Mode Cnt Score Error Units
ComputationOnly...computeWithRawScalars avgt 50 5,071 ± 0,114 ns/op
ComputationOnly...computeWithVectors avgt 50 5,000 ± 0,106 ns/op
CreateAndConsume...consumeDouble avgt 50 3,223 ± 0,147 ns/op
CreateAndConsume...consumeObject avgt 50 3,222 ± 0,130 ns/op
CreateAndConsume...createAndConsumeObject avgt 50 4,236 ± 0,052 ns/op
CreateAndConsume...createAndConsumeSingleVector avgt 50 7,497 ± 0,188 ns/op
CreateAndConsume...createAndConsumeThreeVectors avgt 50 21,976 ± 0,677 ns/op
CreateAndConsume...createAndConsumeTwoVectors avgt 50 14,247 ± 0,339 ns/op
```
Получившиеся результаты полностью коррелирует с полученными ранее (для jre 1.8.0\_161).
А вот для пары других бенчмарков получилось интересно:
```
Benchmark Mode Cnt Score Error Units
ComputationBatch...computeWithRawScalars avgt 50 0,924 ± 0,008 ns/op
ComputationBatch...computeWithVectors avgt 50 0,920 ± 0,007 ns/op
FinalOrNotFinal...computeWithFinalsBenchmark avgt 50 0,931 ± 0,021 ns/op
FinalOrNotFinal...computeWithNonFinalsBenchmark avgt 50 0,922 ± 0,006 ns/op
```
Полученный результат идентичен — независимо от того, `final`-поля в классе или нет.
### P.S.
Код бенчмарков на GitHub: [jbreak2018-vector-perf-tests](https://github.com/gnkoshelev/jbreak2018-vector-perf-tests).
**UPD.** Другие публикации серии: [Часть 1](https://habrahabr.ru/company/skbkontur/blog/350800/), [Часть 2](https://habrahabr.ru/company/skbkontur/blog/351300/), [Часть 4](https://habrahabr.ru/company/skbkontur/blog/351812/). | https://habr.com/ru/post/351540/ | null | ru | null |
# Java EE 6. Обзор JPA 2.0, часть 1: Введение
Пожалуй, наибольшее количество изменений с выходом спецификации Java EE 6 было привнесено в JPA (Java Persistence API). В серии статей, начиная с этой, я планирую рассказать подбробно о каждом из нововведений.
### Введение
Технология JPA является абстракцией над JDBC и позволяет быть независимым от SQL. Все классы и интерфейсы JPA расположены в пакете `javax.persistence`, основными составляющими технологии являются:
* ORM (механизм объектно-реляционного отображения);
* Entity manager API — позволяет осуществлять базовые операции CRUD;
* JPQL и Criteria API — механизмы извлечения данных;
* Управление транзакциями и блокировками (как с использованием JTA, так и без);
* Механизмы обратных вызовов и listener-ов.
В JPA 2.0 изменения коснулись следующего:
* Улучшилась поддержка Map-ов: теперь как ключ, так и значение могут быть простым типом, сущностью или встроенным объектом (embedded);
* Коллекции встроенных объектов и простых типов (Integer и т.д.) могут теперь быть вынесены в отдельные таблицы. Ранее в отдельные таблицы было возможно выносить только коллекции сущностей;
* Появилась возможность управлять упорядоченностью персистентных объектов с помощью аннотации `@OrderColumn`;
* Появилась возможность удалять объекты-сироты (orphan removal): при удалении родительского объекта удаляется и дочерний;
* Появилась поддержка пессимистической блокировки (оптимистическая поддерживается с JPA 1.0);
* Новый Query Definition API, который позволяет строить запросы в стиле ООП (в противовес написание в строке JPQL запросов);
* Сильно расширились возможности JPQL (язык запросов в JPA);
* Встроенные (embedded) объекты теперь могут входить в состав других встроенных объектов, а также участвовать в связях с сущностями. Навигация по графу объектов с помощью точки была расширена и для использования со встроенными объектами;
* Добавилась поддержка нового API для кэширования.
В данный момент единственным провайдером JPA 2.0 является [EclipseLink](http://www.eclipse.org/eclipselink/), он же является reference implementation JPA 2.0. Пользуюсь им уже несколько месяцев и готов сказать, что нахожу этот проект очень стабильным.
В следующей статье я расскажу о нововведениях в декларировании ORM.
[Java EE 6. Обзор JPA 2.0, часть 2: Коллекции](http://habrahabr.ru/blogs/java/88683/) | https://habr.com/ru/post/88564/ | null | ru | null |
# Приложения, достигшие самосознания: автоматизированная диагностика в продакшне
Путь к постижению Дзена начинается с разработки приложений, которые могут мониторить сами себя — это позволяет проще и дешевле чинить проблемы на продакшне. В этой статье мы увидим, как современные Windows-приложения могут делать самомониторинг, самодиагностику, и возможно — даже самовосстановление, и всё это — без необходимости иметь внешний агент или тупо перезапускать приложение. Обуздав мощь ETW для точного низкоуровневого мониторинга, счетчики производительности Windows для получения бесплатной по ресурсам статистики и библиотеку CLRMD для анализа собственных потоков, объектов в куче и локов, можно продвинуться по пути достижения самосознания. Всё это будет продемонстрировано на серии демок: автоматический профайлинг CPU, исследование загруженных тредов и стеков, автоматический мониторинг GC (включая выделения объектов), автоматический анализ кучи в целях поиска утечек памяти и многое другое. Дочитав статью до конца, вы получите набор инструментов и техник для реализации самомониторинга в своих собственных приложениях.
Основой статьи является доклад Дины Гольдштейн «Self-aware applications: automatic production monitoring» на DotNext 2017 Moscow. Слайды можно скачать [по ссылке](http://assets.ctfassets.net/9n3x4rtjlya6/2rnNp0Y1iQAW6GasYqQCei/2b19a16deed2bdfd54df11c7af062e9d/Dina-Goldshtein_Self-Aware_Applications.pdf).
Дина, с недавнего времени, — разработчик в Google, до этого работала в Riverbed. Riverbed занимается разработкой инструментов для мониторинга производительности, которые работают на миллионах компьютеров и мобильных девайсов. Дина была в команде, ответственной за центральный механизм сборки информации, который использует низкоуровневые события Windows, собирая из различных источников информацию о производительности. Работая в Riverbed, она много занималась мониторингом производительности, занималась поиском узких мест в процессе загрузки Windows и мониторингом user experience в вебе.
---
Для начала обсудим, зачем именно нужно заниматься мониторингом. Уверена, у вас есть об этом свое представление, но я хотела бы добавить несколько наблюдений, которые, по моему опыту, не всегда очевидны для людей. Во-первых, очевидно, что когда мы разрабатываем что-либо масштабное, мониторинг необходим. Ситуация должна находиться под контролем, чтобы не принести убытка клиентам. Обычно у нас одновременно работает слишком много экземпляров приложений, чтобы следить за ними всеми, и поэтому задачу приходится автоматизировать. Но этот случай как раз очевидный, в отличие от того, о чем я буду говорить далее.
На мой взгляд, мониторинг настолько же важен в простых пользовательских приложениях. В определенном смысле здесь ситуация значительно хуже, чем с приложениями, работающими на серверах. Как правило, сервер, для которого пишется приложение, находится под полным контролем разработчика: известна версия операционной системы, патчи, какие программы установлены. Ничего этого мы не знаем о среде, в которой будут работать написанные нами пользовательские приложения. Вы не знаете, какие средства безопасности установлены на компьютере потребителя, что, по моему опыту, достаточно часто может мешать нормальной работе приложения. Как правило, о проблеме мы узнаем, когда клиенты звонят и сообщают, что у них произошла катастрофа и продлевать лицензию на следующий год они не собираются. И узнать, чем именно была вызвана эта катастрофа, вам очень сложно. У вас может даже не быть связи через интернет со средой, в которой запущено ваше приложение у клиента.
Зачем заниматься разработкой собственных средств профилирования и мониторинга, если существует множество сторонних инструментов? Начну с того, что, по моему личному мнению, заниматься исследованиями производительности крайне интересно, и для меня уже этой причины достаточно. Но если подходить к вопросу с практической точки зрения, разработанные вами средства профилирования и мониторинга будут лучше отвечать специфическим потребностям вашего бизнеса. Вы можете заниматься наблюдением не только общих вещей вроде CPU, памяти, доступа к диску, но и отдельных компонентов, имеющих прямое коммерческое значение для вас. Например, вы можете отслеживать время запуска, размеры очередей, отдельные запросы, время выполнения отдельных компонентов, критичных для вашего бизнеса. Как правило, этого достаточно сложно достичь, пользуясь сторонними средствами профилирования.
Другая причина, по которой стоит заниматься разработкой собственных средств профилирования, заключается в том, что данные диагностики в этом случае идут снизу вверх. Я имею в виду, что вам не нужно после сбора данных отправлять их на внешнюю панель мониторинга, ждать, пока там завершится их анализ, после чего вас посреди ночи разбудит оповещение. Напротив, при предлагаемом мною подходе приложение само занимается сбором данных. Оно, как и сказано в названии статьи, обретает самосознание. Оно может даже предпринимать действия на основе этих данных. Позже я покажу примеры того, что именно можно предпринять, когда приложение обнаружило проблему.
Наконец, именно такой подход, судя по всему, является сегодня «последним писком». Под влиянием принципов DevOps сообщество приходит к выводу о необходимости автоматизации мониторинга, да и вообще всего, что только можно. Сам по себе факт, что все так делают, еще, конечно, не значит, что нужно подражать, но в данном случае обоснования для этих общепринятых практик есть (их я только что перечислила). Надеюсь, вместе эти аргументы вас убедят.
Как именно нам создавать свою систему мониторинга? Очевидно, в работающем приложении не может быть постоянно запущен профилировщик или отладчик. Это потребует слишком большого количества ресурсов, и масштабировать такой подход нельзя. Мое предложение не отличается особенной новизной: использовать ту или иную иерархическую систему мониторинга. Мы будем пользоваться наиболее легковесными из доступных средств для мониторинга наиболее базовых вещей — CPU, память, отдельные запросы, короче говоря, все, что так или иначе потребляет какие-то ресурсы. Это можно достаточно легко делать при помощи *Performance Counters* API под Windows. Он обеспечивает доступ к поставщикам данных, распределенных по всей системе, и обеспечивает информацию связанную как с базовыми показателями (CPU, память), так и с вещами, имеющими отношение к .NET (время сборки мусора, поколения и т. д.). К этим данным можно получить доступ как на уровне системы, так и на уровне нашего процесса. Если вам не нравятся *Performance Counters* — никаких проблем, вы можете пользоваться Win32 API. По большому счету, это одно и тоже, источник у информации один.
Для более редких событий или ситуаций, где нам нужна более подробная информация, мы можем потратить больше времени и ресурсов при сборе данных. Самое интересное начинается именно здесь. Есть инструменты, которые позволяют осуществлять диагностику и анализировать ситуацию непосредственно в работающем приложении, и затем отправлять данные разработчикам, то есть вам, для решения возникших проблем. Ситуации, о которых идет речь, — это редкие исключения, взаимоблокировки (deadlock), замедления работы приложений. Для этой цели существует, к примеру, *ETW* (Event Tracing for Windows, трассировка событий под Windows). Этот инструмент похож на *Performance Counters*. Это API, обеспечивающий доступ к поставщикам данных в системе. В отличие от *Performance Counters*, здесь информация не только количественная. У каждого из его событий есть множество метаданных, есть стеки вызовов, что уже весьма неплохо. К примеру, о событиях сборки мусора сообщается тип сборки мусора, почему она была вызвана, какой именно тип был выделен. Позже я продемонстрирую это на примерах. Ресурсоемкость *ETW* в основном зависит от частоты событий, которые мы отслеживаем, и от количества собираемых данных.
Полезный инструмент, который может дополнить *ETW — ClrMD*. Это опенсорсная библиотека, существующая уже несколько лет. Она доступна на NuGet, исходный код есть на GitHub. Ее поддержку обеспечивает Microsoft. Это API, предоставляющий множество действий, связанных с отладкой: исследование стеков вызовов, обход памяти .NET, доступ к журналам, механизмам синхронизации, и многое другие. Некоторые из этих операций доступны также для нативных приложений (приложений и библиотек, написанных на C/C++), что может быть необходимо, если в вашем приложении несколько уровней, в т. ч. системный. Ресурсоемкость, опять-таки, зависит от частоты использования и от конкретных выполняемых операций. К примеру, получить стеки вызовов нескольких тредов можно достаточно быстро, а вот для обхода 64 гигабайт памяти придется подождать. Как и вообще все в программировании, применять этот инструмент нужно с умом.
Наконец, в действительно критических ситуациях можно выкатывать тяжелую артиллерию отладки и профилирования. Речь идет о *CLR Profiling API*, *CLR Debugging API*, у них есть все доступные профилировщикам и отладчикам функции, в т. ч. они могут приостанавливать работу приложения, пользоваться точками останова и многое другое. Очевидно, регулярно к таким средствам прибегать не стоит. Даже в документации к этим библиотекам указывается, что их не рекомендуется использовать в коде, выполнение которого зависит от скорости. Но знать о существовании этих инструментов полезно. Здесь прилагаются ссылки на них. Сегодня мы о них говорить не будем, поскольку, положа руку на сердце, сама я ими не пользовалась.
Наконец, если вас интересуют определенные низкоуровневые API, можно пользоваться ими. Я их тоже отношу к категории наиболее ресурсоемких и громоздких средств, потому что правильно ими пользоваться достаточно сложно. По моему опыту, многие средства безопасности также пользуются точками перехвата. Когда несколько инструментов делают это по отношению к одному API, а при этом один из них делает это неправильно, последствия могут быть кошмарными. При возможности, стоит пытаться получать данные другими способами. Ресурсоемкость, опять-таки, зависит от характера выполняемых действий.
Со вступительной частью на этом все, перейдем к делу. Посмотрим на примерах, что можно узнать о работе ваших приложений. Начать я хотела бы с профилирования CPU. Несмотря на то, что пример достаточно простой, и не подогнан под чье-либо конкретное приложение, уже он демонстрирует выгоды, которые можно получить. В основном докладе конференции Андрей говорил о перформанс-тестировании на стадии разработки. Но, я думаю, со всеми вами случалось, что на этой стадии все было в порядке, а в продакшне выяснялось, что все работает совсем не так, как задумано. Возможно, клиент что-то делает не так, или у него установлена не та версия Windows — опять-таки, я говорю здесь о пользовательских приложениях, которые должны функционировать в разных средах у разных клиентов. Может быть неясно, как воспроизвести проблемы, они могут возникать нерегулярно. К примеру, раз в три дня загрузка CPU подскакивает в течение 10 секунд, а ваши клиенты этим крайне недовольны, потому что они очень важные люди, и эти 10 секунд все им испортили. Как с такими проблемами бороться? Представьте, что можно было бы собирать данные о текущем состоянии вашего работающего приложения, записывать их в журнал и отправлять разработчикам. Именно такой подход я сейчас и продемонстрирую.
Как я уже говорила, для достижения этой цели нужно будет реализовать иерархическую систему мониторинга. Для начала, проблему необходимо обнаружить. Это несложно, мы будем отслеживать использование CPU при помощи *Performance Counters*. Это займет самый минимум ресурсов, поэтому делать это можно достаточно часто. Затем нужно будет определить некоторые правила работы приложения, например, оно не должно занимать более 80% CPU в течение более чем 10 секунд непрерывной работы. Какие именно это будут правила вы должны решить сами, или спросить ваших клиентов.
Как только мы определили, что в данный момент мы находимся в проблемной ситуации, можно вложить больше ресурсов, чтобы определить источник проблемы: провести диагностику, получить стеки вызовов. Это мы будем делать при помощи *ETW*, который, как вы помните, предоставляет стеки вызовов тех событий, отслеживанием которых он занимается. В случае с CPU, *ETW* может просто сэмплировать CPU, к примеру, каждую миллисекунду (то есть, 1000 сэмплов в секунду — это значение по умолчанию). Таким образом мы получим тот же результат, который мы бы получили, если бы прикрепили к приложению профилировщик и провели сэмплирование. В реальном времени с *ETW* мы будем это делать при помощи опенсорсной библиотеки *[LiveStacks](https://github.com/goldshtn/LiveStacks)*, которая переводит сделанные *ETW* выборки циклов в имена функций. Благодаря этому мы сможем восстановить деревья стеков вызовов, найти стеки, потребляющие больше всего ресурсов CPU, вывести данные в виде флеймграфов (flame graphs) или любой другой удобной форме. Больше того, можно даже сделать рекомендации относительно действий, которые приложение может сразу же при обнаружении проблемы. Я приведу несколько примеров, но, уверена, вы сами можете придумать конкретные решения, более подходящие для сферы вашего бизнеса.
Предположим, ваш `AuthenticationController` вдруг начинает занимать слишком много ресурсов CPU. Возможно, на вас идет DDoS-атака? Это предположение уже позволяет принять какие-то меры, какие именно — мне сказать сложно, поскольку я не веб-эксперт. Наверное, можно закрыть каналы коммуникаций, попробовать фильтровать определенные IP. Другой пример: какой-то механизм обработки вдруг оказывается перегружен. Если он находится на сервере, то, возможно, пришло время масштабирования. И будет особенно здорово, если это масштабирование можно осуществить автоматически. Наконец, если ничего умного придумать не получается, можно попросту записать всю доступную информацию в журнал и отправить его разработчикам. Уже за это они будут очень благодарны.
Посмотрим демонстрацию такого подхода. У меня сервер на ASP.NET, называется «Los Gatos». Все демонстрации у меня [записаны на видео](https://www.youtube.com/embed/xrYbM2xJCRU?start=1259&end=1265), поскольку я не хотела, чтобы возникли какие-либо помехи во время доклада. На экране слева виден сайт, а справа — *perfmon*, UI для *Performance Counters*. Я настроила его на отслеживание времени использования процессора. Мы видим, что когда я захожу на сайт, в течение нескольких секунд процессор оказывается перегружен, после чего загрузка снова падает. В этой ситуации клиент не успеет позвать вас, чтобы вы решили эту проблему с помощью профилировщика. Было бы неплохо получить данные о ней в реальном времени. Посмотрим, как это можно сделать.
Хочу сделать оговорку: я не уверена, что с точки зрения дизайна и архитектуры в этом коде наилучшим образом реализованы классы и наследование. Он написан специально для демонстрации, так что копировать его в чистом виде в вашу систему, наверное, не стоит. Кроме того, мы не будем слишком сильно вдаваться в детали — я уверена, вы можете самостоятельно прочитать документацию API. Моя задача — продемонстрировать, чего именно можно достичь, и каким образом.
Посмотрим на класс `CPUMonitor, который наследует от класса`EventStacksMonitor, который, в свою очередь, наследует от `Monitor. В`Monitor присутствует наиболее базовый функционал. С некоторой частотой (в данном случае — раз в секунду) он сэмплирует *Performance Counters* и отслеживает нарушения заданных нами правил. Если `Monitor обнаруживает три нарушения подряд, он вызывает то, что я назвала «интенсивным режимом»,`SampleIntensively`. Реализуется же`SampleIntensively` в дочерних классах в зависимости от того, что именно они отслеживают.
Взглянем более внимательно на `CPUMonitor`. В переменных здесь заданы правила, нарушения которых мы будем отслеживать: `CounterThreshold` — 90%, `PerformanceCounter` — "% Processor Time", `PerformanceInstance` — "\_Total". В случае с мониторингом CPU нам будут необходимы стеки вызовов. Их получением занимается клас `EventStacksMonitor`.
Здесь мы видим реализацию «интенсивного режима» в функции `OnIntensiveSamplingStart()`. В ней мы получаем текущий процесс и создаем `LiveSession`. О `LiveSession` подробнее я скажу позже, она служит оболочкой для *ETW*, что позволяет нам получить стеки вызовов. Мы начинаем сессию, ждем в течение некоторого времени (кажется, 5 секунд), останавливаем ее, и, после того, как завершена сборка данных, обращаемся к ее свойству `Stacks.TopStacks`. Там мы получаем стеки, больше всего загружавшие процессор в ходе этой сессии, и записываем их в журнал. Если интересно, метод `.Resolve()` переводит адреса функций в памяти в имена функций, чтобы разработчики позже могли установить источник проблемы.
Вернемся к классу `LiveSession`. Я не буду заходить в него, он скопирован с репозитория *LiveStacks* на GitHub. Это просто оболочка для *ETW*, которая занимается настройкой событий, сборка которых будет происходить для получения информации о сэмплировании CPU. Только что был показан общий принцип ее работы. Давайте взглянем теперь на журнал, получившийся в результате нашей попытки зайти в приложение.
Мы видим, что поначалу все выглядит хорошо, загрузка CPU низкая. Через какое-то время обнаруживаются три нарушения, включается режим сэмплирования CPU. Через 5 или 10 секунд работы было собрано достаточно данных и в журнал были записаны три стека вызовов, поглощающих наибольшее количество времени процессора. К сожалению, некоторые из адресов перевести не удалось — возможно, для этого не было соответствующих символов, у Microsoft их иногда нет. Результат несколько разочаровывает (и я вернусь к этому вопросу позже): по-видимому, первый стек вызовов — это собственно код мониторинга. Однако он попал сюда в результате уже возникшего пика загрузки процессора, из-за включения интенсивного режима, в обычных условиях он не потребляет столько мощностей. Перейдем к следующему стеку вызовов. Тут мы видим много вызовов, связанных с ASP.NET. Поскольку я не эксперт в ASP.NET, я не могу сказать наверняка, что тут можно сделать, но, по-моему, это полезная информация. Наконец, третий стек вызовов. Перед нами метод `Login()` нашего приложения — у нас это не должно вызывать удивления, поскольку мы видели, что проблема возникла непосредственно после входа в приложение. Стоит, однако, помнить, что, когда разработчики читают журнал, они могут не знать, какие именно действия выполнялись во время пика загрузки процессора. Если взглянуть на стек вызовов более подробно, мы увидим функцию, занимающуюся вычислением хэша.
Теперь мы можем вернуться к коду. Находим функцию по ее имени, и видим, что она занимается вычислением хэша каждый раз, когда адрес электронной почты заканчивается на «gmail.com». Именно эти подсчеты загружают процессор. Итак, мы обнаружили в реальном времени проблему с использованием CPU, и в результате профилирования нашли ту функцию в коде, которая эту проблему вызывала. По-моему, это весьма неплохой результат.
Следующий пример взят из реальной жизни.
На экране — скриншот, в котором мы видим открытые Visual Studio и Process Explorer, и в Process Explorer выделен процесс `devenv`. Все это вы можете проверить на своих компьютерах. У процесса `devenv есть дочерний процесс,`perfwatson2`, и «perf» в названии тут явно указывает на перформанс. Далее, мы видим, что`perfwatson2` создает сессию *ETW* с четырьмя поставщиками. Мне не удалось точно установить, что именно они записывают, но известно, что этот процесс занимается профилированием Visual Studio. Разработчики Visual Studio сочли, что им необходима телеметрия того, что происходит внутри программы во время ее использования. И они воспользовались тем же способом, который я продемонстрировала вам в предыдущем примере. Он уже входит в практику некоторых компаний. Мне не удалось добраться до файла, в который записывались данные этой телеметрии, возникли какие-то странные ошибки, но не в этом суть. Мониторинг Visual Studio самой себя при помощи *ETW* является частью ее функциональности (хотя в общем случае, это неясно — Microsoft описывает PerfWatson, но он не является частью публичной документации на VisualStudio). Как видим, не я изобрела этот способ, он уже входит в практику некоторых компаний. Следующие примеры, о которых я буду говорить, тоже связаны с реальной практикой.
Поговорим о мониторинге сборки мусора, вернее, о проблемах, которые могут повлиять на ее эффективность. Речь пойдет о ситуациях с большим количеством выделений памяти. Очевидно, что паузы GC при обработке запросов — это плохо.
Но, опять-таки, не стоит забывать о ситуации с пользовательскими приложениями. Если у пользователей будут возникать сбои и замедления в работе UI из-за длинных остановок в сборке мусора, им это, очевидно, не понравится. Я хочу еще раз подчеркнуть, что вещи, которые мы здесь обсуждаем, касаются всех типов приложений, не только серверных.
Принцип здесь будет тот же, что и в прошлом примере, но в этот раз мы будем иметь дело с памятью, а не с процессором. При помощи счетчиков производительности мы будем отслеживать скорость выделения памяти, и, как только заметим скачок производительности, можно будет начать более интенсивное профилирование. В данном случае это будет значить получение данных о выделении памяти: на какие именно типы уходит память, и где это происходит. Кроме того, можно выяснить, сколько времени занимает сборка мусора, получить информацию о поколениях, о том, сколько памяти было высвобождено, сколько осталось занято. Можно даже прикрепить *ClrMD* и увидеть в целом, что находится в нашей куче (позже мы это и сделаем): сегменты, поколения, типы объектов, количество объектов. Все это может помочь нам понять, что происходит в приложении и где именно локализована проблема.
[[видео с демонстрацией]](https://www.youtube.com/embed/xrYbM2xJCRU?start=2170&end=2200)
Итак, перед нами приложение, в котором мы отслеживаем скорость выделения. При выходе на "About" мы наблюдаем внезапный пик выделений. Это не значит, что у нас непременно возникнет проблема со сборкой мусора, но она становится весьма вероятной.
Чтобы узнать больше, посмотрим на наш код, а именно — на класс `AllocMonitor`. Он также наследует от `EventStacksMonitor`, потому что, как и в случае с отслеживанием чрезмерной загрузки процессора, нас будут интересовать стеки вызовов, в которых происходят выделения. Для этого нам понадобится *ETW*. Как и в прошлый раз, здесь в переменных уточняются правила, по которым мы будем следить за *Performance Counters*, например, `CounterThreshold` равен `100000` (очевидно, в своем приложении вы выставите его исходя из ваших потребностей). Событие *ETW*, которое мы будем ожидать, и от которого мы получим стеки вызовов, называется `clr:gc:gc/allocationtick`. Это событие даст нам информацию о типе создаваемого объекта, и о том, где происходит выделение памяти. Функция `OnEventOccurred() ловит это событие. У структуры данных`GCAllocationTickTraceData есть свойство, которое сообщает, сколько памяти было выделено, и есть информация о типе созданного объекта. Пока нам понадобятся именно эти данные, хотя там есть много других. Во время режима интенсивного сэмплирования эти данные будут храниться в словаре, и мы будем знать, сколько за время этого режима было выделено объектов каждого типа. Кроме того, мы получим стеки вызовов, в которых эти выделения памяти происходили.
После этого мы в течение некоторого времени будем собирать статистику о том, что происходит в куче. Делать это мы будем при помощи библиотеки *ClrMD*. Кода здесь достаточно много, но он очень простой. Главный API, который нам понадобится — `AttachToProcess`. Мы получаем среду выполнения CLR, у нее нам нужно будет свойство `runtime.Heap, благодаря ему мы сможем совершать обход кучи. В нем также есть общий размер кучи, размеры поколений. Однако самое важное, что при помощи этого свойства мы можем пронумеровать всю кучу и получить для каждого объекта тип, имя и размер. Все эти данные помещаются в словарь, и мы теперь знаем, что в куче такое-то количество строк, такое-то количество массивов и т. д.
Взглянем на журнал. Поначалу в нем все в порядке, но затем начинаются выделения памяти, и возникает три нарушения. Как вы помните, мы собирали стеки вызовов, в которых происходили выделения. Здесь перед нами те стеки, в которых произошло наибольшее количество выделений. На этот раз мы сразу же находим нужный нам результат: стек с методом `About()`. Опять-таки, это не удивительно, поскольку мы знаем, что выделения начались, когда мы вышли на страницу "About". Если посмотреть более подробно, то выяснится, что выделения происходят при объединении строк. Чтобы прояснить ситуацию, вернемся к коду.
Мы видим, что метод `About()` анализирует большое количество XML. Вызываются некие функции `.append`, отсюда возникает большое количество строк, промежуточных объектов, объединений, записи и прочего. Все это вызывает проблему с выделениями. Чтобы подтвердить источник проблемы, можно взглянуть, какая еще информация есть в журнале, ведь туда была записана статистика по куче. Вполне ожидаемо, мы там находим большое количество строковых объектов. Это подтверждает наш изначальный диагноз проблемы.
В следующем примере мы будем исследовать проблему, доставляющую всем большое количество неприятностей: утечки памяти. Здесь уже нет смысла собирать стеки вызовов. Мы будем следовать все тому же общему принципу отслеживания использования памяти. В качестве одного из симптомов можно следить за скачками использования памяти, но сами по себе они не дают уверенности, что произошла утечка. Помимо этого, можно указать, что приложение не должно использовать больше, например, 100 мегабайт памяти. Если этот порог превышен, ситуация требует нашего внимания, даже если это не утечка. Здесь можно применить *ClrMD*, по тому же принципу, что и в предыдущем примере, и выяснить, что именно занимает необычно большой объем памяти. Если все-таки есть вероятность утечки, мы, как разработчики, можем автоматизировать реакцию приложения. Можно сделать несколько снапшотов кучи, и попытаться их сравнить. Так мы выясним, какие объекты были выделены, какая память освобождена, какая нет и почему. Все это можно сделать при помощи *ClrMD*, а затем можно сравнить эту информацию с полученной от *ETW*, если мы готовы потратить на это дополнительные усилия.
[[видео с демонстрацией]](https://www.youtube.com/embed/xrYbM2xJCRU?start=2711&end=2740)
Взглянем на демонстрацию. На этот раз я отслеживаю байты во всех кучах, это наша управляемая память. Я регистрируюсь на сайте, и пока я ввожу данные, состояние памяти не меняется. Как только я нажимаю на кнопку регистрации, происходит скачок использования памяти. Даже если мы не опасаемся утечки, следует выяснить, что именно является причиной скачка.
Для этого обратимся к классу `LeakMonitor`. Поскольку стеки вызовов нам на этот раз не нужны (нет события *ETW*, которое можно было бы использовать для анализа данной ситуации с памятью), он наследует не от `EventStacksMonitor`, а напрямую от `Monitor`. Как и в предыдущих примерах, в переменных указан порог, троекратное превышение которого вызывает интенсивный режим, и указан отслеживаемый параметр. Посмотрим, что именно происходит при обнаружении чрезмерного использования памяти. Я попытаюсь показать, что именно здесь можно автоматизировать на стадии разработки. Мы сделаем три снапшота пространства памяти. Обратите внимание, что перед каждым снапшотом делается вызов сборщика мусора, поскольку я хочу, чтобы статистика была как можно более чистой. Позже, я сравню, что именно освободилось, а что — нет. После сборки мусора я подключаюсь к процессу, получаю снапшот кучи, жду несколько секунд, затем повторяю цикл. После завершения цикла я сравниваю снапшоты и записываю результаты в файл.
Взглянем на снапшот кучи. Он достаточно примитивен, в нем не будет статистики по отдельным объектам. Это, очевидно, заняло бы значительно больше времени, а его не всегда хочется тратить. Собраны только данные о количестве объектов каждого типа и об общем размере всех объектов определенного типа. Это делается абсолютно таким же способом, как и в предыдущем примере: делается обход кучи, извлекаются данные о размере, имени и типе, и добавляются в два словаря, размер в зависимости от типа, и количество в зависимости от типа. Эти два словаря сравниваются даже не с помощью *ClrMD*, а простой функцией, сверяющей данные в словарях разных снапшотов. Наконец, все это записывается в журнал.
В журнале поначалу нет ничего необычного, но ниже мы видим, что программа обнаруживает нарушение заданных нами правил. Благодаря сделанным снапшотам мы видим, что значительно возросло количество массивов байтов. Очевидно, здесь есть проблема. Сложность в том, что массивы байтов могут возникать где угодно. В оптимальном сценарии вам удастся найти специфичный для вашего приложения тип, в котором создаются эти массивы. В рассматриваемом примере мы знаем, что проблема возникла при регистрации, поэтому мы можем найти соответствующий код.
Функция регистрации проверяет пароль, и при этом добавляет данные в некоторый статический список. А создание этих данных вызывает выделение достаточно большого массива байтов. Очевидно, пример не слишком реалистичен, тем не менее, я думаю, в вашей практике все равно была бы та или иная структура данных, которую можно было бы обнаружить в подобном случае. Но даже если речь идет о массивах байтов, вы, наверное, знаете, где именно в вашем коде происходит выделение этих массивов. Либо можно соотнести эти данные с данными по выделениям памяти из *ETW*, и обнаружить, что именно в этой ветви кода происходит их значительное количество.
На сладкое сегодня будет пример об обнаружении взаимоблокировок (англ. deadlock). Тут есть отличие от других рассмотренных нами примеров, поскольку нет простого численного показателя, по которому можно было бы определить, что возникла взаимоблокировка. Можно только обозначить некоторые симптомы. Одним из них может быть ситуация, когда загрузка процессора вдруг становится необычно низкой, и приложение ничего не делает. Или если запросы не возвращаются по истечении времени их ожидания, это может значить, что треды, которые должны отвечать на эти запросы, оказались подвешены. А может быть и обратная ситуация, ваш пул тредов открывает все больше и больше тредов, потому что другие находятся во взаимоблокировке, а на запросы отвечать надо. Но точно определить список симптомов вам необходимо самим исходя из потребностей вашего бизнеса.
Если есть подозрение, что возникла взаимоблокировка, то для ее обнаружения мы прикрепим *ClrMD* и взглянем на стеки вызовов. Я не уверена, есть ли что-то, что можно предпринять для разрешения взаимоблокировки в таком случае, но, по крайней мере, проблема будет занесена в журнал, который будет отправлен разработчикам.
[[видео с демонстрацией]](https://www.youtube.com/embed/xrYbM2xJCRU?start=3188&end=3208)
Перейдем непосредственно к примеру. Я пытаюсь выйти на страницу контактов, и выясняется, что она подвисла. Загрузка процессора почти нулевая, страница не загружается. Возможно, возникла взаимоблокировка. Взглянем на код, класс `DeadlockMonitor`. В данном примере я не реализовала обнаружение взаимоблокировки, поскольку тут может быть много решений, и мы уже видели достаточно их примеров. Я хочу просто показать, насколько просто можно получить доступ к стекам вызовов при помощи *ClrMD* и проверить, присутствует ли цикл в графе ожидания тредов.
Каждые несколько секунд мы будем запускать достаточно простой рекурсивный метод `FindDeadlocks()`. Он проходит все треды, которые мы получили от *ClrMD*, и для каждого из тредов обходит все объекты, которые этот тред ожидает. Их можно найти при помощи свойства треда `thread.BlockingObjects`. У каждого из этих объектов есть свойство `Owners`, которое отсылает к другому треду, владельцу этого объекта. Все вместе это позволяет нам построить граф того, что происходит в приложении, и посмотреть, есть ли в графе цикл. Если есть, можно будет получить стек вызовов, в котором он происходит, и записать его в журнал.
Обращаясь к журналу, мы видим, что, действительно, в `HomeController.ProcessDetails()` была обнаружена взаимоблокировка.
Если вернуться в код и найти там эту функцию, мы увидим две блокировки и вызов функцией самой себя, классический пример взаимоблокировки. Итак, функцию удалось обнаружить, что, по-моему, весьма неплохо.
В оставшееся время я хотела бы сказать несколько общих вещей. Очевидно, примеров предлагаемого подхода можно приводить множество и на все времени не хватит, но я упомяну некоторые. Можно заниматься мониторингом фрагментации кучи. CLR не будет сжимать крупные объекты в куче, если вы специально этого не укажете, поскольку это занимает много времени. Если вы осуществляете мониторинг фрагментации, то у вас есть информация, чтобы решить, хотите вы тратить это время или нет. Другая возможность, о которой я хотела упомянуть, заключается в использовании *ETW* для анализа утечек памяти на системном уровне. Есть возможность получать стектрейсы. Для этого в *ETW* можно получать события с указанием источника. Имеются в виду стектрейсы, сгенерированные нативными приложениями, написанными на C/C++ и использующими неуправляемую Win32 кучу.
В качестве небольшого отступления хочу заметить, что *ClrMD* может работать не только с запущенными процессами, его можно подключить к аварийному дампу и автоматизировать анализ дампа (просмотр стеков вызовов, поиск неисправных компонентов). В этом случае было бы оптимальным агрегировать все аварийные завершения одного типа, и, возможно, даже автоматизировать создание отчетов об ошибках для разработчиков.
Наконец, хочу заметить, что у описанного подхода помимо очевидных достоинств есть и недостатки. Достоинство заключается в том, что у вас есть видимость внутри вашего приложения, но при этом нет необходимости расширять команду при масштабировании приложения. Один из недостатков в том, что происходит увеличение сложности приложения. Больше кода значит больше потенциальных проблем. Риск можно сократить, выполняя все операции, которые я демонстрировала, в отдельном процессе. В приведенных примерах все выполнялось в одном процессе, но серьезных препятствий для того, чтобы вынести мониторинг в отдельный процесс, нет. Данные от *ETW* и счетчиков производительности все равно собираются по всей системе, *ClrMD* может подключаться к любому процессу.
Другой недостаток в увеличении ресурсоемкости. На это я уже обращала внимание в связи с первым примером, где самый большой по загрузке процессора стек вызовов был от самого *ETW*. Ту же проблему, судя по всему, испытывают некоторые пользователи Visual Studio: если вы наберете в поисковике «perfwatson2», вы увидите множество вопросов о том, как этот процесс можно отключить.
Наконец, дополнительный код требует времени разработчиков. Стоит ли его тратить — решение, которое должны принимать вы или ваши менеджеры.
На этом статья подходит к концу. Мы увидели, почему важна диагностика в продакшне, независимо от типа создаваемого приложения. Увидели, как ее можно осуществить при помощи иерархической системы мониторинга: легковесный мониторинг для обнаружения проблемы, больше ресурсов для диагностики. Наконец, были приведены четыре примера, демонстрирующих весьма неплохие результаты, которые может дать описанный подход: обнаружение в коде реальных проблем, связанных с загрузкой процессора, памяти, и с взаимоблокировками. Все демки [доступны в сети](https://github.com/dinazil/self-aware-applications).
> Минутка рекламы. Как вы, наверное, знаете, мы делаем конференции. Ближайшая конференция по .NET — [DotNext 2018 Piter](https://dotnext-piter.ru/). Она пройдет 22-23 апреля 2018 года в Санкт-Петербурге. Какие доклады там бывают — можно посмотреть в [нашем архиве на YouTube](https://www.youtube.com/watch?v=MpFEkVPbgiU&list=PLtWrKx3nUGBeYn-pSCjEgBPL90SvpylZL). На конференции можно будет вживую пообщаться с докладчиками и лучшими экспертами по .NET в специальных дискуссионных зонах после каждого доклада. Короче, заходите, мы вас ждём. | https://habr.com/ru/post/353298/ | null | ru | null |
# Эффективный параллакс
Нравится вам это или нет, но параллакс остается. При разумном использовании он может придавать глубину и изящество веб-приложению. Проблема, однако, заключается в том, что эффективно реализовать параллакс не всегда удается. В этой статье мы рассмотрим решение, которое является одновременно эффективным и, что не менее важно, кроссбраузерным.
### Коротко
* Не используйте для создания параллакс-анимации прокрутку событий или background-position.
* Для создания более четкого параллакс-эффекта используйте 3D-трансформации средствами CSS.
* Для Mobile Safari используйте position: sticky, чтобы обеспечить распространение эффекта параллакса.
Если вам нужно готовое решение, заходите в [репозиторий UI Element Samples на GitHub](https://github.com/GoogleChromeLabs/ui-element-samples) и берите [Parallax JS хелпер](https://github.com/GoogleChromeLabs/ui-element-samples/blob/gh-pages/parallax/scripts/parallax.js)! В репозитории GitHub вы можете увидеть [демонстрацию параллакс-прокрутки в реальном времени](https://googlechromelabs.github.io/ui-element-samples/parallax/).
### Проблемы с параллаксами
Для начала давайте рассмотрим два распространенных способа достижения эффекта параллакса и, в частности, почему они не подходят для наших целей.
#### Плохой вариант: использование событий при прокрутке
Ключевым требованием параллакса является то, что он должен быть связан со скроллингом; при каждом изменении положения прокрутки страницы позиция параллакс-элемента должна обновляться. Звучит просто, но важным механизмом современных браузеров является их способность работать асинхронно. В нашем конкретном случае это относится к событиям прокрутки. В большинстве браузеров события прокрутки передаются по принципу "best-effort" ("наилучшая попытка") и не гарантируется, что они будут выполнены для каждого кадра анимации скроллинга!
Эта важная деталь информирует нас о том, почему мы должны избегать JavaScript-решений, перемещающих элементы на основе событий прокрутки: **JavaScript не гарантирует, что параллакс будет соответствовать положению прокручиваемой страницы**. В ранних версиях Mobile Safari события прокрутки доставлялись фактически в конце скроллинга, что делало невозможным создание скролл-эффекта на основе JavaScript. Более поздние версии *действительно* передают события прокрутки во время анимации, но, как и в Chrome, по принципу - "наилучшая попытка". Если основной поток занят какой-либо другой работой, события прокрутки сразу не будут доставлены, а значит, эффект параллакса будет потерян.
#### Плохой вариант: обновление background-position
Еще одна ситуация, которой мы хотели бы избежать, — это прорисовка на каждом кадре. Многие решения пытаются изменить background-position для обеспечения параллакс-вида, что заставляет браузер перерисовывать затрагиваемые части страницы при прокрутке, а это может быть достаточно затратным, что значительно ухудшает анимацию.
Если мы хотим воплотить в жизнь идею создания параллакс-движения, то необходимо что-то, применяемое в качестве ускоренного свойства (что сегодня означает придерживаться трансформаций и непрозрачности), и которое не зависит от событий прокрутки.
### CSS в 3D
[Scott Kellum](https://codepen.io/scottkellum/details/bHEcA) и [Keith Clark](https://keithclark.co.uk/articles/pure-css-parallax-websites/demo3/) проделали значительную работу в области использования CSS 3D для обеспечения параллакс-движения, и техника, которую они применяют, заключается в следующем:
* Настройте содержащийся элемент на прокрутку с `overflow-y: scroll` (и, возможно, `overflow-x: hidden`).
* К этому же элементу примените значение `perspective`, а для `perspective-origin` установите значение `top left` или `0 0`.
* К его дочерним элементам примените сдвиг в Z и масштабируйте их обратно, чтобы обеспечить параллакс-движение без изменения их размера на экране.
CSS для этого подхода выглядит следующим образом:
```
.container {
width: 100%;
height: 100%;
overflow-x: hidden;
overflow-y: scroll;
perspective: 1px;
perspective-origin: 0 0;
}
.parallax-child {
transform-origin: 0 0;
transform: translateZ(-2px) scale(3);
}
```
Что предполагает наличие HTML-сниппета, подобного этому:
```
```
#### Настройка масштаба для перспективы
Отодвигая дочерний элемент назад, вы уменьшите его размер пропорционально значению перспективы. Можно рассчитать, насколько его нужно масштабировать, с помощью следующего уравнения: **(перспектива — расстояние) / перспектива**. Поскольку мы, скорее всего, хотим, чтобы параллакс-элемент отображался с эффектом параллакса, но в том размере, в котором мы его создали, его нужно было бы масштабировать таким образом, а не оставлять как есть.
В приведенном выше коде перспектива равна **1px**, а расстояние по Z у `parallax-child` равно -**2px**. Это означает, что элемент должен быть увеличен в **3 pаза**, что видно из значения, введенного в код: `scale(3)`.
Для любого содержимого, к которому не применяется значение `translateZ`, можно подставить нулевое значение. Это означает, что масштаб равен **(переспектива — 0) / перспектива**, и в итоге дает значение 1, то есть масштаб не увеличивается и не уменьшается. Достаточно удобно, на самом деле.
### Как работает этот подход
Важно понять, почему это работает, поскольку мы собираемся использовать эти знания в ближайшее время. Прокрутка — это фактически преобразование, поэтому ее можно ускорить; в основном она включает в себя перемещение слоев с помощью GPU. В обычном скролле, который не имеет понятия перспективы, прокрутка происходит в пропорции 1:1 при сравнении прокручиваемого и его дочерних элементов. Если вы прокручиваете элемент вниз на 300px, то его дочерние элементы трансформируются вверх на ту же величину: 300px.
Однако применение значения перспективы к прокручиваемому элементу нарушает этот процесс; оно изменяет матрицы, лежащие в основе трансформации прокрутки. Теперь прокрутка на 300px может переместить дочерние элементы только на 150px, в зависимости от выбранных значений `perspective` и `translateZ`. Если у элемента значение `translateZ` равно 0, он будет прокручиваться со скоростью 1:1 (как и раньше), но дочерний элемент, сдвинутый по Z от начала перспективы, будет прокручиваться с другой скоростью! В итоге: параллакс-движение. И, что очень важно, это обрабатывается как часть внутреннего механизма прокрутки браузера автоматически, то есть нет необходимости слушать scroll события или изменять `background-position`.
#### Ложка дегтя в бочке меда: Mobile Safari
У каждого эффекта есть свои оговорки, и одна из них касается трансформаций — сохранение 3D-эффектов для дочерних элементов. Если в иерархии между элементом с перспективой и его дочерними элементами с параллаксом существуют еще какие-нибудь элементы, 3D перспектива "сплющивается", то есть эффект теряется.
```
```
В приведенном выше HTML, `.parallax-container` будет новым, он фактически сплющит значение `perspective`, и мы потеряем эффект параллакса. Решение, в большинстве случаев, довольно простое: добавьте `transform-style: preserve-3d` к элементу, что заставит его распространять любые 3D-эффекты (например, наше значение перспективы), которые были применены дальше по дереву.
```
.parallax-container {
transform-style: preserve-3d;
}
```
Однако в случае с Mobile Safari все немного сложнее. Применение `overflow-y: scroll` к элементу-контейнеру технически работает, но ценой отсутствия способности прокрутки скролл-элемента. Решением является добавление `-webkit-overflow-scrolling: touch`, но это также приведёт к сплющиванию `perspective`, и мы не получим никакого параллакса.
С точки зрения прогрессивного улучшения, это, вероятно, не слишком большая проблема. Даже если мы не можем использовать параллакс в любой ситуации, наше приложение все равно будет работать, но было бы неплохо найти обходной путь.
### position: sticky на помощь!
На самом деле, есть некоторая помощь в виде `position: sticky`, которая существует, чтобы позволить элементам "прилипать" к верхней части области просмотра или заданному родительскому элементу во время прокрутки. Спецификация, как и большинство других, довольно объемная, но в ней есть одна жемчужинка:
> Липко позиционированный блок размещается аналогично относительно позиционированному блоку, но смещение рассчитывается применительно к ближайшему предку с прокручиваемым блоком или к области просмотра, если у предка нет прокручиваемого блока. — [Модуль позиционированного макета CSS Уровень 3](https://www.w3.org/TR/css-position-3/#sticky-pos)
>
>
На первый взгляд это может показаться не очень важным, но ключевым моментом в этом предложении является указание на то, как именно рассчитывается прилипание элемента: **"смещение вычисляется по отношению к ближайшему предку с прокручиваемым полем"**. Другими словами, расстояние, на которое нужно переместить прилипший элемент (чтобы он оказался прикрепленным к другому элементу или к области просмотра), рассчитывается *до* применения любых других преобразований, а не *после*. Это означает, что, как и в предыдущем примере с прокруткой, если смещение было рассчитано на 300px, появляется новая возможность использовать перспективы (или любое другое преобразование) для манипулирования значением смещения на 300px до того, как оно будет применено к любым прилипшим элементам.
Применяя `position: -webkit-sticky` к параллакс-элементу, мы можем эффективно "отменить" эффект сплющивания от `-webkit-overflow-scrolling: touch`. Это гарантирует, что параллакс-элемент ссылается на ближайшего предка с прокручиваемым полем, которым в данном случае является `.container`. Затем, как и раньше, к `.parallax-container` применяется значение perspective, которое изменяет рассчитанное смещение прокрутки и создает эффект параллакса.
```
```
```
.container {
overflow-y: scroll;
-webkit-overflow-scrolling: touch;
}
.parallax-container {
perspective: 1px;
}
.parallax-child {
position: -webkit-sticky;
top: 0px;
transform: translate(-2px) scale(3);
}
```
Это позволяет восстановить эффект параллакса для Mobile Safari, что является отличной новостью для всех!
### Предостережения по позиционированию "липких" элементов
Однако здесь *есть* разница: `position: sticky` *действительно* изменяет механику параллакса. Липкое позиционирование пытается прикрепить элемент к прокручиваемому контейнеру, в то время как нелипкая версия этого не делает. Это означает, что параллакс с липким позиционированием становится обратным параллаксу без него:
* С `position: sticky`, чем ближе элемент к z=0, тем **меньше** он перемещается.
* Без `position: sticky`, чем ближе элемент к z=0, тем **больше** он движется.
Если все это представляется немного абстрактным, [посмотрите на демонстрацию](https://jsbin.com/sexiwe/edit?html,css,js,output) от Robert Flack, которая показывает, как по-разному ведут себя элементы с липким (sticky) позиционированием и без него. Чтобы увидеть разницу, вам понадобится Chrome Canary (на момент написания статьи это версия 56) или Safari.
Это параллакс с использованием перспективы на элементе переполнения (overflow). Начало перспективы находится за пределами скроллера. Это означает, что для того, чтобы элемент параллакса не двигался, он должен находиться бесконечно далеко.
* начало перспективы (элемент прокрутки).
Это параллакс с использованием позиционного прилипания. Начало перспективы находится внутри скроллера, поэтому он перемещается вверх по мере прокрутки.
Чтобы элемент параллакса двигался в пропорции 1:1 с прокручиваемым содержимым, он должен быть бесконечно далеко.
[Демонстрация от Robert Flack](https://jsbin.com/sexiwe/edit?output), показывающая, как `position: sticky` влияет на параллакс-прокрутку.
### Различные ошибки и обходные пути
Однако, как и везде, здесь все еще есть неровности, которые нужно сгладить:
* **Поддержка технологии прилипания непостоянна.** В Chrome она все еще реализуется, в Edge отсутствует полностью, а в Firefox есть [ошибки рисования, когда липкость сочетается с трансформациями перспективы](https://bugzilla.mozilla.org/show_bug.cgi?id=1254260). В таких случаях стоит внести небольшой код, чтобы добавлять `position: sticky` (версия с префиксом `-webkit-`) при необходимости, и это только для Mobile Safari.
* **Этот эффект не "просто работает" в Edge.** Edge пытается обрабатывать прокрутку на уровне ОС, что в целом хорошо, но в данном случае это не позволяет ему обнаружить изменения перспективы при прокрутке. Чтобы исправить это, можно добавить элемент с фиксированной позицией, поскольку это, похоже, [переключает Edge на метод прокрутки не на уровне ОС](https://developer.microsoft.com/microsoft-edge/platform/issues/5084491/) и гарантирует, что он учитывает изменения перспективы.
* **"Содержимое страницы только что стало огромным!".** Многие браузеры учитывают масштаб при определении размера содержимого страницы, но, к сожалению, Chrome и Safari [не учитывают перспективу](https://bugs.chromium.org/p/chromium/issues/detail?id=643213). Поэтому если к элементу применен масштаб, скажем, 3x, вы вполне можете увидеть полосы прокрутки и тому подобное, даже если после применения `perspective` элемент будет иметь размер 1x. Эту проблему можно обойти, масштабируя элементы из правого нижнего угла (с помощью `transform-origin: bottom right`), и это работает, поскольку приводит к тому, что элементы больших размеров вырастают в "отрицательную область" (обычно левую верхнюю) прокручиваемой области; прокручиваемые области никогда не позволяют видеть или прокручивать содержимое в отрицательной области.
### Заключение
Параллакс — интересный эффект в случае продуманного использования. Как вы видите, его можно реализовать таким образом, чтобы он был высокопроизводительным, связанным с прокруткой и кроссбраузерным. Поскольку для получения желаемого эффекта потребуется немного математических выкладок и небольшое количество бойлерплейта, мы подготовили небольшую библиотеку-хелпер и пример, которые вы можете найти в нашем [GitHub-репозитории UI Element Samples](https://github.com/GoogleChromeLabs/ui-element-samples/tree/gh-pages/parallax).
---
Всех желающих приглашаем на открытое занятие «Анимация модального окна сайта: основы и полезные фишки». На вебинаре рассмотрим один из самых популярных элементов — открытие модального окна при нажатии на кнопку. Также потренируемся в анимации его открытия и закрытия, чтобы сделать элемент отличным от большинства сайтов. Регистрация — [**по ссылке.**](https://otus.pw/tR8S/) | https://habr.com/ru/post/663454/ | null | ru | null |
# Поддержка протокола SPDY в Node.JS
[donnerjack13589](http://habrahabr.ru/users/donnerjack13589/) анонсировал новый модуль для [Node.JS](http://nodejs.org/), — [**node-spdy**](https://github.com/donnerjack13589/node-spdy), который добавляет поддержку протокола [SPDY](https://sites.google.com/a/chromium.org/dev/spdy/spdy-whitepaper), который был предложен компанией Google и внедрен в Chromium/Google Chrome и на сайтах компании Google ([подробнее...](http://habrahabr.ru/blogs/webstandards/117230/)).
Напомню, что основной целью при создании протокола SPDY было снижение задержек при доставке контента.
Пример использования модуля node-spdy:
```
var options = {
key: fs.readFileSync(__dirname + '/../keys/spdy-key.pem'),
cert: fs.readFileSync(__dirname + '/../keys/spdy-cert.pem'),
ca: fs.readFileSync(__dirname + '/../keys/spdy-csr.pem'),
NPNProtocols: ['spdy/2']
};
spdy.createServer(options, function(req, res) {
res.writeHead(200);
res.end('hello world!');
});
```
Приветствуется помощь сообщества в разработке. | https://habr.com/ru/post/117957/ | null | ru | null |
# Redmine на MySQL с RocksDB быстрее, чем с InnoDB, от 20% до 3 раз
Мы собрали форк MySQL от Facebook с движком RocksDB вместо InnoDB и потестировали его с реальными приложениями: Drupal, Wordpress, Redmine.
Это офигенная штука. При низкой нагрузке выигрыш маленький, десятки процентов. Зато при высокой нагрузке выигрыш в разы. Когда RocksDB добавят в стабильный релиз в MariaDB, я уверен, что в течение полугода половина народа перейдет с InnoDB на RocksDB. Особенно, небольшие сайты на cloud/VPS и выделенных серверах.
Что такого хорошего в MyRocks? Линейная запись вместо случайной и снижение числа дисковых операций вообще. То есть транзакции базы данных порождают меньше дисковых операций, меньше занимают очередь диска, и пишутся намного быстрее.
Я собрал в статью результаты тестирования реальных сценариев Redmine, добавил анализ результатов и выводы. Redmine на MySQL с RocksDB оказался быстрее, чем с InnoDB — от 20% при минимальной нагрузке до 3 раз при максимальной. Позже подготовлю материалы по Drupal и другим PHP-приложениям.
Вы сможете проверить работу MyRocks и самостоятельно — в конце статьи есть ссылки на инсталляторы и виртуальные машины с LAMP/LEMP/Ruby стеками, собранные с MyRocks вместо MySQL.
Введение
--------
Facebook на базе своего хранилища [RocksDB](http://rocksdb.org) создал storage engine для MySQL — [MyRocks](http://myrocks.io). Работающая реализация MyRocks в виде MySQL 5.6 с патчами от Facebook передана в open source и размещается на GitHub — <https://github.com/facebook/mysql-5.6>. MyRocks является альтернативой InnoDB и дает несколько преимуществ:
* Снижение объема записи
* Лучшая компрессия
* Уменьшения случайных чтений
Все это в сумме существенно повышает скорость транзакций на HDD и уменьшают изнашиваемость SSD, а также ускоряют репликацию.
MariaDB и Percona уже ведут работы по интеграции MyRocks в свои форки MySQL: [Facebook MyRocks at MariaDB](https://mariadb.com/resources/blog/facebook-myrocks-mariadb), [Announcing MyRocks in Percona Server for MySQL](https://www.percona.com/blog/2016/10/24/announcing-myrocks-in-percona-server-for-mysql/). MariaDB объявила, что MyRocks будет доступен в release candidate 10.2 этой зимой. На Jetware в число альтернатив MySQL [добавлена](http://ru.jetware.org/names/myrocks-mysqld) оригинальная реализация MyRocks от Facebook на базе MySQL 5.6.
Тестирование производительности на синтетических тестах показывает впечатляющие результаты. В зависимости от типа устройства хранения, выигрыш по скорости составляет от 20% до 10x. Результаты тестирования LinkBench можно посмотреть в публикации Yoshinori Matsunobu [MyRocks: A space- and write-optimized MySQL database](https://code.facebook.com/posts/190251048047090/myrocks-a-space-and-write-optimized-mysql-database/) и в [блоге](http://smalldatum.blogspot.com) Mark Callaghan, например, [MyRocks: use less IO on writes to have more IO for reads](http://smalldatum.blogspot.com/2016/11/myrocks-use-less-io-on-writes-to-have.html). Эти тесты во многом ориентируются на большие объемы баз данных (десятки и сотни гигабайт) и мощные машины.
В дополнение к синтетическим тестам и тестам на больших объемах данных, мы решили протестировать и оценить выигрыш в производительности для типовых веб-приложений и сайтов небольшого размера.
Первым мы тестируем Redmine. Мы знаем как он устроен, активно используем его в разработке и поэтому тестирование имеет для нас также практическую ценность — если результат окажется хорошим, мы переходим на MyRocks.
Условия тестирования
--------------------
### Программное обеспечения
Мы используем Redmine 3.3.1 с Ruby 2.3.1, в конфигурации по умолчанию, без дополнительных плагинов.
В качестве серверов баз данных используем:
* [MyRocks MySQL 5.6.27.75](http://ru.jetware.org/packages/myrocks-mysqld-5.6.27.75-jet3-e34c228) из репозитория Facebook, [коммит bc17d30](https://github.com/facebook/mysql-5.6/tree/e34c228d28dd3da06d0f42b20df432545c779677) ([show variables](http://ru.jetware.org/blog/redmine-performance-on-myrocks/file/myrocks-mysqld-5.6.show_variables.txt))
* [MySQL 5.6.31](http://ru.jetware.org/packages/mysqld-5.6.31) ([show variables](http://ru.jetware.org/blog/redmine-performance-on-myrocks/file/mysqld-5.6.31.show_variables.txt))
* [MariaDB 10.1.16](http://ru.jetware.org/packages/mariadb-mysqld-10.1.16) ([show variables](http://ru.jetware.org/blog/redmine-performance-on-myrocks/file/mariadb-mysqld-10.1.16.show_variables.txt))
Все бинарники собраны одним компилятором GCC 4.9.3, с рекомендуемыми параметрами сборки и оптимизации.
Операционная система — Ubuntu 14.04 x86\_64, Linux kernel 3.13.0. Файловая система — ext4.
### Наборы данных
Перед выполнением тестов база данных наполняется сгенерированными заранее проектами, пользователями и задачами. Таких вариантов тоже три:
1. Малый набор
* 30 пользователей
* 3 проекта и 10 подпроектов второго уровня, в каждом проекте по 10 пользователей
* 1000 задач с 10 комментариями каждая
2. Большой набор
* 1000 пользователей
* 10 проектов первого, 100 подпроектов второго и 10 подпроектов третьего уровня, в каждом проекте по 10 пользователей
* 10000 задач с 10 комментариями каждая
3. Гигантский набор
* 10000 пользователей
* 100 проектов первого, 1000 подпроектов второго и 100 подпроектов третьего уровня, в каждом проекте по 10 пользователей
* 100000 задач с 10 комментариями каждая
Большинство реальных случаев использования Redmine приходятся на размеры между Малым и Большим. Объемы уровня Гигантского бывают значительно реже.
**Объем занятого пространства**
[Исходные данные](http://ru.jetware.org/blog/redmine-performance-on-myrocks/file/storage_size.yml)
*Столбцы показывают объемы занятого пространства для разных баз данных и разных наборов данных (меньше — лучше)*
### Оборудование
* Процессор: 4-core Xeon E31220 3.10GHz
* Память: 16 Gb RAM, DDR3 1333
* HDD: RAID mirror, 2 x Western Digital RE4 1 Tb
### Виртуальная машина
Мы имитируем работу Redmine в условиях, близких работе у облачного провайдера или на офисном сервере. Для этого мы выделяем не весь физический сервер, а размещаем его в виртуальной машине с гораздо меньшим количеством ресурсов и имитируем различную нагрузку на дисковую систему со стороны соседей. В качестве платформы виртуализации используется Xen 4.6, в dom0 — Linux kernel 3.16.7. Устройство хранения разбивается с помощью LVM, обычное linear, без thin provision и снэпшотов. Том размещается посередине HDD.
Использовались три конфигурации виртуальных машин:
1. 1 Gb RAM, 4 CPU, HDD 16 Gb
2. 2 Gb RAM, 4 CPU, HDD 16 Gb
3. 8 Gb RAM, 4 CPU, HDD 16 Gb
### Тестируемые операции
Мы проверяем скорость работы наиболее часто используемых в Redmine операций — создание задач, добавление комментариев к задачам, изменение статуса и ответственного лица задачи. Из этих операций мы создали два теста, два рабочих цикла задачи:
* Создание задачи
Создание задачи в проекте одним участником проекта, назначение ее на другого участника проекта и добавление в нее 10 комментариев от лица других участников проекта.
* Обработка 10 задач
Получение пользователем 10 назначенных на него задач, переведение их всех в In Progress, и затем поочередное переведение задачи в Resolved и назначение ее на создателя задачи.
Тесты проводятся на 1, 2 и 4 параллельных процессах Redmine.
### Сторонняя нагрузка на диск
Нагрузка создается с помощью утилиты `fio`, которая читает и пишет 50/50 случайные блоки в оставшуюся часть диска. Мы имитировали несколько уровней нагрузки на диск, которые характерны для типовых случаев работы виртуальных машин — у провайдеров публичных облаков и VPS, или при запуске на собственном сервере нескольких виртуальных машин под VMWare, Hyper-V, KVM или XenServer.
Для имитации неполной загрузки мы запускаем fio с ограничением IOPS с помощью ключа `--rate_iops` и замеряем утилизацию диска. При 100% однопоточной нагрузке это около 80 IOPS. Утилизация 25% создается нагрузкой 14 IOPS. Большая нагрузка имитируется увеличением числа потоков ключем `--iodepth`.
В зависимости от количества соседних виртуальных машин, характера их работы и пиков нагрузки, загруженность диска может серьезно отличаться как у облачных провайдеров и VPS, так и на собственном сервере. Поэтому мы проводили тестирование при отсутствии сторонней нагрузки, при незначительной однопоточной нагрузке (14 IOPS, 25%), так и при и полных сторонних нагрузках в 1, 2 и 4 потока.
### Измеряемые значения
Мы измеряем полное время выполнения каждой операции Redmine на большом числе операций и сравниваем среднее время выполнения. Первые 10% результатов игнорируются — на них мы разогреваем систему. Последние 10% результатов игнорируются для того, чтобы исключить хвостовое искажение из-за разного времени завершения параллельных процессов.
Измерения проводятся в разных комбинациях условий:
* для разных конфигураций виртуальных машин и разных наборов данных
* для разного числа параллельных процессов Redmine (основная нагрузка) и разных сторонних нагрузок на диск
Время выполнения замеряется для всех трех баз — MyRocks MySQL, MySQL и MariaDB. Мы также вычисляем разницу в скорости MyRocks MySQL по отношению к MySQL и MariaDB. Собранные данные представлены в виде графиков.
Результаты тестирования
-----------------------
### Малый набор данных и малая виртуальная машина
* Виртуальная машина: 1 Gb RAM, 4 CPU, HDD 16 Gb
* Набор данных: 30 пользователей, 13 проектов и подпроектов, 1000 задач
**Графики времени выполнения операций**
*1) создание задачи; 2) обработка 10 задач*
[Исходные данные](http://ru.jetware.org/blog/redmine-performance-on-myrocks/file/bench-1gb-4cpu-small.yml)
*Столбцы показывают время выполнения операции (меньше — лучше). Линии показывают во сколько раз сервер MySQL или MariaDB был медленнее сервера MyRocks MySQL.*
*Минимальная нагрузка — один процесс Redmine и отсутствует сторонняя нагрузка. Максимальная нагрузка — 4 процесса Redmine и 4 полных потока сторонней нагрузки на диск.*
Мы видим, что время создания задачи для MyRocks при увеличении нагрузки до максимума меняется незначительно, и возрастает от 0.018 сек до 0.023 сек, на 23%. Для MySQL и MariaDB минимальное время создания задачи составляет 0.022 сек и возрастает в десять раз до 0.23 сек при максимальной нагрузке. При минимальной нагрузке MySQL и MariaDB оказываются медленнее на 24%, чем MyRocks; при максимальной нагрузке они оказываются медленнее в 9.5 раз.
Время обработки задач для MyRocks вырастает от 0.245 сек при минимальной нагрузке до 0.327 сек при максимальной, на 33%. Для MySQL и MariaDB минимальное время обработки задач возрастает примерно в 7 раз — с 0.283 сек при минимальной нагрузке до 2.245 сек при максимальной.
Объема оперативной памяти не хватает для эффективного кэширования чтения, и это очень сказывается на скорости InnoDB.
### Большой набор данных и средняя виртуальная машина
* Виртуальная машина: 2 Gb RAM, 4 CPU, HDD 16 Gb
* Набор данных: 1000 пользователей, 120 проектов и подпроектов, 10000 задач
**Графики времени выполнения операций**
*1) создание задачи; 2) обработка 10 задач*
[Исходные данные](http://ru.jetware.org/blog/redmine-performance-on-myrocks/file/bench-2gb-4cpu-large.yml)
*Столбцы показывают время выполнения операции (меньше — лучше). Линии показывают во сколько раз сервер MySQL или MariaDB был медленнее сервера MyRocks MySQL.*
*Минимальная нагрузка — один процесс Redmine и отсутствует сторонняя нагрузка. Максимальная нагрузка — 4 процесса Redmine и 4 полных потока сторонней нагрузки на диск.*
В данной конфигурации ресурсы виртуальной машины лучше соответствуют объему данных и нагрузке. Для MyRocks время создания задачи остается прежним — от 0.018 сек до 0.023 сек, вырастая на 23%. Для MySQL и MariaDB минимальное время становится чуть больше — 0.023 сек и вырастает только в два раза — до 0.056 сек при максимальной нагрузке. Они оказываются медленнее, чем MyRocks, на 30% при минимальной нагрузке, и в 2.3 раза при максимальной.
Для обработки задач ситуация похожая. Время выполнения у MyRocks при увеличении нагрузки слабо растет от 0.248 сек до 0.331 сек. Для MySQL и MariaDB минимальное время уже на 10% больше, чем для Малого набора данных и составляет 0.296 сек. При максимуме нагрузки время увеличивается почти в два раза — до 0.595 сек. MySQL и MariaDB оказываются медленнее, чем MyRocks, на 18% при минимальной нагрузке и на 80% при максимальной.
### Гигантский набор данных и большая виртуальная машина
* Виртуальная машина: 8 Gb RAM, 4 CPU, HDD 16 Gb
* Набор данных: 10000 пользователей, 1200 проектов и подпроектов, 100000 задач
**Графики времени выполнения операций**
*1) создание задачи; 2) обработка 10 задач*
[Исходные данные](http://ru.jetware.org/blog/redmine-performance-on-myrocks/file/bench-8gb-4cpu-giant.yml)
*Столбцы показывают время выполнения операции (меньше — лучше). Линии показывают во сколько раз сервер MySQL или MariaDB был медленнее сервера MyRocks MySQL.*
*Минимальная нагрузка — один процесс Redmine и отсутствует сторонняя нагрузка. Максимальная нагрузка — 4 процесса Redmine и 4 полных потока сторонней нагрузки на диск.*
Десятикратное увеличение объема данных немного увеличило время создания задачи для всех баз: 0.020 сек для MyRocks, 0.026-0.029 для MySQL и MariaDB. Увеличение нагрузки замедляет MyRocks на 35% до 0.027 сек. Для MySQL и MariaDB рост нагрузки сказывается на скорости больше — при максимальной нагрузке время увеличивается в 3 раза — до 0.088 сек, и они оказываются медленнее, чем MyRocks, в 3.2 раза.
При обработке задач время выполнения MyRocks увеличивается на 32%, от 0.255 до 0.33 сек. У MySQL и MariaDB время увеличивается в 4 раза — с 0.309 до 1.242 сек. И они отстают от MyRocks в 3.8 раз.
Объем данных уже вырос до таких размеров, что начинают сказываться задержки случайной записи при обновлении индексов InnoDB и разница в скорости между RocksDB и InnoDB при максимальных нагрузках снова выросла.
Анализ результатов
------------------
### Объем памяти
Для работы Redmine объем 1 Gb является минимальным рекомендуемым. Для эффективного кэширования данных в page cache размер памяти уже недостаточен, поэтому скорость работы очень чуствительна к нагрузке на диск. Задержки возникают уже на SELECT-запросах, так как для них приходится считывать данные с диска. Меньший объем хранимых данных у RocksDB привел к более эффективному кэшированию чтения, чем для InnoDB. Поэтому даже при большой нагрузке скорость операций у MyRocks изменилась совсем незначительно.
При увеличении памяти до 2 Gb основные используемые данные уже вмещаются в page cache и серверу БД уже не нужно постоянно их считывать с диска. В этом случае диск является узким горлышком только при изменениях в базе. Транзакции записываются на диск без writeback cache и интенсивная дисковая нагрузка увеличивает время ожидания завершения записи.
Организация хранения данных в RocksDB, способствующая линейной записи, и уменьшенный объем записываемых данных, уменьшают количество операций записи. Поэтому мы наблюдаем, что даже при высокой дисковой нагрузке, скорость выполнения транзакций в RocksDB лишь немного уменьшается и значительно превышает скорость при использовании InnoDB.
### Скорость RocksDB vs InnoDB
Исходя из принципа работы RocksDB, мы ожидали ускорения при выполнении транзакций. На синтетических тестах производительности разработчики получали 10-кратный прирост скорости в работе СУБД. Для приложений, таких как Redmine, время выполнения операции состоит из времени выполнения Ruby-скрипта и времени выполнения запроса в БД. Разумеется, замена storage engine на RocksDB никак не увеличит скорость работы Ruby, и эта составляющая остается неизменной. Но и с учетом этого прирост в скорости за счет ускорения БД оказался впечатляющим.
Здесь мы приводим краевые результаты тестирования для виртуальной машины 2 Gb и Большого набора данных, и для виртуальной машины 8 Gb и Гигантского набора данных. Мы не учитываем здесь тестирование на высокой нагрузке для виртуальной машины 1 Gb, так как это случай экстремальной нехватки ресурсов.
**Графики времени выполнения операций**
*1) создание задачи; 2) обработка 10 задач*
*Столбцы показывают время выполнения операции (меньше — лучше)*
*Минимальная (1 процесс Redmine без сторонней дисковой нагрузки) и максимальная нагрузка (4 процесса Redmine и 4 потока полной сторонней нагрузки на диск)*
При **низкой нагрузке** Redmine на MyRocks оказался на **15%-25%**, быстрее, чем на MySQL и MariaDB. Размер хранимых данных мало влияет на эту скорость и у RocksDB, и у InnoDB — увеличение числа задач Redmine в 10 раз увеличило время выполнения примерно на 10%.
При **высокой нагрузке** (увеличении числа параллельных процессов и повышении сторонней дисковой нагрузки) поведение полностью меняется. Отрыв MyRocks стал больше — **от 2-кратного до почти 4-кратного**. Размер хранимых данных также стал существенно влиять на скорость — 10-кратное увеличение числа задач Redmine заметно (в 1.5-2 раза) замедлило скорость выполнения на серверах с InnoDB, и менее заметно замедлило выполнение на RocksDB (0-15%).
**Одновременное увеличение объема данных и высокая нагрузка** замедлили работу Redmine с MyRocks в 1.5 раза, в то время как Redmine на MySQL и MariaDB стал медленнее в 4 раза.
Стабильность работы
-------------------
При тестировании мы обнаружили нюанс поведения одного из SQL-запросов Redmine при поиске с учетом parent issues. Из-за него некоторые виды поиска оказывались медленнее в MyRocks. Но это небольшое упущение со стороны Redmine — `parent_id` не имел в таблице индекс. Также мы столкнулись с небольшим багом, приводящим к расходу CPU после некоторых конфликтных транзакций в MyRocks.
Мы не сталкивались с другими проблемами. По словам разработчиков, Facebook использует MyRocks в production уже давно.
Вы можете использовать MyRocks уже сейчас или дождаться более широкого тестирования после появления MyRocks в MariaDB release candidate 10.2 или в Percona Server for MySQL. Пакет MyRocks доступен в репозитории Jetware как одна из альтернатив `mysqld` в [конструкторах](http://ru.jetware.org/names/myrocks-mysqld/constructors) стеков, например, PHP LAMP/LEMP), Ruby RAMP/REMP, или приложений, например, Redmine.
Несколько недель назад мы перевели свой внутренний Redmine-сервер на MyRocks и успешно в нем работаем.
Заключение
----------
1. Redmine с RocksDB оказался быстрее, чем с InnoDB — от 20% при минимальной нагрузке до 3 раз при максимальной.
2. Увеличение объема данных и нагрузки, замедлившее Redmine с InnoDB в 4 раза, всего лишь в 1.5 раза замедлило Redmine с RocksDB.
P.S. Тестирование MyRocks с другими приложениями
------------------------------------------------
В данном тесте мы проверили производительность MyRocks для приложения Redmine. В следующих тестах мы собираемся проверить производительность MyRocks с PHP-приложениями. Скорее всего, первым будет Drupal.
*[Статья на английском языке](http://jetware.org/blog/redmine-performance-on-myrocks)* | https://habr.com/ru/post/319500/ | null | ru | null |
# Обзор современных технологий создания RIA-приложений
#### Введение
Несколько лет назад в области создания Интернет-приложений наметилась тенденция к переходу от стандартных HTML/JavaScript/CSS технологий к платформам, которые позволяют запускать в среде веб-браузера программы, по внешенему виду и поведению не отличающиеся от оконных(desktop) приложений. Такой вид программных продуктов принято называть Rich Internet Applications([RIA](http://ru.wikipedia.org/wiki/RIA)), что в переводе обозначает «богатые интернет-приложения». Несмотря на то, что некоторые из технологий RIA выпущены довольно давно(конец 90-х годов), широкое распространение они получили не более 3-4 лет назад.
Разговор об особенностях RIA стоит начать с концептуального отличия от приложений на основе HTML. Обычные сайты-сервисы работают по принципу перехода на другую страницу по гиперссылкам и отправки формы на сервер средствами веб-браузера. Другими словами, работа таких приложений сконцентрирована вокруг [клиент-серверной архитектуры](http://ru.wikipedia.org/wiki/Клиент_—_сервер) с [тонким клиентом](http://ru.wikipedia.org/wiki/Тонкий_клиент). HTML, являясь языком разметки документов и отображаемый браузером, идеально подходит для этого. Последовательность действий пользователей представляет собой постоянную отправку запросов на сервер. При таком подходе существует ряд проблем:
1. Сохранение пользовательских данных между сеансами работы приложения и их синхронизация с сервером.
2. Проблема отправки и получения данных с сервера только по мере необходимости, а не на каждое действие пользователя.
3. Проблема запуска приложения при отсутствии подключения к сети.
Какое решение этих проблем предлагает концепция RIA? С точки зрения архитектуры она переводит такие программы в категорию приложений с толстым клиентом. Все RIA имеют схожую особенность: наличие промежуточной части, которая передается по сети клиенту и отвечает за взаимодействие с сервером и отображение пользовательского интерфейса, намного превосходящего HTML-аналоги. На рисунке 1 можно увидеть принципы организации взаимодействия с пользователями в случае HTML и RIA приложений.
Рисунок 1 — Принципы работы HTML и RIA-приложений
Решение проблемы сохранения пользовательских данных происходит за счет средств платформы RIA(платформенно-независимая среда для запуска RIA приложений). Промежуточная часть, загружаемая из сети, обращается к ней для сохранения и чтения информации. Отсюда появляется возможность отправлять и получать данные с сервера только по мере необходимости, за счет кеширования на стороне клиента. Вопрос нестабильного подключения также решаем. Платформы RIA могут выполнить установку приложения на компьютере пользователя. Это означает, что для файлов программы будет отведено место на диске и её можно будет запустить без наличия сети. Таким образом, можно отметить основные отличительные черты RIA:
* на компьютер пользователя загружается клиентская часть приложения, которая отвечает за взаимодействие с сервером и обладает возможностями кэширования данных и работы без подключения к сети;
* запускается в браузере или в виде оконного приложения и требует установки платформы RIA;
Постепенное развитие стандартов сети Интернет привело к реализации подобных технологии на практике. Наиболее известными на данный момент являются следующие:
| | | |
| --- | --- | --- |
| **Название** | **Компания-производитель** | **Дата выпуска**
|
| [Google Web Toolkit(GWT)](http://code.google.com/intl/ru-RU/webtoolkit/) | Google Inc. | 2006 |
| [Adobe Flex/AIR](http://www.adobe.com/products/air/) | Adobe Inc. | 2008 |
| [JavaFX](http://javafx.com) | SUN/ORACLE | 2009 |
| [Silverlight](http://silverlight.net/)
| Microsoft Corporation | 2007 |
| [Java Applets](http://java.sun.com/applets/) | SUN/ORACLE | 1995 |
Таблица 1 — Наиболее распространенные технологии RIA
Выбор этих продуктов обусловлен распространенностью в Интернет и наличием у пользователей установленных платформ для запуска RIA. В следующих разделах статьи для демонстрации основных технических особенностей каждой технологии будут созданы компактные приложения. Задача программ — получить краткую статистику загрузки сервера приложений через определенные периоды времени и отобразить ее пользователю. В ответ на каждый запрос сервер отправляет следующие данные, упакованные в [JSON](http://ru.wikipedia.org/wiki/JSON):
* доменное имя сервера;
* полную емкость выделенной памяти;
* объем свободной памяти;
* максимальный объем памяти;
* количество запущенных потоков.
Такое образом, клиентские части демонстрационных приложений разные, а на стороне сервера их запросы обслуживает Java-сервлет.
#### Приложение на GWT
**Краткое описание технологии.** Разработчик RIA создает интерфейс и логику программы на языке Java, а GWT компилирует исходный код в тщательно оптимизированный JavaScript. Файл скрипта подключается к веб-странице и во время загрузки отображает интерфейс приложения. При этом, во-первых, решается проблема наличия особого плагина для браузера — по сути в случае GWT нужно, чтобы было включено выполнение сценариев Javascript(поддерживают все современные браузеры). Во-вторых, GWT обладает большой библиотекой компонентов для создания полноценных RIA и их число постоянно растет, благодаря большому сообществу разработчиков. На базе этих компонентов можно делать традиционные оконные интерфейсы в браузере.
**Преимущества:**
* Используют меньший, более компактный, кэшируемый код Javascript;
* Автоматически поддерживают браузеры IE, Firefox, Mozilla, Safari и Opera;
* В состав библиотеки входят средства для обработки событий перехода по списку посещенных ранее страниц в браузерах(кнопка «Назад»).
Кроме того, работая в Java, можно использовать:
* Средства отладки, позволяющие отслеживать значения переменных, работать с точками останова и т.д.;
* [Автоматизированные модульные тесты](http://ru.wikipedia.org/wiki/Модульное_тестирование) (на основе [Junit](http://ru.wikipedia.org/wiki/JUnit) и др.) как в программе, так и в браузере;
Что касается содержимого библиотек, то GWT включает в себя:
* Встроенные компоненты пользовательского интерфейса, которые служат кросс-браузерными строительными блоками приложения;
* Удаленный вызов программного кода помогает с клиент-серверными взаимодействи-ями(RPC, AJAX);
* Средства интеграции кода GWT в существующий код JavaScript;
* Инструменты разработчиков для упрощения взаимодействия с дизайнерами интерфейсов(UIBind).
**Недостатки**
* Обязательное знание Java. Несмотря на огромную популярность этого языка в создании веб-приложений, новичку, не знающему базовых принципов пользовательских интерфесов Swing или AWT, будет крайне сложно.
* Кроссбраузерность имеет свои подводные камни. Компоненты пользовательского интерфейса, которые входят в состав дистрибутива, тщательно протестированы и действительно работают одинаково во всех браузерах. Однако сообществом выпускаются новые компоненты, к поведению которых в разных средах следует относиться осторожно. Проблема заключается опыте разработчика.
* Скорость работы GWT-компилятора. Это исполняемый класс на языке Java, который в качестве аргументов принимает пути к исходным текстам. В небольшом проекте автора время компиляции доходило до 2 минут. В качестве альтернативы для запуска приложения можно использовать специальный hosted-режимi, когда проект не компилируется, а запускается специальными средствами в выбранном браузере(GWT версии 2.0). Кроме того, можно компилировать проект только для одного браузера, изменив конфигурацию, что уменьшит время сборки.
**Фрагмент кода приложения**
`currentRequest = requestBuilder.sendRequest(query.toString(), new RequestCallback() {
public void onResponseReceived(Request request, Response response) {
pleaseWaitLabel.setVisible(false);
if (response.getStatusCode() == 200 && response.getText() != null && !response.getText().equals("")) {
JSONValue resVal;
JSONObject resObject;
JSONString serverName;
JSONNumber totalMemory;
JSONNumber freeMemory;
JSONNumber maxMemory;
JSONNumber threadCount;
try {
resVal = JSONParser.parse(response.getText());
} catch (JSONException e) {
Window.alert("Ошибка при обновлении статистики. Получены неверные данные");
return;
}
if ((resObject = resVal.isObject()) == null) {
Window.alert("Ошибка при обновлении статистики. Получены неверные данные");
return;
}
if ((serverName = resObject.get("serverName").isString()) == null) {
Window.alert("Ошибка при обновлении статистики. Получены неверные данные");
return;
}
…..............................................................................................................
setServerName(serverName.stringValue());
setTotalMemory(Integer.toString((int) totalMemory.doubleValue()));
setFreeMemory(Integer.toString((int) freeMemory.doubleValue()));
setMaxMemory(Integer.toString((int) maxMemory.doubleValue()));
setThreatCount(Integer.toString((int) threadCount.doubleValue()));
} else {
Window.alert("Ошибка при обновлении статистики. Получены неверные данные");
}
}
public void onError(Request request, Throwable exception) {
pleaseWaitLabel.setVisible(false);
Window.alert("Ошибка при обновлении статистики. Повторите попытку позже");
}
});`
#### Приложение на Flex/AIR
Краткое описание технологии. Adobe Flex это набор утилит для разработки RIA на платформе Adobe Flash с использованием языка ActionScript 3. Flash предоставляет гораздо больше возможностей, чем можно получить от HTML в плане интерактивности. Но тем не менее разработка на Flash это очень сложный процесс для простых программистов. Flash нацелен больше на дизайнеров. Flex убирает этот барьер, предоставляя программный способ разработки RIA. [MXML](http://ru.wikipedia.org/wiki/MXML), язык на основе XML, используется для описания формата пользовательского интерфейса и поведения, а ActionScript™ 3, мощный объектно-ориентированный язык программирования, используется для создания логической модели поведения программы-клиента.
**Преимущества**
Приложения RIA, созданные во Flex, могут работать в обозревателе, использующем ПО Adobe Flash® Player, или как обычная программа, если в ОС установлено кросс-платформенное приложение Adobe AIR™. Благодаря этому, приложения Flex поддерживают работу как со многими распространенными типами обозревателей, так и операционными системами для настольных компьютеров. При использовании AIR приложения Flex могут получать доступ к локальным данным и системным ресурсам ПК. Тем не менее, модель безопасности AIR не допустит повреждения информации пользователя и системных файлов, запуская приложения в изолированной среде. Flash Player и Adobe AIR доступны для свободной загрузки на сайте Adobe.com. На данный момент [99% ПК](http://riastats.com) имеют Flash Player одной из самых последних версий(9 или 10). Создание пользовательского интерфейса происходит с помощью MXML — относительного простого и интуитивно-понятного языка, следовательно опытные разработчики могут освоить его быстро.
**Недостатки**
* Язык ActionScript был первоначально скриптовым языком для Flash-плеера, который притерпел изменения в Actionscript 3. Как объектно-ориентированный язык ему не хватает массы особенностей, которые Java или .NET разработчики принимают как само собой разумеющееся.
* Количество сторонних библиотек (в частности, open-source) на порядки меньше, чем в Java.
* Несмотря на то, что Flex SDK предоставляется бесплатно, основная среда разработки Flex Builder является коммерческим продуктом.
**Фрагмент кода приложения**
`contentType="application/x-www-form-urlencoded"
id="service"
method="GET"
resultFormat="text"
showBusyCursor="true"
url="/status"
fault="httpFault(event)"
result="httpResult(event)"
useProxy="false"
/>
public function httpResult(event:ResultEvent):void {
//get the raw JSON data and cast to String
pleaseWaitLabel.setVisible(false);
var jObj:Object = JParser.decode(event.result.toString());
serverNameValueLabel.text = jObj.serverName;
totalMemoryValueLabel.text = jObj.totalMemory;
freeMemoryValueLabel.text = jObj.freeMemory;
maxMemoryValueLabel.text = jObj.maxMemory;
threadCountValueLabel.text = jObj.threadCount;
}
public function httpFault(event:FaultEvent):void {
Alert.show("Ошибка при обновлении статистики, повторите попытку позже");
timer.stop();
}`
#### Приложение Java-апплет
**Краткое описание технологии.** Java-апплет — это прикладная программа на Java в форме байт-кода. Java-апплеты выполняются в веб-браузере с использованием виртуальной Java-машины (JVM), или в Sun's AppletViewer, автономном инструменте для тестирования апплетов. Java-апплеты были внедрены в первой версии языка Java в 1995. Создаются на языке программирования Java, но могут быть написаны и на других языках, которые компилируются в байт‐код Java, таких, как Jython.
**Преимущества**
* кроссплатформенность;
* апплет поддерживается большинством браузеров;
* он кэшируется в большинстве браузеров, а потому будет быстро загружаться при возвращении на веб-страницу;
* уровень доступа апплета к клиентским данным настраивается пользователем компьютера;
**Недостатки**
* разработка апплетов требует от программиста среднего уровня знания языка Java, необходимо иметь представление о библиотеках Swing или AWT для создания пользовательского интерфейса;
* он требует установки Java-расширения, которое не во всех браузерах доступно по умолчанию. На данный момент плагин установлен на 90% клиентских ПК;
* для повышения безопасности апплета, ограничивается доступ к пользовательской системе: в частности, он не имеет прямого доступа к диску клиента или буферу обмена;
* некоторые организации допускают только программное обеспечение, установленное администраторами. В результате многие пользователи не могут видеть апплеты по умолчанию.
* апплеты могут потребовать использования определенной версии JRE.
**Фрагмент кода приложения**
`private void updateServerStatus() {
clearStatistics();
pleaseWaitLabel.setVisible(true);
Timer t = new Timer(3000, new AbstractAction() {
public void actionPerformed(ActionEvent actionEvent) {
try {
pleaseWaitLabel.setVisible(false);
URLConnection conn = new URL(url).openConnection();
String json = readStreamToString(conn.getInputStream(), "UTF-8");
JSONObject j = new JSONObject(json);
serverNameValueLabel.setText(j.getString("serverName"));
totalMemoryValueLabel.setText(j.getString("totalMemory"));
freeMemoryValueLabel.setText(j.getString("freeMemory"));
maxMemoryValueLabel.setText(j.getString("maxMemory"));
threadCountValueLabel.setText(j.getString("threadCount"));
} catch (Exception e) {
e.printStackTrace();
}
}
});
t.setRepeats(false);
t.start();
}`
#### Приложение JavaFX
Краткое описание технологии. JavaFX — это платформа для создания RIA, которые могут запускаться на персональных компьютерах и мобильных устройствах. Технология JavaFX позволяет создавать приложения для работы с мультимедийным содержимым, графические интерфейсы пользователя для бизнес-приложений, игры для персональных компьютеров и мобильных устройств, насыщенные графикой, мультимедиа веб-сайты и др. Приложения JavaFX создаются с помощью [декларативного языка программирования](http://ru.wikipedia.org/wiki/Декларативное_программирование) JavaFX Script. Для разработки приложений на языке JavaFX Script необходимо скачать и установить JavaFX SDK. Из кода, написанного на языке JavaFX Script, можно обращаться к любым библиотекам Java. Поэтому совместное использование языков Java и JavaFX Script позволяет решать разнообразные задачи, например, логика бизнес-приложения может быть написана на Java, а графический интерфейс пользователя — на JavaFX Script. Приложения, написанные на языке JavaFX Script могут запускаться на компьютерах с установленной средой исполнения Java 1.5 и выше. В настоящее время поддерживаются следующие операционные системы: Windows, Mac OS X, GNU/Linux и Solaris.
**Преимущества**
* Язык JavaFX Script поддерживает использование библиотек Java и позволяет получать компактный код.
**Недостатки**
* до сих пор остается проблема с запуском на клиентских машинах. JavaFX апплеты не запускаются в браузере Opera, все еще непонятно, что с Linux-системами. Правда это ситуация постепенно исправляется — JavaFX 1.2 по утверждению создателей работает на Ubuntu и OpenSolaris.
**Фрагмент кода приложения**
`var parser = PullParser {
documentType: PullParser.JSON;
onEvent: function (e: Event) {
if (e.type==PullParser.INTEGER and e.name.equals("freeMemory")) {
freeMemoryValueLabel.text = Integer.toString(e.integerValue);
}
if (e.type==PullParser.INTEGER and e.name.equals("maxMemory")) {
maxMemoryValueLabel.text = Integer.toString(e.integerValue);
}
if (e.type==PullParser.TEXT and e.name.equals("serverName")) {
serverNameValueLabel.text = e.text;
}
if (e.type==PullParser.INTEGER and e.name.equals("threadCount")) {
threadCountValueLabel.text = Integer.toString(e.integerValue);
}
if (e.type==PullParser.INTEGER and e.name.equals("totalMemory")) {
totalMemoryValueLabel.text = Integer.toString(e.integerValue);
}
}
}`
#### Приложение Silverlight
Краткое описание технологии. Silverlight предоставляет графическую систему, схожую с [Windows Presentation Foundation](http://ru.wikipedia.org/wiki/Windows_Presentation_Foundation), и объединяет мультимедиа, графику, анимацию и интерактивность в одной программной платформе. Он был создан чтобы работать с [XAML](http://ru.wikipedia.org/wiki/XAML) и с языками Microsoft .NET. XAML используется для разметки страниц с векторной графикой и анимацией. В состав платформы входит плагин для браузера, который позволяет запускать приложения, содержащие анимацию, векторную графику и аудио-видео ролики, что характерно для RIA.
**Преимущества**
* Начиная с версии 2.0, логика программы может быть описана в любом из языков .NET, включая динамические языки программирования такие как Iron Ruby и Iron Python;
* .NET платформа является мощным средством для разработки бизнес-приложений;
* Большое количество сторонних компонентов от Infragistics, Syncfusion, Telerik(коммерческие продукты);
* Большое сообщество .NET разработчиков.
**Недостатки**
* Silverlight реализован для ОС Windows 2000, Windows XP, Windows Server 2003, Windows Vista, Windows 7, Mac OS X 10.4, Mac OS X 10.5 и браузеров Internet Explorer 6.0/7.0/8.0, Mozilla Firefox 1.5/2.0/3, Safari 3.1, Google Chrome 3.0. В будущем также планируется поддержка Opera. Существующие расширения для браузеров в других операционных системах пока на стадии предварительного ознакомления.
**Фрагмент кода приложения**
`void refreshStatistics(object o, EventArgs sender)
{
WebClient proxy = new WebClient();
proxy.OpenReadCompleted += new OpenReadCompletedEventHandler(proxy_OpenReadCompleted);
proxy.OpenReadAsync(new Uri(uri));
}
void proxy_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
JsonObject jsObject = (JsonObject)JsonObject.Load(e.Result);
serverNameValueLabel.Text = jsObject["serverName"];
totalMemoryValueLabel.Text = jsObject["totalMemory"].ToString();
freeMemoryValueLabel.Text = jsObject["freeMemory"].ToString();
maxMemoryValueLabel.Text = jsObject["maxMemory"].ToString();
threadCountValueLabel.Text = jsObject["threadCount"].ToString();
}`
#### Выводы
Выводы о сравнении современных технологий RIA и результатах эксперимента по написанию приложений представлены в таблице 2. Далее сравнение по каждому параметру описано более подробно.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Платформа
| **GWT**
| **Flex/AIR** | **JavaFX**
| **Java-апплеты**
| **Silverlight**
|
| **Разработчик**
| Google Inc.
| Adobe Inc.
| Sun
Microsystems
| Sun
Microsystems
| Microsoft
|
| **Язык создания
приложений**
| Java
| Actionscript
| JavaFX Script
| Java
| C++,
C#, Visual Basic,
Object Pascal и множество
других
|
| **Поддержка
браузером
клиента**
| 100% при включенном
Javascript
| ~97-98% браузеров
| ~70% браузеров
| ~70% браузеров
| ~50% браузеров
|
| **Время изучения
для новичка** | 3-6 часов | 3-6 часов | 3-6 часов | 3-6 часов | 3-6 часов |
| **Время на
разработку демонстраци-
онного приложения** | ~1час | ~2 часа | ~3 часа | ~1час | ~3 часа |
| **Лицензия**
| Apache
License
2.0 | Mozilla Public
License/Adobe
AIR пользователь-
ское соглашение | JavaFX пользователь-
ское
соглашение | SUN/ORACLE
пользователь-
ское соглашение | Microsoft пользователь-
ское
соглашение |
| **Средства
разработки** | Eclipse
(бесплатно),
NetBeans(бес-платно) | Adobe Flex(коммерчес-
кий
продукт) | Eclipse
(бесплатно),
NetBeans(бес-платно) | Eclipse(бесплат-
но),
NetBeans(бес-платно) | Microsoft Web Developer
Studio(бесплат-
но) |
| **Создание
интерфейса в графическом редакторе
средства разработки** | Да(при
наличии
коммер-
ческого
плагина) | Да | Нет | Да | Да |
Таблица 2 — Сравнение технологий RIA
**Время изучения для новичка.** Новичком в данном случае считается программист среднего уровня, которые не знаком ни с одной из рассматриваемых технологий. По мнению автора, написание каждого приложение может занять от трех до шести часов, если учесть время установки всех необходимых программ и чтение документации.
**Время на разработку демонстрационных приложений.** Автор статьи был знаком с тремя технологиями на момент написания приложений, а именно, GWT, Adobe Flex/AIR и Java Applets. Так что максимальное время для одной программы составило 3 часа. Работа с уже известными технологиями продолжалась от одного до двух часов.
**Поддержка браузером клиента.** О том, что на компьютере клиента установлены необходимые платформы и расширения для запуска RIA можно судить по данным статистики с сайта <http://riastats.com>. Лидерами охвата аудитории пользователей являются GWT и Adobe Flex/AIR. Это связано с тем, что в первом случае вообще не требуется установки никаких дополнительных программ, а во втором — сказывается широкое распространение Adobe Flash плеера на компьютерах пользователей Интернет.
Далее следуют технологии JavaFX и Java Applets, охватывающие примерно 70% пользователей. Главное условие их работы — наличие установленной JRE на ПК. Библиотеки для JavaFX входят в её состав начиная с версии 1.5, а поддержка апплетов есть уже давно. С технологией Java Applets не было проблем при запуске в браузере В случае с JavaFX автору так и не удалось этого сделать и приложение запускается только в оконном режиме. Возможно это связано с недавним обновлением JavaFX, когда приложения перестали запускаться в браузерах Opera и Firefox последних версий.
**Лицензирование и стоимость вхождения для разработчиков.**
1. GWT выпускается в рамках лицензии Apache License 2.0. Она даёт пользователю право использовать программное обеспечение для любых целей, свободно распространять, изменять, и распространять изменённые копии. GWT можно бесплатно скачать с сайта разработчика. Продукты, написанные с помощью GWT могут иметь любую лицензию.
2. Adobe Flex/AIR. Flex SDK доступен по лицензии Mozilla Public License, а Adobe AIR SDK — по пользовательскому соглашению с компанией Adobe. Оба продукта можно бесплатно скачать с сайта разработчика. RIA, написанные с использованием Flex SDK и AIR SDK могут выпускаться в рамках любой лицензии.
3. JavaFX SDK распространяется в рамках пользовательского соглашения с компанией SUN/ORACLE. Лицензия не накладывает особых ограничений на распространение приложений на основе JavaFX и они могут быть в том числе и коммерческими.
4. Java Applets. Компоненты для работы Java Applets входят в состав библиотеки JRE. Они доступны в рамках пользовательского соглашения с компанией SUN/ORACLE. JRE можно бесплатно загрузить с сайта производителя.
5. Microsoft Silverlight выпускается в рамках пользовательского соглашения с компанией Microsoft. Оно не накладывает особые ограничения на написанные с помощью Silverlight SDK программы. Комплект SDK можно бесплатно скачать с сайта Microsoft.
**Особенности организации клиент-серверного взаимодействия**
Задача получения статистики загрузки сервера в общем случае состоит из двух этапов. Во-первых, осуществление HTTP-запроса к серверу, во-вторых, получение данных из ответа сервера. Для всех примеров за эти действия в приложении отвечают два объекта. Первый осуществляет HTTP-запрос и в случае получения ответа передает данные второму объекту. Далее он извлекает данные статистики из ответа и интерфейс пользователя обновляется.
Компоненты, отвечающие за осуществление HTTP-запроса входят в стандартную библиотеку SDK каждой технологии. Однако с компонентами, извлекающими данные статистики из ответа в формате JSON дело обстоит иначе. Если у GWT, JavaFX и Silverlight они включены в состав SDK, то у Flex/AIR дополнительно использована библиотека JSwoof([www.waynemike.co.uk/jswoof](http://www.waynemike.co.uk/jswoof)) для работы с JSON, а для Java-апплетов — пакет org.json(<http://json.org>) для Java.
Код клиент-серверного взаимодействия можно сравнить по количеству строк. Результаты находятся в таблице 3:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Платформа
| **GWT**
| **Flex/AIR** | **JavaFX**
| **Java-апплеты**
| **Silverlight** |
| Количество строк
кода для организации клиент-сервер-ного
взаимодействия | ~40 | ~30 | ~30 | ~20 | ~30 |
Таблица 3 — Сравнение количества строк кода для организации клиент-серверного взаимодействия
**Наличие в составе библиотек необходимых компонентов.**
Для написания демонстрационных приложений требовались компоненты двух видов:
* визуальные элементы пользовательского интерфейса;
* невизуальные компоненты для организации клиент-серверного взаимодействия.
В таблице 4 рассмотрено наличие необходимых компонентов в составе стандартных SDK.
| | | |
| --- | --- | --- |
| **Технология** | **Наличие
визуальных компонентов** | **Наличие
компонентов клиент-серверного
взаимодействия** |
| **GWT**
| Да | Да |
| **Flex/AIR** | Да | Дополнительно
использована JSWoof для работы с JSON |
| **JavaFX**
| Да | Да |
| **Java-апплеты**
| Да | Дополнительно
использован пакет org.json для работы с
JSON |
| **Silverlight**
| Да | Да |
Таблица 4 — Использование компонентов SDK
В случае Flex/AIR и Java-апплетов для создания примера использованы дополнительные библиотеки, которые не входят в состав стандартных SDK.
**Способ описания пользовательского интерфейса**
Для описания интерфейсов технологии используют 2 подхода:
* с помощью языка программирования(GWT, Java Applets). В этом случае все компоненты описаны в файле с исходным текстом в виде переменных. На этапе запуска приложения они инициализируются в коде и располагаются в окне приложения.
* декларативным методом, средствами специального языка на основе XML(XAML для Silverlight и MXML для Adobe Flex/AIR) и с помощью JavaFX Script. В исходном тексте соблюдается вложенность компонентов для их последующего расположения на экране. Для Silverlight и Adobe Flex/AIR характерно то, что исходный текст программы и XML-описание интерфейса могут храниться в одном файле.
Подходы, использованные в Silverlight, Adobe Flex/AIR и JavaFX позволяют разделить описание интерфейса и программный код приложения. В этом направлении последняя версия GWT предлагает средство UIBind для организации совместной работы HTML-дизайнеров и программистов. В состав исходных текстов можно включать файлы с HTML-кодом, в которые внедрены элементы пользовательского интерфейса. На этапе компиляции они будут связаны с кодом программы. Это позволяет отдельно работать над дизайном в HTML.
**Техническая документация и сообщество разработчиков.** Информационные ресурсы, посвященные каждой из технологий можно разделить на три категории:
* официальная техническая документация на сайте разработчика;
* статьи с примерами использования технологий, находящиеся в блогах и других информационных ресурсах;
* форумы, посвященные той или иной технологии.
GWT:
* code.google.com/webtoolkit/ — ресурс разработчиков.
* [googlewebtoolkit.blogspot.com](http://googlewebtoolkit.blogspot.com/) — официальный блог о GWT
Adobe Flex/AIR
* [www.adobe.com/products/air](http://www.adobe.com/products/air) и [www.adobe.com/products/flex](http://www.adobe.com/products/flex) — страницы на сайте разработчика, с них можно перейти к блогам, демонстрационным примерам, технической документации
JavaFX:
* [javafx.com](http://javafx.com/) — официальный сайт разработчиков технологии, полезен тем, что на нем есть ссылки на ресурсы сообщества JavaFX, посвященные документации и примерам программ.
* [blogs.sun.com/javafx](http://blogs.sun.com/javafx) — блог о JavaFX.
Java Applets:
* [java.sun.com/applets](http://java.sun.com/applets/) — страница на сайте компании SUN/ORACLE, посвященная технологии Java Applets. Там есть техническая документация и примеры приложений, а также ссылки на форумы и другие ресурсы.
Silverlight
* [silverlight.net](http://silverlight.net) — официальный сайт разработчиков Silverlight.
О заинтересованности разработчиков в той или иной технологии, а значит и создании сообществ можно косвенно судить по количеству проектов, например, в каталоге Google Code(http://code.google.com). С другой стороны, немаловажную роль играет количество предложений о работе по каждой технологии(сайт [indeed.com](http://indeed.com)). Данные представлены в таблице 5 и рисунке 2:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Платформа
| **GWT**
| **Flex/AIR** | **JavaFX**
| **Java-апплеты**
| **Silverlight** |
| Количество
проектов в каталоге Google Code | 1475 | 2388/703 | 119 | 166 | 180 |
Рисунок 2 — Количество вакансий разработчиков RIA
**Выбор технологии, наиболее подходящей для решения задачи**
По мнению автора, нельзя сказать, что какая-то из технологий является приоритетной для решения поставленной задачи. Дело в том, что в начальных условиях не были оговорены ограничения на ПО клиентских компьютеров, особые режимы работы и т. д. Что касается задачи, то её можно успешно решить с помощью каждой из технологий с одинаковым успехом. Об этом можно судить по написанным демонстрационным приложениям.
Исходные тексты можно скачать [здесь](http://domex.su/article/ModernRIAoverview.zip)(проект InelliJ IDEA 9) | https://habr.com/ru/post/84320/ | null | ru | null |
# С++17 wrapper для OpenSSL: ECDH и AES 256
При написании одного клиент-серверного приложения на С++ потребовалось организовать защищённое соединение между двумя удалёнными узлами. Я сразу обратил внимание на алгоритмы использующиеся в TLS 1.3. Опустив реализацию TLS-сертификатов и взяв только часть ответственную за шифрования данных, я приступил к работе. Информацию пришлось выискивать в во множестве совершенно разных источниках(от официальной документации OpenSSL, до ответов на stackoverflow), а местами даже додумывать каким образом скрепить куски кода из этих самых разных источников. Так что после успешной реализации задуманного, я решил написать данную статью, с целью помочь тем кто будет решать подобную проблему. В данной статье мы рассмотрим простую реализацию связки [алгоритма согласования ключей Диффи-Хеллман на элиптических кривых](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB_%D0%94%D0%B8%D1%84%D1%84%D0%B8_%E2%80%94_%D0%A5%D0%B5%D0%BB%D0%BB%D0%BC%D0%B0%D0%BD%D0%B0_%D0%BD%D0%B0_%D1%8D%D0%BB%D0%BB%D0%B8%D0%BF%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85_%D0%BA%D1%80%D0%B8%D0%B2%D1%8B%D1%85) и [алгоритма симметричного шифрования AES 256](https://ru.wikipedia.org/wiki/AES_(%D1%81%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) с использованием библиотеки OpenSSL для организации защищённого соединения.
Генерация ключей ECDH
---------------------
Заголовочный файл выглядит следующим образом:
```
#ifndef SECURITY_HPP
#define SECURITY_HPP
#include
#include "byte\_array.hpp"
namespace security {
/\*\*
\* @brief AES256 key and initialization vector
\*/
struct AES\_t {
uint8\_t key[32] = {
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0
};
uint8\_t init\_vector[16] = {
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0
};
bool isEmpty() const {
static const AES\_t empty\_aes;
return !std::memcmp(this, ∅\_aes, sizeof (AES\_t));
}
void clear() {\*this = AES\_t();}
AES\_t() = default;
AES\_t(ByteArray data) {
\*this = \*reinterpret\_cast(data.begin());
}
};
// ECDH
/\*\*
\* @brief Generate ECDH key pair
\* @return ECDH key pair
\*/
EVP\_PKEY\* genKey();
/\*\*
\* @brief Free key memory
\* @param key
\*/
void freeKey(EVP\_PKEY\* key);
/\*\*
\* @brief Extract public key from key pair
\* @param key\_pair
\* @return ByteArray with public key
\*/
ByteArray extractPublicKey(EVP\_PKEY\* key\_pair);
/\*\*
\* @brief Extract private key from key pair
\* @param key\_pair
\* @return ByteArray with private key
\*/
ByteArray extractPrivateKey(EVP\_PKEY\* key\_pair);
/\*\*
\* @brief Conver ByteArrays to key pair
\* @param priv\_key\_raw
\* @param pub\_key\_raw
\* @return ECDH key pair
\*/
EVP\_PKEY\* getKeyPair(ByteArray priv\_key\_raw, ByteArray pub\_key\_raw);
/\*\*
\* @brief Get AES256 key and initialization vector from ECDH keys
\* @param peer\_key - public key from other side
\* @param key\_pair - private key from this side
\* @return AES256 key and initialization vector
\*/
AES\_t getSecret(ByteArray peer\_key, EVP\_PKEY\* key\_pair);
// AES256
/\*\*
\* @brief Encrypt message
\* @param plain\_text
\* @param aes\_struct
\* @return Cyphertext
\*/
ByteArray encrypt(ByteArray plain\_text, AES\_t aes\_struct);
/\*\*
\* @brief Decrypt message
\* @param ciphertext
\* @param aes\_struct
\* @return plain\_text
\*/
ByteArray decrypt(ByteArray ciphertext, AES\_t aes\_struct);
/\*\*
\* @brief Encode data with base64
\* @param decoded
\* @return
\*/
ByteArray encodeBase64(ByteArray decoded);
/\*\*
\* @brief Decode base64 data
\* @param encoded
\* @return
\*/
ByteArray decodeBase64(ByteArray encoded);
}
#endif // SECURITY\_HPP
```
Для работы со всеми нижеописанными функциями OpenSSL нам потрубуется подключить в файл реализации следующие заголовочные файлы:
```
// файл security.cpp
#include "security.hpp"
#include
#include
// EVP
#include
// AES
#include
// ECDH
#include
#include
#include
// Обработка ошибок
void handleErrors() {
ERR\_print\_errors\_fp(stderr);
throw std::runtime\_error("Security error");
}
// Нижеприведённый код здесь
```
Для начала каждая из сторон должна сгенрировать пары ключей ECDH. Для работы с ключами ECDH будем использовать высокоуровневый интерфейс OpenSSL - [EVP](https://wiki.openssl.org/index.php/EVP).
```
EVP_PKEY* security::genKey() {
EVP_PKEY* key_pair = nullptr; // Ключевая пара
EVP_PKEY_CTX* param_gen_ctx = nullptr; // Контекст генерации параметров
EVP_PKEY_CTX* key_gen_ctx = nullptr; // Контекст генерации ключа
EVP_PKEY* params= nullptr; // Параметры ключа
// Выделяем память для контекста генерации параметров EC-ключа
if(!(param_gen_ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL))) handleErrors();
// Инициализируем контекст генерации параметров EC-ключа
if(!EVP_PKEY_paramgen_init(param_gen_ctx)) handleErrors();
// Задаём элиптичекую кривую prime256v1
if(!EVP_PKEY_CTX_set_ec_paramgen_curve_nid(param_gen_ctx, NID_X9_62_prime256v1))
handleErrors();
// Генерируем параметры
if(!EVP_PKEY_paramgen(param_gen_ctx, ¶ms)) handleErrors();
// Выделяем память для контекста генерации EC-ключа
if(!(key_gen_ctx = EVP_PKEY_CTX_new(params, nullptr))) handleErrors();
// Инициализируем контекст генерации EC-ключа
if(!EVP_PKEY_keygen_init(key_gen_ctx)) handleErrors();
// Генерируем ключ
if(!EVP_PKEY_keygen(key_gen_ctx, &key_pair)) handleErrors();
// Высвобождаем память контекста генерации параметров
EVP_PKEY_CTX_free(param_gen_ctx);
// Высвобождаем память контекста генерации ключа
EVP_PKEY_CTX_free(key_gen_ctx);
// Возвращаем указатель ключевой пары
return key_pair;
}
```
Извлечение ключей ECDH из ключевой пары EVP\_PKEY\* в "сырой буффер"
--------------------------------------------------------------------
Для передачи по сети или же для хранения в файле полезно знать как извлечь публичный и приватный ключ из указателя на EVP\_PKEY.
Поскольку работаем мы с C++ для хранения сырых данных можно использовать `std::vector` или класс на подобии нижеописанного:
```
// Файл byte_array.hpp
#ifndef BYTE_ARRAY_HPP
#define BYTE_ARRAY_HPP
#include
#include
#include
#include
#include
class ByteArray {
uint8\_t\* byte\_array = nullptr;
uint64\_t \_length = 0;
public:
typedef uint8\_t\* iterator;
// Конструктор по умолчанию
ByteArray() = default;
// Коснтруктор с выделением памяти
ByteArray(uint64\_t length)
: byte\_array(new uint8\_t[length]),
\_length(length) {}
// Конструктор копирования из сырого буфера
ByteArray(void\* buffer, uint64\_t length)
: byte\_array(new uint8\_t[length]),
\_length(length) {
memcpy(byte\_array, buffer, \_length);
}
// Конструктор копирования
ByteArray(ByteArray& other)
: byte\_array(new uint8\_t[other.\_length]),
\_length(other.\_length) {
memcpy(byte\_array, other.byte\_array, \_length);
}
// Конструктор перемещения
ByteArray(ByteArray&& other)
: byte\_array(other.byte\_array),
\_length(other.\_length) {
other.byte\_array = nullptr;
}
// Деструктор
~ByteArray() {if(byte\_array) delete[] byte\_array;}
// Изменить размер
void resize(uint64\_t new\_length) {
\_length = new\_length;
byte\_array = (uint8\_t\*)realloc(byte\_array, \_length);
}
// Добавить размер
iterator addSize(uint64\_t add) {
byte\_array = (uint8\_t\*)realloc(byte\_array, \_length + add);
iterator it = byte\_array + \_length;
\_length += add;
memset(it, 0, add);
return it;
}
// Getter для размера
inline uint64\_t length() {return \_length;}
// Оператор взятие елемента
inline uint8\_t& operator[](uint64\_t index) {return byte\_array[index];}
// Оператор присвоения
inline ByteArray& operator=(ByteArray other) {
this->~ByteArray();
return \*new(this) ByteArray(std::move(other));
}
// Итераторы для range-based for
// for(auto byte : byte\_array\_object) {...}
inline iterator begin() {return byte\_array;}
inline iterator end() {return byte\_array + \_length;}
};
#endif // BYTE\_ARRAY\_HPP
```
Функция извлечения публичного ключа:
```
ByteArray security::extractPublicKey(EVP_PKEY* key_pair) {
EC_KEY* ec_key = EVP_PKEY_get1_EC_KEY(key_pair);
EC_POINT* ec_point = const_cast(EC\_KEY\_get0\_public\_key(ec\_key));
EVP\_PKEY\* public\_key = EVP\_PKEY\_new();
EC\_KEY\* public\_ec\_key = EC\_KEY\_new\_by\_curve\_name(NID\_X9\_62\_prime256v1);
EC\_KEY\_set\_public\_key(public\_ec\_key, ec\_point);
EVP\_PKEY\_set1\_EC\_KEY(public\_key, public\_ec\_key);
EC\_KEY \*temp\_ec\_key = EVP\_PKEY\_get0\_EC\_KEY(public\_key);
if(temp\_ec\_key == NULL) handleErrors();
const EC\_GROUP\* group = EC\_KEY\_get0\_group(temp\_ec\_key);
point\_conversion\_form\_t form = EC\_GROUP\_get\_point\_conversion\_form(group);
unsigned char\* pub\_key\_buffer;
size\_t length = EC\_KEY\_key2buf(temp\_ec\_key, form, &pub\_key\_buffer, NULL);
if(!length) handleErrors();
ByteArray data(pub\_key\_buffer, length);
OPENSSL\_free(pub\_key\_buffer);
EVP\_PKEY\_free(public\_key);
EC\_KEY\_free(ec\_key);
EC\_KEY\_free(public\_ec\_key);
EC\_POINT\_free(ec\_point);
return data;
}
```
Функция извлечения приватного ключа:
```
ByteArray security::extractPrivateKey(EVP_PKEY* key_pair) {
EC_KEY* ec_key = EVP_PKEY_get1_EC_KEY(key_pair);
const BIGNUM* ec_priv = EC_KEY_get0_private_key(ec_key);
int length = BN_bn2mpi(ec_priv, nullptr);
ByteArray data(length);
BN_bn2mpi(ec_priv, data.begin());
return data;
}
```
Для получения пары ключей EVP из двух "сырых буферов" можно воспользоваться следующей функцией:
```
EVP_PKEY* security::getKeyPair(ByteArray priv_key_raw, ByteArray pub_key_raw) {
EVP_PKEY* key_pair = EVP_PKEY_new();
EC_KEY *ec_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
const EC_GROUP* ec_group = EC_KEY_get0_group(ec_key);
EC_POINT* ec_point = EC_POINT_new(ec_group);
EC_POINT_oct2point(ec_group, ec_point, pub_key_raw.begin(), pub_key_raw.length(), nullptr);
EC_KEY_set_public_key(ec_key, ec_point);
EC_POINT_free(ec_point);
BIGNUM* priv = BN_mpi2bn(priv_key_raw.begin(), priv_key_raw.length(), nullptr);
EC_KEY_set_private_key(ec_key, priv);
BN_free(priv);
EVP_PKEY_set1_EC_KEY(key_pair, ec_key);
EC_KEY_free(ec_key);
return key_pair;
}
```
Для хранения или передачи ключей не в бинарном, а в текстовом формате можно закодировать буффер с помощью кодировки base64 которая так же поддерживается в OpenSSL:
```
// Закодировать в base64
ByteArray security::encodeBase64(ByteArray decoded) {
ByteArray encoded((4*((decoded.length()+2)/3)) + 1);
EVP_EncodeBlock(encoded.begin(), decoded.begin(), decoded.length());
return encoded;
}
// Декодировать из base64
ByteArray security::decodeBase64(ByteArray encoded) {
ByteArray decoded((3*encoded.length()/4) + 1);
size_t recived_data_size = EVP_DecodeBlock(decoded.begin(), encoded.begin(), encoded.length());
if(recived_data_size < decoded.length())
decoded.resize(recived_data_size);
return decoded;
}
```
Получение общего секрета через протокол ECDH
--------------------------------------------
Каждая из сторон сгенерировала по ключевой паре и успешно обменялась своими публичными ключами. Теперь каждая из сторон должна получить "общий секрет" хэш от которого будет использоваться как ключ AES 256. Для начала определим структуру ключа AES 256:
```
struct AES_t {
// 32 байта для ключа
uint8_t key[32] = {
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0
};
// 16 байт для вектора инициализации
uint8_t init_vector[16] = {
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0
};
// В общей сумме размер ключа 48 байт или 384 бита
// Проверка на пустоту ключа
bool isEmpty() const {
static const AES_t empty_aes;
return !std::memcmp(this, ∅_aes, sizeof (AES_t));
}
// Очистить ключ
void clear() {*this = AES_t();}
// Конструктор по умолчанию
AES_t() = default;
// Конструктор из ByteArray
AES_t(ByteArray data) {
*this = *reinterpret_cast(data.begin());
}
}
```
Как мы видим структура для AES 256 ключа занимает 48 байт или 384 бита, а следовательно для получения AES 256 ключа из общего секрета подойдёт хэш-дайджест размером в 384 бит, то есть нам подходят такие алгоритмы хэширования как sha384(sha2) и sha3\_384(ранее известен как Keccak). Не стоит воспринимать алгоритм sha3 как приемника алгоритма sha2, на текущий момент принято считать что оба алгоритма достаточно безопасны для использования, что не сказать про sha1. Оба этих алгоритма поддерживаются OpenSSL, но в данном случае всё-таки воспользуемся алгоритмом sha3\_384.
```
AES_t security::getSecret(ByteArray peer_key, EVP_PKEY* key_pair) {
EC_KEY *temp_ec_key = nullptr;
EVP_PKEY *peerkey = nullptr;
// Извлекаем полученный с другой стороны публичный ключ
// из сырого буффера в EVP_PKEY*
temp_ec_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
if(temp_ec_key == nullptr)
handleErrors();
if(EC_KEY_oct2key(temp_ec_key, peer_key.begin(), peer_key.length(), NULL) != 1)
handleErrors();
if(EC_KEY_check_key(temp_ec_key) != 1) handleErrors();
peerkey = EVP_PKEY_new();
if(peerkey == NULL)
handleErrors();
if(EVP_PKEY_assign_EC_KEY(peerkey, temp_ec_key)!= 1)
handleErrors();
// Получение общего секрета
EVP_PKEY_CTX *derivation_ctx = EVP_PKEY_CTX_new(key_pair, NULL);
EVP_PKEY_derive_init(derivation_ctx);
EVP_PKEY_derive_set_peer(derivation_ctx, peerkey);
size_t lenght; // Размер общего секрета
void* ptr; // Указатель на буффер с общим секретом
if(1 != EVP_PKEY_derive(derivation_ctx, NULL, &lenght)) handleErrors();
if(NULL == (ptr = OPENSSL_malloc(lenght))) handleErrors();
if(1 != (EVP_PKEY_derive(derivation_ctx, (unsigned char*)ptr, &lenght))) handleErrors();
EVP_PKEY_CTX_free(derivation_ctx);
EVP_PKEY_free(peerkey);
// Хэшируем общий секрет и записываем в структуру AES_t
AES_t aes_key;
EVP_MD_CTX *mdctx;
if((mdctx = EVP_MD_CTX_new()) == NULL)
handleErrors();
if(1 != EVP_DigestInit_ex(mdctx, EVP_sha384(), NULL))
handleErrors();
if(1 != EVP_DigestUpdate(mdctx, ptr, lenght))
handleErrors();
unsigned int length;
if(1 != EVP_DigestFinal_ex(mdctx, (unsigned char*)&aes_key, &length))
handleErrors();
EVP_MD_CTX_free(mdctx);
OPENSSL_free(ptr);
return aes_key;
}
```
Шифрование и дешифрование с использованием AES 256
--------------------------------------------------
На текущий момент обе стороны имеют согласованный ключ AES 256 и теперь можно приступить непосредственно к шифрованию данных:
```
ByteArray security::encrypt(ByteArray plain_text, AES_t aes_struct) {
// Рассчитываем длинну шифротекста
ByteArray ciphertext(plain_text.length() % AES_BLOCK_SIZE == 0
? plain_text.length()
: (plain_text.length() / AES_BLOCK_SIZE + 1) * AES_BLOCK_SIZE);
// Инициализация контекста шифра
EVP_CIPHER_CTX *ctx;
if(!(ctx = EVP_CIPHER_CTX_new()))
handleErrors();
if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), nullptr, aes_struct.key, aes_struct.init_vector))
handleErrors();
// Шифрование исходного текста
int f_length, s_length;
if(1 != EVP_EncryptUpdate(ctx, ciphertext.begin(), &f_length, plain_text.begin(), plain_text.length()))
handleErrors();
// Иногда для записи шифротекста требутеся дополнительный AES блок
if(uint64_t(f_length) == ciphertext.length())
ciphertext.addSize(AES_BLOCK_SIZE);
else if(uint64_t(f_length) > ciphertext.length())
throw std::runtime_error("Predicted ciphertext size lower then actual!");
// Запись последнего AES блока
if(1 != EVP_EncryptFinal_ex(ctx, ciphertext.begin() + f_length, &s_length))
handleErrors();
// Уменьшение размера данных до размера записанного шифротекста
if(uint64_t reuired_length = f_length + s_length; reuired_length < ciphertext.length())
ciphertext.resize(f_length + s_length);
else if(reuired_length > ciphertext.length())
throw std::runtime_error("Predicted ciphertext size lower then actual!");
// Высвобождения выделенной памяти для контекста шифра
EVP_CIPHER_CTX_free(ctx);
return ciphertext;
}
```
Дешифровка данных выглядит следующим образом:
```
ByteArray security::decrypt(ByteArray ciphertext, AES_t aes_struct) {
ByteArray plain_text(ciphertext.length());
// Инициализация контекста шифра
EVP_CIPHER_CTX *ctx;
if(!(ctx = EVP_CIPHER_CTX_new()))
handleErrors();
if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, aes_struct.key, aes_struct.init_vector))
handleErrors();
// Дешифровка шифротекста
int f_length, s_length;
if(1 != EVP_DecryptUpdate(ctx, plain_text.begin(), &f_length, ciphertext.begin(), ciphertext.length()))
handleErrors();
if(1 != EVP_DecryptFinal_ex(ctx, plain_text.begin() + f_length, &s_length))
handleErrors();
// Уменьшение размера буффера до размера полученных данных
plain_text.resize(f_length + s_length);
// Высвобождения выделенной памяти для контекста шифра
EVP_CIPHER_CTX_free(ctx);
return plain_text;
}
```
Пример использования
--------------------
Ниже приведён простой пример использования вышеописанного кода:
```
#include "security.hpp"
#include
int main(int argc, char\* argv[]) {
using namespace security;
// Алиса генерирует ключ
EVP\_PKEY\* alice\_key\_pair = genKey();
// Алиса извлекает публичный ключ
ByteArray alice\_peer\_key = extractPublicKey(alice\_key\_pair);
// Боб генерирует ключ
EVP\_PKEY\* bob\_key\_pair = genKey();
// Боб извлекает публичный ключ
ByteArray bob\_peer\_key = extractPublicKey(bob\_key\_pair);
// Алиса и Боб обмениваются публичными ключами
// через открытый канал передачи данных
// Боб получает согласованный AES 256 ключ
AES\_t bob\_aes\_key = getSecret(alice\_peer\_key, bob\_key\_pair);
// Алиса получает согласованный AES 256 ключ
AES\_t alice\_aes\_key = getSecret(bob\_peer\_key, alice\_key\_pair);
// Алиса шифрует сообщение
std::string alice\_msg = "Hello, Bob";
ByteArray alice\_msg\_buffer(alice\_msg.data(), alice\_msg.length() + 1);
ByteArray alice\_enc\_msg = encrypt(alice\_msg\_buffer, alice\_aes\_key);
// И передаёт зашифрованное сообщение по открытому каналу Бобу
// Боб шифрует сообщение
std::string bob\_msg = "Hello, Alice";
ByteArray bob\_msg\_buffer(bob\_msg.data(), bob\_msg.length() + 1);
ByteArray bob\_enc\_msg = encrypt(bob\_msg\_buffer, bob\_aes\_key);
// И передаёт зашифрованное сообщение по открытому каналу Алисе
// Алиса получает и дешифровывет сообщение
ByteArray alice\_recived\_msg = decrypt(bob\_enc\_msg, alice\_aes\_key);
std::cout << "Bob: " << (char\*)alice\_recived\_msg.begin() << '\n';
// Боб получает и дешифровывет сообщение
ByteArray bob\_recived\_msg = decrypt(alice\_enc\_msg, bob\_aes\_key);
std::cout << "Alice: " << (char\*)bob\_recived\_msg.begin() << '\n';
return 0;
}
```
Исходный код представлен в [этом репозитории GitHub](https://github.com/gbytegear/ECDH_AES256). | https://habr.com/ru/post/591129/ | null | ru | null |
# Как агрегация решает проблемы перерасчёта полей в Битрикс24
Всем привет! На связи [Владимир Колеснев](https://habr.com/ru/users/milky__space/) из ИТ-команды подразделения ДОМ.РФ Земли. Мы занимаемся автоматизацией вовлечения в оборот неиспользуемых или используемых не по назначению федеральных земельных участков и объектов недвижимости. Разрабатываемый нами продукт – это система на базе Битрикс24, в которой земельные участки проходят долгий и всегда разный путь от появления в системе до реализации на торгах и последующего мониторинга.
Сайт земля.дом.рф с земельными участки и объектами, которые можно приобрести у ДОМ.РФ В процессе этого пути чего только ни происходит: начиная с того, что появляется множество различных сущностей, и заканчивая тем, что свойства земельных участков, да и других сущностей могут меняться при перерасчёте из-за зависимостей друг от друга. Про перерасчёт свойств (полей) мы и хотим поговорить.
В этой статье мы расскажем простую историю о механизме агрегаций. Так мы назвали механизм, который отслеживает триггеры на новый расчёт полей. Расскажем, какие проблемы были, и как мы эти проблемы решали и решили.
Если вы строите какую‑либо систему, которая работает с множеством сущностей с кучей бизнес‑процессов, ворочащими эти сущности в разных направлениях с разными вводными и бесконечно растущей бизнес‑логикой, то рано или поздно вы столкнётесь с проблемами того, что свойства сущностей каким‑то образом должны менять свои значения в зависимости от других свойств.
Проблемы
--------
Однажды перед нами встала задача реализации автоматического заполнения свойств инфоблока земельных участков. Свойства в расчётах должны были зависеть от других полей и других связанных сущностей.
Изначально мы реализовали это просто - через события: при добавлении/изменении элемента или свойств мы запускали перерасчёт. Довольно быстро свойств стало гораздо больше, бизнес логика - сложнее, а объемы данных значительно увеличились. И в результате этого мы столкнулись со следующими проблемами:
#### 1. Права доступа (у пользователя нет прав на редактирование полей, но он значится в истории)
Первая проблема возникла с быстрым ростом бизнес-логики расчётов. При изменении даже одного свойства в сущности срабатывала куча триггеров. Например, пользователь поменял название, и в моменте запускается перерасчёт «миллиона» полей. В истории изменений остаётся ложная информация о том, что этот пользователь изменил все эти поля.
#### 2. Производительность
На такие операции со временем стала тратиться уйма ресурсов, ведь изначально поля были простые, их перерасчёт был нетрудозатратен, но в будущем появились поля со сложной логикой, которые усложнили процесс.
#### 3. Консистентность
Ещё одной проблемой стало то, что поля не пересчитывались при изменении поля у связанной сущности, потому что не было механизма для возможности связать сущности в классах.
#### 4. Разные типы сущностей (инфоблоки и CRM)
Еще одна проблема появилась из того, что после реализации перерасчётов одной сущности аналогичное потребовалось и для других. Но из-за того, что земельные участки у нас - это инфоблок, а другие сущности могли быть CRM (сделки, лиды, контакты, компании), события и реализации триггеров отличались бы от реализаций прошлых, что привело бы к необоснованному разрастанию кода и ещё большей путанице.
Пришло время кодить, и было принято решение о создании чего-то универсального: удобного механизма, способного разрешить появившиеся проблемы.
Идея
----
Идея была в том, что новый механизм при изменении сущности будет отслеживать, что изменилось и, исходя из этого, будет знать, что нужно агрегировать.
Реализация
----------
Сейчас мы опишем реализацию в целом, а после уточним некоторые моменты.
Мы создали AggregationManager – класс-менеджер, синглтон, который управляет агрегациями, AggregatableEntity – абстрактный класс для агрегируемых сущностей, AggregatableEntityField – абстрактный класс для полей агрегируемых сущностей. Также мы создали отдельную очередь с воркером.
Внутри менеджера мы подписываемся на события изменения/добавления/удаления элементов и свойств, как и раньше, но теперь мы используем события «до изменения элемента» и «события после изменения элемента» в паре.
В методе, который обрабатывает событие «до изменения элемента» мы получаем тип (например, инфоблок или сделка crm) и идентификатор элемента, производим сохранение в статику исходных данных элемента (если их там ещё нет) и осуществляем поиск всех связанных сущностей. Поиск связанных сущностей до изменения нужен, например, если у земельного участка есть свойство «Документ» и если меняется значение этого свойства, то триггер в последующем нужно будет вызвать как и для старого значения (документа), так и для нового.
В методе, который обрабатывает событие «после изменения элемента», мы получаем список изменённых полей и их новые значения, также записываем их в статику и повторно осуществляем поиск связанных сущностей, так как при изменении поля могли и измениться сущности.
Далее в деструкторе класса менеджера мы вызываем метод, который проверяет действительно ли изменились поля, сравнивая данные элемента до и после. Деструктор класса используются с той целью, что в момент его вызова все события в системе уже точно отработают.
Получив эти данные и зная тип и идентификатор сущности, мы создаем новую очередь. В массив данных для неё мы добавляем такие поля, как
entity – тип связанной сущности
entity\_id – идентификатор связанной
data – это поля до/после изменения.
Очередь агрегацииНа скриншоте (рис.1) выше видно, что сообщение в очереди агрегаций создаётся для каждого элемента связанной сущностей. В конкретном примере мы изменили поле «Приоритет» у сущности сделки (тип CRM\_DEAL).
При разборе очереди из entity\_type и entity\_id мы получаем класс сущности, наследуемый от AggregatableEntity. Далее получаем поля сущности, которые могут агрегироваться и помещаем их в коллекцию (рис.2). Агрегируемые поля мы наследуем от AggregatableEntityField и кладём в определённые namespace (рис.3).
```
/**
* @return AggregatableEntityFieldCollection
*/
public function getFieldCollection(): AggregatableEntityFieldCollection
{
if ($this->fieldCollection === null) {
$this->fieldCollection = new AggregatableEntityFieldCollection();
$baseClass = new \ReflectionClass(static::class);
$filePath = dirname($baseClass->getFileName()) . "/Field/" . str_replace(".php", "", basename($baseClass->getFileName()));
$namespace = $baseClass->getNamespaceName() . "\\Field\\" . str_replace(".php", "", basename($baseClass->getFileName()));
$arFieldFiles = scandir($filePath);
foreach ($arFieldFiles as $fieldFile) {
if (strpos($fieldFile, ".php") !== false) {
$className = $namespace . "\\" . str_replace(".php", "", $fieldFile);
if (class_exists($className)) {
$object = new \ReflectionClass($className);
if(!$object->isSubclassOf("\Local\Portal\Business\Aggregation\AggregatableEntityField")){
continue;
}
/** @var $obField \Local\Portal\Business\Aggregation\AggregatableEntityField */
$obField = new $className();
$obField->setEntity($this);
$this->fieldCollection->add($obField);
}
}
}
}
return $this->fieldCollection;
}
```
*рис. 2. Получение агрегируемых полей*
рис. 3. Расположение классов агрегацииДалее мы проходим по коллекции полей и выясняем, нужно ли обновление текущего поля путем того, что заходим в метод getAggregationCondition() (рис.4) и проверяем, есть ли в триггерах наше изменённое поле.
```
/**
* @inheritDoc
*/
public function getAggregationCondition(): \Local\Portal\Business\Aggregation\ConditionCollection
{
return new \Local\Portal\Business\Aggregation\ConditionCollection([
new \Local\Portal\Business\Aggregation\Condition("CRM_DEAL", "UF_CADASTER_FACT"),
new \Local\Portal\Business\Aggregation\Condition("CRM_DEAL", "PRODUCT_ROWS"),
new \Local\Portal\Business\Aggregation\Condition(EventObjectsRealtyTable::getIblockId(), "ACTIVE"),
new \Local\Portal\Business\Aggregation\Condition(EventObjectsRealtyTable::getIblockId(), "PROPERTY_PRODUCT"),
new \Local\Portal\Business\Aggregation\Condition(EventObjectsRealtyTable::getIblockId(), "ACTIVE_FROM"),
new \Local\Portal\Business\Aggregation\Condition(EventObjectsRealtyTable::getIblockId(), "PROPERTY_EVENT_TYPE"),
]);
}
```
*рис. 4. Получение коллекции триггеров*
После этого, если поле должно измениться, получаем новое значение из метода getAggregationValue() и переписываем данные в базе.
#### Как работают триггеры, и как происходит рекурсия их добавления
Коллекция триггеров создаётся внутри каждого класса агрегируемого поля, наследуемого от AggregatableEntityField. Внутри менеджера при проверке реальных изменений полей в деструкторе (это описано выше) и регистрации этих изменений у сущности мы получаем триггеры для каждого поля связанной сущности.
Цепочки триггеров рекурсивные, потому что при срабатывании триггера для свойства в случае, если свойство переписывается, это же свойство само становится триггером. Рекурсия на рис. 5.
```
/**
* Регистрация изменения связанной сущности
*
* @param $entityTypeId
* @param $arFields
* @param bool $recursive
*/
public function registerReferenceChange($entityTypeId, $arFields, $recursive = true)
{
foreach ($arFields as $fieldCode => $value) {
if ($fieldCode == "PROPERTY_VALUES") {
foreach ($value as $propertyCode => $propertyValue) {
$fieldCodeProperty = "PROPERTY_{$propertyCode}";
if (!$this->hasReferenceChange(new Condition($entityTypeId, $fieldCodeProperty))) {
$this->registeredChanges["{$entityTypeId}#" . ToUpper($fieldCodeProperty)] = $propertyValue;
}
}
}
else {
$this->registeredChanges["{$entityTypeId}#" . ToUpper($fieldCode)] = $value;
}
}
if ($recursive) {
do {
$foundNew = false;
foreach ($this->values as $obField) {
/** @var $obField AggregatableEntityField */
if (!$this->hasReferenceChange(new Condition($obField->getEntity()::getEntityType(), $obField->getCode()))) {
// TODO getAggregatedValue найти другой способ, чтобы минимизировать вызов этого метода
if ($obField->isNeedUpdateAggregation() && $obField->getAggregatedValue() !== null) {
$foundNew = true;
$this->registeredChanges["{$obField->getEntity()::getEntityType()}#" . ToUpper($obField->getCode())] = null;
}
}
}
}
while ($foundNew == true);
}
}
```
*рис. 5. Рекурсия*
#### Как ищутся связанные сущности
Внутри менеджера в обработчиках событий before/after (рис. 6) при поиске связанных сущностей мы проходим по всем агрегируемым сущностям. Агрегируемые сущности мы получаем из метода getAggregatableEntities(), из которого возвращаем массив всех сущностей, которые могут участвовать в агрегации (рис. 7).
В каждой агрегируемой сущности заходим в метод findEntityByReference() (рис. 8), в который передаём тип и идентификатор изначально изменяемой сущности.
Внутри менеджера в обработчиках событий before/after (рис. 6) при поиске связанных сущностей мы проходим по всем агрегируемым сущностям. Агрегируемые сущности мы получаем из метода getAggregatableEntities(), из которого возвращаем массив всех сущностей, которые могут участвовать в агрегации (рис. 7).
В каждой агрегируемой сущности заходим в метод findEntityByReference() (рис. 8), в который передаём тип и идентификатор изначально изменяемой сущности.
```
public static function OnIBlockElementSetPropertyValuesEx($elementId, $iblockId, $arPropertyValues, $arFlags = [])
{
self::getInstance()->incrementEventDepth($iblockId, $elementId);
self::getInstance()->findAggregatableObject($iblockId, $elementId);
}
public static function OnAfterIBlockElementSetPropertyValuesEx($elementId, $iblockId, $arPropertyValues, $arFlags = [])
{
self::getInstance()->decrementEventDepth($iblockId, $elementId);
self::getInstance()->findAggregatableObject($iblockId, $elementId, true);
self::getInstance()->storageReferenceDataAfterSave($iblockId, $elementId, ["PROPERTY_VALUES" => $arPropertyValues], self::OPERATION_TYPE_UPDATE);
}
```
рис. 6. Обработчики событий
```
/**
* Правила аггреации сущеностей
* @return string[\Local\Portal\Business\Aggregation\AggregatableEntity]
*/
public static function getAggregatableEntities(): array
{
return [
\Local\Portal\Business\Aggregation\Crm\Deal::class,
\Local\Portal\Business\Aggregation\Crm\Lead::class,
\Local\Portal\Business\Aggregation\Crm\Company::class,
\Local\Portal\Business\Aggregation\Iblock\Contract::class,
\Local\Portal\Business\Aggregation\Iblock\Security::class,
\Local\Portal\Business\Aggregation\Iblock\AprovedPP::class,
```
рис. 7. Агрегируемые сущности
```
/**
* Определяет список объектов, которые необходимо будет агрегировать и сохраняет текущее состояние (поля)
*
* @param string|int $entityType Код сущности
* @param int $entityId Ид сущности
* @param bool $force Принудительно ещё раз определеить
*/
protected function findAggregatableObject($entityType, int $entityId, $force = false): void
{
if (!self::isEnable()) {
return;
}
$referenceEntity = $this->referenceEntities->find($entityType, $entityId);
if ($referenceEntity === null || $force) {
foreach (self::getAggregatableEntities() as $entity) {
if (is_subclass_of($entity, AggregatableEntity::class)) {
$foundAggregatableEntities = $entity::findEntityByReference($entityType, $entityId);
if(!self::isWorker() && $entityType == $entity::getEntityType()){
$foundAggregatableEntities->add((new $entity())->setEntityId($entityId));
}
if ($foundAggregatableEntities->count() > 0) {
if ($referenceEntity === null) {
$referenceEntity = (new ReferenceEntity)
->setEntityType($entityType)
->setEntityId($entityId)
->storageSourceData();
}
foreach ($foundAggregatableEntities as $aggregatableEntity) {
$referenceEntity->getAggregatableEntities()->add($aggregatableEntity);
}
$this->referenceEntities->add($referenceEntity);
$this->currentStack++;
}
}
}
}
}
```
*рис. 8. Поиск связанных сущностей*
В этом методе в зависимости от того, какой тип сущности меняется, получаем связанные сущности, добавляем их в коллекцию и возвращаем (рис. 9).
```
/**
* @inheritDoc
*/
public static function findEntityByReference($entityType, $entityId): AggregatableEntityCollection
{
$result = new AggregatableEntityCollection();
if ($entityType == \Local\Portal\Business\Iblock\Element\Contract::getIblockId()) {
$rsItems = OksTable::getList([
"filter" => [
"ACTIVE" => "Y",
"PROPERTY_CONTRACT.VALUE" => $entityId,
]
]);
while ($arItem = $rsItems->fetch()) {
$result->add((new self())->setEntityId($arItem["ID"]));
}
}
elseif ($entityType == \Local\Portal\Business\Iblock\Element\InputHouse::getIblockId()) {
$rsItems = OksTable::getList([
"filter" => [
"ACTIVE" => "Y",
"PROPERTY_APPROVEMENT.VALUE" => $entityId,
]
]);
while ($arItem = $rsItems->fetch()) {
$result->add((new self())->setEntityId($arItem["ID"]));
}
}
elseif ...
```
*рис. 9. Поиск связанных сущностей*
Зачем в очередь агрегации добавляются PREVIOUS и CURRENT значения
-----------------------------------------------------------------
Такой подход решает сразу две проблемы:
1. Агрегация выполняется не в моменте, и в очереди могут быть две записи для одного и того же элемента. Для того чтобы сохранить последовательность, используются эти значения.
2. К тому же благодаря этому в агрегациях мы можем получать текущие и предыдущие значения полей. Например, если при переходе лота из одного направления в другое нужно выполнить какую-то бизнес-логику. В таком случае мы знаем, из какого направления переносится лот.
#### Как можно делать перерасчеты полей
Внутри каждого класса агрегируемого поля, наследуемого от AggregatableEntityField есть метод, который возвращает новое значение поля. Внутри него мы можем:
1. Получать значения любых полей данной сущности через $this->getEntity()->getCurrentValue(“PROPERTY\_...”) и после применять их в расчётах свойства. Если поле агрегационное, то вернется уже актуальное пересчитанное значение.
2. Получать значения любых полей до изменений через $this->getEntity()->getPreviousValue(“PROPERTY\_...”)
#### Исключения из правил при расчете
В процессе эксплуатации мы поняли, что в расчете полей иногда могут быть исключения и бизнесу необходимо скорректировать значения, сформированные автоматически.
Для этого мы реализовали возможность задания значения поля вручную. Для этого в класс поля имплементируем интерфейс ManualFixableField. Здесь нет ничего сложного, проверяем класс на этот интерфейс для того, чтобы не перезаписывать значение поля агрегирующим значением, если было ручное изменение. Для хранения ручной фиксации агрегации мы создали таблицу с полями id, entity (сущность), entity\_id (id сущности), field (поле).
#### Пример практического применения агрегации
Например, в каком-то случайном инфоблоке контрактов есть поле NAME, в котором должно быть выводимое название контракта. Причём это поле должно состоять из номера документа (свойство DOCUMENT\_NUMBER) и даты контракта (свойство CONTRACT\_DATE), но к тому же должно иметь возможность заполняться вручную.
Такая задача легко решится агрегацией. Создаём класс поля Name внутри namespace …/Aggregation/Iblock/Field/Contract, наследуем класс от AggregatableEntityField, реализуем три метода и… всё готово!
```
php
namespace Local\Portal\Business\Aggregation\Iblock\Field\Contract;
use Local\Portal\Business\Aggregation\ManualFixableField;
use Local\Portal\Business\Iblock\Element\Internal\ContractTable;
/**
* Название
* Class Name
* @package Local\Portal\Business\Aggregation\Iblock\Field\Contract
*/
class Name extends \Local\Portal\Business\Aggregation\AggregatableEntityField
implements ManualFixableField
{
/**
* @inheritDoc
*/
public function getCode(): string
{
return "NAME";
}
/**
* @inheritDoc
*/
public function getAggregationCondition(): \Local\Portal\Business\Aggregation\ConditionCollection
{
return new \Local\Portal\Business\Aggregation\ConditionCollection([
new \Local\Portal\Business\Aggregation\Condition(ContractTable::getIblockId(), "NAME"),
new \Local\Portal\Business\Aggregation\Condition(ContractTable::getIblockId(), "PROPERTY_DOCUMENT_NUMBER"),
new \Local\Portal\Business\Aggregation\Condition(ContractTable::getIblockId(), "PROPERTY_CONTRACT_DATE"),
]);
}
/**
* Автоматическое. ({Номер документа-основания} от {Дата документа-основания})
*/
public function getAggregatedValue()
{
$number = $this-getEntity()->getCurrentValue("PROPERTY_DOCUMENT_NUMBER");
$date = $this->getEntity()->getCurrentValue("PROPERTY_CONTRACT_DATE");
if (!empty($date) && !$date instanceof \Bitrix\Main\Type\Date) {
$date = \Bitrix\Main\Type\Date::createFromTimestamp(strtotime($date));
}
if(empty($date))
{
return "";
}
$date = $date->format("d.m.Y");
return "{$number} от {$date}";
}
}
```
*рис. 10. Пример агрегации поля NAME*
Итоги
-----
В итоге мы реализовали механизм, который решил все наши проблемы, связанные с автоматическим обновлением полей в сущностях. Теперь, когда в разработку приходит задача на новую бизнес-логику на значения полей, которые вычисляются из значений других полей, нам достаточно создать класс поля, определить триггеры перерасчёта и реализовать сам расчёт значения.
Такой подход сэкономил нам время и нервы, код стал организованнее. Хотим заметить, что решение можно использовать не только для агрегаций, но и для системы нотификаций.
В следующий раз мы расскажем о том, как мы пошли дальше и создали отдельного наблюдателя за изменением свойств - Observer. Это, можно сказать, отдельная низкоуровневая штука, в которой мы отслеживаем все события до/после и всегда знаем, что было до и что стало после вне зависимости от того, сколько раз мы меняем значения внутри множества обработчиков событий. Но это уже совсем другая история.
 | https://habr.com/ru/post/713030/ | null | ru | null |
# Использование rrd4j для OpenHab2 persistence
OpenHab – популярный сервер «умного дома» (или IoT, как сейчас модно говорить) и уже [обозревался](https://habrahabr.ru/search/?q=%5Bopenhab%5D&target_type=posts) на Хабре. Тем не менее, документации по отдельным аспектам настройки сервера не так много, как хотелось бы. А на русском её, считай что и нет.
Важной особенностью OpenHab является модульность. Сам по себе сервер обеспечивает базовые функции (даже без какого бы то ни было UI). Весь остальной функционал предоставляется плагинами. Одним из типов плагинов является persistence – предоставление возможности хранить историю значения для айтемов (параметров устройств). Это необходимо для отображения исторических данных (графики) и восстановления состояния айтемов при рестарте сервера.
Существующие плагины позволяют использовать для хранения все популярные БД. Я же расскажу про настройку очень интересного бекэнда – rrd4j. Это высокопроизводительное хранилище для данных, которые представляют собой ряды значений, привязанных ко времени. Автор вдохновлялся набором RRDTools, но переписал его функционал на Java (OpenHab тоже написан на Java), оптимизировал и расширил функционал. Файлы хранилищ rrd4j не совместимы с файлами RRDTools.
Тут нужно рассказать, что представляет собой это хранилище. Это один или несколько циклических буферов, которые хранят значения параметра с привязкой ко времени. При этом, есть возможность агрегировать несколько изменений в одно значение буфера (например, снимать данные каждую минуту, а хранить одно среднее значение за 5 мин).
Итак, имеем установку OpenHab2 без persistence. Для тестов я буду использовать вот такую плату:
На плате есть два термометра Dallas 18B20 и кнопка.
Для коммуникации с сервером она использует MySensors. Кстати, плагина для протокола MySensors, почему-то, нет в репозитории, поэтому его нужно ставить руками, скачав из [темы на форуме](https://forum.mysensors.org/topic/1598/openhab-2-0-binding) и положив в папку /usr/share/openhab2/addons/.
К серверу по USB подключен типовой шлюз с таким же радиомодулем.
**Прошивка для платы**
```
// Enable debug prints to serial monitor
#define MY_DEBUG
// Enable and select radio type attached
#define MY_RADIO_NRF24
// Static node id
#define MY_NODE_ID 1
#include
#include
#define SKETCH\_NAME "Test board"
#define SKETCH\_MAJOR\_VER "1"
#define SKETCH\_MINOR\_VER "0"
// Item IDs
#define CHILD\_ID\_BTN 3
#define CHILD\_ID\_TEMP 10
// Pin definitions
#define PIN\_BTN 2
#define PIN\_BTN\_LED 3
#define PIN\_ONE\_WIRE 7
// Messages
MyMessage msgBtn(CHILD\_ID\_BTN, V\_STATUS);
MyMessage msgTemp(CHILD\_ID\_TEMP, V\_TEMP);
//OneWire temperature
OneWire oneWire(PIN\_ONE\_WIRE);
DallasTemperature temp(&oneWire);
#define MAX\_TEMP\_SENSORS 10
int cntSensors = 0; // Don't support hotplug
float arrSensors[MAX\_TEMP\_SENSORS];
DeviceAddress arrAddress[MAX\_TEMP\_SENSORS];
void before()
{
temp.begin();
}
void presentation()
{
// Send the sketch version information to the gateway and Controller
sendSketchInfo(SKETCH\_NAME, SKETCH\_MAJOR\_VER "." SKETCH\_MINOR\_VER);
// Present locally attached sensors
present(CHILD\_ID\_BTN, S\_BINARY);
cntSensors = temp.getDeviceCount();
if (cntSensors > MAX\_TEMP\_SENSORS)
cntSensors = MAX\_TEMP\_SENSORS;
Serial.print("Temperature sensors found:");
Serial.print(cntSensors);
Serial.println(".");
for (int i = 0; i < cntSensors; i++)
{
present(CHILD\_ID\_TEMP + i, S\_TEMP);
arrSensors[i] = 0;
temp.getAddress(arrAddress[i], i);
}
}
void setup()
{
// Setup locally attached sensors
pinMode(PIN\_BTN, INPUT\_PULLUP);
pinMode(PIN\_BTN\_LED, OUTPUT);
temp.setWaitForConversion(false);
temp.setResolution(12); // 0,0625 grad celsius
}
void loop()
{
// Send locally attached sensor data here
static unsigned long owNextConversTm = 0;
if (0 == owNextConversTm)
{
temp.requestTemperatures();
int16\_t owConversTm = temp.millisToWaitForConversion(temp.getResolution());
owNextConversTm = millis() + owConversTm + 50; // Wait a little more
}
else if (owNextConversTm < millis() && temp.isConversionComplete())
{
for (int i = 0; i < cntSensors; i++)
{
if (temp.validFamily(arrAddress[i]))
{
int t1 = temp.getTempC(arrAddress[i]) \* 10;
float t = t1 / 10 + (t1 % 10) \* 0.1;
if (t != arrSensors[i])
{
send(msgTemp.setSensor(CHILD\_ID\_TEMP + i).set(t, 1));
arrSensors[i] = t;
Serial.print("Sensor #");
Serial.print(i);
Serial.print(", temperature: ");
Serial.print(t);
Serial.println(" C.");
}
}
}
owNextConversTm = 0;
}
else if ((owNextConversTm + 30000) < millis())
{ // It was couter reset
owNextConversTm = 0;
}
static int currVal = HIGH;
int val = digitalRead(PIN\_BTN);
if (val != currVal)
{
digitalWrite(PIN\_BTN\_LED, val == HIGH ? LOW : HIGH);
send(msgBtn.set(val == LOW));
currVal = val;
Serial.print("Btn state changed to ");
Serial.println(val == HIGH ? "off." : "on.");
}
}
```
Да, я предпочитаю использовать ClassicUI (а UI в OpenHab – это тоже плагины). Мне хочется добавить график для двух термодатчиков (видеть их на одном графике).
Для начала нужно установить плагин для rrd4j. К счастью, он есть в репозитории.
Настройка сохранения производится в файле /etc/openhab2/persistence/rrd4j.persist. Как можно понять из пути и имени, есть возможность сохранять разные данные в разные бекэнды т.к. для каждого из них будет свой файл с расписанием и списком айтемов.
Файл состоит из двух групп настроек – стратегии, где задаётся интервал сохранения в синтаксисе Quartz и элементы, где для айтемов или групп задаются стратегии.
```
Strategies
{
// Strategy name
// | Seconds
// | | Minutes
// | | | Hours
// | | | | Day of month
// | | | | | Month
// | | | | | | Day of week
// | | | | | | | Year
every5sec : "0/5 * * * * ?"
every15sec : "0/15 * * * * ?"
everyMinute : "0 * * * * ?"
every30min : "0 30 * * * ?"
everyHour : "0 0 * * * ?"
everyDay : "0 0 0 * * ?"
default = everyChange
}
Items
{
gTemperature* : strategy = everyMinute, restoreOnStartup
}
```
В моём примере ниже gTemperature – это группа, в которую входят оба айтема для датчиков температуры (группам нужно ставить звёздочку после имени, иначе будет сохранятся значение группы, а не её членов).
Сохраняем файл, он будет перечитан автоматически. Как видно, мы сохраняем значения датчиков каждую минуту. Сейчас это лучший вариант; а почему так – расскажу ниже.
Где же хранятся данные? В папке /var/lib/openhab2/persistence/rrd4j/. Там будет создано по файлу для каждого айтема, причём размер файла будет сразу таким, чтобы хранить все данные, включая архив. Это декларируется как важная фишка RRD-хранилищ — файл не растёт бесконтрольно.
```
root@chubarovo:/etc/openhab2# ll -h1 /var/lib/openhab2/persistence/rrd4j/
total 78K
drwxr-xr-x 2 openhab openhab 4.0K Apr 7 21:53 ./
drwxr-xr-x 5 openhab openhab 4.0K Feb 18 18:59 ../
-rwxr-xr-x 1 openhab openhab 32 Dec 18 15:44 Readme.txt*
-rw-r--r-- 1 openhab openhab 35K Apr 7 21:54 Test_temp1_soc.rrd
-rw-r--r-- 1 openhab openhab 35K Apr 7 21:54 Test_temp2_soc.rrd
```
Ну, раз всё хорошо, добавим графики себе в sitemap:
```
sitemap test label="Тестовый пример"
{
Text item=Test_button_soc label="Кнопка [MAP(ru.map):%s]"
Text item=Test_temp1_soc
Text item=Test_temp2_soc
Chart item=gTemperature refresh=60000 period=4h
}
```
Вот как это выглядит на экране:
Кстати, в мобильном приложении графики также есть:
Ещё одна интересная особенность rrd4j (и оригинальных RRDTools) – встроенный движок рендеринга графиков. В OpenHab такой график можно вставить в другом UI – HabPanel. Выглядит он олдскульно:
Движок доступен и напрямую по ссылке. Она должна выглядеть примерно так:
`http://192.168.144.243:8080/rrdchart.png?groups=gTemperature&theme=black.=h&h=464&w=447`
w и h – размер графика в пикселях. В параметре groups задаются названия групп для отображения. Для отдельных айтемов нужно использовать параметр items. Если нужно показать несколько групп/параметров, то их нужно указать через запятую.
Ладно, как вообще это всё работает? Как часто сохраняется значение? Сколько хранится? Да и вообще, у rrd4j масса настроек, а мы ничего не делали!
Чтобы посмотреть текущее хранилище воспользуемся графической утилитой, которая ходит вместе с плагином для OpenHab. На моём тестовом сервере нет иксов, поэтому я скопировал файлы данных и .jar плагина на основную машину с Windows.
Для запуска, конечно, понадобится Java. У неё есть прикольная особенность запускать любой подобающий класс из .jar по имени. Нам нужен org.rrd4j.inspector.RrdInspector и запускаем его вот так:
```
java -cp rrd4j-2.1.1.jar org.rrd4j.inspector.RrdInspector
```
И вот что мы увидим для нашего архива:
Вот тут-то и кроется причина того, что нет смысла сохранять значение чаще, чем раз в минуту! В хранилище данные записываются каждые 60 сек, а если пытаться сохранять чаще, то будет записано среднее всех значений.
Самое время рассмотреть конфигурирование rrd4j, ведь я хотел бы снимать показания датчиков почаще. Да, и ещё я хочу записывать состояние кнопки, причём хранить не среднее (какой в нём толк для кнопки?), а максимальное значение за период, чтобы знать, была ли нажата кнопка в заданный период.
Как вы уже поняли, конфигурация по умолчанию нам не подходит. Так что неплохо бы её изменить. Настройки хранилища лежат в /etc/openhab2/services/rrd4j.cfg. Сейчас файл пуст, но сверху есть подсказка по синтаксису.
Итак, выше я уже писал общие слова по формату. Теперь пора заняться конфигурированием. Как видно из примера, настройки идут в две строки: .def и .archives. В параметре .items через запитую перечисляются айтемы, для которых будет применяться конфигурация. Те параметры, для которых нет своей конфигурации, будут сохраниться с настройками по умолчанию (мы их видели выше в Java-смотрелке).
Сделаем настройки для градусников:
```
# each 15 sec
temps.def=GAUGE,15,0,100,15
# 4h/15s : 1m/24h : 5m/7d
temps.archives=AVERAGE,0.5,1,960:AVERAGE,0.5,4,1440:AVERAGE,0.5,20,2016
temps.items=Test_temp1_soc,Test_temp2_soc
```
Как можно заметить, синтаксис несколько отличается от классических RRDTools. В .def мы задали тип значения GAUGE – это хранение абсолютных значений. Дальше heartbeat, минимальное, и максимальное возможные значения. И step.
Step – это нормальный интервал между отсчётами в секундах. Я выбрал 15, как и хотел.
Hearbeat добавляется к step и это максимальный интервал времени, для сохранения значения. Если за это время (step + heartbeat = 30 сек в моём случае) не будет записано значение, то rrd4j сохранит в отсчёт NaN.
В .archives задаю настройки хранения. Всё, что записывается в файл, настраивается здесь. Как можно заметить, архивов может быть несколько. Синтаксис одного архива приведён в описании в файле.
В качестве агрегатной функции я использую AVERAGE т.к. у меня температура и при объединении отсчётов нужно сохранять среднее. Дальше – параметр xff, который слабо описан в интернете. Пришлось слазить в исходники. Это оказался коэффициент (по сути, процент), который определяет, при каком количестве NaN, при группировке запишется итоговый NaN.
Например, для второго архива, где объединяются 4 значения, при коэффициенте 0,5 итоговый NaN будет записан, если два или более исходных значения – NaN.
В следующих параметрах задаётся, сколько исходных значений записываются в одно архивное и сколько архивных значений нужно хранить (перезаписываются циклически).
В моей настройке я создал три архива с такими параметрами:
• Храним каждое значение, всего 960 штук (960 \* 15 сек = 4 часа).
• Храним среднее из четырёх значений, всего 1440 штук (1440 \* 15 сек = 24 часа).
• Храним среднее из 20 значений, всего 2016 штук (2016 \* 15 сек = 7 дней).
Закрепляем навыки. Настройки для кнопки:
```
# each 60 sec
temps.def=DERIVE,60,0,100,60
# 6h/60s : 5m/24h : 5m/7d
temps.archives=MAX,0.5,1,360:MAX,0.5,5,288:MAX,0.5,30,336
temps.items=Test_button_soc
```
Здесь я сохраняю значения каждые 60 сек и храню максимальное.
Да. Если в настройке persistence задать сохранение чаще, чем step в конфиге rrd4j, то хранилище будет группировать значения агрегатной функцией из первого архива.
Теперь вернёмся к настройке OpenHab (привожу только часть Items):
```
Items
{
gTemperature* : strategy = every15sec, restoreOnStartup
Test_button_soc : strategy = everyMinute, everyChange
}
```
Я задал для термометров сохранение каждые 15 сек и задал настройки для кнопки. Мы будет сохранять её каждую минуту и при изменении, что в совокупности с агрегатной функцией MAX позволит записать в архив 1, если кнопка была хоть раз нажата в течение минуты.
Доделываю sitemap и вот что вижу:
OpenHab — хорошее решение для «умного дома» и автоматизации ЖКХ. Пользуйтесь и расширяйте русское сообщество! | https://habr.com/ru/post/353030/ | null | ru | null |
# OCP против YAGNI
Эта статья является переводом материала [OCP vs YAGNI](https://enterprisecraftsmanship.com/posts/ocp-vs-yagni/).
В этом посте хочется осветить тему OCP и YAGNI – противоречия между принципом открытости/закрытости и принципом «вам это не понадобится».
OCP
---
Давайте начнем с того, что вспомним, что такое OCP. Принцип открытости/закрытости гласит, что: *Объекты программного обеспечения (классы, модули, функции и т.д.) должны быть открыты для расширения, но закрыты для модификации.*
Впервые он был представлен Бертраном Мейером в его канонической книге «[Конструирование объектно-ориентированного программного обеспечения](https://www.amazon.com/Object-Oriented-Software-Construction-Book-CD-ROM/dp/0136291554)». С тех пор его популяризировал Боб Мартин, когда он представил принципы [SOLID](https://ru.wikipedia.org/wiki/SOLID_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)).
Официальное определение довольно расплывчато и на самом деле не помогает нам понять основной смысл. Итак, давайте углубимся в этот принцип.
В настоящее время существует две интерпретации данного принципа: Бертрана Мейера и Боба Мартина.
Интерпретация Боба Мартина сводится к тому, чтобы избежать волновых эффектов. То есть, когда вы изменяете фрагмент кода, вам не нужно вносить изменения во всю кодовую базу, чтобы учесть эту модификацию. В идеале вы должны иметь возможность добавлять новые функции, ничего не меняя в уже существующем коде. Принцип рекомендует закрыть исходный модуль (класс, метод и т.д.) для модификации и вместо этого открыть в нем точку расширения. Эта точка расширения позволит вам вводить новые функциональные возможности без изменения существующей кодовой базы.
Обычно это реализуется с помощью полиморфизма. Например, следующий фрагмент кода нарушает версию OCP Боба Мартина:
```
public void Draw(Shape shape)
{
switch (shape.Type)
{
case ShapeType.Circle:
DrawCircle(shape);
break;
case ShapeType.Square:
DrawSquare(shape);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
```
Здесь, чтобы ввести новую фигуру, вам нужно будет изменить метод *Draw*. Вы можете сказать, что добавление новой формы будет распространяться по существующей кодовой базе в том смысле, что вам потребуется изменить приведенный выше оператор *switch*.
Чтобы исправить это, вы можете создать абстрактный класс *Shape* и затем переместить логику рисования в его подклассы:
```
public abstract class Shape
{
public abstract void Draw();
}
public class Circle : Shape
{
public override void Draw()
{
/* … */
}
}
/* etc. */
```
Теперь, если вам нужно добавить новую фигуру, вы просто создаете подкласс и переопределяете метод *Draw*. Используя терминологию OCP, вы закрыли класс *Shape* для модификации и открыли в нем точку расширения. Эту точку расширения можно использовать для создания новых функциональных возможностей без изменения какого-либо существующего кода.
Первоначальное намерение Бертрана Мейера, лежащее в основе этого принципа, иное. В то время как интерпретация Боба Мартина направлена на уменьшение количества изменений, Бертран Мейер говорит об обратной совместимости.
Когда существует несколько взаимозависимых модулей, каждый из которых разрабатывается отдельной командой программистов, вам необходимо выполнить некоторые действия, чтобы это работало. Вы не можете просто изменить свой модуль. Вы должны учитывать его клиентов.
Например, если у вас есть библиотека, которая предоставляет метод
```
CreateCustomer(string email)
```
Вы не можете в любой момент добавить к нему новый обязательный параметр, например:
```
CreateCustomer(string email, string bankAccountNumber)
```
Это было бы критическим изменением для клиентского кода, который уже привязан к исходной версии метода.
По сути, это проблема, которую Бертран Мейер пытался решить с помощью принципа OCP. В процессе разработки ваш модуль открыт для модификации, так как еще никто не привязан к нему. Но как только вы его опубликуете, вам нужно будет перестать вносить какие-либо изменения и закрыть его API, чтобы он всегда оставался совместимым с существующими клиентами. Если вам нужно внести изменения после публикации, вы делаете это, создавая новый модуль.
Обратите внимание, что Бертран Мейер говорит здесь конкретно об API, а не о фактической реализации модуля. Вы все еще можете изменить реализацию при условии, что это не изменит API модуля. Другими словами, исправления ошибок и изменения, которые не ломают обратную совместимость, допустимы, но изменение сигнатур методов и требование новых предварительных условий - нет.
Вот полный список того, что представляет собой API:
* Сигнатура метода: имя, параметры, возвращаемое значение.
* Предварительные условия: список требований, которым должны соответствовать клиенты, прежде чем они смогут использовать метод. Примером такого предварительного условия может быть требование сформировать строковый параметр *email* определенным образом.
* Постусловия: список гарантий, которые дает модуль. Примером может служить обещание отправить поздравительное электронное письмо вновь созданному клиенту.
* Инварианты: список условий, которые должны выполняться всегда.
Изменение сигнатуры метода, усиление его предусловий, ослабление постусловий или изменение инвариантов приведет к нарушению изменений.
Единственным типом совместимости, который был актуален в то время, когда Мейер писал об этом принципе, была бинарная совместимость. Это происходит, когда у вас есть две библиотеки, и одной из них необходимо использовать вторую без перекомпиляции и без внесения изменений. Однако такой тип совместимости все еще может быть применен в наши дни.
Все вопросы, касающиеся управления версиями веб-API, по сути, связаны с принципом OCP Мейера, применяемым к крупномасштабным проектам. Если у вас есть Микросервис 1, который зависит от Микросервиса 2, вы не можете внести критическое изменение в Микросервис 2, его API должен быть закрыт для таких изменений. Но вы все равно можете создать его новую версию и предоставить существующим клиентам выбор: либо остаться со старой версией, либо перейти на новую.
Еще один важный момент, который следует отметить, заключается в том, что версия OCP Мейера имеет смысл только в контексте нескольких команд разработчиков, когда каждый модуль разрабатывается разными командами. В типичной среде корпоративного программного обеспечения, когда вы одновременно являетесь автором и клиентом написанного кода, нет необходимости придерживаться таких сложных методов. Вам не нужно закрывать свой код, так как у вас есть все необходимое для исправления любых критических изменений, которые вы можете внести. Только когда вы опубликуете свой модуль/библиотеку/сервис и сделаете его доступным для других команд, вы должны действительно закрыть его API. В противном случае критические изменения не являются проблемой.
> Автор оригинала затронул эту тему более подробно в одной из предыдущих своих статей: [Shared library vs Enterprise development](https://enterprisecraftsmanship.com/posts/shared-library-vs-enterprise-development/)
>
>
Итак, две разновидности OCP, несмотря на одно и то же название, различаются по своему смыслу. Это важно для нашего обсуждения OCP vs YAGNI. Код, который приводился ранее:
```
public void Draw(Shape shape)
{
switch (shape.Type)
{
case ShapeType.Circle:
DrawCircle(shape);
break;
case ShapeType.Square:
DrawSquare(shape);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
```
нарушает интерпретацию OCP Мартина, но не противоречит интерпретации Мейера. Это потому, что добавление новых фигур не требует от нас изменения API метода *Draw*. Все существующие клиенты останутся без изменений, критических изменений не будет.
В этом смысле интерпретация Боба Мартина шире. Она направлен на уменьшение количества изменений в целом, на возможность расширения поведения программного обеспечения путем небольшого изменения исходного кода или его отсутствия. Интерпретация Бертрана Мейера направлена только на сокращение критических изменений: изменений, которые могут вызвать проблемы, когда несколько команд работают вместе.
YAGNI
-----
YAGNI расшифровывается как “Вам это не понадобится” и в основном означает, что вы не должны тратить время на функциональность, которая сейчас не нужна. Вам не следует разрабатывать эту функциональность, а также изменять существующий код, чтобы учесть его появление в будущем. Вот два основных момента, которые объясняют, почему это хорошая идея:
* Бизнес-требования постоянно меняются. Если вы тратите время на функцию, которая не нужна бизнесу в данный момент, вы крадете время у функций, которые ему нужны прямо сейчас. Более того, когда бизнесу, наконец, потребуется разработанная функциональность, взгляд на нее, скорее всего, изменится, и вам все равно придется вносить в нее изменения. Такая деятельность расточительна и приводит к чистым убыткам, так как было бы выгоднее просто реализовать функцию с нуля, когда в этом возникнет реальная необходимость.
* Ваш код - это не актив, а обязательство. Предпочтительно иметь меньше кода, так как любой дополнительный код увеличивает затраты на обслуживание. Введение кода “на всякий случай”, без необходимости, увеличивает общую стоимость поддержки всей кодовой базы. Помните, что вам нужно будет рефакторить эту дополнительную часть, править баги (если они возникнут), покрыть тестами и так далее. Предпочтительнее отложить внедрение новых функций до как можно более поздней стадии вашего проекта.
Существуют ли ситуации, когда YAGNI неприменим? Да.
Вы можете нарушить YAGNI, если разрабатываете функциональность, которую трудно изменить в будущем. Это API-интерфейсы, ориентированные на клиентов, сторонние библиотеки, фундаментальные архитектурные решения, пользовательские интерфейсы (UIs) (их может быть трудно изменить, поскольку пользователи неохотно принимают новый внешний вид). В таких ситуациях стоит потратить некоторое время, чтобы попытаться предсказать, как будущая функциональность будет зависеть от решений, которые вы принимаете сейчас. Например, рекомендуется заранее инвестировать в надлежащую систему управления версиями веб-API, потому что после ее публикации изменить ее будет невозможно. Аналогично, метод или класс, ориентированный на потребителя, в общедоступной библиотеке должен оставаться там для обеспечения обратной совместимости, даже если вы решите, что он больше не нужен. Изменить такие вещи трудно.
Иными словами, если решение, которое вы собираетесь принять, станет чем-то, что высечено на камне, YAGNI не применимо. В этом случае вам необходимо учитывать возможные будущие требования.
Однако рекомендуется принимать как можно меньше таких решений. По крайней мере, постарайтесь отложить их на более поздний этап. Таким образом вы сможете собрать больше информации о реальных потребностях бизнеса. Также имейте в виду, что большинство решений, которые вы принимаете, не входят в их число, их можно довольно легко изменить. YAGNI применим к большей части кода, который мы пишем изо дня в день.
OCP vs YAGNI
------------
Обратите внимание, что YAGNI кроме рекомендации не реализовывать неиспользуемые функции, также запрещает изменять существующие функции для учета возможных новых возможностей в будущем. В этом и заключается противоречие. Этот «учет возможных новых функций в будущем» - это именно то, что предлагает версия OCP Боба Мартина.
Давайте еще раз посмотрим на метод *Draw*:
```
public void Draw(Shape shape)
{
switch (shape.Type)
{
case ShapeType.Circle:
DrawCircle(shape);
break;
case ShapeType.Square:
DrawSquare(shape);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
```
С одной стороны, у нас есть YAGNI, который говорит, что этот оператор *switch* допустим, если результирующий код прост и его легко понять и поддерживать. С другой стороны, у нас есть OCP Боба Мартина, который говорит, что нам нужно иметь возможность расширять его без изменения исходного кода, то есть без изменения самого оператора *switch*.
Какой из этих принципов имеет более высокий приоритет?
Чтобы ответить на этот вопрос, давайте вернемся назад. Обратите внимание, что речь идет о противоречии между YAGNI и OCP Боба Мартина, а не о его версии Бертрана Мейера. Это потому, что YAGNI не противоречит последнему, они в основном говорят о разных вещах.
Что касается версии Боба Мартина, то ее можно рассматривать с двух разных точек зрения. Первая - это когда вы одновременно являетесь автором и клиентом написанного кода. Это ситуация, в которой находится большинство разработчиков корпоративных приложений. Вторая - когда вам нужно опубликовать свой код для внешнего использования. Пакет NuGet или фреймворк являются типичными примерами.
YAGNI превосходит OCP, когда вы полностью контролируете использование кода. Почему? Потому что YAGNI, наряду с [KISS](https://enterprisecraftsmanship.com/posts/kiss-revisited/), является [важнейшим принципом в разработке программного обеспечения](https://enterprisecraftsmanship.com/posts/most-valuable-software-development-principles/). Следование этому должно быть первоочередной задачей любого программного проекта.
Это также имеет смысл, если вы посмотрите более внимательно на OCP Боба Мартина. Почему вы должны закладывать точки расширения в свой код преждевременно, даже если это приведет к чрезмерному усложнению? Действительно ли стоит тратить усилия и дополнительные затраты на замену простого оператора *switch* на отдельную иерархию классов? Конечно нет. Гораздо лучше заложить эти точки расширения постфактум, когда у вас уже есть полная картина и когда вы видите, что оператор *switch* стал слишком раздутым. В этом случае вы можете применить рефакторинг и извлечь эту иерархию классов. Но не раньше, чем необходимость в этом станет очевидной.
Теперь другая ситуация, когда вы не контролируете, то, как используется ваш код. В этом случае, как упоминалось ранее, YAGNI неприменим, потому что стоимость изменения уже реализованной функциональности слишком высока. Вы не можете так легко рефакторить свой код, потому что вы не единственный его потребитель.
В такой ситуации вам действительно нужно определить потенциальные точки вариации и создать вокруг них интерфейс, который позволит потребителям расширять ваши классы, а не изменять их. Итак, в приведенном выше примере кода, если вы ожидаете, что *Draw* будет методом, ориентированным на потребителя, и хотите предоставить средства для его расширения, рекомендуется заранее заменить его базовым классом *Shape* и позволить вашим потребителям создавать свои собственные формы.
Версия OCP Боба Мартина имеет гораздо больше смысла, если вы поместите ее в исходную точку зрения Бертрана Мейера. Точки расширения стоит закладывать только тогда, когда вам придется выставлять свой код для внешнего использования в той или иной форме. В любом другом случае придерживайтесь YAGNI и не вводите дополнительную гибкость без реальной необходимости.
Резюме
------
Существует две интерпретации принципа Открытости/Закрытости:
* Исходная интерпретация Бертрана Мейера касается обратной совместимости. Вам необходимо закрыть API вашего модуля/библиотеки/службы, если он предназначен для внешнего использования.
* Идея Боба Мартина заключается в том, чтобы избежать эффекта пульсации: вы должны иметь возможность расширять поведение программного обеспечения, немного изменяя исходный код или не изменяя его вообще. Это достигается путем добавления точек расширения к вашей кодовой базе.
YAGNI говорит нам, что мы не должны заранее добавлять точки расширения в нашу базу кода, пока в них не возникнет реальная необходимость.
YAGNI противоречит версии OCP Боба Мартина.
Противоречие разрешается, если вы сопоставляете OCP Боба Мартина с исходной точки зрения Мейера. То есть, если вы применяете этот принцип только тогда, когда ваш код используется внешними командами.
YAGNI превосходит OCP Боба Мартина, когда вы единственный потребитель своего кода (разработка корпоративного программного обеспечения).
OCP Боба Мартина превосходит YAGNI, когда вы не единственный потребитель своего кода. | https://habr.com/ru/post/567068/ | null | ru | null |
# 100 строк на canvas-е: часть 1
*Предисловием мне хотелось бы поздравить одного хабраюзера с днём рождения. Расти большим, будь умным, и допили уже наконец свой canvas-фреймворк [Graphics2D](http://habrahabr.ru/post/239261/) до того состояния, которое считаешь приемлемым.
**С днём рождения, я.** :P*
Этим летом мне пришла в голову интересная мысль: если бы я писал микробиблиотеку для canvas в 100 строк, что бы я туда уместил?.. Самый развёрнутый ответ можно написать за 1 вечер. А потом пришла и идея этой статьи.
Предлагаю реализовать ООП, события и анимацию на canvas — самые часто нужные (имхо) вещи… и всё это в 100 строк. Часть первая.
Дисклеймер: тут вас (иногда) поджидают совсем ненужные извращения для экономии пары символов кода. Автор (а это я) считает, что в микробиблиотеках так можно, и очень часто делается. Если это не нарушает производительность, конечно.
#### Рад видеть вас под катом ;)
Начнём с идеи (а первым делом — ООП). 3 главных объекта: пути, изображения, текст. Нет никакой нужды реализовывать, например, прямоугольники и круги в минибиблиотеке: они легко создаются через путь. Как и спрайты — через картинки. И т.п.
Первый аргумент объекта — его содержание.
Второй — стили, которые устанавливаются на canvas перед рисованием.
Я назову это Rat :P
```
Rat = function(context){
this.context = context;
};
```
#### Пути
Как-то так будет неплохо:
```
var path = rat.path([
['moveTo', 10, 10],
['lineTo', 100, 100],
['lineTo', 10, 100],
['closePath']
], {
fillStyle: 'red',
strokeStyle: 'green',
lineWidth: 4
});
```
У всех 3 объектов нужно установить свойством контекст, объект для стилей и т.п… Так что:
```
Rat.init = function(cls, arg){
cls.opt = arg[0];
cls.style = arg[1] || {};
cls.context = arg[2];
cls.draw(arg[2].context);
};
```
Вроде бы всё понятно? У каждого объекта есть 3 свойства: opt (1 аргумент), style (2й) и context (контекст), а также функция draw(ctx), рисующая этот объект.
Наш класс:
```
Rat.Path = function(opt, style, context){
Rat.init(this, arguments);
};
```
Да, как ни странно, конструктор — всё.
Самое главное: отрисовка:
```
Rat.Path.prototype = {
draw: function(ctx){
this.process(function(ctx){
if(this.style.fillStyle)
ctx.fill();
if(this.style.strokeStyle)
ctx.stroke();
}, ctx);
},
process: function(callback, ctx){
ctx = ctx || this.context.context;
Rat.style(ctx, this.style);
ctx.beginPath();
this.opt.forEach(function(func){
ctx[func[0]].apply(ctx, func.slice(1));
});
var result = callback.call(this, ctx);
ctx.restore();
return result;
}
};
```
Функция process тут вовсе неспроста: она понадобится ещё кое-где:
```
isPointIn: function(x,y, ctx){
return this.process(function(ctx){ return ctx.isPointInPath(x, y); }, ctx);
}
```
Зачем callback? Хм… Для красоты.
Функция **Rat.style**, также общая для всех 3 объектов, просто переносит свойства на canvas. Не забываем, что нам также хочется трансформаций:
```
// не смотрите на меня так, в микробиблиотеках иногда можно так извращаться
// иногда
Rat.notStyle = "translate0rotate0transform0scale".split(0);
Rat.style = function(ctx, style){
ctx.save();
style.origin && ctx.translate.apply(ctx, style.origin);
style.rotate && ctx.rotate(style.rotate);
style.scale && ctx.scale.apply(ctx, style.scale);
style.origin && ctx.translate(-style.origin[0], -style.origin[1]);
style.translate && ctx.translate.apply(ctx, style.translate); // интересно, это лучше до или после origin?
style.transform && ctx.transform.apply(ctx, style.transform);
Object.keys(style).forEach(function(key){
if(!~Rat.notStyle.indexOf(key))
ctx[key] = style[key];
});
};
```
Ай, не бейте, я все объясню. `!~Rat.notStyle.indexOf(key)` — тоже самое, что и `Rat.notStyle.indexOf(key) != -1`. Это микробиблиотека всё же.
Ну и, наконец, функция контекста, создающая и возвращающая экземпляр нашего класса:
```
Rat.prototype = {
path : function(opt, style){ return new Rat.Path(opt, style, this); },
};
```
Всё, можно рисовать пути. Ура!
И, помимо основных стилей, присутствуют, как можно было заметить в Rat.style, трансформации:
```
var path = rat.path([
['moveTo', 10, 10],
['lineTo', 100, 100],
['lineTo', 10, 100],
['closePath']
], {
fillStyle: 'red',
strokeStyle: 'green',
lineWidth: 4,
rotate: 45 / 180 * Math.PI,
origin: [55, 55]
});
```
*Картинка обрезана, т.к. нарисована в нулевых координатах.*
#### Картинки
Следуя дальше принципу 2 аргументов, мы хотим воот такой вот класс:
```
var img = new Image();
img.src = "image.jpg";
img.onload = function(){
rat.image(img);
}
```
Помимо этого, в стилях можно передавать параметры **width**, **height** и **crop** (массив из 4 чисел). Всё так же, как в оригинальной drawImage CanvasRendering2DContext-а.
Снова конструктор класса:
```
Rat.Image = function(opt, style, context){
Rat.init(this, arguments);
};
```
Отрисовка выглядит как-то так:
```
Rat.Image.prototype.draw = function(ctx){
Rat.style(ctx, this.style);
if(this.style.crop)
ctx.drawImage.apply(ctx, [this.opt, 0, 0].concat(this.style.crop));
else
ctx.drawImage(this.opt, 0, 0, this.style.width || this.opt.width, this.style.height || this.opt.height);
ctx.restore();
};
```
Всё, вроде бы, просто.
И последнее, конечно же:
```
Rat.prototype = {
...
image : function(opt, style){ return new Rat.Image(opt, style, this); },
};
```
Ура, и картинки есть.
#### Текст
3й глобальный объект:
```
var text = rat.text("Hello, world!", {
fillStyle: 'blue'
});
```
Также есть свойство maxWidth.
Конструктор:
```
Rat.Text = function(){
Rat.init(this, arguments);
};
```
Отрисовка очень простая. А решение, как всегда, не очень чистое, зато работающее ).
```
Rat.Text.prototype.draw = function(ctx){
Rat.style(ctx, this.style);
if(this.style.fillStyle)
ctx.fillText(this.opt, 0, 0, this.style.maxWidth || 999999999999999);
if(this.style.strokeStyle)
ctx.strokeText(this.opt, 0, 0, this.style.maxWidth || 9999999999999999);
ctx.restore();
};
```
А ещё текст на canvas-е можно мерить. Ширину, да. Высота определяется размером шрифта.
```
Rat.Text.prototype.measure = function(){
var ctx = this.context.context;
Rat.style(ctx, this.style);
var w = ctx.measureText(this.opt).width;
ctx.restore();
return w;
};
```
Не забываем:
```
Rat.prototype = {
...
image : function(opt, style){ return new Rat.Image(opt, style, this); },
};
```
#### По мелочи
Иногда нужно простить, забыть, выкинуть всё и начать с чистого листа. Для таких случаев есть функция clear:
```
Rat.prototype = {
...
clear: function(){
var cnv = this.context.canvas;
this.context.clearRect(0, 0, cnv.width, cnv.height);
}
};
```
Для всего остального есть **draw**, рисующий все объекты из массива:
```
Rat.prototype = {
...
draw: function(elements){
var ctx = this.context;
elements.forEach(function(element){
element.draw(ctx);
});
}
};
```
#### Примеры:
Ну а теперь… Давайте, например, накодим кнопку на canvas-е (самое простое, что придумалось):
```
// квадратик
var path = rat.path([
['moveTo', 10, 10],
['lineTo', 100, 10],
['lineTo', 100, 40],
['lineTo', 10, 40],
['closePath']
], {
fillStyle: '#eee',
strokeStyle: '#aaa',
lineWidth: 2
});
// текст
var text = rat.text("Hello, world", {
translate: [55, 28],
textAlign: 'center',
fillStyle: 'black'
});
```
И пуусть… При наведении мыши она подсвечивается:
```
var bounds = ctx.canvas.getBoundingClientRect();
var hover = false;
ctx.canvas.addEventListener('mousemove', function(e){
var x = e.clientX - bounds.left,
y = e.clientY - bounds.top;
if(x > 10 && x < 100 && y > 10 && y < 40){
if(hover)
return;
hover = true;
path.style.fillStyle = '#ccc';
rat.clear();
rat.draw([path, text]);
}
else if(hover){
hover = false;
path.style.fillStyle = '#eee';
rat.clear();
rat.draw([path, text]);
}
});
```
#### А зачем?
Самое интересное, что на базовом canvas можно накодить примерно то же примерно тем же количеством кода.
**Скрытый текст**
```
// квадратик
var path = {
fill: '#eee',
draw: function(){
ctx.moveTo(10, 10);
ctx.lineTo(100, 10);
ctx.lineTo(100, 40);
ctx.lineTo(10, 40);
ctx.closePath();
ctx.fillStyle = this.fill;
ctx.strokeStyle = '#aaa';
ctx.lineWidth = 2;
ctx.fill();
ctx.stroke();
}
};
// текст
var text = {
draw: function(){
ctx.textAlign = 'center';
ctx.fillStyle = 'black';
ctx.fillText("Hello, world", 55, 28);
}
};
path.draw();
text.draw();
var bounds = ctx.canvas.getBoundingClientRect();
var hover = false;
ctx.canvas.addEventListener('mousemove', function(e){
var x = e.clientX - bounds.left,
y = e.clientY - bounds.top;
if(x > 10 && x < 100 && y > 10 && y < 40){
if(hover)
return;
hover = true;
path.fill = '#ccc';
ctx.clearRect(0, 0, 800, 400);
path.draw();
text.draw();
}
else if(hover){
hover = false;
path.fill = '#eee';
ctx.clearRect(0, 0, 800, 400);
path.draw();
text.draw();
}
});
```
Но это стало очевидно только после того, как 100 строк написаны…
[github.com/keyten/Rat.js/blob/master/rat.js](https://github.com/keyten/Rat.js/blob/master/rat.js)
Ну что ж… В следующей части (если хабрахабру будет интересна эта тема) я покажу реализацию обработки мыши, и 3 часть — анимация. Всё снова в 100 строк (посмотрим, получится ли).
Пойду праздновать день рождения.
#### Всем интересного кода! | https://habr.com/ru/post/270255/ | null | ru | null |
# Как QA-инженер может влиять на unit-тесты
Привет! Меня зовут Алёна Луцик, я QA-инженер в команде Авито. За время работы я много раз убеждалась, что разработчик и тестировщик смотрят на код по-разному.
Зачастую перед тестировщиком стоит задача покрытия функциональности автотестами без избыточных проверок, с соблюдением пропорций пирамиды. Но прежде, чем начать покрывать бизнес-логику, стоит понять, что вообще можно покрыть на уровне unit-тестов.
В статье я расскажу о шагах, которые помогут прийти к взаимопониманию с коллегами-разработчиками.
*Примеры будут приведены в рамках микросервисной архитектуры на языке Golang.*
### Что поможет QA-инженеру договориться с разработчиками
Одна из целей QA-инженера — обеспечить высокое качество продукта без избыточного тестирования. Это не значит, что придётся писать все автотесты своими руками — важно понимать, какая функциональность уже проверяется ими на базовом уровне. Для этого нужно правильно выстроить коммуникацию с разработчиками. На примере покажу, как это сделать.
Предположим, вы QA-инженер. У вас есть задача: нужно продумать покрытие новой фичи автотестами. Вы понимаете, какие тесты вам надо покрыть на уровне e2e-тестов, а какие сценарии покрыть компонентными и интеграционными.
Уровнем покрытия unit-тестов занимаются разработчики. Чтобы понять, как посчитать соотношение количества тестов на разных уровнях [пирамиды тестирования](https://habr.com/ru/post/672484/), нужно выяснить, что мы можем покрыть на уровне юнитов. Для этого стоит прийти к коллеге-разработчику и задать ему уточняющие вопросы.
Шапка QA-инженераТеперь посмотрим на ситуацию со стороны разработчика. Он спокойно делает свою работу: пишет код, покрывает его unit-тестами. И тут к нему приходит ваш коллега-тестировщик с вопросами. Разработчик не всегда понимает, зачем тратить время на объяснения — всё же и так хорошо работает.
Шапка разработчикаДля того, чтобы у тестировщика и разработчика получился диалог, я решила в рамках своей команды использовать несколько шагов, которые опишу ниже.
Шаг 1: проговаривать мотивацию
------------------------------
Мотивация QA-инженера — понять, что находится в основании пирамиды. Но для других членов команды это не очевидно. Поэтому нужно объяснить им, что вы хотите от unit-тестов и зачем.
**Что проговорить коллеге-разработчику:**
> Я хочу ***понимать***, что покрывают юнит тесты, чтобы правильно и ***не избыточно*** покрывать функциональность уровнями выше.
>
>
**Что проговорить команде:**
> Я трачу время на понимание, чтобы не тратить его на написание избыточных тестов.
>
>
Шаг 2: научиться читать код
---------------------------
Это важный навык для QA-инженера. Можно пройти курсы по языку программирования, который используют в команде. Кроме этого, нужно разбираться, что делает конкретный участок кода.
На курсах разработки задачи обычно сформулированы прозрачно и код решения кажется понятным. Но в реальных проектах всё сложнее. Обсудите с коллегой из разработки, что делает каждая функция и unit-тест для неё. Тогда станет понятнее, какие тесты можно улучшить с точки зрения бизнес-процесса.
Это самый долгий и сложный этап. Его результатом должен быть ответ на вопрос:
«**Что мы можем покрыть на unit-тестах?»**
Шаг 3: добавить обсуждение unit-тестов в процесс
------------------------------------------------
Тестировщик смотрит на функцию как на часть бизнес-процесса, а разработчик отвечает за внутреннюю логику её работы. На стыке этих задач появляются полезные unit-тесты. Поэтому обсуждать их лучше на этапе, когда создаётся функциональность или формулируется задача. Тогда QA-инженеру становится понятнее, что можно покрыть на уровне unit-тестов, а что нужно проверять на следующих этапах.
При тестировании иногда полезно «двигаться влево» — подключаться к разработке как можно раньшеНе важно, используете ли вы [TDD](https://habr.com/ru/company/ruvds/blog/450316/) или нет, важно, что вы поговорили об этом *до начала работы.*
Каких результатов добилась моя команда
--------------------------------------
Помните, что польза описанного мною подхода в каждом отдельном случае будет индивидуальной. Поэтому когда будете коммуницировать с разработчиком, посмотрите сами, что полезного в связи с этим получилось.
#### Увеличилось покрытие негативных сценариев
Разработчики в unit-тестах проверяют, что все функции работают корректно. Для этого нужен позитивный тест, который проанализирует несколько основных ветвлений. Такой подход хорошо покрывает код. Но остаются непроверенные кейсы — например, [логирование ошибок.](https://habr.com/ru/company/avito/blog/681752/)
До: 2 позитивных теста, 2 негативных теста, покрытие 73.3%.
После: 2 позитивных теста, 9 негативных тестов, покрытие 95.0%Вам не обязательно читать код в примере — достаточно видеть цветовую дифференциацию. Зелёным обозначен код, который был вызван тестами, красным — пропущенный.
При этом для QA-инженера важно узнать, что именно не работает. Поэтому нужно участвовать в код-ревью и менять unit-тесты, если требуется.
#### Увеличилось покрытие dataset
QA-инженер — это главный специалист по подбору значений для dataset, всё как в [анекдоте](https://pikabu.ru/story/testirovshchik_v_bare_3046939). Если мы тщательно подберем данные для тестов на этапе написания юнитов, то потратим меньше времени — нужно будет дописать всего пару строк. Для проверки тех же дополнительных значений на уровнях выше нам потребуется вложить больше ресурсов.
Данные для тестирования функции Filter\_Int#### Улучшилось нахождение сценариев для деградации
Чтобы понять, как найти сценарии деградации, возьмём гипотетические «Наш сервис» и «Другой сервис» — они взаимодействуют друг с другом и обмениваются данными. Причём «Другой сервис» — это фронт-слой, его видят пользователи. «Наш сервис» — промежуточный, он подключается к базе данных, ещё одному нашему сервису и соседнему. Затем собирает их ответы и передаёт на фронт-слой.
На схеме мы любую ошибку передаём выше в чистом виде с кодом 500В этой архитектуре самое логичное решение со стороны разработки — передавать ошибки на слой выше. Но с точки зрения QA можно доработать этот сценарий так, чтобы пользоваться продуктом стало удобнее. Например, посмотреть бизнес-процессы и определить, какая информация и от какого сервиса критически важна, а какую можно пропустить.
На этой схеме мы уже задеградировали два сценарияОт базы данных «Наш сервис» получает информацию, без которой невозможно продолжить пользовательский сценарий. Он передаёт «Другому сервису» ошибку. А данные от ещё одного нашего сервиса не так важны для сценария. «Наш сервис» возвращает «Другому сервису» пустой массив и идёт дальше. Это считается деградацией сценария.
**Пример из жизни Авито:**
> Когда создаётся объявление, на экране появляется аватарка пользователя, который его размещает. Если эта аватарка по какой-то причине не прогружается, нет смысла останавливать прорисовку экрана и передавать на фронт ошибку. Для пользовательского сценария полезнее продолжить работу без аватарки.
>
>
QA-инженер может заметить подобные сценарии на этапе unit-тестирования. Если в автотесте у разработчика функция возвращает ошибку и останавливается, стоит уточнить у него, почему так происходит. Возможно, с точки зрения бизнес-логики лучше обработать ошибку как-то иначе или деградировать сценарий.
### Как я отслеживаю unit-тесты у себя в команде
Кроме общения с разработчиками, QA-инженеру было бы хорошо посчитать общее число unit-тестов. В нашей компании есть готовое решение по выгрузке автотестов из кода в [тестохранилку](https://medium.com/avitotech/what-does-our-test-case-management-system-looks-like-8ab44acf7d52), где реализована тестовая модель с фичами, к которым крепятся автотесты. Подробнее про механизм выгрузки автотестов из кода в хранилище можно посмотреть в [докладе](https://www.youtube.com/watch?v=_Q3Tnw--vT0) моего коллеги.
Все unit-тесты в нашей команде отмечаются комментарием и tagID. В комментарии понятно и кратко описано, что именно проверяет этот тест, а tagID показывает, к какой фиче будет прикреплён тест.
Пример позитивного unit-теста для SomeFunc:
```
// tagID 4637 Параметры. Позитивный тест получения параметров
func Test_SomeFunc_Positive(t *testing.T) {
contrl := gomock.NewController (t)
defer ctrl.Finish ()
categoryID := map[string]interface{}{"first": 123}
composition := NewMockComposition(ctrl)
result, err := composition.GetRequestFormByParams(context.Background(), categoryID)
assert.Nil(t, err)
assert. Equal(t, expexted: 123, result)
}
```
Тесты выгружаются во внутреннее хранилище, которое автоматически считает их число. В нём учитываются unit-тесты, интеграционные, компонентные и UI-тесты. Здесь же можно посмотреть сгенерированную пирамиду тестирования: сколько проверок на каждом уровне у выбранной фичи и какое общее тестовое покрытие.
Зелёные блоки показывают процент покрытого автотестами кода, красные — непокрытого### Вывод
Мой подход к обсуждению помог повысить понимание unit-тестов, поэтому я советую QA-инженерам попробовать его в своей работе. Напомню, что нужно делать:
* Объяснять коллегам из разработки, почему для вас важно разбираться в unit-тестах.
* Учиться читать код и стараться понять, какой именно кейс покрыт.
* Заранее проговаривать, какую функциональность можно протестировать на уровне unit.
Я понимаю, что для большинства QA-инженеров сложно выделить достаточное количество времени для такой детальной проработки нижних уровней пирамиды тестирования. Но мне бы очень хотелось повысить общее понимание уровней unit-тестов для тестировщиков. Тогда мы сможем понять, что мы можем убрать из наших тяжеловесных прогонов e2e-тестов. Начните с беседы со своими коллегами, я верю, что вы найдете в них отклик и желание помочь.
*Предыдущая статья:* [*Как мы улучшили типографику на сайте Авито*](https://habr.com/ru/company/avito/blog/691262/) | https://habr.com/ru/post/692940/ | null | ru | null |
# Telegram-bot + Google Analytics
Приветствую хабравчане. Хочу рассказать о том, как мы прикручивали Google Analytics к телеграмм-боту, с какими столкнулись проблемами, и что в итоге пока не получилось настроить.
По старинке Google Analytics устанавливается на сайт с доменом или в приложение с SDK. Погуглив тему, стало понятно, что примеров нет, поэтому решили сделать сами. В нашем случае не было сайта или мобильного приложения, но было желание отслеживать события в Телеграм боте. И частично это получилось сделать.
#### Проблема №1
Боты физически находятся по адресу [t.me/benice\_tools\_bot](https://t.me/benice_tools_bot). Это похоже на обычный сайт, но без прямого доступа к корневым файлам, для установки кода счетчика, и настройки событий.
Фронтенд в этом случает является сам Телеграм, к которому у нас нет доступа.
Наш бот работает с API Binance и API Телеграма, и соответственно есть бекэнд, через который стало возможно маневрировать c настройками аналитики.
В Google Analytics создали счетчик «для сайта», и прописали события с параметрами “Action, Label, Category”. Подробные настройки описываются на десятках сайтов. И после этого появилась первая проблема.
Стандартными гугловскими методами не получалось разместить цели в боте, не было доступа к фронту.
На помощь [пришла библиотека](https://github.com/peaksandpies/universal-analytics), которая позволила передавать и обрабатывать с бекэнда параметры событий.
После настройки, начали тестировать работоспособность метода, и получили первый успех. Выполненные события стали отображаться в Google Analytics, в режиме “реального времени” было видно, сколько людей онлайн в боте, и остальные данные.
 
После самостоятельных тестов, и юзеров с рекламного трафика, стало понятно, что нужная нам информация достоверна на 100%. Стало видно сколько людей онлайн, и какие конкретно события выполняются.
Но некоторые ошибки все равно были. Например не правильно определялся тип устройства, отображался “Настольный компьютер”, даже если использовать Телеграм с мобильного устройства. Геоположение указывало только на Грецию, потому что сервер с ботом находился в этой стране. Демография, интересы, браузеры и ОС, отображались как "(not set)".
#### Проблема №2
Мы создавали промо-ссылки, которые при активации давали доступ к платным функциям на 7 дней. И переходы по этим ссылкам нужно было связать с Google Analytics, что бы анализировать рекламные кампании.
По умолчанию Google Analytics сам генерирует id пользователя или оставляет без этого параметра. Однако, можно самостоятельно создавать custom id, и отправлять это в Гугл.
Этим методом мы и воспользовались. Создали учет пользователей через зашифрованный userId нашей системы.
Телеграм передаёт мета-данные при старте бота. Это работает также, как и привычные utm метки.
В ссылку, для рекламной кампании, вставляется метка после start.
Например:
```
http://t.me/benice_tools_bot?start=habrahabr
```
При старте бота мы парсим параметры для старта, и принимаем их за конкретную кампанию.
На бэкенде, в профиле пользователя, будет информация о том, что он пришёл по конкретной кампании campaign\_habrahabr.
Оставалось конктретизировать нашего посетителя(visitor) в коде:
```
if (!code) code = "organic";
const visitor = ua(googleAnalyticsProjectId, `token:${code};CLIENTID:${saltUserId}`, { strictCidFormat: false });
visitor.event(category, action, label).send();
```
Если пользователь пришёл сам, без рекламной кампании, то этот источник распознается как «organic».
Таким образом, получилось анализировать срабатывание целей от конкретного пользователя, пришедшего с рекламной кампании.
#### P.S.
Все звонки в Google Analytics заканчивались недоумением со стороны поддержки. При первых звонках, когда ещё ничего не работало, никаких подсказок не удавалось получить. А когда события уже передавались в аналитикс, то поддержка брала 15 минутный перерыв “уточнить детали” вопроса, и возвратившись, сами начинали задавать вопросы: “Как вы это сделали?”. | https://habr.com/ru/post/442610/ | null | ru | null |
# Переход с AngularJS на Angular: проблемы и решения гибридного режима (2/3)
Переход в гибридном режиме — естественная процедура, хорошо подготовленная и описанная командой Angular. Тем не менее, на практике возникают сложности и затыки, которые приходится решать на лету. В сегодняшнем продолжении нашей статьи про миграцию на Angular мы расскажем про проблемы, с которыми столкнулась команда Skyeng, и поделимся своими решениями.
[Первая часть](https://habrahabr.ru/company/skyeng/blog/348356/), [третья часть](https://habrahabr.ru/company/skyeng/blog/348606/).
#### Динамическая компиляция из строки
В angularjs все очень просто:
```
const compiledContent = this.$compile(template)(scope);
this.$element.append(compiledContent);
```
А в Angular не совсем.
**Первое решение** — взять вариант из ангуляра, через JiT компилятор. Оно подразумевает, что в продакшен сборку, несмотря на AoT компиляцию статичных компонентов, всё равно тащится тяжёленький компилятор для сборки динамических шаблонов. Выглядит как-то так:
```
// в некотором модуле
import {NgModule, Compiler} from "@angular/core";
import {JitCompilerFactory} from "@angular/compiler";
export function compilerFactory() {
return new JitCompilerFactory([{ useDebug: false, useJit: true }]).createCompiler();
}
@NgModule({
providers: [
{ provide: Compiler, useFactory: compilerFactory },
...
],
declarations: [
DynamicTemplateComponent,
]
})
export class DynamicModule {
}
// компонент
import {
Component, Input, Injector, Compiler, ReflectiveInjector, ViewContainerRef,
NgModule, ModuleWithProviders, ComponentRef, OnInit, OnChanges, SimpleChanges,
} from "@angular/core";
import {COMPILER_PROVIDERS} from "@angular/compiler";
@Component({
selector: "vim-base-dynamic-template",
template: "",
})
export class DynamicTemplateComponent implements OnInit, OnChanges {
@Input() moduleImports?: ModuleWithProviders[];
@Input() template: string;
private componentRef: ComponentRef | null = null;
private dynamicCompiler: Compiler;
private dynamicInjector: Injector;
constructor(
private injector: Injector,
private viewContainerRef: ViewContainerRef,
) {
}
public ngOnInit() {
this.dynamicInjector = ReflectiveInjector.resolveAndCreate(COMPILER\_PROVIDERS, this.injector);
this.dynamicCompiler = this.injector.get(Compiler);
this.compileComponent(this.template, this.moduleImports);
}
public ngOnChanges(changes: SimpleChanges) {
if (this.dynamicCompiler && changes.template) {
this.compileComponent(this.template, this.moduleImports);
}
}
private compileComponent(template: string, imports: ModuleWithProviders[] = []): void {
if (this.componentRef) {
this.componentRef.destroy();
}
const component = Component({ template })(class {});
const module = NgModule({ imports, declarations: [ component ] })(class {});
this.dynamicCompiler.compileModuleAndAllComponentsAsync(module)
.then(factories => factories.componentFactories.filter(factory => factory.componentType === component)[0])
.then(componentFactory => {
this.componentRef = this.viewContainerRef.createComponent(
componentFactory,
null,
this.viewContainerRef.injector
);
});
}
}
```
И вроде бы всё относительно неплохо (толстый компилятор в бандле всё равно нивелируется горой других либ и кодом самого проекта, если это что-то большее, чем todo list), но тут конкретно мы въехали вот в такую проблему:
<https://github.com/angular/angular/issues/19902>
Шесть секунд на компиляцию одного из наших слайдов с упраженениями, пусть и довольно большого. При том, что три секунды идёт непонятный простой. Судя по ответу в issue, ситуация ближайшие месяцы не изменится, и нам пришлось искать другое решение.
Также оказалось, что мы не можем в этом случае задействовать уже скомпилированные при AoT сборке фабрики компонентов, используемых в слайдах, т.к. нет возможности заполнить кэш JiT компилятора. Такие компоненты по сути компилировались два раза — на бэкэнде при AoT сборке и в рантайме при компиляции первого слайда.
**Вторым решением** на скорую руку была сделана компиляция шаблонов через `$compile` из angularjs (у нас же всё ещё гибрид и ангуляржс):
```
class DynamicTemplateController {
static $inject = [
"$compile",
"$element",
"$scope",
];
public template: string;
private compiledScope: ng.IScope;
constructor(
private $compile: ng.ICompileService,
private $element: ng.IAugmentedJQuery,
private $scope: ng.IScope,
) {
}
public $onChanges() {
this.compileTemplate();
}
private compileTemplate(): void {
if (this.compiledScope) {
this.compiledScope.$destroy();
this.$element.empty();
}
this.compiledScope = this.$scope.$new(true);
this.$element.append(this.$compile(this.template)(this.compiledScope));
}
}
```
Компонент ангуляра использовал апгрейженную версию `DynamicTemplateComponent` из ангуляржса, который использовал `$compile` сервис для сборки шаблона, в котором все компоненты были даунгрейжены из ангуляра. Такая короткая прослойка angular -> angularjs ($compile) -> angular.
Этот вариант имеет немного проблем, например, невозможность инжекта компонентов через компонент-сборщик из ангуляржса, но главное — он не будет работать после окончания апгрейда и выпиливания ангуляржса.
Дополнительное гугление и задалбывание народа в gitter'е ангуляра привело к **третьему решению**: вариации на тему того, что используется непосредственно на офф сайте ангуляра для подобного кейса, а именно вставке шаблона напрямую в DOM и ручной инициализации всех известных компонентов поверх найденных тегов. [Код по ссылке](https://stackblitz.com/edit/angular-build-content?file=app%2Fbuild-content%2Fcomponent%2Fbuild-content%2Fbuild-content.ts).
Вставляем пришедший шаблон в DOM как есть, для каждого известного компонента (получаем по токену `CONTENT_COMPONENTS` в сервисе) ищем соответствующие DOM-ноды и инициализируем.
Из минусов:
* немного коряво проставляем инжекторы для корректной работы инжектов родителей;
* небольшой хак для поддержки content projection с select'ами (вытащили пару методов из `@angular/upgrade` модуля);
* инпуты только статичные и только строковые;
* полное доверие пришедшему хтмлу (вставляется без обработки, т.к. может содержать инлайн стили и всякое другое непотребство из нашей админки);
* некорректная последовательность инит хуков для родителей-детей (сначала `OnInit/AfterViewInit` родителей, только потом `OnInit/AfterViewInit` детей).
Но в целом мы имеем довольно шустрый способ инициализировать динамический шаблон, в основе своей решающий конкретно нашу задачу средствами ангуляра и без лагов, как с JiT компилятором.
Казалось бы, на этом можно остановиться, но для нас проблема до конца так и не решилась из-за того, как ангуляр работает с content projection. Нам необходимо содержимое некоторых компонентов (по типу спойлеров) инициализировать только при определённых условиях, что невозможно при использовании обычного `ng-content`, а `ng-template` мы не можем вставить из-за особенностей способа сборки контента. В дальнейшем будем искать более гибкое решение, возможно, заменим html-контент на JSON структуру, по которой обычными ангуляр-компонентами будем рендерить слайд с учётом динамического показа/скрытия части контента (потребует использования самописных компонентов вместо `ng-content`).
Кому-то может подойти **четвёртый вариант**, который станет официально доступен в виде беты с релизом angular 6 — `@angular/elements`. Это custom elements, реализованные через ангуляр. Регистрируем по некоторому тегу, любым способом вставляем этот тег в DOM, и на нём автоматически инициализируется полноценный ангуляр компонент со всем привычным функционалом. Из ограничений — взаимодействие с основным приложением только через события на таком элементе.
Информация по ним пока доступна только в виде нескольких выступлений с ng-конференций, статей по этим выступлениям и техническим демкам:
* <https://www.youtube.com/watch?v=vHI5C-9vH-E>
* <https://medium.com/vincent-ogloblinsky/export-angular-components-as-custom-elements-with-angular-elements-a2a0bfcd7f8a>
* <https://stackblitz.com/edit/ng-be-2017-demo-elements-hello-world-with-angular?file=regular-app%2Fmodule.ts>
Сайт ангуляра планирует сразу же, с первой версией `@angular/elements`, перейти на них вместо текущего способа сборки:
* <https://github.com/angular/angular/pull/21939>
* <https://github.com/angular/angular/pull/22028>
Change Detection
----------------
В гибриде есть несколько неприятных проблем с работой CD между ангуляром и ангуляржсом, а именно:
#### AngularJS в зоне Angular
Сразу после инициализации гибрида мы получим просадку по производительности из-за того, что angularjs код будет запускаться в зоне angular'а, и любые `setTimeout`/`setInterval` и другие асинхронные действия из кода angularjs и из используемых thirdparty библиотек будут дёргать тик CD angular'а, который дёрнет `$digest angularjs`. Т.е. если раньше мы могли не беспокоиться о лишних digest'ах от активности сторонних либ, т.к. angularjs требует явного пинания CD, то теперь он будет срабатывать на каждый чих.
Чинится пробраcыванием `NgZone` сервиса в angularjs (через даунгрейд) и оборачиавния инициализации сторонних либ или родных таймаутов в `ngZone.runOutsideAngular`. В будущем обещают возможность инициализировать гибрид так, чтобы CD ангуляра и ангуляржса не дёргали друг друга в принципе (ангуляржс будет работать вне зоны ангуляра), и для взаимодействия между разными кусками надо будет явно дёргать CD соответствующего фреймворка.
#### downgradeComponent и ChangeDetectionStrategy.OnPush
Даунгрейженные компоненты некорректно работают с `OnPush` — при изменении инпутов не дёргается CD на этом компоненте. [Код](https://stackblitz.com/edit/angular-hybrid-downgraded-onpush).
Если закомментировать `changeDetection: ChangeDetectionStrategy.OnPush,` в `angular.component`, то счётчик будет обновляться корректно
Из решений только убрать `OnPush` с компонента, пока он используется в шаблонах ангуляржс компонентов.
UI Router
---------
У нас изначально был ui-router, который работает с новым ангуляром и имеет кучку хаков для работы в гибридном режиме. С ним было немало возни по бутстрапу приложения и проблемам с protractor.
В итоге пришли к таким хакам инициализации:
```
import {NgModuleRef} from "@angular/core";
import {UpgradeModule} from "@angular/upgrade/static";
import {UrlService} from "@uirouter/core";
import {getUIRouter} from "@uirouter/angular-hybrid";
import {UrlRouterProvider} from "@uirouter/angularjs";
export function deferAndSyncUiRouter(angularjsModule: ng.IModule): void {
angularjsModule
.config([ "$urlServiceProvider", ($urlServiceProvider: UrlRouterProvider) => $urlServiceProvider.deferIntercept()])
// NOTE: uglyhack due to bug with protractor https://github.com/ui-router/angular-hybrid/issues/39
.run([ "$$angularInjector", $$angularInjector => {
const url: UrlService = getUIRouter($$angularInjector).urlService;
url.listen();
url.sync();
}]);
}
export function bootstrapWithUiRouter(platformRef: NgModuleRef, angularjsModule: ng.IModule): void {
const injector = platformRef.injector;
const upgradeModule = injector.get(UpgradeModule);
upgradeModule.bootstrap(document.body, [ angularjsModule.name ], { strictDi: true });
}
```
и в main.ts:
```
import angular from "angular";
import {platformBrowserDynamic} from "@angular/platform-browser-dynamic";
import {setAngularLib} from "@angular/upgrade/static";
import {AppMainOldModule} from "./app.module.main";
import {deferAndSyncUiRouter, bootstrapWithUiRouter} from "../bootstrap-with-ui-router";
import {AppMainModule} from "./app.module.main.new";
// NOTE: uglyhack https://github.com/angular/angular/issues/16484#issuecomment-298852692
setAngularLib(angular);
// TODO: remove after upgrade
deferAndSyncUiRouter(AppMainOldModule);
platformBrowserDynamic()
.bootstrapModule(AppMainModule)
// TODO: remove after upgrade
.then(platformRef => bootstrapWithUiRouter(platformRef, AppMainOldModule));
```
Встречаются неочевидные даже по официальной документации роутера места, например, использование angularjs-like инжектов для `OnEnter`/`OnExit` хуков в angular части роутинга:
```
testBaseOnEnter.$inject = [ "$transition$" ];
export function testBaseOnEnter(transition: Transition) {
const roomsService = transition.injector().get(RoomsService);
...
}
// test page
{
name: ROOMS\_TEST\_STATES.base,
url: "/test/{hash:[a-z]{8}}?tool&studentId",
...
onEnter: testBaseOnEnter,
},
```
Информацию об этом пришлось добывать через gitter канал ui-router'а, часть её уже внесли в документацию.
Protractor
----------
Через протрактор у нас работает куча e2e тестов. Из проблем в гибридном режиме столкнулись только с тем, что совсем отвалился метод `waitForAngular`. QA команда впиливала какие-то свои хаки, а также попросила нас реализовать meta-тег в хэдере со счётчиком активных апи запросов, чтобы на основе этого понимать, когда основная активность на странице прекратилась.
Счётчик делали через появившиеся в ng4 HttpClient Interсeptor'ы:
```
@Injectable()
export class PendingApiCallsCounterInterceptor implements HttpInterceptor {
constructor(
private pendingApiCallsCounterService: PendingApiCallsCounterService,
) {
}
public intercept(req: HttpRequest, next: HttpHandler): Observable> {
this.pendingApiCallsCounterService.increment();
return next.handle(req)
.finally(() => this.pendingApiCallsCounterService.decrement());
}
}
@Injectable()
export class PendingApiCallsCounterService {
private apiCallsCounter = 0;
private counterElement: HTMLMetaElement;
constructor() {
this.counterElement = document.createElement("meta");
this.counterElement.name = COUNTER\_ELEMENT\_NAME;
document.head.appendChild(this.counterElement);
this.updateCounter();
}
public decrement(): void {
this.apiCallsCounter -= 1;
this.updateCounter();
}
public increment(): void {
this.apiCallsCounter += 1;
this.updateCounter();
}
private updateCounter(): void {
this.counterElement.setAttribute("content", this.apiCallsCounter.toString());
}
}
@NgModule({
providers: [
{ provide: HTTP\_INTERCEPTORS, useClass: PendingApiCallsCounterInterceptor, multi: true },
PendingApiCallsCounterService,
]
})
export class AppModule {
}
```
В [окончании этой истории](https://habrahabr.ru/company/skyeng/blog/348606/) мы делимся новыми конвенциями, которые помогают команде привыкнуть к работе в Angular. | https://habr.com/ru/post/348512/ | null | ru | null |
# Разработка приложения живого поиска по Twitter с помощью Knockout, jQuery и ASP.NET MVC 3
Достаточно не тривиально разработать хорошо спроектированный front-end веб-приложения с уровнем отклика, производительностью и фичами, которые ожидают пользователи сегодня. Легко потеряться в кипящей смеси jQuery обработчиков событий, HTML разметки и AJAX вызовов и даже относительно простой GUI быстро может стать кошмаром для сопровождения.
Один из способов добавления некоторой структуры и порядка на клиентской стороне – использование фреймворка вроде Knockout. Knockout – это свободная Javascript библиотека с открытым исходным кодом, которая помогает реализовать [Model-View-View Model (MVVM) паттерн](http://ru.wikipedia.org/wiki/Model-View-ViewModel) на клиенте. Она хорошо [документирована](http://knockoutjs.com/documentation/introduction.html) и официальный веб сайт великолепная точка старта с кучей [реальных примеров](http://knockoutjs.com/examples/), которые не только демонстрируют использование встроенных фич библиотеки, но и показывают, как расширить её свои собственными фичами.
В этом посте мы рассмотрим, как Knockout может быть использован совместно с плагином отображения, каким-нибудь jQuery и ASP.NET MVC 3 backend (или модель, как вам нравится) для построения простого, но эффективного приложения для живого поиска в Twitter.
#### Цель
Наша цель проста: пользователю следует иметь возможность ввода некоторых поисковых критериев (вроде hashtag или имени пользователя Twitter), после этого приложению следует представить соответствующие самые актуальные твиты. Также, множество результатов следует автоматически обновлять в некой фоновой процедуре на клиенте так, чтобы GUI всегда показывал самые последние найденные твиты. (Это может быть полезным, например, при отслеживании некоторого события, которое происходит здесь и сейчас.) В конечном итоге, мы хотели бы получить что-то похожее на это:
#### Шаг 1: Определение модели
Twitter представляет [поисковый API](http://search.twitter.com/api/), который достаточно прост для использования и который может возвращать ответ на поисковые запросы в XML (Atom) или JSON формате. Мы могли бы позволить нашему клиенту напрямую общаться с Twitter API, но это лишило бы нас возможности улучшить приложение через добавление кеширования, какой-нибудь заглушки на случай падения Twitter и т.д.; поэтому хорошей идей было бы создать вместо этого нашу собственную модель, и для этого мы собираемся использовать очень простое ASP.NET MVC 3 приложение.
Во-первых, создайте стандартное пустое веб-приложение (с Razor в качестве движка отображения) и добавьте контроллер – давайте назовём его **TwitterController**. Затем переименуйте “Index” действие, которое автоматически создалось вместе с новым контроллером, в “Search”. Контроллер будет выглядеть как-то так:
> `public class TwitterController : Controller
>
> {
>
> [HttpGet]
>
> public ActionResult Search()
>
> {
>
> return View();
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее, мы собираемся создать метод действия, который выполняет актуальный поиск в Twitter. Для этой задачи, мы будем использовать Atom версию поискового API. URL запроса соответствует следующему формату **[search.twitter.com/search.atom?q=](http://search.twitter.com/search.atom?q=)[URL-encoded search parameters]**. Т.к. Atom – это XML, мы можем использовать LINQ to XML для того, чтобы распарсить и преобразовать множество результатов (Twitter [возвращает массу данных](http://search.twitter.com/search.atom?q=knockoutjs), которые нам будут не нужны, так что мы их сократим до минимума).
Но у нас нет желания посылать XML на клиент – лучше JSON. К счастью, легко конвертировать большинство объектов в JSON, и в данном случае простейший путь – это использовать встроенный Json метод, который возвращает JsonResult. Всё сводится к:
> `[HttpPost]
>
> public ActionResult Search(string query)
>
> {
>
> var atomResult = XDocument.Load(string.Format(
>
> "http://search.twitter.com/search.atom?q={0}",
>
> HttpUtility.UrlEncode(query)));
>
> XNamespace ns = "http://www.w3.org/2005/Atom";
>
> var searchResult =
>
> from tweet in atomResult.Descendants(ns + "entry")
>
> let image = tweet.Elements(ns + "link")
>
> .Where(e => e.Attributes()
>
> .Any(a => a.Name == "rel" &&
>
> a.Value == "image"))
>
> .First().Attribute("href").Value
>
> let url = tweet.Elements(ns + "link")
>
> .Where(e => e.Attributes()
>
> .Any(a => a.Name == "rel" &&
>
> a.Value == "alternate"))
>
> .First().Attribute("href").Value
>
> select new
>
> {
>
> id = tweet.Element(ns + "id").Value,
>
> author = tweet.Element(ns + "author").Element(ns + "name").Value,
>
> imageUrl = image,
>
> tweetUrl = url,
>
> tweetText = tweet.Element(ns + "title").Value
>
> };
>
> return Json(searchResult);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
(Код выше включает процедуру парсинга для выделения аватара в профиле автора и ссылки на каждый отдельный твит.)
На этом всё – мы построили нашу модель!
#### Шаг 2: Реализация модели вида
До того, как мы начнём разрабатывать GUI, нам будет нужно добавить некоторые ссылки в наше решение. Либо через [NuGet](http://nuget.org/), либо вручную загрузив jQuery, Knockout и jQuery.tmpl. Затем добавьте “Search.cshtml” вид в Views/Twitter (не используйте “master page” или layout – легче получить представление о сути в небольшой задаче, похожую на нашу, если мы не будем размазывать решение по множеству отдельных файлов). Добавьте упомянутые Javascript ссылки. Когда вы это сделаете, у вас будет что-то похожее на это:
> `DOCTYPE html>
>
> <html>
>
> <head>
>
> <meta charset="utf-8" />
>
> <title>Twitter Live Searchtitle>
>
> <script src="@Url.Content("~/Scripts/jquery-1.6.2.js")"
>
> type="text/javascript">script>
>
> "@Url.Content("</font>~/Scripts/jquery.tmpl.min.js<font color="#A31515">")"</font><br/>
> type=<font color="#A31515">"text/javascript"</font>>
>
> "@Url.Content("</font>~/Scripts/knockout-1.2.1.js<font color="#A31515">")"</font><br/>
> type=<font color="#A31515">"text/javascript"</font>><font color="#0000ff"></</font><font color="#800000">script</font><font color="#0000ff">></font><br/>
> <font color="#0000ff"></</font><font color="#800000">head</font><font color="#0000ff">></font><br/>
> <font color="#0000ff"><</font><font color="#800000">body</font><font color="#0000ff">></font><br/>
> <font><!-- TODO --></font><br/>
> <font color="#0000ff"></</font><font color="#800000">body</font><font color="#0000ff">></font><br/>
> <font color="#0000ff"></</font><font color="#800000">html</font><font color="#0000ff">></font></font><br/>
> <br/>
> <font color="gray">\* This source code was highlighted with <font color="gray">Source Code Highlighter</font>.</font></code></blockquote><br/>
> Настало время построить нашу модель вида. Модель вида включает логику приложения на клиентской стороне или, если вам нравится, она определяет что приложение может делать и какие свойства имеет, без непосредственной привязки к любому элементу разметки или DOM элементам.<br/>
> <br/>
> Для этой задачи модель вида чрезвычайно проста: содержит 2 свойства, используемые для хранения текущего поискового запроса и найденных твитов, и соответственно метод для выполнения поиска по модели. Это может выглядеть так: <br/>
> <blockquote><code><a href="http://virtser.net/blog/post/source-code-highlighter.aspx"></a><font color="black"><script type=<font color="#A31515">"text/javascript"</font>><br/>
> <font color="#0000ff">function</font> SearchViewModel() {<br/>
> <font color="#0000ff">this</font>.query = ko.observable(<font color="#A31515">''</font>);<br/>
> <font color="#0000ff">this</font>.tweets = ko.observableArray();<br/>
> }<br/>
> <br/>
> SearchViewModel.prototype.search = <font color="#0000ff">function</font> () {<br/>
> <font color="#0000ff">var</font> q = <font color="#0000ff">this</font>.query();<br/>
> <font color="#0000ff">if</font> (q.length > 0) {<br/>
> $.ajax({<br/>
> type: <font color="#A31515">'POST'</font>,<br/>
> url: <font color="#A31515">'/Twitter/Search'</font>,<br/>
> data: { query: q },<br/>
> dataType: <font color="#A31515">'json'</font>,<br/>
> success: <font color="#0000ff">function</font> (data) {<br/>
> <font color="#008000">// TODO</font><br/>
> }.bind(<font color="#0000ff">this</font>)<br/>
> });<br/>
> } <font color="#0000ff">else</font> {<br/>
> <font color="#008000">// TODO</font><br/>
> }<br/>
> };<br/>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Трудно сказать, что здесь есть что-то значимое; свойства запроса и твитов изначально пусты, поисковый метод использует jQuery для того, чтобы отправить AJAX запрос к нашей модели на сервере и вернуть результаты в виде JSON объекта (массива твитов).
Как нам следует реализовать “успешный” обработчик в методе поиска? Мы можем очистить массив твитов и добавить новые результаты поиска. Но помните, что мы хотим постоянно получать “обновления” для наших поисковых результатов, в идеале мы хотели бы просто добавлять новые твиты (и удалять старые), не заменяя коллекцию целиком.
Это великолепная возможность попробовать [Mapping плагин для Knockout](http://knockoutjs.com/documentation/plugins-mapping.html). После того, как мы его загрузили и добавили ссылку на скрипт, мы можем реализовать успешный обработчик AJAX запроса:
> `success: function (data) {
>
> ko.mapping.updateFromJS(this.tweets, data);
>
> }.bind(this)
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И затем задать “[key definition](http://knockoutjs.com/documentation/plugins-mapping.html#uniquely_identifying_objects_using_keys)” для коллекции твитов (который используется отображением для того, чтобы определить какие элементы следует добавить, обновить или удалить), мы просто немного перепишем наш конструктор:
> `function SearchViewModel() {
>
> this.query = ko.observable('');
>
> this.tweets = ko.mapping.fromJS(
>
> [],
>
> {
>
> key: function (tweet) { return ko.utils.unwrapObservable(tweet.id) }
>
> });
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Заметьте, что мы определяем ключ для коллекции твитов как значение ID, которое Twitter также удобно предоставляет. Если вам нужно больше информации о Mapping плагине, посетите официальный сайт Knockout.
Следующее: реализация фичи авто-обновления. Каждый раз, когда есть поисковый запрос, соответствующие твиты должны обновляться, скажем, каждые 3 секунды для отражения изменений в модели. Один из способов достичь этого – завести успешный calback для поискового AJAX запроса вызывающего рекурсивно, но задержкой, метод поиска. **Полная модель вида** в этом случае выглядит так:
> `"text/javascript"</font>><br/>
> <font color="#0000ff">function</font> SearchViewModel() {<br/>
> <font color="#0000ff">this</font>.query = ko.observable(<font color="#A31515">''</font>);<br/>
> <font color="#0000ff">this</font>.tweets = ko.mapping.fromJS(<br/>
> [],<br/>
> {<br/>
> key: <font color="#0000ff">function</font> (tweet) { <font color="#0000ff">return</font> ko.utils.unwrapObservable(tweet.id) }<br/>
> });<br/>
> <font color="#0000ff">this</font>.autoRefreshId = <font color="#0000ff">null</font>;<br/>
> }<br/>
> <br/>
> SearchViewModel.prototype.search = <font color="#0000ff">function</font> () {<br/>
> <font color="#0000ff">var</font> timeoutId = <font color="#0000ff">this</font>.autoRefreshId;<br/>
> <font color="#0000ff">if</font> (timeoutId) {<br/>
> window.clearTimeout(timeoutId);<br/>
> <font color="#0000ff">this</font>.autoRefreshId = <font color="#0000ff">null</font>;<br/>
> }<br/>
> <font color="#0000ff">var</font> q = <font color="#0000ff">this</font>.query();<br/>
> <font color="#0000ff">if</font> (q.length > 0) {<br/>
> $.ajax({<br/>
> type: <font color="#A31515">'POST'</font>,<br/>
> url: <font color="#A31515">'/Twitter/Search'</font>,<br/>
> data: { query: q },<br/>
> dataType: <font color="#A31515">'json'</font>,<br/>
> success: <font color="#0000ff">function</font> (data) {<br/>
> ko.mapping.updateFromJS(<font color="#0000ff">this</font>.tweets, data);<br/>
> <font color="#0000ff">this</font>.autoRefreshId = window.setTimeout(<br/>
> <font color="#0000ff">this</font>.search.bind(<font color="#0000ff">this</font>), 3000);<br/>
> }.bind(<font color="#0000ff">this</font>)<br/>
> });<br/>
> } <font color="#0000ff">else</font> {<br/>
> ko.mapping.updateFromJS(<font color="#0000ff">this</font>.tweets, []);<br/>
> }<br/>
> };<br/>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
(Я добавил пару строк для отключения авто-обновления, когда строка ввода поискового запроса пуста; плюс проверка, которая прерывает любой работающий поиск, когда пользователь начинает новый. Также, поисковые результаты обнуляются, если выполнить поиск по пустому запросу.)
#### Шаг 3: Дизайн вида
Для того чтобы сохранить вещи простыми и очевидными, вид будет состоять только из строки ввода поискового запроса и списка твитов. Мы хотим достигнуть чего-то в этом духе:
> `<form>
>
> <input type="search" placeholder="Input #hashtag, @@username or something else" autofocus />
>
> <input type="submit" value="Search" />
>
> form>
>
>
>
> <ul id="tweets">
>
> <li>
>
> <a href="[url-of-tweet]" title="[author-name]">
>
> <img src="[url-of-author-image]" alt="[author-name]" />
>
> a>
>
> <h6>[author-name]h6>
>
> <p>[tweet-text]p>
>
> li>
>
>
>
> ul>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Давайте также добавим немного декларативных Knockout привязок данных, которые свяжут вид и модель вида. Если мы немного модифицируем **поисковую форму**…
> `<form data-bind="submit: search">
>
> <input type="search" data-bind="value: query, valueUpdate: 'afterkeydown'" placeholder="Input #hashtag, @@username or something else" autofocus />
>
> <input type="submit" value="Search" />
>
> form>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
…Knockout будет обновлять свойство запроса модели вида автоматически, когда пользователь изменит текст в поле поискового запроса, и поиск будет выполнен, как только пользователь нажмёт клавишу Enter.
Что насчёт **поисковых результатов**? Превосходный сценарий для использования Knockout [привязки шаблонов](http://knockoutjs.com/documentation/template-binding.html)! Во-первых, создайте шаблон для каждого твита:
> `<script id="tweetTemplate" type="text/html">
>
> - "attr: { id: id }"
> >
>
> "attr: { href: tweetUrl, title: author }">
>
> ![]()"attr: { src: imageUrl, alt: author }" />
>
> ###### "text: author">
>
>
>
> "text: tweetText">
>
>
>
>
>
> script>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Затем data-bind свойство HTML списка твитов в модели вида, задавая ваш шаблон как способ для отображения каждого из них. Относительно легко:
> `<ul id="tweets"
>
> data-bind="template: {
>
> name: 'tweetTemplate',
>
> foreach: tweets
>
> }, visible: tweets().length > 0">
>
> ul>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
(Заметьте, что список не будет видимым, если модель вида не содержит твитов)
**Бонус:** Добавьте анимацию, которая используется, когда новые твиты добавляются в список, используя afterAdd опцию привязки шаблона:
> `<ul id="tweets"
>
> data-bind="template: {
>
> name: 'tweetTemplate',
>
> foreach: tweets,
>
> afterAdd: function (element) {
>
> $(element).hide().fadeIn('fast');
>
> }
>
> }, visible: tweets().length > 0">
>
> ul>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
К этому моменту осталось доделать только одну вещь – логику начальной загрузки. Когда DOM загрузился, нам нужно создать экземпляр нашей модели вида и попросить Knockout присоединить наши привязки к ней. Одна строка кода в jQuery обработчике события “document ready”:
> `"text/javascript"</font>><br/>
> $(<font color="#0000ff">function</font> () {<br/>
> ko.applyBindings(<font color="#0000ff">new</font> SearchViewModel());<br/>
> });<br/>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**И сделано!** Проверено на моей Windows 7 машине в Chrome 12, Internet Explorer 9 и Firefox 5. Здесь законченное решение (где я добавил немного CSS для того чтобы это выглядело менее ужасно): [**TwitterLiveSearchLab.zip**](http://blog.jayway.com/wordpress/wp-content/uploads/2011/07/TwitterLiveSearchLab1.zip) | https://habr.com/ru/post/123692/ | null | ru | null |
# Быстрая десериализация действительно больших JSON-ответов
 Под катом находится небольшое, но полезное описание того, как быстро и просто превратить пришедший JSON-ответ в набор объектов. Никакого ручного парсинга. А если вы сталкивались с OutOfMemory проблемой на старых смартфонах – и для этого есть решение, поддерживающее Android 2.X версий.
Кроме того, под катом будет ссылка на репозиторий на гитхабе с примером кода. А вот картинок не будет, зато найдётся место для небольшой таблички.
Итак, на текущем проекте у меня возникла необходимость парсить ответ сервиса, состоящий из пачки вложенных друг в друга объектов, внутри которых могли быть объекты, внутри которых… Данные были в формате JSON, кроме того, было использовано gzip-сжатие сервером, всё-таки разница в размере переданных данных была значительна (4 мегабайте против 300 килобайт в сжатом виде – для мобильной связи это не шутка).
Как человеку ленивому, парсить руками каждое поле и объект мне было совсем не с руки… Таким образом, была задействована библиотека Gson, судя по тестом – быстрейший десериализатор из формата JSON. Ну а теперь, приступим, и начнём сразу с кода. Для простоты весь вывод ведём в консоль, что бы не думать о вьюшках и прочем.
Вот так выглядят объекты, которые прилетают нам из сети:
```
public class HumorItem {
public String text;
public String url;
}
public class HumorItems {
List Items; //тут может быть больше списков, и не только списки, для примера упростим.
}
```
А вот так – код, который его скачивает и десериализует.
**Первый вариант кода**
```
public class LoadData extends AsyncTask {
String \_url="";
public LoadData(String url){
\_url=url;
}
@Override
protected Void doInBackground(Void... voids) {
try {
//скачивание данных
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(\_url);
HttpResponse response = httpclient.execute(httppost);
HttpEntity httpEntity=response.getEntity();
InputStream stream = AndroidHttpClient.getUngzippedContent(httpEntity); //для скачивания gzip-нутых данных
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(stream));
StringBuilder responseBuilder= new StringBuilder();
char[] buff = new char[1024\*512];
int read;
while((read = bufferedReader.read(buff)) != -1) {
responseBuilder.append(buff, 0, read) ;
Log.d("скачано " + PrepareSize(responseBuilder.length()));
}
//парсинг полученных данных
HumorItems list= Gson.fromJson(responseBuilder.toString(),HumorItems.class);
//тестовый вывод
for (HumorItem message:list.Items){
Log.d("Текст: "+message.text);
Log.d("Ссылка: "+message.url);
Log.d("-------------------");
}
Log.d("ВСЕГО СКАЧАНО "+list.Items.size());
} catch (IOException e) {
e.printStackTrace();
Log.e("ошибка "+e.getMessage());
}
return null;
}
}
```
**Обёртка вокруг Log и метод для оформления размера файла**
```
public class Log {
public static final String TAG="hhh";
public static void d(String text){
android.util.Log.d(TAG,text);
}
public static void e(String text){
android.util.Log.e(TAG,text);
}
}
public String PrepareSize(long size){
if (size<1024){
return size+" б.";
}else
{
return size/1024+" кб.";
}
}
```
И это решение отлично работало! До поры до времени. Ответ для одной из комбинации параметров весил порядка 8 мегабайт. При тестировании на части телефонов – программа падала, где на пятом скачанном мегабайте, где на третьем.
Гугл подсказал сначала простое решение — выставить largeHeap в фале AndroidManifest.
Этот параметр позволяет приложению выделить под себя больше оперативной памяти. Вариант конечно ленивый и простой, но телефонами на Android ниже 3й версии не поддерживается. Да и в целом подход какой-то пораженческий – “зачем оптимизировать, если можно купить ещё железа?”
Далее, после нескольких попыток был выбран такой, простой вариант:
* Не наполняем файлом переменную, нет – скачиваем данные непосредственно на флешку (ну или внутреннюю память, что под руку подвернётся).
* Натравливаем Gson на этот файл. Проблема в парсинге и занимаемой файлом памяти не возникает.
Сказано-сделано:
**Второй вариант кода - с временным файлом**
```
public class LoadBigDataTmpFile extends AsyncTask {
String \_url="";
File cache\_dir;
public LoadBigDataTmpFile(String url){
\_url=url;
cache\_dir = getExternalCacheDir();
}
@Override
protected Void doInBackground(Void... voids) {
try {
//скачивание данных
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(\_url);
HttpResponse response = httpclient.execute(httppost);
HttpEntity httpEntity=response.getEntity();
InputStream stream = AndroidHttpClient.getUngzippedContent(httpEntity);
//нечто новое - открываем временный файл для записи
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(stream));
File file = new File(cache\_dir, "temp\_json\_new.json");
if (file.exists()){ //если таковой уже есть - удаляем и создаём новый
file.delete();
}
file.createNewFile();
FileOutputStream fileOutputStream=new FileOutputStream(file,true);
BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(fileOutputStream));
char[] buff = new char[1024\*1024];
int read;
long FullSize=0;
while((read = bufferedReader.read(buff)) != -1) {
bufferedWriter.write(buff,0,read); //запись в файл
FullSize+=read;
Log.d("скачано " + PrepareSize(FullSize));
}
bufferedWriter.flush();
fileOutputStream.close();
//парсинг из файла
Log.d("начали парсинг...");
FileInputStream fileInputStream=new FileInputStream(file);
InputStreamReader reader = new InputStreamReader(fileInputStream);
HumorItems list= Gson.fromJson(reader,HumorItems.class);
Log.d("закончили парсинг.");
/тестовый вывод
for (HumorItem message:list.Items){
Log.d("Текст: "+message.text);
Log.d("Ссылка: "+message.url);
Log.d("-------------------");
}
Log.d("ВСЕГО СКАЧАНО "+list.Items.size());
} catch (IOException e) {
e.printStackTrace();
Log.e("ошибка "+e.getMessage());
}
return null;
}
}
```
Вот и всего-то. Код проверен в боевых условиях, работает стабильно на ура. Впрочем, можно сделать ещё проще и обойтись без временного файла.
**Третий вариант кода - без временного файла**
```
public class LoadBigData extends AsyncTask {
String \_url="";
public LoadBigData(String url){
\_url=url;
}
@Override
protected Void doInBackground(Void... voids) {
try {
//скачивание данных
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(\_url);
HttpResponse response = httpclient.execute(httppost);
HttpEntity httpEntity=response.getEntity();
InputStream stream = AndroidHttpClient.getUngzippedContent(httpEntity);
//открывам потом на чтение данных
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(stream));
//и сразу направляем его в десериализатор
InputStreamReader reader = new InputStreamReader(stream);
HumorItems list= Gson.fromJson(reader,HumorItems.class);
//тестовый вывод
for (HumorItem message:list.Items){
Log.d("Текст: "+message.text);
Log.d("Ссылка: "+message.url);
Log.d("-------------------");
}
Log.d("ВСЕГО СКАЧАНО "+list.Items.size());
} catch (IOException e) {
e.printStackTrace();
Log.e("ошибка "+e.getMessage());
}
return null;
}
}
```
Минус – не удастся контролировать процесс скачивания (прервать его адекватным способом), а так же – неизвестно, сколько уже скачано данных. Красивый прогресс-бар не нарисуешь.
Есть ещё один вариант, [приведённый в документации](https://sites.google.com/site/gson/streaming), позволяющий последовательно вытаскивать объекты и тут же их обрабатывать, но с ним проблематично работать, если у вас объект разных массивов объектов, а не просто массив однотипных. Впрочем, если у вас есть красивое решение – с удовольствием увижу его в комментариях, и обязательно включу в статью в update’е!
В качестве бонуса – немного статистики.
| | | | |
| --- | --- | --- | --- |
| Размер файла | Число объектов внутри | Время десериализации на эмуляторе | Время десериализации на Highscreen Boost |
| 5.79 МБ | 4000 | 35 секунд | 2 секунды |
| 13.3 МБ | 9000 | 1 минута 11 секунд | 5 секунд |
Пример использования – [на гитхабе](https://github.com/Newbilius/big_json_import_demo), тестовые файлы там же.
[Ссылка на библиотеку Gson](http://code.google.com/p/google-gson/).
Если кому будет интересна тема разработки под андроид, то впереди как минимум посты о push-нотификациях (серверная и клиентская сторона – на хабре были статьи на эту тему, но они все несколько устарели), о работе с базой и иные на тему разработки под Android.
**Update.** [На гитхабе показали](https://github.com/Newbilius/big_json_import_demo/issues/1) решение проблемы «Минус – не удастся контролировать процесс скачивания (прервать его адекватным способом), а так же – неизвестно, сколько уже скачано данных. Красивый прогресс-бар не нарисуешь.». Подробности — в последнем коммите в репозитории. | https://habr.com/ru/post/200898/ | null | ru | null |
# STM32F3xx + FreeRTOS. Modbus RTU с аппаратным RS485 и CRC без таймеров и семафоров
Всем привет! Относительно недавно, закончив ВУЗ, я попал в небольшую компанию, которая занималась разработкой электроники. Одна из первых задач с которой я столкнулся — необходимость в реализации Modbus RTU Slave протокола с использованием STM32. С грехом пополам я её тогда написал, однако этот протокол начал встречаться мне из проекта в проект и я решил зарефакторить и оптимизировать либу с использованием FreeRTOS.
Введение
---------
В текущих проектах я часто использую связку STM32F3xx + FreeRTOS, поэтому решил максимально использовать аппаратные возможности данного контроллера. В частности:
* Прием/отправку с использованием DMA
* Возможность аппаратного расчета CRC
* Возможность аппаратной поддержки RS485
* Определение конца посылки через аппаратные возможности USART, без использования таймера
Сразу оговорюсь, тут я не описываю спецификацию протокла Modbus и как с ним работает мастер, об этом можно почитать [тут](https://www.modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf) и [тут](https://habr.com/ru/post/281430/).
### Файл конфигурации
Для начала, я решил немного упростить задачу переноса кода между проектами, хотя бы в рамках одного семейства контроллеров. Поэтому я решил написать небольщой conf.h файл, который позволит быстренько переконфигурировать основные части реализации.
**ModbusRTU\_conf.h**
```
#ifndef MODBUSRTU_CONF_H_INCLUDED
#define MODBUSRTU_CONF_H_INCLUDED
#include "stm32f30x.h"
extern uint32_t SystemCoreClock;
/*Registers number in Modbus RTU address space*/
#define MB_REGS_NUM 4096
/*Slave address*/
#define MB_SLAVE_ADDRESS 0x01
/*Hardware defines*/
#define MB_USART_BAUDRATE 115200
#define MB_USART_RCC_HZ 64000000
#define MB_USART USART1
#define MB_USART_RCC RCC->APB2ENR
#define MB_USART_RCC_BIT RCC_APB2ENR_USART1EN
#define MB_USART_IRQn USART1_IRQn
#define MB_USART_IRQ_HANDLER USART1_IRQHandler
#define MB_USART_RX_RCC RCC->AHBENR
#define MB_USART_RX_RCC_BIT RCC_AHBENR_GPIOAEN
#define MB_USART_RX_PORT GPIOA
#define MB_USART_RX_PIN 10
#define MB_USART_RX_ALT_NUM 7
#define MB_USART_TX_RCC RCC->AHBENR
#define MB_USART_TX_RCC_BIT RCC_AHBENR_GPIOAEN
#define MB_USART_TX_PORT GPIOA
#define MB_USART_TX_PIN 9
#define MB_USART_TX_ALT_NUM 7
#define MB_DMA DMA1
#define MB_DMA_RCC RCC->AHBENR
#define MB_DMA_RCC_BIT RCC_AHBENR_DMA1EN
#define MB_DMA_RX_CH_NUM 5
#define MB_DMA_RX_CH DMA1_Channel5
#define MB_DMA_RX_IRQn DMA1_Channel5_IRQn
#define MB_DMA_RX_IRQ_HANDLER DMA1_Channel5_IRQHandler
#define MB_DMA_TX_CH_NUM 4
#define MB_DMA_TX_CH DMA1_Channel4
#define MB_DMA_TX_IRQn DMA1_Channel4_IRQn
#define MB_DMA_TX_IRQ_HANDLER DMA1_Channel4_IRQHandler
/*Hardware RS485 support
1 - enabled
other - disabled
*/
#define MB_RS485_SUPPORT 0
#if(MB_RS485_SUPPORT == 1)
#define MB_USART_DE_RCC RCC->AHBENR
#define MB_USART_DE_RCC_BIT RCC_AHBENR_GPIOAEN
#define MB_USART_DE_PORT GPIOA
#define MB_USART_DE_PIN 12
#define MB_USART_DE_ALT_NUM 7
#endif
/*Hardware CRC enable
1 - enabled
other - disabled
*/
#define MB_HARDWARE_CRC 1
#endif /* MODBUSRTU_CONF_H_INCLUDED */
```
Наиболее часто, на мой взгляд, меняются следующие вещи:
* Адрес устройства и размер адресного простарнства
* Частота тактирования и параметры пинов USART(pin, port, rcc, irq)
* Параметры каналов DMA(rcc, irq)
* Включение/отключение аппаратного CRC и RS485
### Конфигурация железа
В данной реализации я использую обычный CMSIS, не из-за религиозных убеждений, просто мне так проще и меньше зависимостей. Настройку портов я описывать не буду, это можно посмотреть по ссылке на гитхаб которая будет внизу.
Начнем с настройки USART:
**USART configure**
```
/*Configure USART*/
/*CR1:
-Transmitter/Receiver enable;
-Receive timeout interrupt enable*/
MB_USART->CR1 = 0;
MB_USART->CR1 |= (USART_CR1_TE | USART_CR1_RE | USART_CR1_RTOIE);
/*CR2:
-Receive timeout - enable
*/
MB_USART->CR2 = 0;
/*CR3:
-DMA receive enable
-DMA transmit enable
*/
MB_USART->CR3 = 0;
MB_USART->CR3 |= (USART_CR3_DMAR | USART_CR3_DMAT);
#if (MB_RS485_SUPPORT == 1)
/*Cnfigure RS485*/
MB_USART->CR1 |= USART_CR1_DEAT | USART_CR1_DEDT;
MB_USART->CR3 |= USART_CR3_DEM;
#endif
/*Set Receive timeout*/
//If baudrate is grater than 19200 - timeout is 1.75 ms
if(MB_USART_BAUDRATE >= 19200)
MB_USART->RTOR = 0.00175 * MB_USART_BAUDRATE + 1;
else
MB_USART->RTOR = 35;
/*Set USART baudrate*/
/*Set USART baudrate*/
uint16_t baudrate = MB_USART_RCC_HZ / MB_USART_BAUDRATE;
MB_USART->BRR = baudrate;
/*Enable interrupt vector for USART1*/
NVIC_SetPriority(MB_USART_IRQn, configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY);
NVIC_EnableIRQ(MB_USART_IRQn);
/*Enable USART*/
MB_USART->CR1 |= USART_CR1_UE;
```
Тут есть несколько моментов:
1. В семействе F3, как и во многих других например F0, присутствует функция настраиваемого таймаута при тишине на линии, данный таймер отсчитывает от последнего принятого стоп-бита и обнуляется если был принят следующий фрейм. Прерывание по таймауту мы и будем использовать для определения конца посылки. Кстати, в F1 серии такой функции не было, поэтому приходилось использовать аппаратный таймер. Включаются прерывания битом *USART\_CR1\_RTOIE* в регистре *СR1*. Важно отметить, что не все USART на борту могут иметь эту функцию, так что внимательней читайте RM!
2. Таймаут настраивается через регистр *RTOR*. В него заносится значение таймаута в битах, то есть длина 3.5 символа, которая означает конец посылки соответствует значению 35 (1 символ — 8 бит + 1 старт бит + 1 стоп бит). Для скоростей больше 19200 бод/с позволяется использовать интервал 1.75 мс, который тоже можно выразить в длинах символов:
```
MB_USART->RTOR = 0.00175 * MB_USART_BAUDRATE + 1;
```
3. Мы будем использовать прерывание по таймауту для определения конца посылки и пробуждения таска OC, поэтому приоритет прерывания нужно указывать минимум как *configLIBRARY\_MAX\_SYSCALL\_INTERRUPT\_PRIORITY* или выше, так как в этом прерывании используется функция FreeRTOS типа **FromISR** и если указать приоритет выше, могут случиться нехорошие вещи вплоть до полной блокировки таска. Этот дефайн обычно определен в файле FreeRTOS\_Config.h, почитать можно [тут](https://www.freertos.org/a00110.html#kernel_priority)
4. RS485 настраивается двумя битфилдами: *USART\_CR1\_DEAT* и *USART\_CR1\_DEDT*. Эти битфилды позволяют задать время снятия и установки сигнала DE до и после отправки в размерностях 1/16 или 1/8 бита в зависимости от параметра oversampling модуля USART. Остается только включить функцию в регистре *CR3* битом *USART\_CR3\_DEM*, обо всем остальном позаботится железо.
Настройка DMA:
**Настройка DMA**
```
/*Configure DMA Rx/Tx channels*/
//Rx channel
//Max priority
//Memory increment
//Transfer complete interrupt
//Transfer error interrupt
MB_DMA_RX_CH->CCR = 0;
MB_DMA_RX_CH->CCR |= (DMA_CCR_PL | DMA_CCR_MINC | DMA_CCR_TCIE | DMA_CCR_TEIE);
MB_DMA_RX_CH->CPAR = (uint32_t)&MB_USART->RDR;
MB_DMA_RX_CH->CMAR = (uint32_t)MB_Frame;
/*Set highest priority to Rx DMA*/
NVIC_SetPriority(MB_DMA_RX_IRQn, 0);
NVIC_EnableIRQ(MB_DMA_RX_IRQn);
//Tx channel
//Max priority
//Memory increment
//Transfer complete interrupt
//Transfer error interrupt
MB_DMA_TX_CH->CCR = 0;
MB_DMA_TX_CH->CCR |= (DMA_CCR_PL | DMA_CCR_MINC | DMA_CCR_DIR | DMA_CCR_TCIE | DMA_CCR_TEIE);
MB_DMA_TX_CH->CPAR = (uint32_t)&MB_USART->TDR;
MB_DMA_TX_CH->CMAR = (uint32_t)MB_Frame;
/*Set highest priority to Tx DMA*/
NVIC_SetPriority(MB_DMA_TX_IRQn, 0);
NVIC_EnableIRQ(MB_DMA_TX_IRQn);
```
Так как Modbus работает в режиме запрос-ответ, мы используем один буфер, как для приема так и для передачи. В буфер получили, там же обработали из него же отправили. Во время обработки входные данные не принимаются. Rx канал DMA кладет данные из регистра приема USART (RDR) в буфер, Tx канал DMA наоборот из буфера в регистр отправки(TDR). Прерывание Tx канала нам нужно, чтобы определить, что ответ ушел и можно переключиться в режим приема.
Прерывание Rx канала по сути не нужно, ведь мы предполагаем, что посылка Modbus не может быть больше 256 байт, но, что если на линии шум и кто-то беспорядочно шлет байты? Для этого я сделал буфер размером 257 байт, и если прерывание от Rx DMA случится, значит, кто-то «мусорит» в линию, а мы перекидываем Rx канал в начало буфера и слушаем снова.
Обработчики прерываний:
**Interrupt handlers**
```
/*DMA Rx interrupt handler*/
void MB_DMA_RX_IRQ_HANDLER(void)
{
if(MB_DMA->ISR & (DMA_ISR_TCIF1 << ((MB_DMA_RX_CH_NUM - 1) << 2)))
MB_DMA->IFCR |= (DMA_IFCR_CTCIF1 << ((MB_DMA_RX_CH_NUM - 1) << 2));
if(MB_DMA->ISR & (DMA_ISR_TEIF1 << ((MB_DMA_RX_CH_NUM - 1) << 2)))
MB_DMA->IFCR |= (DMA_IFCR_CTEIF1 << ((MB_DMA_RX_CH_NUM - 1) << 2));
/*If error happened on transfer or MB_MAX_FRAME_SIZE bytes received - start listening*/
MB_RecieveFrame();
}
/*DMA Tx interrupt handler*/
void MB_DMA_TX_IRQ_HANDLER(void)
{
MB_DMA_TX_CH->CCR &= ~(DMA_CCR_EN);
if(MB_DMA->ISR & (DMA_ISR_TCIF1 << ((MB_DMA_TX_CH_NUM - 1) << 2)))
MB_DMA->IFCR |= (DMA_IFCR_CTCIF1 << ((MB_DMA_TX_CH_NUM - 1) << 2));
if(MB_DMA->ISR & (DMA_ISR_TEIF1 << ((MB_DMA_TX_CH_NUM - 1) << 2)))
MB_DMA->IFCR |= (DMA_IFCR_CTEIF1 << ((MB_DMA_TX_CH_NUM - 1) << 2));
/*If error happened on transfer or transfer completed - start listening*/
MB_RecieveFrame();
}
/*USART interrupt handler*/
void MB_USART_IRQ_HANDLER(void)
{
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
if(MB_USART->ISR & USART_ISR_RTOF)
{
MB_USART->ICR = 0xFFFFFFFF;
//MB_USART->ICR |= USART_ICR_RTOCF;
MB_USART->CR2 &= ~(USART_CR2_RTOEN);
/*Stop DMA Rx channel and get received bytes num*/
MB_FrameLen = MB_MAX_FRAME_SIZE - MB_DMA_RX_CH->CNDTR;
MB_DMA_RX_CH->CCR &= ~DMA_CCR_EN;
/*Send notification to Modbus Handler task*/
vTaskNotifyGiveFromISR(MB_TaskHandle, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}
```
Обработчики DMA достаточно простые: все отправил — почисти флаги, переходи в режим приема, принял 257 байт — ошибка фрейма, чисти флаги, переходи в режим приема снова.
Обработчик USART говорит нам, что пришло какое-то количество данных и дальше была тишина. Фрейм готов, определяем количество принятых байт (максимальное количество байт приема DMA — количество которое осталось принять), выключаем прием, будим таск.
Один нюанс, раньше для пробуждения таска я использовал бинарный семафор, однако разработчики FreeRTOS рекомендуют использовать [TaskNotification](https://www.freertos.org/RTOS_Task_Notification_As_Binary_Semaphore.html):
> Unblocking an RTOS task with a direct notification is 45% faster and uses less RAM than unblocking a task with a binary semaphore
>
>
Иногда в **FreeRTOS\_Config.h** бывает не включена в сборку функция *xTaskGetCurrentTaskHandle()*, в таком случае нужно добавить строку в этой файл:
```
#define INCLUDE_xTaskGetCurrentTaskHandle 1
```
Без использования семафора прошивка похудела почти на 1 кБ. Мелочь конечно, но приятно.
Функции отправки и приема:
**Send and Receve**
/\*Configure DMA to receive mode\*/
```
void MB_RecieveFrame(void)
{
MB_FrameLen = 0;
//Clear timeout Flag*/
MB_USART->CR2 |= USART_CR2_RTOEN;
/*Disable Tx DMA channel*/
MB_DMA_RX_CH->CCR &= ~DMA_CCR_EN;
/*Set receive bytes num to 257*/
MB_DMA_RX_CH->CNDTR = MB_MAX_FRAME_SIZE;
/*Enable Rx DMA channel*/
MB_DMA_RX_CH->CCR |= DMA_CCR_EN;
}
/*Configure DMA in tx mode*/
void MB_SendFrame(uint32_t len)
{
/*Set number of bytes to transmit*/
MB_DMA_TX_CH->CNDTR = len;
/*Enable Tx DMA channel*/
MB_DMA_TX_CH->CCR |= DMA_CCR_EN;
}
```
Обе функции переинициализируют каналы DMA. При приеме включается функция отслеживающая таймаут в регистре *CR2* битом *USART\_CR2\_RTOEN*.
### CRC
Переходим к хардварному расчету CRC. Всегда мозолила мне эта функция контроллера глаза, но всегда как-то не складывалось, в какой то серии нельзя было задать произвольный полином, в какой-то нельзя было менять размерность полинома и так далее. В F3 же все хорошо, и полином задавай и размер меняй, но приседание пришлось одно сделать:
```
uint16_t MB_GetCRC(uint8_t * buffer, uint32_t len)
{
MB_CRC_Init();
for(uint32_t i = 0; i < len; i++)
*((__IO uint8_t *)&CRC->DR) = buffer[i];
return CRC->DR;
}
```
Оказалось, что просто так побайтно закидывать в регистр *DR* нельзя — считать будет неправильно, надо использовать byte-access. Такие «выкрутасы» у STM я уже встречал с модулем SPI в который хочется писать побайтно.
### Таск
```
void MB_RTU_Slave_Task(void *pvParameters)
{
MB_TaskHandle = xTaskGetCurrentTaskHandle();
MB_HWInit();
while(1)
{
if(ulTaskNotifyTake(pdTRUE, portMAX_DELAY))
{
uint32_t txLen = MB_TransactionHandler(MB_GetFrame(), MB_GetFrameLen());
if(txLen)
MB_SendFrame(txLen);
else
MB_RecieveFrame();
}
}
}
```
В нем мы инициализируем указатель на таск, это нужно чтобы использовать его для разблокировки через TaskNotification, инициализируем железо и ждем спим пока не придет уведомление. Если необходимо, можно вместо *portMAX\_DELAY* поставить значение таймаута, чтобы определять, что связи не было определенное время. Если уведомление пришло — обрабатываем посылку, формируем ответ и отправляем, если же фрейм пришел битый или не по адресу, просто ждем следующий.
```
/*Handle Received frame*/
static uint32_t MB_TransactionHandler(uint8_t * frame, uint32_t len)
{
uint32_t txLen = 0;
/*Check frame length*/
if(len < MB_MIN_FRAME_LEN)
return txLen;
/*Check frame address*/
if(!MB_CheckAddress(frame[0]))
return txLen;
/*Check frame CRC*/
if(!MB_CheckCRC(*((uint16_t*)&frame[len - 2]), MB_GetCRC(frame, len - 2)))
return txLen;
switch(frame[1])
{
case MB_CMD_READ_REGS : txLen = MB_ReadRegsHandler(frame, len); break;
case MB_CMD_WRITE_REG : txLen = MB_WriteRegHandler(frame, len); break;
case MB_CMD_WRITE_REGS : txLen = MB_WriteRegsHandler(frame, len); break;
default : txLen = MB_ErrorHandler(frame, len, MB_ERROR_COMMAND); break;
}
return txLen;
}
```
Сам обработчик не представляет особого интереса: проверка длины фрейма/адреса/CRC и формирование ответа или ошибки. Данная реализация поддерживает три основные функции: 0x03 — Read Registers, 0x06 — Write register, 0x10 — Write Multiple Registers. Обычно, мне достаточно этих функций, но при желании можно без проблем расширить функционал.
Ну и запуск:
```
int main(void)
{
NVIC_SetPriorityGrouping(3);
xTaskCreate(MB_RTU_Slave_Task, "MB", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
vTaskStartScheduler();
}
```
Для работы таска достаточно стека размером в 32 x uint32\_t (или 128 байт) именно такой размер у меня выставлен в дефайне *configMINIMAL\_STACK\_SIZE*. Для справки: изначально я ошибочно предполагал, что *configMINIMAL\_STACK\_SIZE* задается в байтах, если не хватало добавлял еще, однако, работая с F0 контроллерами, где RAM поменьше, один раз пришлось посчитать стек и оказалось, что *configMINIMAL\_STACK\_SIZE* задается в размерностях типа*portSTACK\_TYPE*, который определен в файле **portmacro.h**
```
#define portSTACK_TYPE uint32_t
```
Заключение
----------
Данная реализация Modbus RTU оптимально использует аппаратные возможности микроконтроллера STM32F3xx.
Вес выходной прошивки вместе с ОС и оптимизацией -o2 составил: Program size: 5492 Байта, Data size: 112 байт. На фоне 6 кБ похудение на 1 кБ от семафоров, выглядит существенно.
Перенос на другие семейства возможен, например F0 поддерживает таймаут и RS485, однако там есть проблема с аппаратным CRC, так что можно обойтись софтовым методом расчета. Также могут быть различия в обработчиках прерываний DMA, где-то они бывают совмещенными.
[Ссылка на гитхаб](https://github.com/DoHelloWorld/STM32F3xx_FreeRTOS_ModbusRTU_RS485/tree/master)
Возможно кому-то пригодится.
Полезные ссылки:
* [STM32F303 Reference Manua](https://www.st.com/resource/en/reference_manual/dm00043574-stm32f303xbcde-stm32f303x68-stm32f328x8-stm32f358xc-stm32f398xe-advanced-armbased-mcus-stmicroelectronics.pdf)l
* [Modbus Specification](https://www.modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf) | https://habr.com/ru/post/522960/ | null | ru | null |
# Динамика по подотрезкам: базовые вещи и «одна хорошо, а две лучше»
Добрый вечер.
В этом посте я разберу задачу *B «Дубы»* с практического тура городской олимпиады школьников Санкт-Петербурга по информатике.
Задача эта на динамическое программирование по подотрезкам и идея решения интересна тем, что удобнее посчитать две динамики вместо одной. Если вас заинтересовало (незнание динамики не освобождает, но будет труднее) — добро пожаловать.
Условие
-------
Для начала можете посмотреть условие задачи. Оно вместе с тестами лежит [тут](http://neerc.ifmo.ru/school/archive/2007-2008.html#practice) (только условия можно [скачать](http://min.us/mvphlBX) с min.us).
После откидывания легенды остаётся следующая задача:
* Имеется n (2<=n<=200) дубов, у каждого есть высота — целое число от 1 до 1000 (вкл.) .
* Мы умеем: удалить дуб из последовательности, если:
+ Либо он **строго** меньше обоих соседей
+ Либо **строго** больше их же
Например, на следующем рисунке зелёным выделены «дубы», которые можно удалить:
* Надо за минимальное количество операций превратить последовательность в *нестрого* возрастающую. Последовательность удалений также надо вывести. Например, так:
Если хотите, можете подумать (название поста может Вам подсказать).
Основная идея
-------------
Как можно было догадаться из тегов — решение есть некая динамика. Если Вы забыли или не знали, что такое динамическое программирование, я напомню. Идея динамики в том, что для совсем маленьких примеров (например, одно дерево) ответ очевиден (ничего не пилить), а для больших решение можно получить, зная решения для каких-то более мелких *независимых* подзадач. В этом месте динамика очень напоминает индукцию. Как же свести задачу, например, для десяти деревьев к меньшим? Предположим, что мы уже знаем ответ (мы не будем этим пользоваться, но это полезно представить). В нём есть два крайних дерева и какая-то середина. Давайте переберём любое дерево из этой середины (вообще любое, которое лежит по высоте между границами — в противном случае его оставлять нельзя):
Можно заметить, что все операции будут производиться либо в левой части, либо в правой. Значит, друг от друга они не зависят никак. Вот и разбили на две *независимые* подзадачи. Можно прорелаксировать (выбрать лучший) ответ на нашем большом отрезке.
А что делать, когда на отрезке между нашими границами нет деревьев (например, деревья 4 и 9)? Тут мы понимаем, что в таком случае нам нужно срубить все деревья на интервале. Вопрос — в каком порядке? Есть соблазн сделать жадный алгоритм: срубать первое попавшееся дерево и так, пока они не кончатся. Однако он неверен:
Думаю, очевидно, что не стоит придумывать различные оптимизации в стиле «на последних двух шагах запустить перебор» и пр. — это всё обламывается большим случайным тестом.
Нужно что-то поумнее. Смотрим на название поста еще разок и придумываем очень похожуюю динамику по подотрезкам: для двух деревьев и меньше удалять вообще ничего не надо. А для большего количества надо перебрать дерево, которое удалим последним и заметить, что опять получили две подзадачи: слева и справа. Единственный отличающий момент — надо проверить, что это дерево можно будет в конце удалить (когда его соседями станут границы интервала)
Например, удалить дерево 4 последним можно, а 3 — нельзя.
Восстановление ответа
---------------------
Ответ восстанавливается классическим методом — запоминаем оптимальный переход из каждого состояния (где достигся самый лучший ответ) в массив, а потом идём с конца. В динамике по подотрезкам восстановление удобно писать рекурсивно:
##### Восстановление ответа
`vector<int> ans; // Последовательность удалений
// a и b - границы интервала, на котором хотим срубить все деревья
void deleteAll(int a, int b) {
assert(del[a][b] >= 0);
if (del[a][b] == a) return;
deleteAll(a, del[a][b]);
deleteAll(del[a][b], b);
ans.push\_back(del[a][b]);
}
// аналогично
void restoreAns(int a, int b) {
assert(fr[a][b] >= 0);
if (fr[a][b] == a) {
deleteAll(a, b);
return;
}
restoreAns(a, fr[a][b]);
restoreAns(fr[a][b], b);
}`
Время работы
------------
Всего у нас *O(n2)* состояний каждой динамики (по одному на каждый подотрезок). В каждой динамике переход производится за *O(n)* — перебрать дерево внутри интервала. При восстановлении ответа каждое состояние мы посещаем не более одного раза. Получается квадрат, но так это асимпотически (бесконечно меньше на бесконечно больших *n*) меньше куба, то им можно пренебречь.
Итоговое время работы — *O(n3)*, что при *n=200* составляет *O(8\*106)*, что отрабатывает мгновенно. Это нас тоже устраивает.
Как писать
----------
Для начала надо считать данные в массив/вектор. Это Вы делать умеете.
### Первая динамика
Далее надо подсчитать динамику для удаления всех деревьев. Будем хранить её в массиве *int del[a][b]* — *-1*, если невозможно удалить все деревья на интервале *(a, b)*, и номер последнего дерева иначе.
Для перебора подотрезков есть соблазн написать два цикла:
`for (int left = 0; left < n; left++)
for (int right = left; right < n; right++) {
**// ...**
}`
Однако это в корне неверно, посколько переход динамики будет верным только тогда, когда мы знаем ответ для «меньших» подзадач. В нашем случае — для подотрезков меньшей длины. Поэтому надо сначала перебрать длину отрезка, а затем — начало (или конец):
`for (int l = 2; l < n; l++)
for (int a = 0; a + l < n; a++) {
int b = a + l;
**// ...**
}`
В этом цикле надо перебрать последнее дерево и проверить возможность удаления. Также не следует забывать проинициализировать динамику для пустых интервалов:
`// Можем ли мы удалить дерево высоты h2, если его соседи имеют высоты h1 и h3
bool can(int h1, int h2, int h3) {
if (h1 < h2 && h3 < h2) return true;
if (h1 > h2 && h3 > h2) return true;
return false;
}
// ...
for (int a = 0; a + 1 < n; a++)
del[a][a + 1] = a;
for (int l = 2; l < n; l++)
for (int a = 0; a + l < n; a++) {
int b = a + l;
for (int i = a + 1; i < b; i++)
if (del[a][i] >= 0 && del[i][b] >= 0 && can(h[a], h[i], h[b])) {
del[a][b] = i;
break;
}
}`
### Вторая динамика
Вторую динамику будем хранить в двух массивах — *int dyn[a][b]* и *int fr[a][b]*. Первый — собственно, ответ для подотрезка (сколько минимум деревьев надо удалить), или бесконечность (я использую 109), если нельзя оставить неубывающую подпоследовательность. А во втором массиве мы будем хранить либо *-1*, если в первом записана бесконечность, либо последнее удалённое дерево.
Итак, пишем. Тут можно инициализировать всё по ходу (отдельный цикл нужен только для заполнения бесконечностями):
`// Точно также перебираем отрезки
for (int l = 1; l < n; l++)
for (int a = 0; a + l < n; a++) {
int b = a + l;
if (h[a] > h[b]) continue; // Если левая граница выше правой, тут мы бессильны
if (del[a][b] >= 0) { // Если можно удалить вообще все поддеревья, давайте попробуем
dyn[a][b] = b - a - 1;
fr[a][b] = a;
}
for (int i = a + 1; i < b; i++) {
// Если наше дерево ниже левой границы, или выше правой,
// оно нам не точно подходит - оставить мы его не можем
if (h[a] > h[i] || h[i] > h[b]) continue;
// Если хоть в одном месте будет бесконечность, то в сумме
// также будет число, большее бесконечности
int cans = dyn[a][i] + dyn[i][b];
if (dyn[a][b] > cans) {
dyn[a][b] = cans;
fr[a][b] = i;
}
}
}`
### Восстановление ответа
Оно было уже полностью написано [выше](#restore) — тот код полностью работает. Осталось лишь проверить, что ответ есть, вызвать функцию, и вывести результат:
`int a = 0, b = n - 1;
if (fr[0][n - 1] < 0) printf("-1\n");
else {
ans = vector<int>();
restoreAns(a, b);
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d\n", ans[i] + 1);
}`
### Всё вместе
Всю программу можно просмотреть на [pastebin](http://pastebin.com/XAD30aEG). Так как она писалась на олимпиаде, в ней присутствуют некоторые сокращения для быстрого набора и отсутствуют комментарии. Впрочем, весь значимый код я привёл в статье.
Тестирование
------------
На тему тестирования алгоритмических задач можно написать много больших статей. Но нам же хочется побыстрее, правда же? Поэтому вспоминаем, куда мы скачали тесты в начале статьи, распаковываем их куда-нибудь (задача называется *oaks*) и либо ручками прогоняем все 50 тестов, либо компилируем файл *check.dpr* ([скомпилированный](http://min.us/mveQC51)) и пишем скрипт на CMD:
`@echo off
for %%i IN (tests\??) DO (
del oaks.in oaks.out >nul 2>&1
copy %%i oaks.in >nul 2>&1
main >nul 2>&1
if errorlevel 1 exit
check oaks.in oaks.out %%i.a
if errorlevel 1 exit
)
echo ALL IS OK!
pause`
Запускаем. Если увидели надпись *ALL IS OK!* и «Нажмите Any key» — ваше решение верное. Если нет — значит есть тест, на котором оно работает неверно. Не спешите смотреть этот тест — гораздо полезнее будет самостоятельно найти и исправить баг.
Заключение
----------
Вот и всё, что я хотел рассказать. Надеюсь, Вы всё поняли и я не зря потратил Ваше время.
Спасибо за внимание, легких вам Accepted'ов.
Буду рад конструктивной критике. | https://habr.com/ru/post/112386/ | null | ru | null |
# Планирование задач в сервере при помощи boost.task
Недавно на профильном ресурсе один программист задал вопрос: *«Что использовать в сервере ММО для работы с потоками?»*. Программист склонялся к [Intel TBB](http://ru.wikipedia.org/wiki/Intel_Threading_Building_Blocks), но даже не к базовым примитивам, а к кастомному планированию задач (task scheduling). Ну нравится TBB — ну и ладно. А немного позже я увидел исходники сервера ММО другого программиста, который недавно начал переписываться его с нуля для улучшения архитектуры. И там было очень много велосипедов, которые писались самим программистом вместо того что бы использовать сторонние компоненты такие как boost (к примеру класы обертки над pthread-ом, и это в 2010 году, когда [boost.thread](http://www.boost.org/doc/libs/1_42_0/doc/html/thread.html) уже почти в стандарте). Была там реализована и поддержка пула потоков с планировщиком задач. Тема эта мне очень интересна и я начал копать информацию о готовых решениях планировки задач (как в TBB) и нашел [boost.task](http://lists.boost.org/Archives/boost/2009/06/152125.php), про что и решил написать.
### Определение
Задача (task) — это логически объедененный набор действий. Планировщик задач (task scheduler) асинхронино выполняет задачи руководствуясь определенными стратегиями по выбору кто должен выполняться в данный момент в каком потоке.
Задачи позволяют абстрагировться от обычных потоков и оперировать на более высоком уровне.
### Зачем нужен планировщик задач?
Как работает сферический сервер в вакууме? Очень просто:
1. Приходит запрос от клиента
2. Он обрабатывается!
3. Отсылается ответ
Ну кроме того в сервере могут происходить какие то процессы, которые выполняются и без запроса клиента. Например рассылка уведомлений по всей базе пользователей, очистка базы от устаревших данных (крончик), обработка дневной статистики и тд.
Сейчас загвоздка именно в том, как обрабатывается запрос. Надо разобраться как его обрабатывать.
Возьмем к примеру memcached-подобный сервер: у нас есть hash\_map с данными, есть запросы чтения, есть запросы записи, которые делают простой лукап по хеш-мапе и возвращают данные либо записывают их в хеш-мап. Пока всё происходит в одном потоке, но что делать, если нам надо задействовать все процессоры системы?
Создаем столько потоков, сколько ядер. В каждом потоке обрабатываем пользователей, которых при создании соеденения раскидываем по принципу [round-robin](http://ru.wikipedia.org/wiki/Round-robin_(алгоритм)). При обращении к контейнеру используем rwlock-и (boost::shared\_mutex). Отлично. А как нам быть с удалением элементов из контейнера? Создаем поток, который раз в N секунд просыпается и чистит контейнер.
Это был простой пример, а теперь более сложный пример: сервис, который может в зависимости от запроса пользователя сделать запрос в базу данных, сделать http запрос на какой то сайт. Что будет если сделать серрвер по предидущей модели (все запросы к другим компонентам будут выполняться синхронно)? Ну база данных находится на той же площадке, что и сервер, ответ будет в приделах пары миллисекунд. Отослать email — тоже не проблема — ставим sendmail на ту же машину, отдаём ему данные, а он сам разберется как отослать письмо.
Отлично. Хотя не совсем. А что делать с http-запросом? Он же может занять очень долго — всё зависит от сайта который находится где то далеко и не известно сколько будет обрабатывать запрос. В таком случае поток будет бездействовать, хотя в очереди есть много запросов, которые могут выполниться, но они ждут пока освободится этот поток.
Такой запрос необходимо выполнять асинхронно. Реализовать можно так:
> `class LongRequestHandler
>
> {
>
> public:
>
> void Handle()
>
> {
>
> // read client request parameters
>
> // mysql request 1
>
> // mysql request 2
>
> HttpRequestExecutor::GetInstance()->Execute(
>
> "example.com?x=1",
>
> boost::bind(this, &LongRequestHandler::HandleStage2)
>
> );
>
> }
>
> void HandleStage2(const std::string & http\_request\_result)
>
> {
>
> // mysql request 3
>
> // write response to client
>
> }
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
HttpRequestExecutor принемает url запроса и колбек, который надо вызвать по завершению запроса (тип колбека — boost::function).
И такой подход в работает, правда не слишком красиво.
В блоге [Thinking Asynchronously in C++](http://blog.think-async.com/) показана интерестная реализация выполнения асинхронных задач. Выглядит результат следующим образом:
> `template void async\_echo(
>
> tcp::socket& socket,
>
> mutable\_buffer working\_buffer,
>
> Handler handler,
>
> // coroutine state:
>
> coroutine coro = coroutine(),
>
> error\_code ec = error\_code(),
>
> size\_t length = 0)
>
> {
>
> reenter (coro)
>
> {
>
> entry:
>
> while (!ec)
>
> {
>
> yield socket.async\_read\_some(
>
> buffer(working\_buffer),
>
> bind(&async\_echo,
>
> ref(socket), working\_buffer,
>
> box(handler), coro, \_1, \_2));
>
> if (ec) break;
>
> yield async\_write(socket,
>
> buffer(working\_buffer, length),
>
> bind(&async\_echo,
>
> ref(socket), working\_buffer,
>
> box(handler), coro, \_1, \_2));
>
> }
>
> handler(ec);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Coroutine и yield в С++ смотрятся необычно;) Реализовано это на [дефайнах](http://blog.think-async.com/2009/08/secret-sauce-revealed.html), в блоге можно почитать как это удалось автору.
Постепенно логика усложняется, добавляются новые элементы, которые надо обрабатывать асинхронно, реализация тоже усложняется. В дальнейшем задачу
```
mysql request 1
mysql request 2
http request 1
mysql request 3
http request 2
mysql request 4
mysql request 5
```
И выполняя её последовательно с остановками в http запросах мы видим, что запросы
```
mysql request 2
http request 1
```
и
```
mysql request 3
http request 2
mysql request 4
```
можно выполнять паралельно и если мы захотим это сделать, то прийдется ещё сильнее усложнять логику. А хотелось бы написать простой код, например:
```
mysql request 1
x = run(func1)
y = run(func2)
wait(x, y)
mysql request 5
func1:
mysql request 2
http request 1
func2:
mysql request 3
http request 2
mysql request 4
```
Вот тут и пригодиться планировщик задач.
### Реализации
Про поддержку планировщика задач в новом стандарте 0x можно почитать [тут](http://www.justsoftwaresolutions.co.uk/threading/multithreading-in-c++0x-part-8-futures-and-promises.html).
* [just::thread](http://www.stdthread.co.uk/) — реализация библиотеки потоков стандарта C++0x от отца boost::thread
* [Parallel Patterns Library (PPL)](http://msdn.microsoft.com/en-us/library/dd492418(VS.100).aspx) — реализцаия от Microsoft
* [Asynchronous Agents Library](http://msdn.microsoft.com/en-us/library/dd492627(VS.100).aspx) — и ещё одна от Microsoft
* [Intel Threading Building Blocks](http://www.threadingbuildingblocks.org/) — очень мощная библиотека для паралельного программирования от Intel. Включает в себя и планировщик задач.
* [boost::task](http://www.boostpro.com/vault/index.php?directory=Concurrent%20Programming) — — реализация от Oliver Kowalke, не принятая ещё в boost
Мне наиболее понравился boost.task. Дальше его детальное рассмотрение.
### Описание boost.task
boost.task — реализация предложения в стандарт [C++0x](http://ru.wikipedia.org/wiki/C%2B%2B0x). Она поддерживает задание стратегий выполнения задач, создание под-задач, прерывание задач.
Библиотека зависит от:
* [boost](http://www.boost.org/) >=1.41
* [boost.atomic](http://www.chaoticmind.net/~hcb/projects/boost.atomic/) — реализация атомарных объектов C++0x для boost
* [boost.move](http://svn.boost.org/svn/boost/sandbox/move/) — реализация семантики Move для C++03 стандарта в котором ещё нет [rvalue references](http://www.artima.com/cppsource/rvalue.html)
* [boost.fiber](http://www.boostpro.com/vault/) — аналог boost.thread для [легковесных](http://en.wikipedia.org/wiki/Fiber_(computer_science)) [потоков](http://en.wikipedia.org/wiki/Light-weight_process)
boost.task и boost.fiber компилируемые библиотеки (boost.atomic и boost.move — header-only) — так что прийдется их собирать. Что бы было удобнее эксперементировать собрал все зависимости в одном месте, приправил cmake-ом и залил поект на [github](http://github.com/ghisguth/tasks). Работает на linux-е, для сборки под windows — потребуется 2-3 строчки добавить в cmake файлы.
### Пример использования
API библиотеки достаточно простой, реализовать обработчик запроса, который описывался выше не совтавит труда. Приведу его ещё раз:
```
mysql request 1
mysql request 2
http request 1
mysql request 3
http request 2
mysql request 4
mysql request 5
```
В качестве эмуляции запроса к mysql будет использован обычный sleep на случайное время:
````
boost::this_thread::sleep(boost::posix_time::milliseconds(rand()%100 + 10));
````
В качестве внешнего http-запроса будет использован асинхронный таймер из boost::asio.
Итак:
Request — класс запроса.
> `class Request
>
> {
>
> public:
>
> Request(const std::string & data);
>
> const std::string & Read() const;
>
> void Write(const std::string & answer);
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
А RequestHandler — класс обработчика запроса.
> `class RequestHandler
>
> {
>
> public:
>
> RequestHandler(boost::asio::io\_service & io\_service, const RequestPtr & request);
>
> void Process() const;
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
io\_service — передается для того, что бы можно было выполнить внешний вызов (использовать таймер boost::asio::deadline\_timer).Итак начнем. Определяем пул потоков, для обработки наших задач:
> `boost::tasks::static\_pool< boost::tasks::unbounded\_fifo > pool( boost::tasks::poolsize( 5) );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
boost.task поддерживает два основных вида стратегий планировки задач:
* **ограниченные** (bounded) — имеют порог количества выполняемых задач, при достижении которого добавление новой задачи блокирует поток, который выполняет это действие. Основная задача — избежать исчерпания ресурсов (resource exhaustion) когда скорость добавления задач превышает скорость их выполнения
* **неограниченные** (unbounded) — позволяют добавлять бесконечное число задач в очередь
Также есть возможность задания стратегии обработки задач внутри очереди:
* **fifo** — первая добавленная задача выполняется первой
* **priority** — у задачи есть приоритет, для выполнения выбираются задачи с высшим приоритетом
* **smart** — очередь такого типа возможно сильно кастомизировать передавая параметры в шаблон. по умолчанию есть возможность индексировать задачи по любому ключу и заменять старую задачу на новую, если она сущесвует
Соответственно описанная строчка кода создает пул из 5 потоков с неограниченной очередью типа fifo.
Теперь нам понадобится создать io\_service и пул из 3-х потоков для обработки внешних запросов.
> `boost::asio::io\_service io\_service;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Если вызвать io\_service::run в момент когда в нем нету задач, метод сразу завершится, а для нормальной работы нам необходимы работающие потоки. Обычно это достигается тем, что в io\_service добавлен accept-ор порта, на который подключаются клиенты, а в данном случае можно занять io\_service ожиданием исполнения таймера:
> `boost::asio::deadline\_timer dummy\_timer(io\_service);
>
> dummy\_timer.expires\_from\_now(boost::posix\_time::seconds(10));
>
> // void dummy\_handler(const boost::system::error\_code&) {}
>
> dummy\_timer.async\_wait(&dummy\_handler);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
После этого можно создать пул потоков:
> `boost::thread\_group io\_service\_thread\_pool;
>
> for(int i = 0; i < 3; ++i)
>
> io\_service\_thread\_pool.create\_thread(
>
> boost::bind(&boost::asio::io\_service::run, &io\_service)
>
> );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее создаём запрос:
> `RequestPtr request(new Request("some data"));
>
> RequestHandlerPtr handler(new RequestHandler(io\_service, request));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все готово, можно выполнять задачу:
> `boost::tasks::handle< void > request\_processing(
>
> boost::tasks::async(
>
> boost::tasks::make\_task( &RequestHandler::Process, handler ),
>
> pool));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
boost::tasks::make\_task( &RequestHandler::Process, handler ) — создает задачу вызова Process у объекта handler, которую можно будет выполнить. boost::tasks::async инициирует асинхронное выполнение задачи. boost::tasks::handle объект, по которому можно отслеживать статус завершения задачи, получить результат если он есть.
boost::tasks::async поддерживает 4 алгоритма выполнения задачи:
* **own\_thread** — синхронное выполнение в том же потоке
* **new\_thread** — для задачи создается поток, в котором она будет выполнена, после чего поток будет завершен
* **as\_sub\_task** — если текущая задача выполняется в пуле — добавляет новую задачу в него, иначе создает новый поток, как new\_thread. Это поведение по умолчанию
* **static\_pool** — выполнить задачу в пуле потоков
Далее подождем пока задача выполнится:
> `request\_processing.wait();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И остановим io\_service:
> `io\_service.stop();
>
> io\_service\_thread\_pool.join\_all();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Функция Process получилась на удивление очень простой
> `void Subtask1() const
>
> {
>
> Request("query2");
>
> ExternalRequest("extquery1");
>
> }
>
>
>
> void Subtask2() const
>
> {
>
> Request("query3");
>
> ExternalRequest("extquery2");
>
> Request("query4");
>
> }
>
>
>
> void Process() const
>
> {
>
> std::string data = request\_->Read();
>
>
>
> Request("query1");
>
>
>
> boost::tasks::handle< void > subtask1(
>
> boost::tasks::async(
>
> boost::tasks::make\_task( &RequestHandler::Subtask1, this )));
>
> boost::tasks::handle< void > subtask2(
>
> boost::tasks::async(
>
> boost::tasks::make\_task( &RequestHandler::Subtask2, this )));
>
>
>
> boost::tasks::waitfor\_all( subtask1, subtask2);
>
>
>
> Request("query5");
>
>
>
> request\_->Write("some answer");
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Подзадачи выполняются при помощи boost::tasks::async без указания policy на запуск и автоматически выбирается as\_sub\_task алгоритм, который выполнит задачи в том же пуле потоков, что и родительская задача. Реализация функций подзадач тоже тривиальная.
RequestHandler::Request — вызывает boost::this\_thread::sleep, а с ExternalRequest все немного сложнее:
> `void ExternalRequest(const std::string & what) const
>
> {
>
> ExternalRequestHandler external\_handler(io\_service\_);
>
> boost::tasks::spin::auto\_reset\_event ev;
>
> external\_handler.PerformExternalReqeust(what, &ev);
>
> ev.wait();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Создается хендлер, а так же событие с автоматическим сбросом — boost::tasks::spin::auto\_reset\_event. Это событие передается обработчику внешнего запроса и по его завершению будет вызвано ev.set(), а до тех пор ev.wait() блокирует задачу.
В противовес обычным потокам и примитивам синхронизации (boost::condition) ev.wait() не блокирует поток, а блокирует задачу (вызывает в цикле this\_task::yield()). А это значит, что ресурсы процессора будут использованы другими задачами.
Файл целиком может быть найден [тут](http://github.com/ghisguth/tasks/blob/master/src/main.cpp#L5).
### Выводы
**boost.task** вполне удобная библиотека для планирования задач. Она позволяет посмотреть как будет выглядить поддержка асинхронного выполнения кода в новом стандарте C++0x, и её можно использовать уже прямо сейчас не дожидаясь пока будет выпущен стандарт.
Код с использованием boost.task становится меньше и намного понятнее, чем при обычном использовании потоков.
Есть канечно и недостатки: код ещё не оптимизирован, что может вызвать проблемы в редких случаях; библиотека ещё не принята в boost (вместе с её зависимостями).
### Что почитать по теме?
* [Native Concurency](http://blogs.msdn.com/nativeconcurrency/)
* [Parallel Roads](http://www.parallelroads.com/blog/)
* [Thinking Asynchronously in C++](http://blog.think-async.com/)
* [The Free Lunch Is Over](http://www.gotw.ca/publications/concurrency-ddj.htm)
* [Многопоточная архитектура игровых движков](http://www.gamasutra.com/features/20060906/monkkonen_01.shtml) | https://habr.com/ru/post/88288/ | null | ru | null |
# Никогда больше не игнорируйте обучение с подкреплением
Привет, Хабр! Представляю вашему вниманию перевод статьи «Don’t Ever Ignore Reinforcement Learning Again» автора Michel Kana, Ph.D.
Обучение с учителем и обучение без учителя — это ещё не все. Все это знают. Начните с OpenAI Gym.
*Собираетесь победить чемпиона мира по шахматам, нардам или го?*
Есть способ, который позволит вам это сделать — обучение с подкреплением.
Что такое обучение с подкреплением?
-----------------------------------
Обучение с подкреплением — это обучение принятия последовательных решений в окружающей среде с максимальным полученным вознаграждением, которое даётся за каждое действие.
В нем нет учителя, только сигнал вознаграждения от окружающей среды. Время имеет значение, и действия влияют на последующие данные. Такие условия создают трудности для обучения как с учителем, так и без него.
В примере ниже, мышь пытается найти столько еды, сколько может, и избегает ударов тока, когда это возможно.
Мышь может быть храброй и может получить разряд, чтобы добраться до места с большим количеством сыра. Это будет лучше, чем просто стоять на месте и ничего не получать.
Мышь не хочет принимать лучшие решения в каждой конкретной ситуации. Это потребовало бы от неё больших умственных затрат, и было бы не универсально.
Обучение с подкреплением предоставляет некие магические наборы методов, которые позволяют нашей мыши самой учиться, как избежать электрошока и получить столько еды, сколько возможно.
Мышь — это агент. Лабиринт со стенами, сыром и электрошокерами — это **окружающая среда**. Мышь может двигаться влево, вправо, вверх, вниз — это **действия**.
Мышь хочет сыра, а не получить удар током. Сыр — это **вознаграждение**. Мышь может осматривать окружающую среду — это **наблюдения**.
Обучение с подкреплением на льду
--------------------------------
Давайте оставим мышь в лабиринте и перейдём на лёд. «Зима наступила. Вы и ваши друзья перекидывались фрисби в парке, когда вы вдруг закинули фрисби на середину озера. В основном вода в озере замёрзла, но осталось несколько дыр, где лёд растаял. ([источник](https://gym.openai.com/envs/FrozenLake-v0/))
«Если вы наступите на одну из дыр, вы упадёте в ледяную воду. К тому же в мире огромный дефицит фрисби, так что абсолютно необходимо, чтобы вы прошли по озеру и нашли диск.» ([источник](https://gym.openai.com/envs/FrozenLake-v0/))
Как вам быть в подобной ситуации?
---------------------------------
Это задача для обучения с подкреплением. Агент контролирует движения персонажа в мире-сетке. Некоторые плитки сетки проходимы, а другие приводят к тому, что персонаж падает в воду. Агент получает вознаграждение за нахождения проходимого пути к цели.
Мы можем смоделировать такое окружение используя [OpenAI Gym](https://github.com/openai/gym) — инструментарий для разработки и сравнения алгоритмов обучения с подкреплением. Он обеспечивает доступ к стандартизированному набору сред, таких как в нашем примере, которая называется «[Frozen Lake](https://gym.openai.com/envs/FrozenLake-v0/)» («Замершее Озеро). Это текстовая среда, которая может быть создана парой строк кода.
```
import gym
from gym.envs.registration import register
# load 4x4 environment
if 'FrozenLakeNotSlippery-v0' in gym.envs.registry.env_specs:
del gym.envs.registry.env_specs['FrozenLakeNotSlippery-v0']
register(id='FrozenLakeNotSlippery-v0',
entry_point='gym.envs.toy_text:FrozenLakeEnv',
kwargs={'map_name' : '4x4', 'is_slippery': False},
max_episode_steps=100,
reward_threshold=0.8196
)
# load 16x16 environment
if 'FrozenLake8x8NotSlippery-v0' in gym.envs.registry.env_specs:
del gym.envs.registry.env_specs['FrozenLake8x8NotSlippery-v0']
register(
id='FrozenLake8x8NotSlippery-v0',
entry_point='gym.envs.toy_text:FrozenLakeEnv',
kwargs={'map_name' : '8x8', 'is_slippery': False},
max_episode_steps=100,
reward_threshold=0.8196
)
```
Теперь нам нужна структура, которая позволит нас систематически подходить к проблемам обучения с подкреплением.
Процесс принятия решений Маркова
--------------------------------
В нашем примере, агент контролирует передвижение персонажа по миру-сетке, и это окружение называется полностью наблюдаемой средой.
Поскольку будущая плитка не зависит от прошлых плиток с учётом текущей плитки
( мы имеем дело с последовательностью случайных состояний, то есть со **свойством Маркова** ), поэтому мы имеем дело с так называемым [Марковским процессом](https://en.wikipedia.org/wiki/Markov_chain).
Текущее состояние инкапсулирует все, что необходимо для решения, какой будет следующий ход, ничего запоминать не требуется.
На каждой следующей клетке (то есть ситуации) агент выбирает с некоторой вероятностью действие, которое ведёт к следующей клетке, то есть ситуации, и окружение отвечает агенту наблюдением и наградой.
Добавим в процесс Маркова функцию вознаграждения и коэффициент скидки, и мы получим так называемый *процесс вознаграждения Маркова*. Добавив набор действий мы получим *процесс принятия решений Маркова* (**MDP**). Ниже более подробно рассказывается о компонентах MDP.
Состояние
---------
Состояние — это часть окружающей среды, числовое представление того, что агент наблюдает в определённый момент времени в окружающий среде, состояние сетки озера. S — начальная точка, G — цель, F — твёрдый лёд, на котором агент может стоять, и H — дыра, в которое упадёт агент, если наступит на неё. У нас есть 16 состояний в среде сетки 4 на 4, или 64 состояния в среде 8 на 8. Ниже мы нарисуем пример среды 4 на 4 используя OpenAI Gym.
```
def view_states_frozen_lake(env = gym.make('FrozenLakeNotSlippery-v0')):
print(env.observation_space)
print()
env.env.s=random.randint(0,env.observation_space.n-1)
env.render()
view_states_frozen_lake()
```
Действия
--------
У агента есть 4 возможных действия, которые представлены в окружении как 0, 1, 2 ,3 для лево, право, низ, верх соответственно.
```
def view_actions_frozen_lake(env = gym.make('FrozenLakeNotSlippery-v0')):
print(env.action_space)
print("Possible actions: [0..%a]" % (env.action_space.n-1))
view_actions_frozen_lake()
```
Модель перехода состояний
-------------------------
Модель перехода состояний описывает, как меняется состояние окружающей среды, когда агент предпринимает действия, исходя из текущего своего состояния.
Модель обычно описывается вероятностью перехода, который выражается в виде квадратной переходной матрицы размером N х N, где N — это число состояний нашей модели. Иллюстрация ниже — это пример такой матрицы для погодных условий.
В условиях среды Frozen Lake, мы предполагаем, что озеро не скользкое. Если мы идём вправо, то точно идём вправо. Поэтому все вероятности равны.
«Влево» перемещает агента на 1 клетку влево или оставляет его на той же позиции, если агент находится у левой границы.
«Вправо» двигает его на 1 клетку вправо или оставляет на той же позиции, если агент находится у правой границы.
«Вверх» перемещает агента на 1 клетку вверх, или агент остаётся на том же месте, если он стоит у верхней границы.
«Вниз» перемещает агента на 1 клетку вниз, или он остаётся на том же месте, если он находится у нижней границы.
Вознаграждение
--------------
В каждом состоянии F агент получает 0 награды, в состоянии H он получает -1, так как перейдя в это состояние, агент умирает. И когда агент достигает цели, он получает +1 награду.
Из-за того что обе модели, переходная модель и модель награды, являются детерминированными функциями, это делает среду детерминированной. \
Скидка
------
Скидка — это необязательный параметр, который контролирует важность будущих вознаграждений. Он измеряется в диапазоне от 0 до 1. Цель этого параметра — не допустить, чтобы общее вознаграждение не уходило в бесконечность.
Скидка также моделирует поведение агента, когда агент предпочитает немедленное вознаграждение вознаграждению, которое может быть получено в будущем.
Ценность
--------
Ценность состояния — это ожидаемый долгосрочный доход со скидкой для состояния.
Политика(π)
-----------
Стратегия, которую агент использует для выбора следующего действия, называется политикой. Среди всех доступных политик оптимальной является та, которая максимизирует сумму вознаграждения, полученного или ожидаемого за время эпизода.
Эпизод
------
Эпизод начинается, когда агент появляется на стартовой клетке, и заканчивается, когда агент либо падает в дыру или достигает целевой клетки.
Давайте визуализируем все это
-----------------------------
После рассмотрения всех концепций, участвующих в процессе принятия решений Маркова, мы теперь можем моделировать несколько случайных действий в среде 16x16 с использованием OpenAI Gym. Каждый раз агент выбирает случайное действие и выполняет его. Система вычисляет вознаграждение и отображает новое состояние окружающей среды.
```
def simulate_frozen_lake(env = gym.make('FrozenLakeNotSlippery-v0'), nb_trials=10):
rew_tot=0
obs= env.reset()
env.render()
for _ in range(nb_trials+1):
action = env.action_space.sample() # select a random action
obs, rew, done, info = env.step(action) # perform the action
rew_tot = rew_tot + rew # calculate the total reward
env.render() # display the environment
print("Reward: %r" % rew_tot) # print the total reward
simulate_frozen_lake(env = gym.make('FrozenLake8x8NotSlippery-v0'))
```
Заключение
----------
В этой статье мы кратко разобрали основные концепции обучения с подкреплением. Наш пример дал представлении об OpenAI Gym toolkit, который позволяет легко экспериментировать с предварительно построенными средами.
В следующей части мы представим, как спроектировать и имплементировать политики, которые позволят агенту делать набор действий, чтобы обязательно достичь цели и получить награду, такую, как победить чемпиона мира.
Спасибо за внимание. | https://habr.com/ru/post/475236/ | null | ru | null |
# 20 модулей для Node.js, о которых полезно знать
Филип Акерман, автор статьи, перевод которой мы сегодня публикуем, говорит, что в последние годы платформа Node.js становится всё популярнее и популярнее. Она часто используется для создания серверных частей веб-приложений, а также для решения других задач, возникающих в процессе разработки ПО. В настоящее время в реестре [npm](https://www.npmjs.com/), менеджера пакетов для Node.js, насчитывается более полумиллиона модулей.
[](https://habrahabr.ru/company/ruvds/blog/352636/)
Мы представляем вашему вниманию обзор модулей, которые автор материала, программист, занимающийся, кроме прочего, ещё и веб-разработкой, считает полезными. Среди них — библиотеки для работы с изображениями, средства для проверки того, что пользователи вводят в формы, модули для оптимизации и минификации данных различных типов, инструменты для создания PDF-файлов, для логирования и разработки приложений командной строки.
Графика
-------
### ▍1. Работа с изображениями
GraphicsMagick и ImageMagick — это два популярных инструмента для работы с изображениями. Ими можно пользоваться из JavaScript-кода благодаря npm-модулю [gm](https://github.com/aheckmann/gm). В целом, всё это позволяет создавать, править, комбинировать изображения. Например — менять их размеры, кадрировать, выполнять преобразование форматов.
Вот как выглядит работа с этим модулем.
```
const gm = require('gm');
gm('/path/to/image.jpg')
.resize(500, 250)
.autoOrient()
.write(response, error => {});
```
### ▍2. Обработка изображений
Модуль [sharp](https://github.com/lovell/sharp) основан на невероятно быстрой библиотеке обработки изображений libvips. В задачах сжатия изображений и изменения их размера он, как говорится на его странице, в 4-5 раз быстрее ImageMagick или GraphicsMagick. Модуль поддерживает форматы JPEG, PNG, WebP, TIFF, GIF и SVG, он умеет выводить изображения в форматах JPEG, PNG, WebP, или в виде несжатых потоков исходных пиксельных данных.
### ▍3. Создание спрайт-листов
Спрайт-листы — это графические файлы, которые содержат множество маленьких изображений (например — иконок). В нашем случае речь идёт о так называемых CSS-спрайтах. Они часто используются для того, чтобы облегчить задачу загрузки изображений, что благотворно влияет на скорость вывода страниц. Создание спрайт-листов вручную — задача неблагодарная. Автоматизировать этот процесс можно с помощью модуля [spritesmith](https://github.com/Ensighten/spritesmith). На вход этого модуля передают сведения о папке с графическими файлами, а он преобразует все эти файлы в единый спрайт-лист. Кроме того, он генерирует JSON-файл со сведениями о координатах каждого изображения в готовом спрайт-листе, которым можно пользоваться в CSS.
Даты, строки, цвета
-------------------
### ▍4. Форматирование дат
*Moment.js — отличная альтернатива стандартному объекту Date*
В стандартном API JavaScript имеется объект Date, предназначенный для работы со значениями, представляющими собой дату и время. Однако, этот объект не особенно удобен в делах вывода и форматирования дат. Для того, чтобы упростить работу с датой и временем можно воспользоваться библиотекой [Moment.js](https://github.com/moment/moment). Она имеет чёткий, продуманный интерфейс, а код, который получается при её использовании, оказывается понятным и читабельным.
```
moment()
.add(7, 'days')
.subtract(1, 'months')
.year(2009)
.hours(0)
.minutes(0)
.seconds(0);
```
Кроме того, имеется плагин к этой библиотеке, который используется для разбора и форматирования дат для различных временных зон.
### ▍5. Проверка строковых данных
Если вы предлагаете пользователям вашего сайта заполнить форму, не забывайте о проверке введённых ими данных. Делать это стоит не только на стороне клиента, но и на сервере — для того, чтобы отфильтровать опасные данные, отправленные злоумышленником. Модуль, предназначенный для решения задач проверки строк, [validate.js](https://github.com/chriso/validator.js), даёт в распоряжение разработчика множество полезных методов, назначение которых понятно из их названий. Например, это методы `isEmail()`, `isURL()`, `isMobilePhone()`, `isCreditCard()`. Пользоваться им можно и на сервере, и на клиенте.
### ▍6. Работа с цветовыми значениями
Преобразование значений, представляющих цвета из одного формата в другой — это одна из задач, которая периодически встаёт перед фронтенд-разработчиком. Модуль [TinyColor2](https://www.github.com/bgrins/TinyColor) упрощает решение этой задачи, пользоваться им можно и в браузере, и в среде Node.js. Он даёт в распоряжение программиста набор методов для преобразования цветовых значений, вроде `toHexString()`, `toRGBString()`, а также методы для выполнения различных операций с цветами. Среди них — `lighten()`, `saturate()`, `complement()`.
Работа с данными различных форматов
-----------------------------------
### ▍7. Создание PDF-файлов
Если вам нужно динамически генерировать PDF-файлы — обратите внимание на модуль [PDFKit](https://github.com/devongovett/pdfkit). Он поддерживает встраивание в документы шрифтов, изображений и описаний векторных рисунков, либо генерируемых программно (используя API, похожее на Canvas), либо созданных в формате SVG. Более того, с его помощью можно создавать гиперссылки, включать в файлы заметки, выделять текст и делать ещё много всего полезного. Пожалуй, если вам нужно нечто подобное, начать работу с PDFKit стоит с изучения его [интерактивной демонстрации](http://pdfkit.org/demo/browser.html), которая работает в браузере.
### ▍8. Обработка HTML-файлов
*Cheerio упрощает разбор HTML-файлов на сервере*
Если вы попадали в ситуацию, когда надо было разобрать на сервере HTML-файл, и при этом вам не хватало возможностей jQuery, то вам, вполне возможно, стоит взглянуть на [Cheerio](https://github.com/cheeriojs/cheerio). Хотя этот модуль представляет собой лишь реализацию подмножества возможностей jQuery, он значительно облегчает разбор HTML-файлов на сервере. Он построен на базе модуля [htmlparser2](https://github.com/fb55/htmlparser2) (это — парсер для HTML, XML и RSS). Кроме того, принимая во внимания результаты бенчмарков, он в восемь раз быстрее чем [jsdom](https://github.com/tmpvar/jsdom), ещё один модуль, позволяющий работать с DOM на сервере.
### ▍9. Обработка CSV-файлов
*Модуль node-csv упрощает работу с CSV-данными*
Формат CSV (comma-separated value, значения, разделённые запятыми) часто используется для организации обмена данными, представленными в виде таблиц. Например, Microsoft Excel позволяет экспортировать или импортировать данные, используя этот формат. Модуль [node-csv](https://github.com/wdavidw/node-csv) упрощает процесс работы с CSV-данными в JavaScript и даёт средства для создания, обработки, трансформации CSV-файлов, позволяет преобразовывать их в строки. Его API поддерживает функции обратного вызова, потоки, есть и его синхронный вариант, что даёт разработчику возможность выбрать именно то, что ему нужно.
### ▍10. Обработка markdown-файлов
Markdown — это популярный формат для создания материалов, предназначенных для веб. Если вам нужно программно обрабатывать markdown-данные (то есть, например, вы хотите создать собственный markdown-редактор) — взгляните на модуль [marked](https://github.com/chjj/marked). На вход он принимает код в формате markdown, а выводит уже HTML-код. При этом средства этого модуля позволяют производить дальнейшую обработку полученного HTML-кода, используя средства рендеринга, настраиваемые разработчиком.
Оптимизация и минификация данных
--------------------------------
### ▍11. Оптимизация и минификация изображений
*Imagemin — модуль для минификации и оптимизации изображений*
[Imagemin](https://github.com/imagemin/imagemin) — это отличный модуль для минификации и оптимизации изображений. Его можно использовать из командной строки, в виде плагина для gulp или Grunt, работать с ним можно и средствами imagemin-app — приложения с графическим интерфейсом, доступного для всех самых распространённых ОС. Архитектура imagemin основана на плагинах. Это говорит о гибкости данного модуля, и о том, что его возможности по поддержке различных графических форматов можно расширять.
### ▍12. Минификация HTML
*Средство html-minifier может считаться лучшим из существующих HTML-минификаторов*
После оптимизации изображений стоит задуматься о минификации HTML-кода веб-приложения. Эту задачу позволяет решить модуль [html-minifier](https://github.com/kangax/html-minifier), который может работать из командной строки, а так же доступен для gulp и Grunt. Кроме того, существуют решения, позволяющие интегрировать его в веб-фреймворки вроде Koa и Express, в результате HTML можно минифицировать прямо в процессе работы сервера, до отправки HTML-страниц клиентам. В соответствии с результатами бенчмарков, которые имеются на домашней странице модуля, это — лучший из существующих инструментов для минификации HTML-кода.
### ▍13. Минификация CSS
Минифицировав и оптимизировав HTML-код и изображения, отправляемые с сервера клиентам, стоит рассмотреть и вопрос минификации CSS. Решить эту задачу позволяет очень быстрый модуль [clean-css](https://github.com/jakubpawlowicz/clean-css), который можно использовать и из командной строки, и из JS-кода. Он поддерживает карты кода (source maps), а также — различные режимы совместимости, которые позволяют обеспечивать работу с полученным минифицированным CSS в старых версиях IE.
### ▍14. Минификация JavaScript
*Модуль UglifyJS2 умеет не только минифицировать JavaScript-код, но эту задачу он решает очень хорошо*
Популярный модуль [UglifyJS2](https://github.com/mishoo/UglifyJS2) часто используется для минификации JS-кода, но, благодаря его возможностям по разбору кода, его, в принципе, можно использовать для решения широкого круга задач, связанных с обработкой текстов программ на JavaScript. Этот модуль преобразует JavaScript-код в абстрактное синтаксическое дерево (это — объектная модель, представляющая код) и предоставляет средства для обхода этого дерева. Этот модуль подойдёт и тем, кто подумывает о написании собственного JavaScript-оптимизатора.
### ▍15. Минификация SVG
Тема минификации SVG-данных приведена в конце этого раздела, но она так же важна, как и всё то, о чём мы тут говорили. В последние несколько лет можно наблюдать возрождение этого формата. Всё дело в том, что его отлично поддерживают браузеры, и в том, что существуют удобные инструменты для работы с ним. К сожалению, SVG-данные, которые генерируют редакторы, часто содержат в себе избыточную или бесполезную информацию вроде комментариев и метаданных.
Для того, чтобы убрать всё лишнее из SVG-данных, можно воспользоваться модулем [SVGO](https://github.com/svg/svgo). Этот модуль поддерживает систему плагинов, тут практически каждая оптимизация представлена в виде отдельного плагина. Как и в случае с другими модулями, предназначенными для минификации, SVGO можно использовать как из командной строки, так и из JS-кода.
Утилиты
-------
### ▍16. Логирование
Когда вы работаете со сложными веб-приложениями, то, и в ходе разработки, и в продакшне, хорошая библиотека для логирования может оказаться весьма полезной для того, чтобы находить ошибки, возникающие в процессе работы этих приложений. В этой сфере весьма популярен модуль [winston](https://github.com/winstonjs/winston). Он поддерживает различные способы работы с данными, например, может выводить информацию в консоль, писать в файл, сохранять в базе данных (например, в CouchDB, MongoDB или Redis), или даже давать доступ к ним по HTTP для дальнейшей обработки.
### ▍17. Создание фиктивных данных
В ходе разработки или тестирования пользовательских интерфейсов часто возникает необходимость в неких условных данных, таких, как адреса электронной почты, имена пользователей, домашние адреса, телефонные номера. Помочь в решении подобных задач может библиотека [faker.js](https://github.com/Marak/Faker.js). Пользоваться ей можно и на сервере (в виде модуля для Node.js), и на клиенте. Этот инструмент предоставляет набор методов для создания фиктивных данных. Вам нужно имя пользователя? Вызовите метод `faker.internet.userName()` — и случайным образом сгенерированное имя в вашем распоряжении. Требуется название компании? Обратитесь к методу `faker.company.companyName()`. На самом деле, faker.js способен помочь в создании практически любых данных такого рода.
### ▍18. Отправка сообщений электронной почты
*Nodemailer поддерживает SSL/STARTTLS и умеет отправлять сообщения, содержащие обычный текст, HTML и изображения*
В ходе разработки веб-сайтов нередко возникает необходимость в программной отправке электронных писем. Подобное нужно, например, для отправки пользователям подтверждений регистрации, для рассылки уведомлений о важных событиях, новостей. На самом деле, существует масса ситуаций, в которых нужны возможности по работе с электронными письмами.
В стандартном API Node.js нет средств для отправки электронных писем. Эту задачу можно решить с помощью модуля [Nodemailer](https://github.com/nodemailer/nodemailer). Он поддерживает отправку писем, содержащих в себе обычный текст, HTML, изображения, и, что самое важное, поддерживает безопасный протокол обмена информацией SSL/STARTTLS.
### ▍19. Создание REST-API
REST — это стандарт де-факто, применяемый при создании веб-приложений, использующих веб-сервисы. Фреймворки вроде Express помогают в деле создания подобных сервисов, но часто, «в нагрузку», разработчик получает средства для работы с шаблонами и системы рендеринга, которые, в зависимости от конкретной ситуации, могут оказаться невостребованными. В подобной ситуации стоит взглянуть на модуль [restify](https://github.com/restify/node-restify), который ориентирован исключительно на разработку и тестировании REST-API. Его API очень похож на ПО промежуточного слоя Connect (на котором основан фреймворк Express), но обеспечивает разработчику более высокий уровень контроля над HTTP-взаимодействиями и поддерживает DTrace для поиска проблем с приложениями в реальном времени.
### ▍20. Создание приложений командной строки
Существует огромное количество приложений командной строки, созданных средствами Node.js и предназначенных для решения самых разных задач (например, это относится к рассмотренным выше средствам для минификации и оптимизации данных). Если вы подумываете о создании собственного приложения командной строки — обратите внимание на пакет [Commander.js](https://github.com/tj/commander.js/). Его удобные инструменты позволяют описывать различные аспекты таких приложений, среди которых — команды, опции, псевдонимы, справочные материалы. Он серьёзно упрощает процесс создания приложений командной строки.
Итоги
-----
На самом деле, в этом материале мы рассмотрели лишь малую часть из тех полезных инструментов, которые созданы для Node.js. Сейчас JavaScript пользуется невероятной популярностью, и новые npm-модули появляются буквально каждую неделю. Если вы хотите самостоятельно найти что-нибудь интересное — посмотрите домашнюю страницу [npm](https://www.npmjs.com/), обращая внимание на проекты, получившие самые высокие оценки сообщества, и загляните на [GitHub](https://github.com/trending/javascript), в раздел популярных репозиториев.
**Уважаемые читатели!** Если вы заняты разработкой для платформы Node.js, у вас, наверняка, есть список любимых модулей. Просим о них рассказать.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/352636/ | null | ru | null |
# SEO-friendly HTML для верстальщика
В этой статье не будет подробного разбора всех аспектов SEO-friendly сайта. Я собрал здесь лишь тот объем информации, с которым мне необходимо было познакомиться для решения SEO-задач в компании.
---
В компанию ВсеИнструменты я попал больше года назад. До того момента мне еще не приходилось так тесно заниматься задачами поисковой оптимизации, а возраст и размер проекта лишь прибавляли волнения при решении seo задач. Так или иначе тот период прошел, и я не испортил своими правками уровень сайта в выдаче, благо мне помогали коллеги из SEO-подразделения.
Наш сайт, без преувеличения, состоит из огромной кодовой базы, и каждый день мы планомерно улучшаем его, добавляя новые фичи и исправляя существующие баги. Еще в начале своего пути я получил несколько крупных задач по улучшению текущей верстки проекта с использованием [validator.w3.org](https://validator.w3.org/). После окончания работ над этими задачами у меня возникла мысль собрать некоторую информацию по написанию валидной и SEO-пригодной верстки в одну небольшую статью с указанием ссылок на дополнительную и более подробную информацию.
Вы познакомитесь с несколькими важными областями валидной SEO-верстки и найдете примеры работы с validators.w3.org. Дополнительные материалы, указанные ниже, будут весьма полезны в повседневной работе верстальщика.
Семантические теги
------------------
Семантическая верстка - это html элементы со смыслом понятные разработчику, браузеру и поисковым роботам. К таким относят: header, footer, main, article, section, nav, aside и тд. Использование перечисленных тегов описывается по спецификациям [W3C](https://www.w3.org/) или [WHATWG](https://whatwg.org/). Короткую вводную можно получить в цикле видео\статей “[HTML шорты](https://htmlacademy.ru/blog/boost/frontend/short-11)” от Вадима Макеева. Приведу описание к нескольким тегам.
**Section** - определяет раздел в документе. В соответствии со спецификацией W3C по HTML5: "Раздел — это тематически сгруппированный контент, как правило с заголовком."
**Article** - определяет независимый, самодостаточный контент. Контент, помещенный в этот элемент, должен иметь смысл сам по себе, т. е. он должен быть понятен в отрыве от остальных частей веб-сайта.
Подробнее о **article**, а так же **section** написано [здесь](https://yandex.ru/turbo?text=https%3A%2F%2Fru.hexlet.io%2Fblog%2Fposts%2Fkak-pravilno-ispolzovat-semanticheskie-tegi-article-i-section-nyuansy-html5-i-dostupnosti-saytov).
**Header** -предназначен для определения заголовочного блока или "шапки" документа или раздела. Подробнее [здесь](https://css-live.ru/articles/element-header.html).
**Footer** - предназначен для определения "подвала" документа или раздела.
**Nav** - Предназначен только для основного блока навигационных ссылок.
**Aside** - определяет некий контент, находящийся в стороне от контента, внутри которого он расположен (как боковой блок страницы, "сайдбар").
В целом, тема доступности сайтов довольно обширна. Со всеми нюансами предлагаю ознакомиться в [этой статье](https://developer.mozilla.org/ru/docs/Learn/%D0%94%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%BD%D0%BE%D1%81%D1%82%D1%8C/Whatisaccessibility) и еще советую пройтись по всей серии “HTML шорты”. Еще могу посоветовать ресурс [Веб стандарты](https://web-standards.ru/articles/tags/html/), некоторые статьи писали авторы спецификации HTML5 (переводы на русский). И для понимания, можно ознакомиться с контентной моделью [HTML](https://html5book.ru/kontentnaya-model-html5/).
Микроразметка Schema.org
------------------------
Чаще всего инструкции по включению микроразметки в HTML-код вы будете получать от SEO-специалистов. Но для понимания немного осветим эту тему.
**Schema.org** - стандарт семантической разметки данных, который помогает поисковикам лучше понимать данные, представленные на сайте. Например, с помощью разметки можно явно указать поисковым роботам, что на странице *site.ru/product\_page1* находится товар, и передать основные параметры: *название, цену, артикул, производителя* и т.д. На основе этих данных поисковики формируют расширенные [сниппеты](https://ru.wikipedia.org/wiki/%D0%A1%D0%BD%D0%B8%D0%BF%D0%BF%D0%B5%D1%82) в поисковой выдаче.
Сайты с разметкой отличаются от остальных тем, что в поисковой выдаче их сниппеты более информативны и привлекательны. Они включают в себя больше полезного контента для пользователя. Если конкурент окажется в выдаче выше, но, допустим, у него не будет микроразметки либо там будут реализованы не все фичи, наш сниппет может оказаться больше и привлекательнее. Впоследствии это может выразиться в большем количестве переходов и, соответственно, повышении поведенческих факторов, что в итоге поднимет позиции в выдаче.
Подробно о микроразметке написано в вики [Яндекса](https://yandex.ru/support/webmaster/schema-org/what-is-schema-org.html). Документация [Schema.org](https://schema.org/docs/full.html). Так же стоит обратить внимание и на [гайд от Google](https://developers.google.com/search/docs/guides/intro-structured-data?hl=ru).
Как проверить свой HTML
-----------------------
Так как один из критериев к SEO - это валидная верстка, необходимо прогонять написанный код через ранее упомянутый [валидатор](https://validator.w3.org/). К слову, помимо него есть [валидатор от Google](https://search.google.com/test/rich-results) - в нем необходимо следить за выбранным роботом (Компьютер/Смартфон) и [инструмент от Яндекса](https://webmaster.yandex.ru/tools/microtest/). Эти инструменты помогут Вам в задачах связанных с микроразметкой. Следует сравнивать новый и старый код, удостовериться, что ошибок нет и все существующие ранее сущности правильно считываются.
В целом, работа с ними сводится к тому, чтобы скопировать HTML код из браузера и вставить его в соответствующее текстовое поле валидатора. Можно копировать куски кода сразу из вашего IDE, но это должен быть чистый HTML с готовыми данными. После прохождения проверки вы будете получать уведомления о различных ошибках в коде. **Warning** можно опустить. Но от всех **Error** необходимо избавиться, чтобы верстка удовлетворяла принципам валидной HTML-страницы. В процессе работы могут возникнуть нерешаемые проблемы. Такое стоит гуглить и принимать во внимание, что валидаторы могут не поспевать за всеми нововведениями.
Перейдем к нескольким конкретным примерам (не)валидной верстки и их проверке с validator.w3.org.
**Списки**
К спискам относятся теги ul и ol (маркированные и нумерованные соответственно).
Выглядит это так:
```
* item 1
1. item 1
```
Внутри открывающего и закрывающего тегов *ul* могут стоять только элементы *li*, а уже внутри самих этих элементов (пунктов) можно вставлять любой контент (текст, картинки, заголовки, абзацы, ссылки и даже другие списки). То есть, является не валидной версией, и <https://validator.w3.org/nu/> явно об этом напишет в выводе ошибок (Рис 1).
Рис 1. Ошибка списка**Ссылки**
В использовании тега тоже есть нюанс, в href недопустимы пробелы. То есть, `[phone](tel:+7 (967) 321-22-33)` не является валидным вариантом (Рис. 2), однако `[phone](tel:+7(967)321-22-33)` соответствует всем критериям.
Рис 2. Ошибка ссылки**Атрибуты**
У каждого html тега есть свой набор валидных атрибутов. Часть из них можно увидеть [здесь](https://www.w3schools.com/html/html_attributes.asp), остальное можно найти [тут](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes).
При использовании атрибутов необходимо помнить, что существуют устаревшие.
**Таблицы**
Часто приходится немного корректировать базовые стили таблицы. Раньше такое реализовывалось через соответствующие атрибуты.
```
```
На данный код мы получим сразу 4 ошибки об устаревших атрибутах (Рис. 3).
Рис 3. Устаревшие атрибуты таблицыЭто можно спокойно переписать с использованием стилей и классов.
* **border** - <http://htmlbook.ru/html/table/border>
* **cellpadding** -<http://htmlbook.ru/html/table/cellpadding>
* **cellspacing** - <http://htmlbook.ru/html/table/cellspacing>
* **width** -<http://htmlbook.ru/html/table/width>
Резюмируя вышеописанное получим примерно такой код:
```
.table {
border-collapse: collapse;
width: 400px;
border-spacing: 0;
}
.column {
padding: 0;
border: 1px solid #333;
}
| |
| --- |
| |
```
Подобное решение относится ко всем атрибутам, влияющим на стили элементов. Но есть такие, которые относятся к логике DOM-элементов. Чаще их реализация полностью падает на браузеры. Остальное можно реализовать с помощью JavaScript.
**Атрибут id**
Этот атрибут является неотъемлемой частью HTML. На нем часто завязаны стили и клиентский JavaScript. Данный подход уже давно не используется ввиду усложнения поддержки написанного кода. Используя **id** в браузере, часто можно наткнуться на проблему отсутствия уникальности значений этого свойства. Поэтому чаще всего чистый id заменяют на data-id или более специфичные названия. У нас часто используются data-атрибуты – data-behavior и data-selector. Первый подходит для взаимодействия с пользователем, второй чаще используется для манипуляций с DOM. Однако, насколько я знаю, это необязательное правило. Помимо этого, в css можно писать код с обращением в любые из свойств элементов, будь то data-\* или любой другой атрибут.
Пример микроразметки
--------------------
Помимо примеров валидной верстки хотелось бы привести небольшой кейс использования микроразметки Schema.org. Используя микроразметку, желательно размечать верстку, которая видна на странице и никоем образом не скрывается от пользователя при помощи *opacity*, *visibility*, *display* или *top/left/right/bottom: -100500px*. Поисковики не жалуют скрытый контент. Иногда бывают исключения, но их стоит уточнять у SEO специалистов.
Перед тем, как мы продолжим хотелось бы описать значение используемых атрибутов:
**Itemscope** - задает область действия словаря в структуре данных. Как правило, работает совместно с атрибутом itemtype и задаёт пределы, где itemtype будет активен. У этого атрибута нет значений.
**Itemtype** - указывает адрес словаря, который будет применяться для определения свойств элемента в структуре данных. Яндекс и Google поддерживают стандарт разметки Schema.org. Соответственно, в качестве значения itemtype указывается адрес словаря на этом сайте. К примеру, для разметки организаций используется значение <https://schema.org/Organization>.
**Itemprop** - используется для добавления свойств словаря микроданных к элементу. Имя свойства определяется значением itemprop, а значение свойства определяется содержимым HTML-элемента, к примеру, текстом который располагается внутри элемента.
Приведем пример микроразметки [Article](https://schema.org/Article).
```
<...>
ВсеИнструменты.ру
{{ article.getUpdatedTimeObj().format('d.m.Y') }}
 }})
<...>
```
В данном примере представлена микроразметка статьи. Действие микроразметки ограничено дивом с атрибутами itemscope, itemtype = Article. Внутри включает микроразметку автора статьи и дату публикации. Включает в себя также краткое описание статьи и изображение. В данном кейсе при помощи бэкенда на этапе публикации парсится весь список изображений и выдается фронтенду при помощи метода *getShemaOrgImageUrl()*.
Я не хотел бы сильно погружаться в детальные гайды по микроразметке, поэтому просто укажу несколько полезных статей на эту тему.
1. [Микроразметка для сайта интернет-магазина: как настроить разметку Schema.org для товаров и категорий](https://pr-cy.ru/news/p/7359-mikrorazmetka-dlya-sayta-internet-magazina--kak-nastroit-razmetku-tovarov-i-kategoriy)
2. [Микроразметка товаров](https://dh-agency.ru/mikrorazmetka-tovarov/)
Итог
----
Хотелось бы, чтобы этот материал был вам полезен. Я старался предоставить информацию для работы с SEO-версткой максимально сжато. Надеюсь, я смог достичь этой цели. Данной информации не хватит для формирования по-настоящему SEO-friendly сайта, поэтому я рекомендую использовать дополнительные материалы при разработке своих страниц. Эта тема сложна и обширна. Для плодотворного продвижения и удержания позиций сайта в поисковой выдаче необходимо работать в паре с SEO-специалистом и постоянно вести работы над улучшениями своих продуктов. Спасибо за уделенное время! | https://habr.com/ru/post/538892/ | null | ru | null |
# Три редко используемых возможности Python 3, о которых каждый должен знать
Python 3 существует уже какое-то время и довольно много разработчиков, особенно те, кто только начинает свой путь в Python, уже используют эту версию языка. Несмотря на то, что множество новых возможностей широко используются, похоже, что некоторые остались за кадром. В этой статье я расскажу о трех наименее известных, но полезных, возможностях. Я знаю о них из других языков и они делают Python 3 классным.
*Данная статья является переводом [3 Neglected Features in Python 3 That Everyone Should Be Using](https://medium.com/better-programming/3-neglected-features-in-python-3-that-everyone-should-be-using-65cffc96f235)*.
Перечисления
------------
Перечисления я много использовал в Java и Swift. Продолжаю их использовать теперь и в Python.
Объявление перечисления в Python очень просто сделать и это было возможно и до третьей версии (хотя и с ограничениями):
```
from enum import Enum
class State(Enum):
AIR = 0
LAND = 1
SEA = 2
myState = State.AIR
# Выводит 0
print(myState.value)
# Выводит AIR
print(myState.name)
```
В коде выше перечисление вводится путем объявления класса, наследованного от `Enum`. А далее просто описываются все нужные состояния. В моем случае: `AIR`, `LAND` и `SEA`.
Функциональность, которая была добавлена в Python 3 — возможность использовать `.value` и `.name`. Они позволяют получить число и строку соответствующие перечислению.
Например, вывод значения `State.LAND.name` будет `LAND`.
Перечисления полезны в коде, когда вы хотите иметь некоторые текстовые идентификаторы для констант. Например, вместо сравнения состояния с 0 или 1 гораздо показательнее сравнивать с `State.MOVING` или `State.STATIONARY`. Константы могут меняться и если кто-то посмотрит код позже, то слово `MOVING` даст гораздо больше понимания, чем 0. В результате сильно повышается читабельность кода.
Больше информации можно найти в официальной документации Python 3 по [Enum](https://docs.python.org/3/library/enum.html).
Форматирование
--------------
Добавленные в версии 3.6, `fstrings` — это мощное средство форматирования текста. Они позволяют создавать гораздо более читабельный и безошибочный код (чем я наслаждаюсь после перехода из Java). Это лучше, чем `format`, который использовался ранее в Python. Вот пример использования `format`:
```
name = 'Михаил'
blog_title = 'codeatcpp.com'
# Привет, меня зовут Михаил и я пишу в своем блоге codeatcpp.com.
a = "Привет, меня зовут {} и я пишу в своем блоге {}.".format(name, blog_title)
```
Легко заметить пустые фигурные скобки внутри строки и после список с названиями переменных в определенном порядке.
Теперь посмотрим на такой же код, но с использованием `fstring` — более читабельный и очень похожий на способ форматирования в Swift.
```
name = 'Михаил'
blog_title = 'codeatcpp.com'
# Привет, меня зовут Михаил и я пишу в своем блоге codeatcpp.com.
a = f"Привет, меня зовут {name} и я пишу в своем блоге {blog_title}."
```
Чтобы получить такую аккуратную строку, нужно всего лишь поместить букву `f` перед кавычками, и затем вместо пустых скобок можно сразу писать названия переменных или данные прямо в строке. Поскольку переменные пишутся прямо в строке, нет необходимости считать количество элементов и следить в каком порядке располагать переменные в конце. Они просто находятся сразу там, где нужны их значения.
Использование `fstring` дает более читабельный и более простой в поддержке код, чем использование классических подходов.
Классы данных
-------------
Классы данных может быть более непонятная тема, чем предыдущие, поэтому потребует чуть больше пояснений. Классы данных — это что-то, что мне очень понравилось в языке Kotlin, поэтому я люблю их использовать также и в Python.
Класс данных — это класс, единственная цель которого хранить данные. Класс содержит переменные, которые можно читать и писать, но не имеет никакой дополнительной логики.
Представьте, что у вас есть программа, в которой вам нужно передавать строку и массив чисел между разными классами. У вас могут быть методы вроде `pass(str, arr)`, но гораздо удобнее сделать класс, который содержит строку и массив в качестве единственных членов класса.
Использование класса данных лучше показывает что вы пытаетесь сделать и также упрощает создание юнит-тестов.
Пример ниже показывает простой класс данных, который представляет собой трехмерный вектор, но он может быть легко расширен для представления любой комбинации различных данных:
```
from dataclasses import dataclass
# Определяем класс данных
@dataclass
class Vector3D:
x: int
y: int
z: int
# Создаем вектор
u = Vector3D(1,1,-1)
# Выводит: Vector3D(x=1, y=1, z=-1)
print(u)
```
Здесь легко заметить, что определение класса данных очень похоже на определение обычного класса, за исключением того, что используется декоратор `@dataclass` и затем каждое поле определяется в виде `имя: тип`.
Хотя функциональность созданного `Vector3D` сильно ограничена, суть использования класса данных в том, чтобы повысить эффективность и уменьшить количество ошибок в коде. Ведь гораздо лучше передавать в качестве параметра `Vector3D`, чем набор переменных типа `int`.
Больше информации про декоратор `@dataclass` можно найти в [официальной документации Python 3](https://docs.python.org/3/library/dataclasses.html).
Заключение
----------
Дайте знать в комментариях, как вам эти возможности. Интересно будет услышать про новые сценарии их использования. Удачного кодирования! | https://habr.com/ru/post/514444/ | null | ru | null |
# Наследование методов в GO отсутствует? А вот и нет
Дисклаймер
----------
Статья имеет единственную цель - изучение аспектов языка GO. Жду нескончаемый поток критики и готов к ней.
Предисловие
-----------
Недавно начал изучать GO. По моему мнению: концепция полиморфизма в GO достаточно элегантная. "Путь упрощения ради эффективности" - это мой путь.
Итак, в процессе изучения я "придумал" себе задачу, достаточно нагромождённую, что бы попробовать все, что предлагает GO. И вот на одном из этапов, я спроектировал композицию у которой импортируемая (старшая) структура реализует некий интерфейс и мне понадобилось, что бы принимаемая композицию структура "переопределила" один из методов интерфейса старшей структуры. И как оказалось это возможно! Несмотря на отсутствие в языке типового полиморфизма.
Пример
------
Сразу скажу: пример учебный. Это значит он не является продуктом "хорошего" проектирования архитектуры структур. Все сделано так, как сделано для ясности понимания темы статьи.
Итак, в чем идея?
Вот что имеем изначально:
```
package main
import "fmt"
//Speaker - интерфейс говоруна
type Speaker interface {
toSpeak() //метод говоруна - говорить
}
//speaker - структура описывающая говоруна
type speaker struct {
message string //что нужно сказать хранится здесь
}
//Реализация интерфейса
func (s speaker) toSpeak() {
fmt.Println(s.message)
}
//NewSpeaker -"конструктор" говоруна
func NewSpeaker(message string) Speaker {
var result speaker = speaker{
message: message, //Передаем "что сказать" полю структуры
}
return result
}
//Запускаем говоруна
func main() {
var s Speaker = NewSpeaker("говорю")
s.toSpeak()
}
```
Вывод:
`говорю`
Тут у нас есть Говорун ( структура speaker), который "научился" говорить, реализовав метод интерфейса Speaker.toSpeak().
В main мы создаем говоруна через экземпляр интерфейса, что бы показать, что все у нас полиморфно и может использоваться в коде любого сервера, который умеет обращаться с интерфейсом Speaker ( и не зависеть от частных реализаций этого интерфейса).
Все просто.
Далее на сцену выходит новая структура: Пересмешник - repeater.
```
type repeater struct {
speaker
howManyTimesToRepeat int
}
```
По сценарию, его задача сказать message столько раз, сколько записано в его поле howManyTimesToRepeat, и при этом он имеет встраиваемую композицию от speaker'а.
Вопрос: как переопределить поведение метода интерфейса Speaker.toSpeak() для экземпляров структуры repeater, при этом не реализуя данный интерфейс для структуры repeater ( тем более, что это будет теневой реализацией - перекрытием методов) ?
Ответ, который я хочу показать, заключается в использовании в качестве типа одного из полей структуры speaker функции. GO позволяет хранить функции в структуре!
Для меня, как для новичка, это конечно же открытие. И признаюсь, как его использовать для задачи подобной этой, я додумался сам. Так, что не судите строго, если это окажется частью "всем известных знаний". С первой попытки интернеты ничего мне не подсказали.
И так вот, что получается в итоге:
```
package main
import "fmt"
//Speaker - интерфейс говоруна
type Speaker interface {
toSpeak() //метод говоруна - говорить
}
//speaker - структура описывающая говоруна
type speaker struct {
message string
callBackFunc func() //То самое новое поле хранящее функцию
}
//toSpeak - Реализация интерфейса - !ЭТО ВАЖНОЕ МЕСТО!
//теперь реализация метода интерфеса имеет полиморфное поведение!
func (s speaker) toSpeak() {
//fmt.Println(s.message) <- вот так было раньше
s.callBackFunc() //<- теперь здесь будет вызов той функции, что была сохранена в поле структуры!
}
//howToSpeak - локальная (закрытая) реализация "как говорить" говоруну
func (s speaker) howToSpeakSpeaker() {
fmt.Println(s.message)
}
//NewSpeaker -"конструктор" говоруна
func NewSpeaker(message string) Speaker {
var result speaker = speaker{
message: message, //Передаем "что сказать" полю структуры
}
//!!ЭТО ВАЖНОЕ МЕСТО!
//Назначаем полю частную реализацию метода "как говорить" говоруну
result.callBackFunc = result.howToSpeakSpeaker
return result
}
//repeater - это пересмешник
type repeater struct {
speaker //композиция говоруна в структуре пересмешника
howManyTimesToRepeat int
}
//howToSpeak - локальная (закрытая) реализация "как говорить" пересмешнику
func (r repeater) howToSpeakRepeater() {
fmt.Println(r.message) //Здесь он просто говорит
for i := 1; i < r.howManyTimesToRepeat; i++ {
//А вот здесь он уже передразнивает - повторяет много раз
fmt.Println(r.message)
}
}
//NewSpeaker -"конструктор" пересмешника
func NewRepeater(message string, count int) Speaker {
var result repeater = repeater{
speaker: speaker{
message: message,
},
howManyTimesToRepeat: count,
}
//Назначаем полю - как должен говорит пересмешник
result.callBackFunc = result.howToSpeakRepeater
return result
}
func main() {
var s Speaker = NewSpeaker("говорю")
s.toSpeak()
var r Speaker = NewRepeater("говорю как пересмешник три раза", 3)
r.toSpeak()
}
```
Вывод:
`говорю
говорю как пересмешник три раза
говорю как пересмешник три раза
говорю как пересмешник три раза`
Что же произошло и как это работает?
Прежде всего обратите внимание на новое поле callBackFunc func() структуры speaker ( строка 13) . В этом поле мы будем хранить ссылку на частный метод реализующий "говорение". Для говоруна это будет один метод, для пересмешника другой.
Далее: изменилась реализация метода интерфейса ( строка 20). Теперь вместо статической реализации у метода полиморфное поведение: будет вызван тот метод, который хранится в поле callBackFunc конкретного экземпляра структуры.
Ну остальное, я думаю, и так ясно: У каждой структуры есть своя реализация метода говорения ( howToSpeakSpeaker и howToSpeakRepeater) и в конструкторе каждой структуры назначается в поле callBackFunc нужный метод.
Вроде все, что хотел показать.
Всем спасибо, кто прочел. | https://habr.com/ru/post/653449/ | null | ru | null |
# Microsoft понадобилось 10 дней, чтобы удалить исходники Windows XP с принадлежащего им GitHub
*В исходниках Windows XP нашли секретную тему в стиле Mac*
В сентябре вся индустрия всполошилась после новости об утечке исходных кодов Windows XP и Windows Server 2003. Новость оказалась не фейком. Исходные коды настоящие, и из них [скомпилировали рабочие версии обеих ОС](https://habr.com/ru/news/t/521454/).
Напомним, что всё началось 24 сентября: на портале 4chan неизвестные [выложили торрент](https://habr.com/ru/news/t/520598/) на 42,9 ГБ с полными исходниками Windows XP и Windows Server 2003. Хотя сегодня под XP работает меньше 1% компьютеров в мире, а разработчик не обеспечивает никакой поддержки, утечка исходников всё равно вызвала лёгкую эйфорию среди программистов. Ведь мы много лет [гадали, как реализованы те или иные функции или API](https://habr.com/ru/post/522212/), а теперь можно посмотреть на код своими глазами.
Так или иначе, Microsoft мгновенно начала войну. Уже на следующий день исходники стали удалять везде, где только можно.
Одновременно Microsoft [запустила внутреннее расследование](https://habr.com/ru/news/t/520746/) по поводу утечки. Вероятно, она произошла через от одну из компаний-партнёров или правительственные организации, с которыми Microsoft вынуждена делиться исходниками для аудита безопасности.
Утечка началась через 4chan, торренты и файлообменник Mega. Файл с Mega был удалён практически сразу после жалобы правообладателя.
С торрентами пришлось повозиться. Хотя некоторые торрент-трекеры действительно реагируют на запросы об удалении информации, сайты вроде The Pirate Bay с радостью индексируют практически всё, включая утечки исходного кода. Здесь даже могущественная Microsoft мало что может сделать.
В крупных агрегаторах информации, как Google или Twitter, ссылки на исходный код были удалены практически полностью и очень быстро, но если ввести в строке поиска значение из magnet-ссылки, то оно встречается и у Google, и у Twitter (если вы хотите нарушить закон и скачать исходники, то совет — в торренте нужен только файл *nt5src.rar*).
Это не кликабельная ссылка, а просто хеш, сочетание букв и цифр:
```
3d8b16242b56a3aafb8da7b5fc83ef993ebcf35b
```
В принципе, запретить это сочетание символов никто не может согласно первой поправке к Конституции США о свободе слова. Эти символы можно свободно печатать на кружках и одежде, как по отдельности, так и целиком.
Но через несколько дней после утечки началось самое интересное. 29 сентября некий разработчик под ником `shaswata56` решил, что неплохо будет разместить исходный код Windows XP в репозиторий на Github, чтобы мир мог его увидеть и скачать — для более удобного обсуждения, исправления ошибок и так далее. Интересно здесь то, что Github принадлежит Microsoft, поэтому Microsoft фактически сама разместила утечку собственного кода.
Учитывая серьёзность инцидента, можно было предположить, что Github мгновенно обнаружит и удалит репозиторий. Но этого не произошло. Несмотря на всю огласку, Microsoft потребовалось целых десять дней, чтобы что-то с этим сделать. Более того, **ей пришлось отправить собственной компании уведомление DMCA с просьбой удалить код!**
«Я работаю в Microsoft Security Incident Response. Код, о котором идёт речь, взят из утечки исходного кода Windows XP, — говорится в [уведомлении DMCA](https://github.com/github/dmca/blob/master/2020/10/2020-10-08-xp.md) от 8 октября в адрес Github. — Контент на Github извлечён непосредственно из торрента (который также удалён)», — сказано в документе.
Изначально в этом уведомлении даже было указано вышеупомянутое хеш-значение из торрента `7c370b5e00b91b12fc02e97bacdca24306dc12b5`, но позже Microsoft опомнилась и удалила его. Однако оно сохранилось в архивных копиях заявления.
Очевидно, Microsoft ошибается в утверждении, что торрент «удалён», поскольку magnet-ссылка широко разошлась в интернете.
Тем не менее, при большом желании и вмешательстве самого высшего руководства, наверное, можно было бы легко принудить дочернюю компанию сделать то, что хочет начальство, — удалить исходный код. Это заняло бы 5 минут. Один телефонный звонок. Вместо этого потребовалось ровно 10 дней — целая вечность, когда речь идёт об утечках; даже немного неловко, что ваш собственный сайт столько времени распространял утечку, гайз.
Учитывая то, что в кеше Google тоже до сих пор доступны magnet-ссылки, есть другая версия. Возможно, Microsoft понимает, что все эти меры бесполезны. Может, она не слишком беспокоится или даже рада публикации исходников. Вдруг сообщество найдёт серьёзные баги в тех частях кода, которые до сих пор работают в Windows 10 и Windows Server 2019 (а таких частей, наверняка, немало). И Microsoft сможет исправить эти ошибки. | https://habr.com/ru/post/523262/ | null | ru | null |
# Гибриды побеждают или холивары дорого
Мотивом для написания данной статьи послужил тот факт, что на habr.com участилось появление материалов маркетингового характера про Apache Kafka. А также тот факт, что из статей складывается впечатление что пишут их немного далекие от реального использования люди — это конечно же только впечатление, но почему-то в большинстве своем статьи обязательно содержат сравнение Apache Kafka с RabbitMQ, причем не в пользу последнего. Что самое интересное — читая подобные статьи управленцы без технического бэкграунда начинают тратить деньги на внутренние исследования, чтобы ведущие разработчики и технические директора выбрали одно из решений. Так как я очень жадный/домовитый, а также так как я сторонник тезиса "В споре НЕ рождается истина" предлагаю вам ознакомится с другим подходом — почти без сравнения разных брокеров.
Без сравнения никуда
--------------------
Вообще, по правильному, я должен был сделать статью в формате `Kafka+RabbitMQ+Nats+ActiveMQ+Mosquito+etc`, но мне кажется, что для Вас дорогие читатели это будет перебор, хотя обычно в моих архитектурных решениях присутствуют все вышеуказанные сервисы (и не только). И это я еще не рассказываю про AzureServiceBus/AmazonServiceBus — которые также участвуют в "гибридах" при крупных программах проектов. Поэтому пока остановимся на связке Kafka+RabbitMQ и далее вы поймете почему: по аналогии можно подключить любой сервис с его протоколом. Потому что:
> сравнивая Apache Kafka и RabbitMQ вы сравниваете 2 (два) бренда, а точнее 2 коммерческие компании — Confluent и vmWare, и немножко Apache Software Foundation (но это не компания)
то есть формально при сравнении мы должны сравнивать бизнес-модели компаний которые являются основными драйверами развития наших сегодняшних подоопытных. Так как Хабр все таки не портал экономических исследований, поэтому мы для начала должны вспомнить не бренды, а те описания которые стоят за этими брендами (то как сами себя называют наши сегодняшние участники).
* **RabbitMQ** — мультипротокольный и расширяемый брокер сообщений
* **Apache Kafka** — платформа для распределенной потоковой передачи событий
* **Confluent Platform** — платформа потоковой передачи событий с возможностью создания высокопроизводительных конвейеров обработки данных для целей аналитики и интеграции в бизнес-сценариях
Я не зря третьим пунктом выделяю наработки компании Confluent — те кто собирается использовать Apache Kafka в продуктиве должны хотя бы видеть какую функциональность дополнительно добавляет Confluent к Apache Kafka. А это `SchemeRegistry`, `RestProxy`, `kSQL` и еще несколько интересных штук, о одной из которых мы поговорим ниже, она называется **`Kafka-Connect`**.
Но вернемся к сравнению — внимательный читатель видит, что RabbitMQ сам себя называет брокером сообщений выделяя свою главную фишку "мультипротокольность", а товарищи из экосистемы Kafka почему-то называют себя аж платформой (завышенное самомнение оно такое).
Итак — чтобы было совсем понятно, куда я веду.
* ключевая особенность RabbitMQ — **мультипротокольность** и расширяемость. (основной язык якобы Erlang)
* ключевая особенность экосистемы Kafka — **потоковая передача с обработкой** (основной язык якобы Scala/Java)
Отсюда и возникают минусы каждого из решений
* для RabbitMQ мы не сможем построить нормального решения для потоковой обработки. Точнее сможем, но **НЕ штатно**.
* а для Kafka мы не сможем сделать мультипротокольность, точнее сможем но **НЕ штатно**.
Сократ не говорил, что в споре рождается истина
-----------------------------------------------
Еще одна новость: действительно, если почитать источник, то Сократ вообще-то в итоге пришел к тому, что нужно обеспечить диалог, а если по научному — то истина рождается в `научном споре`, который формально представляет собой процесс `публикация со ссылкой на источники` -> `а затем научная критика оппонентов` -> `истина`
А значит перейдем к ссылкам — для начала их будет три. Когда 14 лет назад я совместно с коллегами начинал использовать брокеры сообщений в качестве основы для построения своих интеграционных решений, мы сразу обратили внимание, что фактически с точки зрения "клиента" (конечного приложения), под разные задачи подходят разные протоколы интеграции.
* ODBC
* AMQP
* MSMQ
* XMPP
* IP over Avian Carriers
так как тогда наша задача была интегрировать всякое (python, C#, java) и 1С — был придуман проект `One-S-Connectors` ([ссылка](https://code.google.com/archive/p/one-c-connectors/source/default/source)). Сейчас он имеет сугубо академический интерес (так как в 1С мире моя персона достаточно известна и на Хабре много 1С специалистов из сообщества "воинствующих 1С-ников" — эта ссылка специально для них).
Однако уже тогда (в 2006 году) стало понятно, что по большому счету конечному разработчику придется менять/выбирать протокол под бизнес-задачу. А инфраструктурщикам придется обеспечить максимально широкий спектр интеграционных протоколов. От ODBC до Kafka/NATs/ModBus.
Но вернемся к дню сегодняшнему — когда я начал использовать в проектах уровня ГИС (государственные информационные системы) различные транспорта данных `внезапно выяснилось`, что универсальные адаптеры — это не только концепт воинствующих 1С-ников, но и соседей. Поэтому многие идеи при внедрении черпались из еще двух интересных проектов
* [библиотека Kombu (для Python)](https://docs.celeryproject.org/projects/kombu/en/stable/introduction.html#transport-comparison)
* [комплект CAP для .NetCore](https://github.com/dotnetcore/CAP)
> маленькое примечание для менеджеров про Kombu — как то так получилось, что имплементация протокола Apache Kafka до сих пор [открыта](https://github.com/celery/kombu/issues/301) и почему-то перешла в разряд "Дайте денег", поэтому для Python проектов приходится использовать дополнительно <https://github.com/confluentinc/confluent-kafka-python>
Когда вы дочитаете до этого момента — предполагаю, что вы зададите вопрос про остальные языки: Java, GoLang, RUST, etc. Но во первых я не зря выше указал что по серьезному в наш обсуждаемый сегодня гибрид нужно добавить историю про NATs и ActiveMQ и внезапно JMS — поэтому просьба дочитать до конца: Java будет, а во вторых мы переходим к еще трем полезным ссылкам
* <https://github.com/rabbitmq/rabbitmq-server/tree/master/deps/>
* <https://docs.confluent.io/current/connect/kafka-connect-rabbitmq/index.html>
* <https://github.com/84codes/kafka-connect-rabbitmq/blob/master/docker-compose.yml>
Прокомментируем их? Дело в том, что как бы вы не хотели, а для полноценного использования "в длинную" — вам придется подписаться на историю релизов как сервера RabbitMQ и самое главное на те самые **расширения** (лежат в каталоге `/deps`) которые постоянно добавляются в ядро RabbitMQ, так и на портал компании Confluent где она публикует приложения полезные для конечного бизнеса использующего Apache Kafka в продуктиве.
> подход к расширяемости за счет активируемых расширений также используется в экосистеме PostgreSQL — тот который `CREATE EXTENSION hypopg`, так что подход реализованный компанией Pivotal/vmWare далеко не новый в нашем чудесном мире архитектуры программного обеспечения
Дополнительно — на чудесном рынке облачных услуг в формате "Серьезная штука как сервис" есть еще один игрок — это [`компания 84Codes`](https://github.com/84codes). Когда в рамках проектов внедрения нет нормальных инженеров по инфраструктуре — именно **84Codes** спасает пилотные проекты, потому как у них можно легко арендовать бесплатные/сильнодешевые контура CloudAMQP и CloudKarafka.
Я как бы обещал, что не буду ничего говорить про деньги, однако придется отразить 2 ключевых момента:
* компания vmWare зарабатывает известно на чем, поэтому RabbitMQ ей развивается как часть своей платформы — то есть они инвестируют в открытый проект не особо занимаясь его монетизацией. Возврат их инвестиций происходит в других местах, ну и также за счет контрибьюторов на GitHub.
* а вот компания Confuent собирается монетизировать свою платформу через Enterprise лицензию в которую включает те самые коннекторы **Enterprise-Kafka-Connect**, а также GUI для управления платформой.
> Когда-то давно существовал <https://github.com/jcustenborder/kafka-connect-rabbitmq>, примечателен тот факт, что товарищ Джереми его скрыл, оставив только свои наработки для Java разработчиков в виде [Maven Archetype](https://github.com/jcustenborder/kafka-connect-archtype) — еще раз обращаю Ваше внимание, что компания Confluent будет и дальше пытаться монетизировать свою деятельность, так что переводить всю интеграцию только на Kafka я бы на вашем месте поостерегся.
Поэтому когда вам **`топят за Kafka`** учитывайте, что вы либо изучаете Java, либо платите за Enterprise лицензию. А когда вам **`топят за RabbitMQ`** учитывайте, что либо вы изучаете системное администрирование (Erlang накладывает особенности системного администрирования), либо покупаете сервис у провайдеров типа `84Codes`. Кодить на Erlang никогда не придется — там это не нужно, если только вы не контрибьюторы OpenStack.
Поставил и забыл — уже не работает
----------------------------------
Приближаемся к дальнейшему пониманию. Данный раздел уже будет полезен инфраструктурщикам, хотя и разработчикам важно знать, что в эпоху когда семимильными шагами развивается имплементация ITILv4, для того чтобы перейти от текста и менеджерских хитростей про риски и деньги к реальности нам придется осознать 3 тезиса
* использование только одного протокола интеграции приводит к появлению **ProtocolLock** и как следствие к **VendorLock** — я же не зря выше написал, что за каждым открытым продуктом, стоит какой-то ключевой комплект вендоров — как они себя поведут: мы не знаем.
* в мире ИТ больше нет серьезных продуктов, которые бы представляли собой монолитную службу — все приложения давно стали **композитными**.
* все нормальные вендоры сокращают свои релизные циклы по ключевым продуктам — нормальной практикой стало выпускать редакции **`раз в 3 месяца`** — `TDD, BDD, CICD, ScallableAgile и DevOps (DocOps, DevSecOps)` — эти инженерные практики и методики управления не просто так развиваются. Всем очень хочется сокращать себестоимость и **TimeToMarket**.
Абзац выше важен, как финальный аккорд, прежде чем мы перейдем к *Docker-Compose*. А именно к нему я вел — чтобы и разработчики и инфраструктурщики понимали что такое **гибридная инфраструктура в режиме мультипротокольности (с)** — нужно сделать так, чтобы каждый мог поэкспериментировать с предлагаемым контуром. Как я уже указал выше — первично подобное применительно к Kafka+RabbitMQ было подсмотрено именно у коллег из [`84Codes`](https://www.84codes.com/) (хорошие ребята — всем советую).
Чтобы вы смогли поэкспериментировать сами
-----------------------------------------
Итак подходим к примерам, так как обоснования и вводных уже хватит. Предположим вы уже поняли, что вам также нужна мультипротокольность, однако мы же помним, что все рекламные материалы про Apache Kafka нам рассказывают что это единственное решение с реализацией `exactly-ones` доставки сообщений от отправителя получателю. Собственно на самом деле — нам и нужен гибрид, чтобы сделать из связки `ТочкаОбмена->Очередь` журнал Kafka (это тот который `Topic`) — чтобы возникла сущность под называнием `Offsets` у нашей очереди событий.
**exactly-ones**
проверка на внимательность читающего **exactly-ones** — это шутка в формате "Хотя бы один раз из 1С", а имеется в виду концепт **Exactly once** — строго однократная доставка сообщений получателю, без необходимости повторной отправки от отправителя.
Предлагаю попробовать. Концепт для проверки Вашими руками будет состоять из:
* Zookeper
* KafkaBroker
* RabbitMQ
* KafkaConnect
и трех приложений приложений
* отправитель на Python по протоколу AMQP 0.9
* получатель на С# по протоколу AMQP 1.0
* получатель на C# по протоколу Kafka
> Еще интересное замечание: когда вы смотрите на всякие обучающие видео по Apache Kafka — авторы часто (но не всегда) старательно пишут примеры на Java, это они делают скорее всего для того, чтобы скрыть от вас особенности использования **librdkafka** — C++ библиотеки на основе которой сделаны многие не-джава адаптеры,. Я же наоборот предлагаю вам начинать исследование интеграции с Kafka именно с неё, чтобы четко оценивать риски "куда вы ввязываетесь": очень примечательно что там работает фактически один разработчик, формально в одиночку <https://github.com/edenhill/librdkafka/pulse/monthly>, а допустим wmWare старается поддерживать [свою линейку](https://github.com/rabbitmq) клиентов под своим брендом.
Ну и самое главное и тяжелое:
контур содержит открытый форк старого `RabbitMQ-Kafka-Sinc-Connector` — того самого который товарищи из Confluent в своё время скрыли с Github.
Докер контура для экспериментов
-------------------------------
Для показательного эксперимента мы сделаем 2 композитных приложения — инфраструктурное-трансформационное и непосредственно бизнес-приложения.
### Развертываем RabbitMQ и Kafka
контур инфраструктуры который нам понадобится — запускается достаточно просто
```
docker-compose -f dockers/infra.yml up -d
```
Если вам интересно что же там внутри, нашего композитного приложения, то в конце статьи дается ссылка на полный комплект исходников, наиболее интересен в нем **Kafka-UI** и непосредственно **RabbitMQ-Sinc**, все остальное обычно и штатно для всех известных примеров по Kafka или RabbitMQ
```
image: provectuslabs/kafka-ui:latest
ports:
- 8080:8080
depends_on:
- kafka-broker
- zookeeper
environment:
KAFKA_CLUSTERS_0_NAME: local
KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: broker:29092
KAFKA_CLUSTERS_0_ZOOKEEPER: zookeeper:2181
KAFKA_CLUSTERS_0_JMXPORT: 9101
```
Но самое главное кроется в репозитории Java
```
com.github.jcustenborder.kafka.connect
kafka-connect-parent
1.0.0
```
Если подробно изучить **pom.xml** — то выяснится, что существует [заглавный проект для всех коннекторов к Кафка](https://github.com/jcustenborder/kafka-connect-parent), в котором используется Java-Kafka-Adapter
И непосредственно синхронизацией c RMQ занимается [штатный Java клиент](https://www.rabbitmq.com/java-client.html):
```
com.rabbitmq
amqp-client
${rabbitmq.version}
```
Таким образом — по правильному, чтобы получились повторить тот же эксперимент что и у меня, необходимо выполнить:
* собрать из исходников java синхронизатор — `-1-build-connect-jar.bat`
* собрать контейнер с синхрозатором — `00-build-connect-image.sh`
и уже потом запустить полный инфраструктурный контур
* стартуем полный инфраструктурный контур — `01-start-infra.sh`
> обратите внимание — так как Docker использует разное поведение при работе с PWD для Windows и Linux — приходится делать дубликаты скриптов. В остальных случаях — под обоими операционными системами используется интерпретатор sh
В итоге вы получите следующий комплект сервисов
На картинке можно увидеть как подключаются конфигурационные файлы к RabbitMQ и какая топология сетевых портов у нас будет участвовать в эксперименте:
Назначение портов:
* **9092** — будет использоваться для Kafka протокола
* **8080** — используется для отображения красивой картинки состояния Apache Kafka UI
* **5672** — будет использоваться для протокола AMQP 0.9 и он же будет работать и как AMQP 1.0
* **15672** — используется для красивой картинки управления RabbitMQ
* **28082** — отладочный порт для управления через `curl` трансформатором протоколов
В этот момент нужно остановиться и прокомментировать особенность развертывания RabbitMQ в Docker:
* хорошей практикой является версионирование включенных плагинов расширений — `enabled-rmq-plugins`
```
[
rabbitmq_management,
rabbitmq_amqp1_0,
rabbitmq_mqtt,
rabbitmq_federation,
rabbitmq_federation_management,
rabbitmq_shovel,
rabbitmq_shovel_management,
rabbitmq_prometheus
].
```
* а также в крупных проектах когда нужно передать разработчику преднастроенную топологию точек обмена и очередей, можно и нужно добавлять это в виде конфигурационного файла — `rmq_definitions.json`
```
"bindings":[
{
"source":"orders-send",
"vhost":"/",
"destination":"orders-amqp-10-consumer",
"destination_type":"queue",
"routing_key":"",
"arguments":{
```
### Запускаем наши приложения
Остается только запустить наши приложения эмулирующие подключения
```
docker-compose -f dockers/infra.yml restart protocol-connect-sync
docker-compose -f applications.yml build
docker-compose -f applications.yml up
```
Топология наших тестовых приложений достаточно простая
Исходный код также максимально упрощён:
* отправляется как-будто бы заказ `Васи` с периодичностью в 2 секунды
```
producer = conn.Producer(serializer='json')
producer.publish({'client': 'Вася', 'count': 10, 'good': 'АйФончик'},
exchange=order_exchange,
declare=[kafka_queue, amqp10_queue])
time.sleep(2)
```
```
RUN python -m pip install \
kombu \
librabbitmq
```
причем используется для этого максимально производительная библиотека на Си для AMQP 0.9 — [librabbitmq](https://github.com/alanxz/rabbitmq-c) наследуется именно от неё.
* создан подписчик который уже по протоколу AMQP 1.0 — смотрит в свою очередь и получает события, соответственно очередь очищается и больше мы заказов Васи не получим. В этом потоке нам это и не нужно.
```
Attach recvAttach = new Attach()
{
Source = new Source()
{
Address = "orders-amqp-10-consumer",
Durable = 1,
},
```
```
ReceiverLink receiver =
new ReceiverLink(session,"netcore_amqp_10_consumer", recvAttach, null);
Console.WriteLine("Receiver connected to broker.");
while (true) {
Message message = receiver.Receive();
if (message == null)
{
Console.WriteLine("Client exiting.");
break;
}
Console.WriteLine("Received "
+ System.Text.Encoding.UTF8.GetString((byte[])message.Body)
```
Причем в качестве драйвера выбран
```
```
именно его <https://github.com/Azure/amqpnetlite> Microsoft использует для маркетинга своей реализации сервисной шины. Собственно именно **AMQP 1.0** как протокол они и [рекламируют](https://docs.microsoft.com/ru-ru/azure/service-bus-messaging/service-bus-amqp-overview).
Ну и финально
* создан подписчик по протоколу Kafka — который при каждом старте перечитывает с нуля журнал отправленных заказов Васи. Тот самый **Exactly once**.
```
AutoOffsetReset = AutoOffsetReset.Earliest
```
```
c.Subscribe("orders-from-amqp");
```
```
while (true)
{
try
{
var cr = c.Consume(cts.Token);
```
Выглядит наш контур в итоге следующим образом:
* 5 инфраструктурных контейнеров
* 3 контейнера с приложениями
* готовый журнал транзакций заказов который можно посмотреть через Kafka-Ui
* и готовый контур связей для RabbitMQ
#### А где же Java ?
Не волнуйтесь — при таком гибридном подходе, без неё никуда, для того чтобы всё вышеуказанное заработало пришлось сделать форк и актуализировать версии Kafka-Connect-Base
```
[submodule "dockers/rabbitmq-kafka-sink"]
path = dockers/rabbitmq-kafka-sink
url = https://github.com/aliczin/kafka-connect-rabbitmq
```
Но самое интересное не это, самое интересное что в этом самом Kafka-Connect нет по сути никакой магии — только код трансформации.
По сути нам предлагают:
* создать наследника абстрактной задачи Источника
```
public class RabbitMQSourceTask extends SourceTask {
```
* выполнить подписку на очередь сообщений
```
this.channel.basicConsume(queue, this.consumer);
log.info("Setting channel.basicQos({}, {});", this.config.prefetchCount, this.config.prefetchGlobal);
this.channel.basicQos(this.config.prefetchCount, this.config.prefetchGlobal);
```
* трасформировать полученные сообщения в абстрактные записи причем с буфером.
```
@Override
public List poll() throws InterruptedException {
List batch = new ArrayList<>(4096);
while (!this.records.drain(batch)) {
```
Отдельно можно выделить чудесный трансформатор сообщений из AMQP 0.9 в Кафка. У несведующего в Java глаз может задергаться. У автора чувствуется многолетний опыт работы в J2EE.
```
private static final Logger log = LoggerFactory.getLogger(MessageConverter.class);
static final String FIELD_ENVELOPE_DELIVERYTAG = "deliveryTag";
static final String FIELD_ENVELOPE_ISREDELIVER = "isRedeliver";
static final String FIELD_ENVELOPE_EXCHANGE = "exchange";
static final String FIELD_ENVELOPE_ROUTINGKEY = "routingKey";
static final Schema SCHEMA_ENVELOPE = SchemaBuilder.struct()
.name("com.github.jcustenborder.kafka.connect.rabbitmq.Envelope")
.doc("Encapsulates a group of parameters used for AMQP's Basic methods. See " +
"`Envelope `\_")
.field(FIELD\_ENVELOPE\_DELIVERYTAG, SchemaBuilder.int64().doc("The delivery tag included in this parameter envelope. See `Envelope.getDeliveryTag() `\_").build())
.field(FIELD\_ENVELOPE\_ISREDELIVER, SchemaBuilder.bool().doc("The redelivery flag included in this parameter envelope. See `Envelope.isRedeliver() `\_").build())
.field(FIELD\_ENVELOPE\_EXCHANGE, SchemaBuilder.string().optional().doc("The name of the exchange included in this parameter envelope. See `Envelope.getExchange() `\_"))
.field(FIELD\_ENVELOPE\_ROUTINGKEY, SchemaBuilder.string().optional().doc("The routing key included in this parameter envelope. See `Envelope.getRoutingKey() `\_").build())
.build();
```
Но… Не будем критиковать, мы же в самом начале договорились — что наша главная задача добиться конечного результата удобным на сегодня способом. А итоги у нас получаются следующие.
Итоги
-----
Все что здесь продемонстрировано естественно лежит на Github.
В репозитории — <https://github.com/aliczin/hybrid-eventing>. Лицензия выставлена простая до невозможности **Creative Commons Attribution 4.0 International**.
Полезно использовать в обучающих целях для команд разработки и инфраструктуры — и поиграться с DevOps и поиграться с мультипротокольными приложениями. Ничего особо экстравагантного в данном концепте конечно нет, ключевое тут я как я написал в самом начале — мы делаем избыточное количество интеграционных протоколов, добавляя транформаторов между потоками интеграции.
Схема коммуникации в итоге для "разработчика интеграционных потоков" (с) выглядит следующим образом — для источника и брокеров
```
orderEventsApp->Amqp09: send order
Amqp09->Amqp10: fanout\n copy event
Amqp09->KafkaQ: fanout\n copy event
KafkaQ->KafkaConnect: consume\n on message
KafkaConnect->KafkaConnect: transform\n message
KafkaConnect->Kafka: publish to topic
```
а для приемников — все упрощается
```
Amqp10->orderEventSubApp: subcribe\n for event
orderJournalApp->Kafka: read kafka journal
```
> Приемники берут нужные им данные только по нужному им протоколу
Ключевые посылы
---------------
Ключевые моменты которые я хотел раскрыть данной статьей
* стройте эксперименты и продуктивы с Apache Kafka не со штатным Java клиентом, а librdkafka и базирующихся на ней адаптерах — это позволит вам отладить сценарии разных версий протоколов `KafkaAPI`. Java вам пригодится в другом месте.
* не ввязывайтесь с священные войны, что лучше RabbitMQ/Kafka/Nats/ActiveMQ — просто развертывайте сервисы и публикуйте протоколы и пробуйте свои бизнес-сценарии.
* начните уже внедрять продуктивный Docker, или хотя бы пилотные и разработческие контура.
* реальный ИТ ландшафт почти всегда будет мультипротокольным
Примечание для понимающих
-------------------------
чтобы гибриды развивались дальше:
* **Mosquito** — очень удобен как встраиваемый брокер на уровне контролера SCADA для преобразования из ModBus/OPC-UA. Хотя как вы уже поняли из статьи — интересны реализации "мостов из протокола в протокол" — пример <https://github.com/mainflux/mainflux>
* **ActiveMQ** — удобен для Java разработчиков, потому что у них есть боязнь Erlang, но как мы выше уже сказали — мост `RabbitMQ AMQP 1.0 -> ActiveMQ` легко организуется средствами RabbitMQ, кстати также как и JMS.
* **NATs** — интересен как часть `OpenFaaS` платформы, при внедрении "своего маленького" `Amazon Lambda` с преферансом. И опять же подход будет всё тот же — мультипротокольные мосты с трансформацией: <https://github.com/nats-io/nats-kafka> — если Вам не страшно [посмотрите эксперименты с OpenFaaS веселых 1С-ников](https://youtu.be/8sF-oGGVa9M) — 2.5 часа примеров.
Надеюсь мой архитектурный подход Вам придется по душе и вы перестанете тратить деньги заказчика (инвестора/свои — если вы стартапщик: Маша это замечание специально для тебя) на бессмысленные обсуждения что же выбрать в качестве брокера/платформы, и начнете наконец-то делать функциональность, которая будет использовать тот протокол, который удобен прямо сейчас. С возможностью переключения в случае **"если чё"**
```
Функциональность: Мультипротокольный адаптер
Как разработчик я хочу иметь абстракцию Produser/Consumer
С возможностью изменения протокола интеграции
Чтобы под каждую задачу выбирать разные протоколы
и единый интерфейс вызова для обеспечения независимости от вендора предоставляющего транспорт
Сценарий: vmWare реализует протокол Stream средствами RabbitMQ
Когда vmWare закончит свой плагин для потоков
Тогда я активирую новый протокол
И быстро воткну его в приложение
И так как у меня есть продуктивный кластер RabbitMQ
И мне нужно будет просто поменять канал для отдельных бизнес сценариев
Сценарий: Завтра придут 1С-ники со своим ActiveMQ из Шины для 1С
Когда мне нужно быстро включить очереди 1С в общий контур
И чтобы на Питоне использовать старые наработки с Kafka API
Тогда я добавляю трансформацию ActivemeMQ2Kafka
и живу по старому а события ходят уже и из 1С
etc
```
А чтобы вы не думали, что данный подход — это нечто уникальное — вот Вам еще [интересная ссылка](https://github.com/fclairamb/ftpserver/pull/34) — это когда нужен FTP сервер, а хочется S3.
Ну и в качестве финального момента — обратите внимание: есть и риски данного подхода: но они я думаю Вам и так понятны.
* Придется оркестрировать такой комплект сервисов и вручную это почти невозможно. Придется использовать DevOps штуки типа k8s, OpenShift, etc — но если вы уже решились на интеграцию в режимах слабой связаности приложений в режиме онлайн, у вас что-то на эту тему уже скорее всего есть.
* Трансформаторы между протоколами приходится дорабатывать — ничего готового открытого и PRODUCTION-READY на данный момент найти почти невозможно.
### Финальное примечание для любителей писать ТЗ по ГОСТу
так как Хабр читают любители цифровой трансформации (чтобы кто ни понимал под этим словом) советую в техническое задание добавлять не упоминание конкретных реализации серверов, а что-то примерно следующее:
> комплект программ для интеграции должен реализовывать коммуникацию конечных приложений по открытым протоколам HTTP, AMQP 0.9, AMQP 1.0, Apache Kafka не ниже версии 23, MQTT, WebSockets, <ЛюбойДругойХотьSOAPХотяЭтоЖуть> с возможность преобразования между протоколами дополнительными средствами администрирования
Надеюсь моя публикация после долгого перерыва Вам будет полезна в ваших интеграционных проектах. Предполагаю что будет вопрос про 1С — и тут у меня совет только один. Используйте Google по ключевым словам `1С+RabbitMQ или 1С+Kafka или 1С+OpenFaas` — и RabbitMQ и Kafka "в 1С" давно и непринужденно используются. Потому что 1С — это не только язык, но и несколько сообществ где уже давно сделаны все возможные адаптеры и платные и бесплатные. Собственно как и в Java/C#/Python/C++/Rust/etc.
Данная статья написана с применением расширения <https://shd101wyy.github.io/markdown-preview-enhanced> для Visual Studio Code — за что автору летят дополнительные лучи добра.
Ну и в качестве финального момента хотел бы заметить, что выбор `Cunfluent Inc` в качестве платформы разработки `Kafka-Connect` — экосистемы JDK выглядит все таки странно. Не удивлюсь если их конкуренты сделают такое же, но на GoLang, NodeJS (что-нибудь типа `Kafka-Beats-Hub`).
Красивые картинки в формате GraphViz я делаю при помощи хитрого проекта Docker2GraphViz — помогает поддерживать актуальный контур и техническую документацию в формате Markdown
```
set CURPATH=%~dp0
set DOCKER_DIR=%CURPATH%\dockers
docker run --rm -it --name dcv -v %DOCKER_DIR%\:/input pmsipilot/docker-compose-viz render -m image --force --output-file=infra-topology.png infra.yml
docker run --rm -it --name dcv -v %CURPATH%\:/input pmsipilot/docker-compose-viz render -m image --force --output-file=apps-topology.png applications.yml
copy /b/v/y dockers\infra-topology.png content\assets\infra-topology.png
copy /b/v/y apps-topology.png content\assets\apps-topology.png
``` | https://habr.com/ru/post/536680/ | null | ru | null |
# Git scraping: методика бесплатного хостинга не совсем статических сайтов
Ни для кого не секрет, что, используя GitHub Pages, вы можете бесплатно разместить свой статический веб-сайт в сети Интернет. 1 Гбайт доступного пространства, SSL-сертификат, возможность привязать собственный домен — разве не сказка? Но что делать, если вам необходимо, чтобы содержимое вашего статического ресурса периодически обновлялось? Допустим, несколько раз в час.
Пути решения уже существуют, и в этой статье я расскажу об одном из них. Вооружившись GitHub Actions в качестве среды выполнения и отдельной веткой Git-репозитория в качестве хранилища, мы организуем автоматизированный пайплайн получения, обработки и отображения малых неконфиденциальных данных, который будет ежемесячно нам обходиться в целых 0 рублей.
Давайте сразу расставим все точки над i: данная статья не будет повествовать о no-code решениях и визуальном программировании. Для реализации подобного пайплайна вам необходимо владеть хотя бы одним языком, имеющим инструменты для генерации статических страниц. Python, Java, JavaScript, C#, Go, Ruby — нет особой разницы, что вы используете. Мне по душе Python и Rust, поэтому я буду приводить примеры на этих двух языках.
Процесс, который мы построимТакже я не буду углубляться в парсинг и преобразование данных, потому что эта часть кода сильно зависит от вашей прикладной задачи, и разбор этих методов выходит за рамки моей статьи. Я буду отмечать подобные места в коде, как *"not implemented"*. Приступим!
Git scraping как часть ETL
--------------------------
Вы наверняка слышали об [ETL](https://ru.wikipedia.org/wiki/ETL) — это один из основополагающих процессов работы с данными. Аббревиатура расшифровывается как extract, transform, load — извлечение, преобразование и загрузка. Сначала мы откуда-то берём данные, затем обрабатываем, изменяя их форму, и после этого помещаем результат в *определённое место*.
Британский программист [Саймон Виллисон](https://en.wikipedia.org/wiki/Simon_Willison), известный нам по Django Framework, в 2020 году предложил в качестве того-самого конечного *определённого места* использовать Git-репозиторий. Эту технику Саймон назвал **Git scraping**. [В своей статье разработчик показывает](https://simonwillison.net/2020/Oct/9/git-scraping/), как можно использовать данную методику для периодического отслеживания изменений интересующих вас данных. По сути, это только "extract" и "load" из вышеупомянутой аббревиатуры.
Здесь же мы продвинемся немного дальше: добавим заготовку под "transform", а также позаботимся о том, чтобы наши данные было удобно просматривать конечному пользователю, то есть применим генерацию статических веб-страниц. Конечно же, сайт не будет полностью статичен, его содержимое будет меняться по расписанию, которое укажете вы. Никто не говорит о realtime, но несколько раз в час — без проблем.
Виновники торжестваЗаранее стоит обговорить ограничения GitHub Actions и GitHub Pages (актуальные на февраль 2023):
* Время работы GitHub Actions [ограничено](https://docs.github.com/ru/billing/managing-billing-for-github-actions/about-billing-for-github-actions#%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BE%D0%B1%D1%8A%D0%B5%D0%BC-%D1%85%D1%80%D0%B0%D0%BD%D0%B8%D0%BB%D0%B8%D1%89%D0%B0-%D0%B8-%D0%BC%D0%B8%D0%BD%D1%83%D1%82%D1%8B) для приватных репозиториев: не более 2000 минут в месяц, то есть ваш код может расходовать не более 33 часов в месяц на процессы генерации контента, если он не размещён публично
* Также джобам, запущенным из приватных репо, [доступно только](https://docs.github.com/ru/billing/managing-billing-for-github-actions/about-billing-for-github-actions#%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BE%D0%B1%D1%8A%D0%B5%D0%BC-%D1%85%D1%80%D0%B0%D0%BD%D0%B8%D0%BB%D0%B8%D1%89%D0%B0-%D0%B8-%D0%BC%D0%B8%D0%BD%D1%83%D1%82%D1%8B) 500 Мбайт свободного места в среде выполнения
* GitHub Pages [не следует использовать](https://docs.github.com/ru/pages/getting-started-with-github-pages/about-github-pages#%D0%B7%D0%B0%D0%BF%D1%80%D0%B5%D1%89%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5-%D0%B2%D0%B8%D0%B4%D1%8B-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F) для онлайн-бизнеса, электронной коммерции и SaaS
* Финальный размер сгенерированного веб-сайта [не должен превышать](https://docs.github.com/ru/pages/getting-started-with-github-pages/about-github-pages#%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F) 1 Гбайт
* Трафик посещения веб-сайта также [не должен превышать](https://docs.github.com/ru/pages/getting-started-with-github-pages/about-github-pages#%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F) 100 Гбайт в месяц
* Ещё в документации присутствует пункт об [ограничении](https://docs.github.com/ru/pages/getting-started-with-github-pages/about-github-pages#%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F) количества сборок веб-сайта на GitHub Pages: не более 10 в час, но это относится только к сборкам, проводимым после коммитов, сделанных вручную
Стоит отметить, что вы с лёгкостью можете спрятать все ваши секретные переменные в Action secrets: логины, пароли, токены, URL. Эта информация не будет видна даже в публичном репозитории. То есть вам не обязательно помещать код, генерирующий ваш контент, в приватный репо: все секретные данные можно получать из переменных окружения GitHub Actions. Используя этот способ, при желании можно избавиться от первых двух ограничений, указанных выше.
С ограничениями и сферой применения разобрались, идём дальше. Не будем витать в облаках: попробуем сразу применить эту технику в приложении, которое сможет принести реальную пользу людям.
Кейс
----
[В предыдущей статье я рассказал](https://habr.com/ru/post/709120/), что внушительную часть жизни посвятил электронной музыке. Поэтому у меня иногда появляется желание сделать что-нибудь полезное для людей, связанных со звуком. Придумывая идею для очередного пет-проекта, я просто оглядываюсь назад на свою былую рутину музыканта, стараясь найти проблемы, которые было бы возможно решить путём автоматизации.
Подробное описание проблемыОдна из таких проблем: правильный выбор [скорости (BPM)](https://ru.wikipedia.org/wiki/BPM_(%D0%BC%D1%83%D0%B7%D1%8B%D0%BA%D0%B0)) и [тональности (Key)](https://ru.wikipedia.org/wiki/%D0%A2%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D1%8C) для новой композиции. Этот вопрос каждый раз встаёт перед артистом при создании нового проекта в [FL Studio](https://ru.wikipedia.org/wiki/FL_Studio) или [Cubase](https://ru.wikipedia.org/wiki/Steinberg_Cubase). Для электронной танцевальной музыки неверный выбор этих значений может вылиться даже в сложности с попаданием работы на лейбл или в микс. [Подробнее об этом я рассказал здесь.](https://github.com/sergree/whatbpm/wiki/FAQ)
С первого взгляда кажется, что это должно решаться классическим "загугливанием": просто введи в поиск "tech house bpm" и получи результат, но это не совсем так. Значения скоростей и тональностей являются трендами. А тренды имеют свойство меняться. Поисковая выдача довольно часто может становиться неактуальной в этом случае.
В своё время я нашёл такой способ решения этой проблемы:
1. Найти список свежих наилучших треков жанра, в котором я работаю. Для меня авторитетным всегда был [чарт Beatport Top 100](https://www.beatport.com/genre/psy-trance/13/top-100)
2. Получить значения скоростей и тональностей для каждой композиции чарта. Такие ресурсы, как Beatport и Spotify, предоставляют подобную информацию бесплатно
3. Подсчитав полученные значения, составить отчёт, который бы показывал список скоростей и тональностей, отсортированный по популярности
4. Выбрать одно из топовых значений для своей следующей композиции
Именно эту последовательность действий я и собираюсь автоматизировать в данной статье, но не для одного, а для всех жанров, представленных на [Beatport](https://www.beatport.com/).
Итак, делаем анализатор [чартов Beatport Top 100](https://www.beatport.com/genre/psy-trance/13/top-100).
**На входе:** более 30 веб-страниц со списками топ-100 новых композиций для каждого представленного жанра электронной танцевальной музыки.
**На выходе:** ежедневно обновляемая статистика по наиболее часто используемым значениям [скоростей (BPM)](https://ru.wikipedia.org/wiki/BPM_(%D0%BC%D1%83%D0%B7%D1%8B%D0%BA%D0%B0)) и [тональностей (Key)](https://ru.wikipedia.org/wiki/%D0%A2%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D1%8C), оформленная в виде веб-сайта на GitHub Pages.
Незамысловатая схема процессаНа самом деле, выбор кейса не так важен, главное здесь — понять принцип: вы можете на регулярной основе автоматически брать данные из любых источников, обрабатывать их и отображать результат, используя бесплатные возможности GitHub Actions и GitHub Pages.
Указанный здесь код было бы нетрудно доработать под вашу конкретную задачу, не связанную с Beatport. При желании отредактируйте источники данных, порядок действий, модель выходных данных или HTML-шаблоны. Главное, чтобы для выполнения вашего кода хватало ресурсов окружения, а на выходе генерировался статический веб-сайт. Хотя последнее также необязательно: вы вправе, например, загружать результат обработки в Telegram в виде обычного текста, или отправлять JSON во внешний REST API. В таком случае можно было бы отказаться от загрузки данных в GitHub Pages. Но в моём примере результатом ETL-процесса будет именно регулярно обновляемый веб-сайт.
Подготовка
----------
Первым делом создадим репозиторий на GitHub. Я сделаю его публичным.
Также я инициализирую репо с `README.md` и `.gitignore` для моего языка. Я буду приводить примеры на Python и Rust. Примеры на двух языках будут равнозначны, можно выбирать любой.
Клонируем репозиторий локально: для подобных задач мне нравится использовать [GitHub Desktop](https://desktop.github.com/). Этот клиент имеет довольно удобный интерфейс и позволяет сфокусироваться на разработке, давая возможность не тратить время на повторяющиеся команды git.
Мы не собираемся хранить сгенерированные веб-страницы в главной ветке репозитория, поэтому отредактируем файл `.gitignore`, добавив папку `build`.
```
...
# Сгенерированный контент
/build/
```
Теперь подготовим окружение для разработки. Откроем терминал. Я пользуюсь Windows, на других ОС команды могут немного отличаться. Находясь в папке с проектом, выполним несколько действий.
Python: подготовкаСоздадим новое виртуальное окружение:
```
python -m venv venv
```
Активируем его:
```
venv\Scripts\activate
```
Добавим зависимости, создав `requirements.txt`:
```
# Асинхронные HTTP-запросы
aiohttp>=3
# Генерация статических веб-страниц
Jinja2>=3
```
Загрузим зависимости:
```
python -m pip install -r requirements.txt
```
Rust: подготовкаИнициализируем наш пакет в Cargo:
```
cargo init
```
Добавим зависимости, отредактировав `Cargo.toml`:
```
...
[dependencies]
# Среда выполнения асинхронного кода
tokio = { version = "1", features = ["full"] }
# Асинхронные HTTP-запросы
reqwest = { version = "0.11", features = ["json"] }
# Генерация статических веб-страниц
tera = "1"
# Сериализация
serde = { version = "1", features = ["derive"] }
# Обработка ошибок
anyhow = "1"
```
Загрузим зависимости и убедимся, что подготовка пройдена успешно:
```
cargo run
```
План
----
Используем нисходящий подход к разработке. Сначала опишем высокоуровневые шаги нашей программы и только после этого приступим к реализации отдельных компонентов. Я буду давать им названия, которые будут указывать на их роль в ETL-процессе:
* К модулю Extract будут относиться функции **извлечения** данных из внешних источников. Так как в моём кейсе требуется получать немалое количество страниц, я буду пользоваться асинхронным программированием, чтобы извлекать данные [конкурентно](https://habr.com/ru/company/piter/blog/274569/)
* Модуль Transform будет отвечать за парсинг и **преобразование** данных. Как я указал выше, здесь я оставлю только заготовку под ваш будущий код без конкретной реализации
* Функции Load будут отвечать за **загрузку** данных. В данном контексте это будет означать создание статических билдов веб-сайта, которые будут коммититься в отдельную ветку репо посредством GitHub Actions, а после этого будут размещаться на GitHub Pages
* Также я подготовлю компонент Model, в котором будет находиться модель выходных данных
Python: высокоуровневые шаги — main.py
```
import asyncio
from typing import List
import extract
import load
import model
import transform
BEATPORT_URL = "https://www.beatport.com"
async def main():
# Получаем главную страницу Beatport
main_page: str = await extract.page(BEATPORT_URL)
# Достаём из неё ссылки на Top 100 страницы для каждого жанра
genre_top_100_urls: List[str] = transform.main_page_to_genre_top_100_urls(main_page)
# Конкурентно получаем содержимое Top 100 страниц для каждого жанра
genre_top_100_pages: List[str] = await extract.multiple_pages(genre_top_100_urls)
# Анализируем Top 100 страницы, составляя отчёты для каждого музыкального жанра
genre_reports: List[model.Report] = transform.genre_top_100_pages_to_reports(
genre_top_100_pages
)
# Отображаем наши отчёты в виде статической веб-страницы
load.build(genre_reports)
if __name__ == "__main__":
asyncio.run(main())
```
Rust: высокоуровневые шаги — src/main.rs
```
mod extract;
mod load;
mod model;
mod transform;
use anyhow::Result;
const BEATPORT_URL: &str = "https://www.beatport.com";
#[tokio::main]
async fn main() -> Result<()> {
// Получаем главную страницу Beatport
let main_page: String = extract::page(BEATPORT_URL).await?;
// Достаём из неё ссылки на Top 100 страницы для каждого жанра
let genre_top_100_urls: Vec<&str> = transform::main_page_to_genre_top_100_urls(&main_page)?;
// Конкурентно получаем содержимое Top 100 страниц для каждого жанра
let genre_top_100_pages: Vec = extract::multiple\_pages(&genre\_top\_100\_urls).await?;
// Анализируем Top 100 страницы, составляя отчёты для каждого музыкального жанра
let genre\_reports: model::ReportVec =
transform::genre\_top\_100\_pages\_to\_reports(&genre\_top\_100\_pages)?;
// Отображаем наши отчёты в виде статической веб-страницы
load::build(genre\_reports).await
}
```
Далее — модель данных. Её стоит описать заранее, потому что от неё будут зависеть конкретные реализации остальных компонентов. В полноценном решении у вас может быть несколько промежуточных моделей для каждого из подэтапов **преобразования**, но, так как в этой статье мы опустим реализацию Transform, в нашем случае будет одна-единственная модель — для выходных данных. Она будет описывать тот объект, который будет передаваться в генератор статических веб-страниц.
Python: модель данных — model.py
```
from dataclasses import dataclass
from typing import List, Tuple
# Аналитика по музыкальному жанру
@dataclass
class Report:
# Название музыкального жанра
genre: str
# Наиболее популярные значения скоростей (BPM): (количество, значение)
bpm_chart: List[Tuple[int, int]]
# Наиболее популярные значения тональностей (Key): (количество, значение)
# Вместо str следует использовать Enum, но это бы усложнило пример
key_chart: List[Tuple[int, str]]
```
Rust: модель данных — src/model.rs
```
use serde::Serialize;
// Аналитика по музыкальному жанру
#[derive(Serialize)]
pub struct Report {
// Название музыкального жанра
pub genre: String,
// Наиболее популярные значения скоростей (BPM): (количество, значение)
pub bpm_chart: Vec<(usize, u16)>,
// Наиболее популярные значения тональностей (Key): (количество, значение)
// Вместо String следует использовать Enum, но это бы усложнило пример
pub key_chart: Vec<(usize, String)>,
}
// Tera будет выдавать ошибку, если мы не обернём вектор отчетов
#[derive(Serialize)]
pub struct ReportVec {
pub reports: Vec,
}
```
С основными этапами программы и моделью разобрались, следуем дальше. От модуля к модулю.
Извлечение
----------
Существует великое множество источников данных: файлы, веб-страницы, БД, различные API и так далее. Для работы с некоторыми из них имеются удобные библиотеки, которые полностью освобождают нас, разработчиков, от всей боли десериализации байт, парсинга строк и прочего. Думаю, никто не станет спорить, что, например, для работы с тем же Telegram проще пользоваться такими готовыми библиотеками, как [aiogram на Python](https://aiogram.dev/) или [teloxide на Rust](https://github.com/teloxide/teloxide).
Но не везде всё так гладко: многие источники данных лишены подобных удобных "батареек", и без своего "велосипеда" не обойтись. Ситуация усугубляется тем, что не каждый владелец публично доступных данных одобряет автоматизированную работу с ними. Например, ранее, когда на Авито ещё публиковались телефонные номера продавцов, они должны были быть легко доступны только рядовым покупателям, но не злостным ботам-скрейперам.
Взглянем на источник данных нашего кейса — [платформу Beatport](https://www.beatport.com/genre/tech-house/11/top-100).
Чарт Beatport Top 100 для одного из 32 представленных жанровВ нашем приложении мы бы хотели оперировать данными, доступными на подобных страницах сервиса. Да, у платформы есть API, но получить к нему доступ мне так и не удалось.
Попытка сделать Request API Access на BeatportМожно было бы направить тикет в их Help Desk с просьбой предоставить доступ к API, но, скажу по опыту, ответ в данном случае может не прийти. В 2018 году я столкнулся с похожей проблемой Beatport API, и в тот момент заветные `CLIENT_ID` и `CLIENT_SECRET` мне получить так и не удалось. Ну что же, не будем надеяться на других, пойдём в лоб.
Именно в данном случае можно без проблем использовать [веб-скрейпинг](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%B1-%D1%81%D0%BA%D1%80%D0%B5%D0%B9%D0%BF%D0%B8%D0%BD%D0%B3), то есть просто скачивать веб-страницы с необходимым содержимым и доставать заветные данные из них, используя методы HTML-парсинга. Beatport не вносит никаких технических ограничений на этот счёт. Конечно, наш Transform стал бы сложнее из-за этого, но, как мы уже договорились ранее, мы не будем сосредотачиваться на методах преобразования в этой статье.
Итак, извлекаем HTML-код интересующих нас страниц.
Python: извлечение — extract.py
```
import asyncio
from typing import List, Optional
import aiohttp
async def page(url: str) -> Optional[str]:
# Для повторяющихся запросов рекомендуется переиспользовать одну сессию aiohttp.ClientSession
# Подробнее: https://docs.aiohttp.org/en/stable/client_quickstart.html
# Но это бы усложнило пример
async with aiohttp.ClientSession() as session:
async with session.get(url) as resp:
return await resp.text()
# Чтобы понять, что здесь происходит, вы можете ознакомиться с документацией asyncio:
# https://docs.python.org/3/library/asyncio.html
async def multiple_pages(urls: List[str]) -> Optional[List[str]]:
# Конкурентно вызываем page() для каждой входящей ссылки
handles = list(map(lambda x: asyncio.create_task(page(x)), urls))
pages = []
# Получаем результаты в список
for handle in handles:
pages.append(await handle)
return pages
```
Rust: извлечение — src/extract.rsВеб-скрейпинг на Rust наглядно
```
use anyhow::Result;
pub async fn page(url: &str) -> Result {
// Для повторяющихся запросов рекомендуется переиспользовать один клиент reqwest::Client
// Подробнее: https://docs.rs/reqwest/latest/reqwest/
// Конкурентный GET можно было бы реализовать через Client.clone(), но это бы усложнило пример
// https://users.rust-lang.org/t/reqwest-http-client-fails-when-too-much-concurrency/55644
let response = reqwest::get(url).await?.text().await?;
Ok(response)
}
// Чтобы понять, что здесь происходит, вы можете ознакомиться с Tokio Tutorial:
// https://tokio.rs/tokio/tutorial
pub async fn multiple\_pages(urls: &[&str]) -> Result> {
// Конкурентно вызываем page() для каждой входящей ссылки
let handles: Vec<\_> = urls
.iter()
// Передача данных в асинхронные треды требует владения
// Это может быть решено использованием крейта async-scoped, но это выходит за рамки статьи
.map(|url| url.to\_string())
.map(|url| tokio::spawn(async move { page(&url).await }))
.collect();
let mut pages = Vec::with\_capacity(handles.len());
// Получаем результаты в вектор
for handle in handles {
pages.push(handle.await??);
}
Ok(pages)
}
```
Преобразование
--------------
Все существующие варианты преобразования данных также вряд ли удастся сосчитать. Здесь мы ограничены лишь возможностями языка, ресурсами окружения и собственным воображением. Маппинг, фильтрация, агрегация — лишь верхушка айсберга.
Я намеренно оставляю данную часть примера нереализованной, так как эта логика будет сильно зависеть от вашей прикладной задачи. Зачем углубляться в HTML-парсинг, если вы, например, будете получать данные напрямую через REST API или ODBC? Зачем подробно описывать анализ музыкальных характеристик, если в вашем кейсе будут совсем другие сущности?
Поэтому в данном коде я оставляю эти заготовки нереализованными, в качестве интерфейса. Принцип инверсии зависимостей: в этом примере нам **не важно, как именно** функция достаёт URL отдельных страниц из HTML-кода страницы или проводит аналитику музыкального жанра по распарсенному содержимому.
Python: заготовка под преобразование — transform.py
```
from typing import List, Optional
import model
# В данном модуле будет находиться код, специфичный для вашего приложения
def main_page_to_genre_top_100_urls(_page: str) -> Optional[List[str]]:
raise NotImplementedError
def genre_top_100_pages_to_reports(_pages: List[str]) -> Optional[List[model.Report]]:
raise NotImplementedError
```
Rust: заготовка под преобразование — src/transform.rs
```
use crate::model;
use anyhow::Result;
// В данном модуле будет находиться код, специфичный для вашего приложения
// Для подобных конверсий в Rust следует реализовывать трейты From, TryFrom, FromStr,
// Но это бы сильно усложнило пример в данном случае
pub fn main_page_to_genre_top_100_urls(_page: &str) -> Result> {
unimplemented!()
}
// Подробнее про тип аргумента \_pages можно почитать здесь:
// https://stackoverflow.com/a/41180422/12510636
pub fn genre\_top\_100\_pages\_to\_reports(\_pages: &[impl AsRef]) -> Result> {
unimplemented!()
}
```
Подробнее про HTML-парсингЕсли вам всё же интересна тема HTML-парсинга, советую изучить эти библиотеки:
* [Beautiful Soup для Python](https://www.crummy.com/software/BeautifulSoup/bs4/doc/)
* [Scraper для Rust](https://docs.rs/scraper/0.14.0/scraper/)
Для работы с подобными инструментами вам потребуются знания CSS-селекторов. Хороший материал по этой теме на русском языке доступен [здесь](https://learn.javascript.ru/css-selectors).
Простыми словами, в CSS-файлах селекторы используются для стилизации документа, а в парсинге — для выборки данных из HTML-разметки. Например, если нужные вам данные хранятся в первом элементе с тегом и классом `mycontent`, то получить текстовое содержимое этого элемента можно было бы одной командой Beautiful Soup:
```
soup.select_one("div.mycontent").text
```
Если вам интересно узнать, как реализован парсинг именно в моём кейсе анализа Beatport, то вы можете ознакомиться с [полноценным решением на Rust](https://github.com/sergree/whatbpm).
Загрузка
--------
В предыдущих этапах мы **извлекли** все необходимые нам данные и **преобразовали** их к той форме, в которой они могут быть переданы в [шаблонизатор](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD%D0%B8%D0%B7%D0%B0%D1%82%D0%BE%D1%80) — библиотеку, которая будет периодически генерировать наш *не совсем статический* веб-сайт. Кто-то может возразить, сказав, что генерация HTML-страниц также относится к этапу **преобразования** данных, и будет прав. Но мне удобнее ограничивать "transform" собственной программной логикой. Своеобразный mindset shift: всё, что ушло в шаблонизатор, уже относится к "load". Да и, как по мне, структура приложения при таком разграничении становится более естественной.
Создадим наш первый и единственный шаблон `index.html` в новой папке `templates`. Удобство здесь состоит в том, что мы можем переиспользовать одни и те же шаблоны в разных языках программирования. Наш `index.html` будет понятен как и Jinja на Python, так и Tera на Rust. Также помимо разметки применим здесь один из [classless CSS-фреймворков](https://css-tricks.com/no-class-css-frameworks/), чтобы наша страничка выглядела хоть немного приятно.
Шаблон — templates/index.html
```
WhatBPM Prototype
{% for report in reports -%}
Аналитика {{ report.genre }} Top 100 Tracks :: Beatport
-------------------------------------------------------
| Скорость (BPM) |
| --- |
| Позиция | Значение | Количество композиций |
{% for pair in report.bpm\_chart -%}
| {{ loop.index }} | {{ pair[1] }} | {{ pair[0] }} |
{% endfor %}
| Тональность (Key) |
| --- |
| Позиция | Значение | Количество композиций |
{% for pair in report.key\_chart -%}
| {{ loop.index }} | {{ pair[1] }} | {{ pair[0] }} |
{% endfor %}
{% endfor %}
```
Теперь взглянем на код, который будет передавать нашу финальную структуру данных в шаблонизатор, а также сохранять результат в файл.
Python: генерация веб-страницы — load.py
```
import os
from typing import List
from jinja2 import Environment, FileSystemLoader
import model
TEMPLATE_PATH = "templates"
INDEX_NAME = "index.html"
BUILD_PATH = "build"
# Чтобы понять, что здесь происходит, вы можете ознакомиться с Jinja Documentation:
# https://jinja.palletsprojects.com/
def build(reports: List[model.Report]):
# Создаём папку для билда
os.makedirs(BUILD_PATH, exist_ok=True)
# Инициализируем движок шаблонов Jinja
# Этот этап рекомендуется выполнять только один раз
jinja = Environment(loader=FileSystemLoader(TEMPLATE_PATH))
# Рендерим содержимое
content = jinja.get_template(INDEX_NAME).render(reports=reports)
# Открываем файл на чтение
with open(os.path.join(BUILD_PATH, INDEX_NAME), "w", encoding="utf-8") as f:
# Заполняем файл содержимым
f.write(content)
```
Rust: генерация веб-страницы — src/load.rs
```
use crate::model;
use anyhow::Result;
use std::path::Path;
use tera::{Context, Tera};
use tokio::fs;
use tokio::io::AsyncWriteExt;
const TEMPLATE_PATH: &str = "templates/**/*.html";
const INDEX_NAME: &str = "index.html";
const BUILD_PATH: &str = "build";
// Чтобы понять, что здесь происходит, вы можете ознакомиться с Tera Documentation:
// https://tera.netlify.app/docs/
pub async fn build(reports: model::ReportVec) -> Result<()> {
// Создаём папку для билда
fs::create_dir_all(BUILD_PATH).await?;
// Инициализируем движок шаблонов Tera
// Этот этап рекомендуется выполнять только один раз
let tera = match Tera::new(TEMPLATE_PATH) {
Ok(t) => t,
Err(e) => {
println!("Parsing error(s): {e}");
::std::process::exit(1);
}
};
// Рендерим содержимое
let content = tera.render(INDEX_NAME, &Context::from_serialize(reports)?)?;
// Определяем путь конечного файла
let index_path = Path::new(BUILD_PATH).join(INDEX_NAME);
// Открываем файл на чтение
let mut file = fs::File::create(index_path).await?;
// Заполняем файл содержимым
file.write_all(content.as_bytes()).await?;
Ok(())
}
```
Результатом выполнения скрипта станет папка `build` с содержимым вашего веб-сайта. В моём кейсе это будет единственный `index.html`, но ничто не мешает добавлять контент по вашему разумению. Вы вправе генерировать столько HTML-страниц, сколько вам необходимо, а также добавлять соответствующую статику: CSS, JavaScript и тому подобное. И, конечно же, если вы используете Node.js, вы без проблем можете собирать ваш ресурс, используя `npm run build`.
Шаблон, заполненный даннымиВсё, что остаётся, это "доставить" нашу сборку до пользователей, воспользовавшись средствами GitHub.
### Actions
Где же будет выполняться наш код? Где будет генерироваться наш `build`? В ["раннере" GitHub Actions](https://docs.github.com/ru/actions/using-github-hosted-runners/about-github-hosted-runners) — виртуальной машине, которая будет существовать только на момент сборки веб-сайта. Мы будем использовать ["раннер" с Ubuntu Linux](https://github.com/actions/runner-images/blob/main/images/linux/Ubuntu2204-Readme.md), хотя при желании можно использовать и [Windows](https://github.com/actions/runner-images/blob/main/images/win/Windows2022-Readme.md), и [macOS](https://github.com/actions/runner-images/blob/main/images/macos/macos-12-Readme.md).
Как я уже указал выше, вам следует учитывать ограничения GitHub Actions, если вы используете их в приватных репозиториях. Но есть еще один момент, про который стоит упомянуть — [минуты ОС имеют разную стоимость](https://docs.github.com/ru/billing/managing-billing-for-github-actions/about-billing-for-github-actions#%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BE%D0%B1%D1%8A%D0%B5%D0%BC-%D1%85%D1%80%D0%B0%D0%BD%D0%B8%D0%BB%D0%B8%D1%89%D0%B0-%D0%B8-%D0%BC%D0%B8%D0%BD%D1%83%D1%82%D1%8B):
* Linux — бесплатно 2000 минут (33 часа 20 минут) в месяц
* Windows — множитель x2 — бесплатно 1000 минут (16 часов 40 минут) в месяц
* macOS — множитель **х10 (!!!)** — бесплатно 200 минут (3 часа 20 минут) в месяц
Но, повторюсь, эти ограничения не относятся ко времени доступности вашего веб-сайта, он будет доступен постоянно. Данные значения влияют только на время, доступное вашему коду на генерацию содержимого. И, опять же, только в приватных репозиториях.
Теперь давайте определимся, какие шаги должен регулярно выполнять наш "раннер":
1. Загрузить код репозитория в окружение
2. Установить средства языка для компиляции / интерпретации кода
3. Подтянуть необходимые библиотеки и зависимости
4. (По желанию) проверить код линтером и прогнать тесты
5. Исполнить код нашего приложения, получив на выходе папку `build` с актуальным содержимым
6. Запушить билд в отдельную ветку текущего или стороннего репозитория
Эти действия должны быть [декларативно описаны в YAML-файле](https://docs.github.com/ru/actions/quickstart), который будет помещён в каталог `.github/workflows` текущего репозитория. Такие файлы называются [рабочими процессами (workflows)](https://docs.github.com/ru/actions/using-workflows/about-workflows), и при желании их может быть несколько. Внутри файла рабочего процесса необходимо указать, какие [события (events)](https://docs.github.com/ru/actions/using-workflows/events-that-trigger-workflows) будут запускать его. Типов событий довольно много, но чаще всего используется обычный `git push`. Мы также добавим событие `schedule`, позволяющее запускать процессы по расписанию.
Внутри каждого рабочего процесса вы также можете задавать произвольное количество [заданий (jobs)](https://docs.github.com/ru/actions/using-jobs/using-jobs-in-a-workflow), каждое из которых обычно выполняется параллельно на отдельных виртуальных машинах. В нашем примере будет один файл рабочего процесса с одним заданием.
Задания, в свою очередь, состоят из шагов (steps). Шагами могут быть классические команды терминала, а также [действия (actions)](https://docs.github.com/ru/actions/learn-github-actions/understanding-github-actions#%D0%B4%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D0%B8%D1%8F), то есть часто используемые операции, которые были размещены на [GitHub Marketplace](https://github.com/marketplace?type=actions). Проще всего думать о действиях как об удобных внешних функциях, которые мы можем вызывать из нашего YAML-кода.
Рабочие процессы для Python и Rust будут отличаться, но некоторые шаги будут оставаться общими:
* Загрузка кода репозитория (1-й пункт) будет проводиться через официальный [actions/checkout](https://github.com/marketplace/actions/checkout)
* А деплой билда в отдельную ветку репо (6-й пункт) — через [peaceiris/actions-gh-pages](https://github.com/marketplace/actions/github-pages-action)
Сначала разрешим нашему будущему рабочему процессу вносить изменения в наш репозиторий. Для этого зайдём на GitHub в **Settings > Actions > General > Workflow Permissions** и изменим значение на **Read and write permissions**.
Далее создадим папку `.github/workflows`, а в ней файл `main.yml`. Так как в моём кейсе не требуется частое обновление данных, я укажу, чтобы веб-сайт обновлялся один раз в сутки.
Python: рабочий процесс — .github/workflows/main.yml
```
# Название рабочего процесса
name: Main Workflow (Python)
# События, запускающие процесс
on:
# Git push в ветку main
push:
branches:
- main
# По расписанию: каждый день в 0:00 UTC
# https://crontab.guru/every-day
schedule:
- cron: '0 0 * * *'
# Задания
jobs:
# Название задания
Main-Job-Python:
# Запускать на последней версии Ubuntu
runs-on: ubuntu-latest
# Шаги
steps:
# Загрузить код репозитория в окружение
- name: Checkout repository
uses: actions/checkout@v3
# Установить Python 3.10
- name: Install Python
uses: actions/setup-python@v4
with:
python-version: '3.10'
# Установить зависимости
- name: Install Dependencies
run: pip install -r requirements.txt
# Запустить нашу программу на Python
# Этот шаг генерирует папку ./build
- name: Run
run: python main.py
# Разместить содержимое ./build в корень ветки gh-pages текущего репо
- name: Deploy
uses: peaceiris/actions-gh-pages@v3
with:
# Передача токена рабочего прицесса во внешнее действие
# Не требует отдельной настройки секретов, токен передаётся автоматически
github_token: ${{ secrets.GITHUB_TOKEN }}
# Выбор папки билда
publish_dir: ./build
```
Rust: рабочий процесс — .github/workflows/main.yml
```
# Название рабочего процесса
name: Main Workflow (Rust)
# События, запускающие процесс
on:
# Git push в ветку main
push:
branches:
- main
# По расписанию: каждый день в 0:00 UTC
# https://crontab.guru/every-day
schedule:
- cron: '0 0 * * *'
# Задания
jobs:
# Название задания
Main-Job-Rust:
# Запускать на последней версии Ubuntu
runs-on: ubuntu-latest
# Шаги
steps:
# Загрузить код репозитория в окружение
- name: Checkout repository
uses: actions/checkout@v3
# Установить последний стабильный Rust
- name: Install Rust toolchain
uses: dtolnay/rust-toolchain@stable
# Использовать кэш между рабочими процессами при компилировании Rust-библиотек
# ЗНАЧИТЕЛЬНО ускоряет выполнение рабочего процесса в случае с Rust
- name: Rust Cache
uses: Swatinem/rust-cache@v2
# Запустить нашу программу на Rust
# Этот шаг генерирует папку ./build
- name: Run
run: cargo run --release
# Разместить содержимое ./build в корень ветки gh-pages текущего репо
- name: Deploy
uses: peaceiris/actions-gh-pages@v3
with:
# Передача токена рабочего прицесса во внешнее действие
# Не требует отдельной настройки секретов, токен передаётся автоматически
github_token: ${{ secrets.GITHUB_TOKEN }}
# Выбор папки билда
publish_dir: ./build
```
Сохраняем `main.yml` и пробуем сделать коммит.
Если всё было сделано верно, то на GitHub напротив нашего коммита появится *оранжевый кружок*, который даст сигнал, что рабочий процесс был запущен. Через некоторое время на его месте должна появиться *зелёная галочка*. Если во время процесса возникнут ошибки, то их можно будет изучить в разделе Actions.
Также обратим внимание на новое предупреждение. Оно связано с тем, что в репозитории была создана ветка `gh-pages`.
Жмём **Protect this branch**, а затем **Require a pull request before merging** и **Create**. При желании вы можете изучить правила защиты ветвей [здесь](https://docs.github.com/ru/repositories/configuring-branches-and-merges-in-your-repository/defining-the-mergeability-of-pull-requests/about-protected-branches). Остаётся сделать последний шаг, после которого ваш веб-сайт станет доступен для всех.
### Pages
Взглянув на список веток репозитория, вы можете убедиться, что рабочий процесс самостоятельно создал ветку `gh-pages` и поместил туда сгенерированное содержимое. Начиная с этого момента каждый коммит в `main` будет обновлять `gh-pages`. Также ранее мы настроили событие `schedule`, которое будет ежедневно обновлять `gh-pages` независимо от коммитов.
Снизу появилась новая веткаВнесём последнее изменение, которое разместит содержимое ветки `gh-pages` на бесплатном хостинге GitHub Pages. Проследуем в **Settings > Pages**. Изменим **Branch** на `gh-pages` и нажмём **Save**.
Подождём пару минут и проверим, что наша страничка стала доступна для всех. Попробуем пройти по этой ссылке:
```
https://ваш_логин.github.io/имя_репозитория/
```
Обратите внимание, что на конце домена стоит `.io`, а не `.com`. В моём случае (после внушительной доработки и полировки решения кейса) ссылка получилась такой:
```
https://sergree.github.io/whatbpm/
```
Итог
----
Используя этот метод, мы получили веб-сервис, способный обновлять представленную на нём информацию с допустимым заданным интервалом. Да, эту страницу нельзя назвать динамической, но, как по мне, совершенно статической она также не является. Содержимое отображает релевантную информацию, исполняя бизнес-требования. В вышеуказанном кейсе это означает, что [EDM продюсеры](https://ru.wikipedia.org/wiki/EDM) могут использовать аналитику с этой страницы для обдуманного выбора [скорости (BPM)](https://ru.wikipedia.org/wiki/BPM_(%D0%BC%D1%83%D0%B7%D1%8B%D0%BA%D0%B0)) и [тональности (Key)](https://ru.wikipedia.org/wiki/%D0%A2%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D1%8C) своих будущих композиций. Учитывая характер данных, мы смогли немного пренебречь актуальностью. Для музыкантов не так важно основывается ли эта аналитика на данных в реальном времени, или присутствует задержка не более суток. При необходимости мы могли бы уменьшить эту задержку до нескольких минут.
Если потребуется, к страничке на GitHub Pages можно привязать свой домен. [Подробная инструкция на эту тему находится здесь.](https://docs.github.com/ru/pages/configuring-a-custom-domain-for-your-github-pages-site/about-custom-domains-and-github-pages) Также, если вы не хотите публиковать код генерации сайта, вы можете воспользоваться тем, что [peaceiris/actions-gh-pages](https://github.com/marketplace/actions/github-pages-action) позволяет размещать сгенерированное содержимое в отдельном репозитории. В таком случае у вас могло бы быть два репозитория: приватный для генерации контента на GitHub Actions, публичный для его отображения на GitHub Pages. Но в случае с приватным репо у вас есть только 33 часа бесплатного времени GitHub Actions в месяц.
Вариант с приватным репо мог бы выглядеть такРешение кейса, описанного в статье, представляет собой stateless-приложение. Но что делать, если у подобного веб-сайта должно быть собственное состояние? Так как в данном случае не требуется транзакционность, можно было бы обойтись хранением стейта в отдельном файле ветки `gh-pages`. Это мог бы быть простой CSV или JSON. Либо вы могли бы воспользоваться [бесплатным DBaaS из этого списка](https://free-for.dev/#/?id=dbaas).
Способ #1 — хранение состояния в Git-репозиторииСпособ #2 — хранение состояния в DBaaSВсё это, конечно, выглядит не так просто, как хотелось бы. Что делать, если всего лишь хочется перенести свой WordPress-блог на бесплатный GitHub Pages? В данном случае я бы посмотрел в сторону [Jekyll](https://jekyllrb.com/) и [Hugo](https://gohugo.io/). Но здесь также стоит учитывать ограничение размера сайта на GitHub Pages в 1 Гбайт.
Альтернативный способ решения задачи — на клиентеЕсть ещё один способ, как можно было бы реализовать подобный ETL-процесс — перенести всё на клиентскую часть, то есть на браузер. В данном случае стало бы возможно отказаться от генерации контента на GitHub Actions, но появились бы новые нюансы:
* Мы бы резко сократили множество возможных источников данных, так как [в браузере нам доступно ограниченное количество API](https://developer.mozilla.org/ru/docs/Web/API)
* Браузер может делать fetch-запросы только к тем внешним источникам, [которые устанавливают разрешающие CORS-заголовки](https://habr.com/ru/company/macloud/blog/553826/), поэтому не каждый источник сработал бы здесь *(мы же не станем использовать CORS Proxy?)*
* Ограничился бы набор языков, поэтому задачу можно было бы решить только на JavaScript, TypeScript или [чём-то, умеющем компилироваться в WASM](https://www.fermyon.com/wasm-languages/webassembly-language-support)
* Добавилась бы задержка загрузки страницы, так как данные бы извлекались и преобразовывались во время открытия
* Нагрузка на источник данных также бы возросла — вместо одного извлечения в момент выполнения на GitHub Actions, источник бы столкнулся с повторяющимися извлечениями для каждого клиентского запроса
Методика, указанная в статье, не является истиной в последней инстанции. Вполне возможно, что существуют более интуитивные и доступные способы реализации подобных проектов. В своей статье я исходил из того, что мы можем сделать, не выходя за рамки GitHub. Очень может быть, что вы сталкивались с более удобными инструментами для решения таких задач (например, [Replit](https://replit.com/site/hosting)). Если у вас есть замечания или рекомендации по данной теме, прошу, оставляйте комментарии, это будет полезно для всех.
При желании вы можете изучить [полноценное решение кейса из статьи на Rust](https://github.com/sergree/whatbpm). Большое спасибо за уделённое время! | https://habr.com/ru/post/714538/ | null | ru | null |
# Memory on demand
Memory on demand — автоматическое выделение памяти виртуальной машине по необходимости.
Я уже чуть раньше писал об этой идее: [Управление памятью гостевой машины в облаке](http://habrahabr.ru/blogs/cloud_computing/97998/). Тогда это была теория и некоторые наброски с доказательствами, что эта идея сработает.
Сейчас, когда эта технология обрела практическое воплощение, и клиентская и серверная часть готовы и (вроде бы) отлажены, можно поговорить уже не про идею, а про то, как это работает. Как с пользовательской, так и с серверной части. Заодно, поговорим и о том, что получилось не так идеально, как хотелось бы.
Суть технологии *memory on demand* заключается в предоставлении гостю того количества памяти, которое ему нужно в каждый конкретный момент времени. Изменение объёма памяти происходит автоматически (без необходимости что-то менять в панели управления), на ходу (без перезагрузки) и в очень короткие сроки (порядка секунды и меньше). Если быть точным, выделяется объём памяти, который заняли приложения и ядро гостевой ОС, плюс небольшой объём на кеш.
Технически, для Xen Cloud Platform это организовано очень просто: в гостевой машине у нас агент (самописный, ибо штатные утилиты слишком прожорливы и неудобны), написанный на Си. Я выбирал на чём его писать — шелл, питон или Си. За шелл говорила простота реализации (5 строк), за питон — надёжность и красота кода. Но победил Си (около 150 строк кода) по двум причинам: информацию о состоянии машины нужно отправлять часто — и было бы нечестно «проедать» чужое машинное время и чужую память на удобном и красивом коде (вместо не очень изящного, но очень быстрого кода на Си).
Против питона, помимо всего прочего, говорило ещё то, что его нет в минимальной установке Debian'а.
Серверная часть (собственно, решающая сколько нужно памяти и выделяющая её) всё же на питоне — математики там не очень много, зато масса занудных для Си операций, связанных с конвертацией из строк в числа, работы со списками, словарями и т.д. Кроме того, эта машина потребляет служебные ресурсы и не сказывается на затратах клиентов.
Серверная часть принимает данные из гостевой системы и меняет размер памяти у гостей согласно политике управления памятью. Политику определяет пользователь (из панели управления или через API гостевой системы).
Идеальных вещей не бывает. У memory on demand тоже есть свои проблемы — и я думаю, что рассказывать о них заранее лучше, чем ошарашивать клиента пост-фактум.
Недостатки
==========
Асинхронное выделение памяти
----------------------------
Скрипты, регулирующие память, не следят за запросами к ОС, они следят лишь за показателями в самой ОС. Другими словами, если кто-то попросит у ОС пару гигабайт памяти за раз, то ему могут и отказать. А вот если он с интервалами попросит 10 раз по 200 — то вполне дадут. Как показали тесты, в серверной среде именно так — потребление памяти растёт по мере форков демонов и роста нагрузки, причём растёт с вполне конечной скоростью (так, что mod-server вполне успевает накинуть памяти до следующего крупного запроса).
Ещё одна страховка от этого — своп. Те, кто привык работать на VDS'ах на базе openVZ, наверное, удивятся. Те, кто привык к Xen'у или к обычным машинам, даже не обратят на это внимание. Да, в виртуальных машинах есть своп. И он даже используется! Спустя некоторое время работы машины (в реальных условиях, а не в лабораторном ничегонеделании) в свопе оказывается несколько сотен мегабайт данных.
К счастью, линукс весьма и весьма аккуратен со свопом, и выкидывает туда только неиспользующиеся данные (да и регулировать это поведение можно с помощью vm.swapiness).
Так вот, основная задача свопа в условиях Memory on demand — в страховке от слишком быстрых/толстых запросов. Такие запросы будут успешно обработаны без oom\_killer'а, хоть и ценой некоторых тормозов. У пользователя же есть возможность повлиять на это поведение с помощью политик.
Если ~~человек~~ программа в гостевой системе попросила сильно много памяти за раз и часть малоиспользуемого кода оказалась выкинута в своп, то снова срабатывает mod-server (MOD=Memory On Demand), который накидывает памяти. Достаточно, чтобы очистить своп, но линукс существо ленивое, и выгружать из свопа неиспользуемые данные не торопится. Благодаря этому, бОльший объём памяти оказывается отдан под дисковый кеш (увеличение производительности). Если же линуксу потребуется что-то из свопа, то память готова принять эти данные.
Оверхед
-------
Второй недостаток более фундаментальный. Динамическое управление памятью требует… памяти. Да, и довольно много. Для 256Мб это около 12Мб оверхеда, для 512 — около 20, для 2Гб — около 38, для 6Гб — около 60Мб оверхеда. Оверхед «съедается» то ли гипервизором, то ли ядром гостевой системы… Он даже не показывается в 'free' в TotalMem.
Можно подумать, что этот оверхед не очень большой. Однако, если у вас запас 5Гб, а реальное потребление 200, то вы будете иметь оверхед 50Мб (т.е. платить за +25% памяти за право расти до 5Гб). Если потолок спустить до 2 Гб, то оверхед снизится до 10% памяти при 256 базы.
Таким образом, оверхед является платой за готовность получить от гипервизора много памяти. С нашей же стороны (меркантильной, корыстной и т.д.) это является небольшой страховкой, что человек не станет просто так резервировать под себя 64 Гб памяти (ему придётся иметь оверхед около 6Гб, что довольно накладно для машины с потреблением в 200Мб). А вот сделать себе машинку с интервалом 300-2Гб — самое то. Оверхед маленький, запас по памяти есть.
Ещё одним недостатком является то, что менять верхний лимит памяти можно менять только с перезагрузкой.
Анлим
-----
Анлима (любого количества памяти по первому запросу — упор на слова «любого») нет и не будет. Причин несколько.
Во-первых, у нас физически не найдётся для вас 500 Гб памяти прямо-здесь-и-сейчас для одной-единственной виртуальной машины. Даже если попросите. Столько планок памяти в сервер не влазит. Во-вторых, сама технология требует (на настоящий момент) наличия потолка, причём, желательно, не сильно выше среднего потребления (не более, чем на полтора порядка, при больших цифрах сильно растёт оверхед, о нём было выше, запас до 500Гб сожрёт у вас этак гигабайт 30 памяти «в никуда» — дороговатое удовольствие получается).
Обещали анлим. Но не сделали. Точнее, формально его можно сделать в пределах возможности хоста облака, но такие диапазоны (128-48Гб) экономически не целесообразны.
Увы, красивой картинки с полным отсутствием верхней планки памяти не получилось. Зато удалось реализовать технологию оплаты по потреблению. Если вы (ваша ВМ) потребляет мало памяти — то денег платится мало. А запас на случай «шального хабра-эффекта» с пухнущими апачами есть.
Дисковый кеш
-------------
Особый разговор с кешем. Мы не можем выставить объём памяти виртуальной машины строго по потреблению, потому что кеш всё-таки нужен. Не смотря на то, что до физических винтов там два уровня кеширования и десятки гигабайт памяти с кешем (общего назначения). Свой местный кеш позволяет уменьшить число дисковых операций (а они, между прочим, оплачиваются отдельно).
Таким образом, мы можем резервировать небольшой запас памяти в машине, который с одной стороны обслуживает запросы новой памяти внутри виртуальной машины (т.е. уменьшает число операций изменения квоты памяти у машины), а с другой стороны используется как дисковый кеш. Так как мы следим за объёмом памяти в госте, то память для кеша есть практически всегда, кроме моментов острого пикового потребления памяти (на графике это видно).
Сделайте мне сервер с 8Мб оперативной памяти
--------------------------------------------
Не получится. Современные ядра хотят много памяти, так, что даже цифра в 64Мб их не устроит. Как показал тест, имеет смысл говорить о цифрах от 96Мб, или, с небольшой поправкой на кеш, от 128Мб. Если попытаться урезать память ниже этой величины (для пользователей этой возможности мы не предоставляем, а в лаборатории я пробовал), то получается очень плохо — ядро начинает паниковать, начинать делать глупости. Таким образом, разумный лимит, зафиксированный у нас в интерфейсе — это осознанное решение после тестов, а не запрет на экономию.
Я оглянулся посмотреть не оглянулась ли ты, посмоstack overflow
---------------------------------------------------------------
Ещё одной потенциальной проблемой могут быть приложения, стратегия которых состоит в использовании всего доступного объёма памяти. В этой ситуации включается дурная рекурсия:
1. Программа видит, что свободно 32Мб
2. Программа запрашивает у ОС 30 Мб
3. MOD-агент сообщает серверу, что у ОС осталось свободно 2Мб памяти
4. MOD-сервер накидывает гостевой ОС ещё 64Мб памяти
5. Программа видит, что свободно ещё 66 Мб памяти
6. Программа запрашивает у ОС ещё 64Мб памяти
Эта рекурсия закончится в тот момент, когда MOD-сервер не сможет увеличить объём памяти (из-за верхнего лимита).
Я знаю, что так себя ведёт Exchange 2007 и выше, некоторые версии SQL-серверов. Что делать в такой ситуации?
* Отключать возможность выделять память. Памяти столько, сколько поставили в панельке. Скучное решение
* Отключить автоматическое выделение памяти, перейти на API (нужна память, попросил). Основная проблема состоит в том, что такой подход противоречит идее memory on demand — автоматическому выделению памяти
* Изменить настройки программ (все подобные программы позволяют изменять поведение)
* Изменить настройку политики выделения памяти (например, сделать так, чтобы память выделение памяти происходило в тот момент, когда начинает использоваться своп).
Я не знаю, какой подход будет лучше, практика покажет.
Как это реализовано?
====================
Ну, секрета тут особого нет.
`xe vm-memory-dyniamic-range-set max=XXX min=YYY uuid=...` — и дело в шляпе. Сама возможность менять на ходу память у виртуальной машины присутствует в зене давным давно. Однако, существовавшая реализация (xenballoond) была слишком оптимистичной (т.е. резервировала для виртуальной машины объём памяти много больше необходимого) и медлительной — не отрабатывала всплески и пики потребления. Кроме того, она сильно полагалась на своп, что в условиях платных дисковых операций не очень хорошая идея. Не говоря уже о том, что сам демон был написан на шелле.
Перспективы
===========
В настоящий момент управление памятью осуществляется по очень топорному алгоритму с тремя режимами (init/run/stop) и простым гистерезисом, в ближайших перспективах написание алгоритма с оглядкой на статистику предыдущих запросов и подстройкой уровня оптимистичности выделения памяти.
P.S. В эту статью планировалось добавить ~~сисе..~~ графиков потребления и выделения памяти, однако, изготовление стенда, где бы это была не совсем синтетика, оказалось сложнее, чем я думал, так что графики будут через несколько дней.
PPS В качестве тизера — график хабраэффекта на 140 пользователей, одновременно гуляющих по сайту. Синяя линия — выделенная память, красная — занятая память, жёлтая — свободная, циан — своп-файл. По Y — байты (т.е. верх — 1.2Гб), по X — секунды с момента начала теста.
 | https://habr.com/ru/post/99157/ | null | ru | null |
# Как узнать реальную версию Windows из режима совместимости
Думаю каждый хотя бы раз сталкивался с ситуацией, когда на современной ОС не удавалось запустить старую программу, и помогал в этом случае режим совместимости Windows.
В основе работы данного механизма лежит перехват различных функций и эмуляция их поведения, свойственного указанной версии Windows, например, эмулируются ключи реестра, каталоги с документами и прочее. Все это нужно для того, чтобы программа думала, что запущена в выбранной среде.
Если приложение запущено в режиме совместимости, то вызов GetVersionEx вернет фиктивную версию Windows, что, вероятно, не подойдет для системных программ типа твикеров ОС. Как быть в этом случае?
#### Анализ экспортируемых функций
На просторах сети наткнулся на способ детектирования по наличию/отсутствию экспортируемых функций у системных библиотек. Пример кода:
```
TDSiWindowsVersion = (wvUnknown, wvWin31, wvWin95, wvWin95OSR2, wvWin98,
wvWin98SE, wvWinME, wvWin9x, wvWinNT3, wvWinNT4, wvWin2000, wvWinXP,
wvWinNT, wvWinServer2003, wvWinVista);
function DSiGetTrueWindowsVersion: TDSiWindowsVersion;
function ExportsAPI(module: HMODULE; const apiName: string): boolean;
begin
Result := GetProcAddress(module, PChar(apiName)) <> nil;
end; { ExportsAPI }
var
hKernel32: HMODULE;
begin { DSiGetTrueWindowsVersion }
hKernel32 := GetModuleHandle('kernel32');
Win32Check(hKernel32 <> 0);
if ExportsAPI(hKernel32, 'GetLocaleInfoEx') then
Result := wvWinVista
else if ExportsAPI(hKernel32, 'GetLargePageMinimum') then
Result := wvWinServer2003
else if ExportsAPI(hKernel32, 'GetNativeSystemInfo') then
Result := wvWinXP
else if ExportsAPI(hKernel32, 'ReplaceFile') then
Result := wvWin2000
else if ExportsAPI(hKernel32, 'OpenThread') then
Result := wvWinME
else if ExportsAPI(hKernel32, 'GetThreadPriorityBoost') then
Result := wvWinNT4
else if ExportsAPI(hKernel32, 'IsDebuggerPresent') then //is also in NT4!
Result := wvWin98
else if ExportsAPI(hKernel32, 'GetDiskFreeSpaceEx') then //is also in NT4!
Result := wvWin95OSR2
else if ExportsAPI(hKernel32, 'ConnectNamedPipe') then
Result := wvWinNT3
else if ExportsAPI(hKernel32, 'Beep') then
Result := wvWin95
else // we have no idea
Result := DSiGetWindowsVersion;
end; { DSiGetTrueWindowsVersion }
```
Решение интересное, но не считаю его приемлемым, так как с выходом каждой версии Windows требуется нетривиальная поддержка.
#### Используя WMI
Из [википедии](http://ru.wikipedia.org/wiki/WMI)
> Windows Management Instrumentation (WMI) в дословном переводе — это инструментарий управления Windows. Если говорить более развернутo, то WMI — это одна из базовых технологий для централизованного управления и слежения за работой различных частей компьютерной инфраструктуры под управлением платформы Windows.
>
>
Из WMI можно получить и версию Windows. Из документации следует что это можно сделать таким запросом:
`SELECT Version FROM Win32_OperatingSystem`
Запустив [WMI Explorer](http://www.ks-soft.net/hostmon.eng/wmi/) в режиме совместимости с Windows XP, можно увидеть, что это значение не эмулируется:
Метод работает, более того, он полностью документирован, но медленный, и требует тянуть в проект кучу кода по работе с WMI.
#### Ищем в реестре
Пожалуй самый элегантный и правильный способ найденный в сети — это подсмотреть значение в реестре:
`HLKM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\CurrentVersion`
Ну что же, попробуем:
```
with TRegistry.Create do
try
RootKey := HKEY_LOCAL_MACHINE;
if OpenKeyReadOnly('SOFTWARE\Microsoft\Windows NT\CurrentVersion') then
Edit1.Text := ReadString('CurrentVersion');
finally
Free;
end;
```
К сожалению, проверив его на Windows 7 оказалось, что этот ключ реестра эмулируется. Похоже в предыдущих версиях Windows этот способ работал, но, увы — **сейчас этот трюк не сработает**.
#### Анализ версии kernel32.dll
Сам не проверял, но говорят, что версия файла у kernel32.dll совпадает с версией Windows. На моем компьютере с Windows 7 это так:
Вполне пригодный способ, но лично мне по непонятным причинам он не нравится, благо есть еще альтернатива.
#### Анализируем PEB процесса
У каждого Windows-процесса есть структура описывающая его, называется она PEB. Она заполняется при старте процесса и содержит в себе адрес загрузки, список загруженных модулей, параметры командной строки, и, в том числе, версию Windows. Ниже пример модуля, используя который можно получить реальную версию Windows (тестировался на Delphi 2010 Win32):
```
unit RealWindowsVerUnit;
interface
uses
Windows;
var
//Реальная версия ОС, а не та что выдается системой при запуске
//в режиме совместимости
Win32MajorVersionReal: Integer;
Win32MinorVersionReal: Integer;
implementation
type
PPEB=^PEB;
PEB = record
InheritedAddressSpace: Boolean;
ReadImageFileExecOptions: Boolean;
BeingDebugged: Boolean;
Spare: Boolean;
Mutant: Cardinal;
ImageBaseAddress: Pointer;
LoaderData: Pointer;
ProcessParameters: Pointer; //PRTL_USER_PROCESS_PARAMETERS;
SubSystemData: Pointer;
ProcessHeap: Pointer;
FastPebLock: Pointer;
FastPebLockRoutine: Pointer;
FastPebUnlockRoutine: Pointer;
EnvironmentUpdateCount: Cardinal;
KernelCallbackTable: PPointer;
EventLogSection: Pointer;
EventLog: Pointer;
FreeList: Pointer; //PPEB_FREE_BLOCK;
TlsExpansionCounter: Cardinal;
TlsBitmap: Pointer;
TlsBitmapBits: array[0..1] of Cardinal;
ReadOnlySharedMemoryBase: Pointer;
ReadOnlySharedMemoryHeap: Pointer;
ReadOnlyStaticServerData: PPointer;
AnsiCodePageData: Pointer;
OemCodePageData: Pointer;
UnicodeCaseTableData: Pointer;
NumberOfProcessors: Cardinal;
NtGlobalFlag: Cardinal;
Spare2: array[0..3] of Byte;
CriticalSectionTimeout: LARGE_INTEGER;
HeapSegmentReserve: Cardinal;
HeapSegmentCommit: Cardinal;
HeapDeCommitTotalFreeThreshold: Cardinal;
HeapDeCommitFreeBlockThreshold: Cardinal;
NumberOfHeaps: Cardinal;
MaximumNumberOfHeaps: Cardinal;
ProcessHeaps: Pointer;
GdiSharedHandleTable: Pointer;
ProcessStarterHelper: Pointer;
GdiDCAttributeList: Pointer;
LoaderLock: Pointer;
OSMajorVersion: Cardinal;
OSMinorVersion: Cardinal;
OSBuildNumber: Cardinal;
OSPlatformId: Cardinal;
ImageSubSystem: Cardinal;
ImageSubSystemMajorVersion: Cardinal;
ImageSubSystemMinorVersion: Cardinal;
GdiHandleBuffer: array [0..33] of Cardinal;
PostProcessInitRoutine: Cardinal;
TlsExpansionBitmap: Cardinal;
TlsExpansionBitmapBits: array [0..127] of Byte;
SessionId: Cardinal;
end;
//Получить блок PEB своего процесса
function GetPDB: PPEB; stdcall;
asm
MOV EAX, DWORD PTR FS:[30h]
end;
initialization
//Получаем реальную версию ОС
Win32MajorVersionReal := GetPDB^.OSMajorVersion;
Win32MinorVersionReal := GetPDB^.OSMinorVersion;
end.
```
Скорость работы моментальная, ничего лишнего, единственное НО — недокументированная структура PEB, но как известно Microsoft очень заботится об обратной совместимости, так что с большой долей оптимизма можно считать, что раз описание структуры давно бродит по интернету, то в Microsoft она уже считается документированной.
#### Выводы
А выводы простые, если очень нужно получить реальную версию то WMI отличный вариант, если же требуется легковесное решение — смотри в PEB. | https://habr.com/ru/post/227453/ | null | ru | null |
# Исследование качества кода Open XML SDK от Microsoft
Моё знакомство с Open XML SDK началось с того, что мне понадобилась библиотека для создания документов Word с некоторой отчётностью. После работы с Word API более 7 лет, захотелось попробовать что-нибудь новое и более удобное. Так я узнал, что у Microsoft есть альтернативное решение. По традиции, используемые в компании программы и библиотеки мы предварительно проверяем с помощью анализатора PVS-Studio.
Введение
--------
Office Open XML, также известный как OpenXML или OOXML, представляет собой формат на основе XML для офисных документов, включая текстовые документы, электронные таблицы, презентации, а также диаграммы, фигуры и другой графический материал. Спецификация была разработана Microsoft и принята ECMA International в 2006 году. В июне 2014 года Microsoft выпустила Open XML SDK в open source. Сейчас исходники доступны на [GitHub](https://github.com/OfficeDev/Open-XML-SDK) под лицензий MIT.
Для поиска ошибок в исходном коде библиотеки использовался [PVS-Studio](https://www.viva64.com/ru/pvs-studio/). Это инструмент для выявления ошибок и потенциальных уязвимостей в исходном коде программ, написанных на языках С, C++, C# и Java. Работает в 64-битных системах на Windows, Linux и macOS.
Проект достаточно маленький и предупреждений нашлось немного. Но выбор титульной картинки основывался как раз на результатах. Уж очень много бесполезных условных операторов в коде нашлось. Мне кажется, если отрефакторить все такие места в коде, то объём заметно сократится. Вследствие чего ещё и читаемость кода повысится.
Почему Word API, а не Open XML SDK
----------------------------------
Как Вы могли догадаться из заголовка, я продолжил использовать Word API. У этого способа достаточно много минусов:
* Старый неудобный API;
* Должен быть установлен Microsoft Office;
* Необходимость распространять дистрибутив с библиотеками Office;
* Зависимость работы Word API от настроек локали системы;
* Низкая скорость работы.
С локалью вообще забавный случай произошёл. В Windows есть десяток региональных настроек. На одном из серверных компьютеров оказалась каша из локалей USA и UK. Из-за этого создавались документы Word, где вместо символа доллара был рубль, а фунты вообще не выводились. Доработка настроек операционной системы исправила проблему.
Перечисляя всё это, я снова задумался, почему я до сих пор этим пользуюсь…
Но нет, Word API мне пока нравится больше, и вот почему.
OOXML выглядит таким образом:
```
xml version="1.0" encoding="utf-8" standalone="yes"?
This is a paragraph.
This is another paragraph.
```
Где *(Word Run)* — не предложение, и даже не слово, а любой фрагмент текста, имеющий атрибуты, отличные от соседних фрагментов текста.
Программируется это примерно таким кодом:
```
Paragraph para = body.AppendChild(new Paragraph());
Run run = para.AppendChild(new Run());
run.AppendChild(new Text(txt));
```
У документа специфичная внутренняя структура, и в коде нужно создавать те же самые элементы. У Open XML SDK, я считаю, недостаточно абстрактный уровень доступа к данным. Создание документа с помощью Word API будет более понятым и коротким. Особенно, когда дело дойдёт до таблиц и других сложных структур данных.
В свою очередь, Open XML SDK решает большой ряд задач. С ним можно создавать документы не только для Word, но и для Excel и PowerPoint. Наверное, для некоторых задач эта библиотека больше подходит, но я решил пока остаться на Word API. Полностью от него отказаться в любом случае не получится, т.к. для внутренних нужд мы разрабатываем плагин для Word, а там возможно использование только Word API.
Два значения для string
-----------------------
[V3008](https://www.viva64.com/ru/w/v3008/) The '\_rawOuterXml' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 164, 161. OpenXmlElement.cs 164
```
internal string RawOuterXml
{
get => _rawOuterXml;
set
{
if (string.IsNullOrEmpty(value))
{
_rawOuterXml = string.Empty;
}
_rawOuterXml = value;
}
}
```
Тип *string* может иметь 2 типа значений: *null* и текстовое значение. Использовать текстовое значение определённо безопаснее, но оба подхода имеют права на существование. Вот в этом проекте значение *null* использовать неприемлемо и его перезаписывают на *string.Empty*… по крайней мере, так задумывалось. Но из-за ошибки в *RawOuterXml* всё же можно записать *null*, а потом обратиться к этому полю, получив *NullReferenceException*.
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'namespaceUri != null' is always true. OpenXmlElement.cs 497
```
public OpenXmlAttribute GetAttribute(string localName, string namespaceUri)
{
....
if (namespaceUri == null)
{
// treat null string as empty.
namespaceUri = string.Empty;
}
....
if (HasAttributes)
{
if (namespaceUri != null) // <=
{
....
}
....
}
....
}
```
В этом фрагменте используется тот же самой подход, автор кода не сделал какую-то серьёзную ошибку, но всё ещё чувствуется запах неудачного рефакторинга. Скорее всего, одну проверку тут можно удалить, что уменьшит ширину кода, а, следовательно, повысит его читаемость.
Про компактность кода
---------------------
[V3009](https://www.viva64.com/ru/w/v3009/) It's odd that this method always returns one and the same value of '".xml"'. CustomXmlPartTypeInfo.cs 31
```
internal static string GetTargetExtension(CustomXmlPartType partType)
{
switch (partType)
{
case CustomXmlPartType.AdditionalCharacteristics:
return ".xml";
case CustomXmlPartType.Bibliography:
return ".xml";
case CustomXmlPartType.CustomXml:
return ".xml";
case CustomXmlPartType.InkContent:
return ".xml";
default:
return ".xml";
}
}
```
Не знаю, имеет ли место тут какая-нибудь опечатка или просто автор кода написал "красивый" код по его мнению. Я уверен, что нет смысла возвращать из функции столько однотипных значений и код можно сильно сократить.
Это не единственное такое место. Вот ещё парочка таких предупреждений:
* V3009 It's odd that this method always returns one and the same value of '".xml"'. CustomPropertyPartTypeInfo.cs 25
* V3009 It's odd that this method always returns one and the same value of '".bin"'. EmbeddedControlPersistenceBinaryDataPartTypeInfo.cs 22
Интересно было бы услышать, зачем так писать.
[V3139](https://www.viva64.com/ru/w/v3139/) Two or more case-branches perform the same actions. OpenXmlPartReader.cs 560
```
private void InnerSkip()
{
Debug.Assert(_xmlReader != null);
switch (_elementState)
{
case ElementState.Null:
ThrowIfNull();
break;
case ElementState.EOF:
return;
case ElementState.Start:
_xmlReader.Skip();
_elementStack.Pop();
GetElementInformation();
return;
case ElementState.End:
case ElementState.MiscNode:
// cursor is end element, pop stack
_xmlReader.Skip();
_elementStack.Pop();
GetElementInformation();
return;
....
}
....
}
```
К этому коду возникает меньше вопросов. Скорее всего, идентичные кейсы можно объединить и код станет короче и очевиднее.
Ещё несколько таких мест:
* V3139 Two or more case-branches perform the same actions. OpenXmlMiscNode.cs 312
* V3139 Two or more case-branches perform the same actions. CustomPropertyPartTypeInfo.cs 30
* V3139 Two or more case-branches perform the same actions. CustomXmlPartTypeInfo.cs 15
* V3139 Two or more case-branches perform the same actions. OpenXmlElement.cs 1803
Те самые Always true/false
--------------------------
Настало время привести примеры кода, которые определили мой выбор титульной картинки.
**Предупреждение 1**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'Complete()' is always false. ParticleCollection.cs 243
```
private bool IsComplete => Current is null ||
Current == _collection._element.FirstChild;
public bool MoveNext()
{
....
if (IsComplete)
{
return Complete();
}
if (....)
{
return Complete();
}
return IsComplete ? Complete() : true;
}
```
Свойство *IsComplete* используется 2 раза, и по коду легко понять, что его значение не изменится. Таким образом, в конце функции можно просто возвращать второе значение тернарного оператора – *true*.
**Предупреждение 2**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression '\_elementStack.Count > 0' is always true. OpenXmlDomReader.cs 501
```
private readonly Stack \_elementStack;
private bool MoveToNextSibling()
{
....
if (\_elementStack.Count == 0)
{
\_elementState = ElementState.EOF;
return false;
}
....
if (\_elementStack.Count > 0) // <=
{
\_elementState = ElementState.End;
}
else
{
// no more element, EOF
\_elementState = ElementState.EOF;
}
....
}
```
Очевидно, что если в стеке*\_elementStack* не 0 элементов, то их больше. Код можно сократить как минимум на 8 строк.
**Предупреждение 3**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'rootElement == null' is always false. OpenXmlPartReader.cs 746
```
private static OpenXmlElement CreateElement(string namespaceUri, string name)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException(....);
}
if (NamespaceIdMap.TryGetNamespaceId(namespaceUri, out byte nsId)
&& ElementLookup.Parts.Create(nsId, name) is OpenXmlElement element)
{
return element;
}
return new OpenXmlUnknownElement();
}
private bool ReadRoot()
{
....
var rootElement = CreateElement(....);
if (rootElement == null) // <=
{
throw new InvalidDataException(....);
}
....
}
```
Функция *CreateElement* не может вернуть *null*. Если в компании было принято правило писать методы для создания xml-нод, которые либо возвращают валидный объект, либо кидают исключение, то пользователям таких функций можно не злоупотреблять дополнительными проверками.
**Предупреждение 4**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'nameProvider' is always not null. The operator '?.' is excessive. OpenXmlSimpleTypeExtensions.cs 50
```
public static XmlQualifiedName GetSimpleTypeQualifiedName(....)
{
foreach (var validator in validators)
{
if (validator is INameProvider nameProvider &&
nameProvider?.QName is XmlQualifiedName qname) // <=
{
return qname;
}
}
return type.GetSimpleTypeQualifiedName();
}
```
Оператор is имеет такой паттерн:
```
expr is type varname
```
Если результат выражения *is* будет *true*, то в *varname* будет записана ненулевая ссылка, так что дополнительная её проверка на *null* является лишней.
**Предупреждение 5**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'extension == ".xlsx" || extension == ".xlsm"' is always false. PresentationDocument.cs 246
```
public static PresentationDocument CreateFromTemplate(string path)
{
....
string extension = Path.GetExtension(path);
if (extension != ".pptx" && extension != ".pptm" &&
extension != ".potx" && extension != ".potm")
{
throw new ArgumentException("...." + path, nameof(path));
}
using (PresentationDocument template = PresentationDocument.Open(....)
{
PresentationDocument document = (PresentationDocument)template.Clone();
if (extension == ".xlsx" || extension == ".xlsm")
{
return document;
}
....
}
....
}
```
Интересный код получился. Сначала автор отсеял все документы с расширениями не *.pptx*, *.pptm*, .*potx* и .*potm*, а потом решил для перестраховки проверить, что среди них нет *.xlsx* и *.xlsm*. Функция *PresentationDocument* – определённо жертва рефакторинга.
**Предупреждение 7**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'OpenSettings.MarkupCompatibilityProcessSettings == null' is always false. OpenXmlPackage.cs 661
```
public MarkupCompatibilityProcessSettings MarkupCompatibilityProcessSettings
{
get
{
if (_mcSettings is null)
{
_mcSettings = new MarkupCompatibilityProcessSettings(....);
}
return _mcSettings;
}
set
{
_mcSettings = value;
}
}
public MarkupCompatibilityProcessSettings MarkupCompatibilityProcessSettings
{
get
{
if (OpenSettings.MarkupCompatibilityProcessSettings == null) // <=
{
return new MarkupCompatibilityProcessSettings(....);
}
else
{
return OpenSettings.MarkupCompatibilityProcessSettings;
}
}
}
```
Свойство *MarkupCompatibilityProcessSettings* никогда не возвращает *null*. Если в геттере выясняется, что поле класса имеет значение *null*, то объект перезаписывается на новый. Ещё обратите внимание, что это не рекурсивный вызов одного свойства, а это одноимённые свойства из разных классов. Возможно, некоторая путаница и привела к написанию лишних проверок.
Остальные предупреждения
------------------------
**Предупреждение 1**
[V3080](https://www.viva64.com/ru/w/v3080/) Possible null dereference. Consider inspecting 'previousSibling'. OpenXmlCompositeElement.cs 380
```
public OpenXmlElement PreviousSibling()
{
if (!(Parent is OpenXmlCompositeElement parent))
{
return null;
}
....
}
public override T InsertBefore(T newChild, OpenXmlElement referenceChild)
{
....
OpenXmlElement previousSibling = nextNode.PreviousSibling();
prevNode.Next = nextNode;
previousSibling.Next = prevNode; // <=
....
}
```
А вот пример, где дополнительной проверки как раз не хватает. Метод *PreviousSibling* как раз может вернуть значение *null*, а результат этой функции сразу используется без проверки.
Ещё 2 опасных места:
* V3080 Possible null dereference. Consider inspecting 'prevNode'. OpenXmlCompositeElement.cs 489
* V3080 Possible null dereference. Consider inspecting 'prevNode'. OpenXmlCompositeElement.cs 497
**Предупреждение 2**
[V3093](https://www.viva64.com/ru/w/v3093/) The '&' operator evaluates both operands. Perhaps a short-circuit '&&' operator should be used instead. UniqueAttributeValueConstraint.cs 60
```
public override ValidationErrorInfo ValidateCore(ValidationContext context)
{
....
foreach (var e in root.Descendants(....))
{
if (e != element & e.GetType() == elementType) // <=
{
var eValue = e.ParsedState.Attributes[_attribute];
if (eValue.HasValue && _comparer.Equals(....))
{
return true;
}
}
}
....
}
```
Некоторые любят применять оператор '&' к логическим выражениям там, где не надо. В случае этого оператора сначала вычисляется второй операнд, независимо от результата первого. Здесь это не сильно серьёзная ошибка, но такой неаккуратный код после рефакторинга может приводить и к потенциальным исключениям *NullReferenceException*.
**Предупреждение 3**
[V3097](https://www.viva64.com/ru/w/v3097/) Possible exception: type marked by [Serializable] contains non-serializable members not marked by [NonSerialized]. OpenXmlPackageValidationEventArgs.cs 15
```
[Serializable]
[Obsolete(ObsoleteAttributeMessages.ObsoleteV1ValidationFunctionality, false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public sealed class OpenXmlPackageValidationEventArgs : EventArgs
{
private string _message;
[NonSerialized]
private readonly object _sender;
[NonSerialized]
private OpenXmlPart _subPart;
[NonSerialized]
private OpenXmlPart _part;
....
internal DataPartReferenceRelationship
DataPartReferenceRelationship { get; set; } // <=
}
```
Сериализация класса *OpenXmlPackageValidationEventArgs* может стать неудачной из-за того, что одно из свойств забыли пометить несериализуемым. Либо необходимо доработать возвращаемый тип этого свойства до сериализуемого, иначе может возникать исключение в рантайме.
Заключение
----------
Мы в компании любим проекты и технологии Microsoft. В разделе, где мы перечисляем Open Source проекты, [проверенные](https://www.viva64.com/ru/inspections/) с помощью PVS-Studio, мы даже выделили для Microsoft отдельный раздел. Там уже накопился 21 проект, про которые написано 26 статей. Это 27-я.
Уверен, Вас интересует, есть ли среди наших клиентов Microsoft. Ответ – да! Но не будем забывать, что это огромная корпорация, ведущая разработку по всему миру. Определённо есть подразделения, которые уже используют PVS-Studio в своих проектах, но тех, которые не используют, ещё больше! И наш опыт работы с открытыми проектами показывает, что им явно не хватает хорошего инструмента для поиска ошибок ;).
[](https://viva64.com/ru/pvs-studio-download/?utm_source=habr&utm_medium=banner&utm_campaign=0777_OpenXML_SDK_ru)
Ещё из новостей, кому интересен анализ кода на C++, C# и Java: мы недавно добавили поддержку стандарта [OWASP](https://www.viva64.com/ru/owasp/) и активно увеличиваем его покрытие.
[](https://habr.com/en/company/pvs-studio/blog/530180/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [Analyzing the Code Quality of Microsoft's Open XML SDK](https://habr.com/en/company/pvs-studio/blog/530180/). | https://habr.com/ru/post/530178/ | null | ru | null |
# AppCode 3.1 и Swift: быстрое исполнение ваших блестящих идей
Привет, Хабр!
У нас для вас отличные новости — в новой версии нашей IDE для разработчиков под iOS/OS X — AppCode 3.1 — появилась долгожданная поддержка языка Swift, и даже Rename refactoring для кода на этом языке.
#### Swift
Этим летом мы все с восторгом и надеждами встретили новость о выпуске нового языка программирования. А нам язык еще и показался очень знакомым (<http://kotlinlang.org>). К нашей большой радости специально для поддержки языка Swift к команде присоединился Максим Медведев (интервью с ним мы не так давно публиковали в нашем [блоге](//blog.jetbrains.com/objc/2014/11/cooking-swift-an-interview-with-maxim-medvedev/)), имеющий большой опыт поддержки языка Groovy, в котором довольно много общих идей с языком Swift. И уже летом нам удалось выпустить первое обновление AppCode, которое поддерживало создание Swift-файлов и подсветку кода в них. Теперь же мы готовы порадовать вас «умными» возможностями, к которым вы так привыкли в IDE от JetBrains.
Независимо от того, создали ли вы целиком Swift-проект или всего лишь открыли Swift-файл в проекте на Objective-C, AppCode 3.1 поможет вам быть эффективнее с помощью:
* Автоформатирования кода для языка Swift
Все мы предпочитаем различные стили написания кода и его форматирования. Настройте стиль, удобный именно вам, в Preferences | Editor | Code Style. Пробелы, переводы строк, сдвиги — все это и многие другое можно менять для каждого поддерживаемого языка программирования независимо, а встроенное превью сразу покажет ваши изменения:
Код форматируется автоматически при написании, но можно вызвать функцию и вручную с помощью Reformat Code option (**`Alt+Cmd+L`**).
* Подсветки синтаксиса и редактора цветовых схем для языка Swift
Правильно подсвеченный код всегда удобнее читать и поддерживать. Поэтому мы всегда уделяем особое внимание подсветке кода. AppCode позволяет как использовать предустановленные цветовые схемы (взятые из AppCode или заимпортированные из Xcode), так и создавать свои собственные. Цветовые схемы, как и настройки форматирования, можно изменять для каждого языка программирования отдельно:
* Автодополнения для имен типов, методов и переменных
AppCode 3.1 поможет писать код на языке Swift быстрее с помощью функции авто-дополнения. Она работает для имен типов, классов, переменных и методов (к сожалению, в некоторых случаях есть существенные [ограничения](http://youtrack.jetbrains.com/issue/OC-10408), но мы планируем исправить их в последующих 3.1.x-апдейтах).
* Большого выбора функций навигации
Навигация по коду не менее важна, чем возможности быстрого написания кода. AppCode включает в себя множество функций навигации, а версия 3.1 открывает Вам доступ к этим возможностям и в коде на Swift. С помощью меню или уже знакомых сочетаний клавиш можно:
+ перейти к классу по его имени
+ перейти к файлу по его имени
+ перейти к символу по его имени
+ перейти на объявление/определение метода
+ использовать для навигации структуру файла:
* Подсветки всех использований символа в пределах текущего файла или поиска всех использований текущего символа в проекте
Поставьте курсор на интересующий вас символ, и AppCode подсветит все его использования в текущем файле. Если же вы хотите найти все использования символа во всем проекте, то Find Usages (**`Alt+F7`**) соберет их для вас в отдельном окне, где потом можно будет перегруппировать использования в более удобном виде (например, по директориям, где расположены соответствующие файлы).
* Рефакторинга Rename для безопасного переименования символа в проекте
Если нужно изменить имя переменной, константы, функции, типа или класса в вашем коде на Swift, воспользуйтесь рефакторингом Rename. В этом случае вы можете быть уверены, что все использования данного символа также будут переименованы:
* Поддержки юнит-тестирования на языке Swift
Для любого разработчика тесты не менее важны, чем сам код. Поэтому в версии 3.1 появилась поддержка юнит-тестирования на Swift. Тесты, написанные с использованием фреймворка XCTest, можно запускать по одному или все вместе, изучать статистику по прошедшим и упавшим тестам, перезапускать все упавшие тесты и навигироваться на исходный код теста из специального окна с информацией о запуске:
В AppCode 3.1 мы поддержали резолв классов Swift в коде на Objective-C, что гарантирует работу функций навигации, поиска использований (find usages) и других возможностей для Swift-символов, используемых в Objective-C. В последующих обновлениях мы планируем поддержать и обратный резолв — символов Objective-C в коде на Swift.
Конечно, у нас еще множество задач и планов по поддержке языка Swift в AppCode. Целое дерево задач можно увидеть в нашем [трекере](http://youtrack.jetbrains.com/issue/OC-10169). Мы планируем дорабатывать уже готовые возможности и добавлять новые в последующих апдейтах 3.1.x.
#### И не только
Помимо поддержки Swift мы добавили в версию 3.1 еще несколько «вкусных» и полезных возможностей:
* Inline Variable View
Чтобы процесс отладки был более эффективен, AppCode 3.1 помогает увидеть текущие значения переменных прямо в окне редактора во время отладки, напротив их объявления. Опция включена по умолчанию, отключить можно в окне отладки Settings menu | Show Values in Editor.
* Символические брейкпоинты
Возможность поставить точку остановки на символ может оказаться очень полезной, если, например, хочется остановить процесс отладки на символе из iOS-фреймворка. Чтобы облегчить процесс установки, AppCode позволяет использовать автодополнение при указании имени символа:
* Умная клавиша backspace, которая удаляет символы с учетом используемого в проекте стиля и настроек форматирования.
* Улучшения поддержки систем контроля версий, и [многое другое](http://www.jetbrains.com/objc/whatsnew/).
Загрузить 30-дневную бесплатную версию AppCode 3.1 можно с нашего [сайта](http://www.jetbrains.com/objc/download/). Обновление до версии 3.1 бесплатно для всех, у кого есть действующая лицензия. Мы будем рады ответить на ваши вопросы в комментариях. Замечания и предложения по новой версии мы ждем и в нашем [баг-трекере](http://youtrack.jetbrains.com/issues/OC). | https://habr.com/ru/post/245907/ | null | ru | null |
# Learn OpenGL. Урок 5.6 – Parallax Mapping
 Parallax Mapping
----------------
Техника текстурирования *Parallax Mapping* по своему эффекту несколько схожа с *Normal Mapping*’ом, но основана на другом принципе. Схожесть в том, что, как и Normal Mapping, данная техника значительно увеличивает визуальную сложность и детализацию поверхности с нанесенной текстурой заодно создавая правдоподобную иллюзия наличия на поверхности перепадов высот. Parallax Mapping отлично работает в связке с Normal Mapping для создания весьма достоверных результатов: описываемая техника передает эффект рельефа гораздо лучше Normal Mapping, а Normal Mapping дополняет его для правдоподобной имитации динамического освещения. Parallax Mapping вряд ли можно считать техникой, прямо относящейся к методам имитации освещения, но все же я выбрал этот раздел для его рассмотрения, поскольку метод является логическим развитием идей Normal Mapping. Также отмечу, что для разбора этой статьи требуется хорошее понимание алгоритма работы Normal Mapping, в особенности понятия касательного пространства или *tangent space*.
**Содержание**
Часть 1. Начало
1. [OpenGL](https://habrahabr.ru/post/310790/)
2. [Создание окна](https://habrahabr.ru/post/311198/)
3. [Hello Window](https://habrahabr.ru/post/311234/)
4. [Hello Triangle](https://habrahabr.ru/post/311808/)
5. [Shaders](https://habrahabr.ru/post/313380/)
6. [Текстуры](https://habrahabr.ru/post/315294/)
7. [Трансформации](https://habrahabr.ru/post/319144/)
8. [Системы координат](https://habrahabr.ru/post/324968/)
9. [Камера](https://habrahabr.ru/post/327604/)
Часть 2. Базовое освещение
1. [Цвета](https://habrahabr.ru/post/329592/)
2. [Основы освещения](https://habrahabr.ru/post/333932/)
3. [Материалы](https://habrahabr.ru/post/336166/)
4. [Текстурные карты](https://habrahabr.ru/post/337550/)
5. [Источники света](https://habrahabr.ru/post/337642/)
6. [Несколько источников освещения](https://habrahabr.ru/post/338254/)
Часть 3. Загрузка 3D-моделей
1. [Библиотека Assimp](https://habrahabr.ru/post/338436/)
2. [Класс полигональной сетки Mesh](https://habrahabr.ru/post/338436/)
3. [Класс 3D-модели](https://habrahabr.ru/post/338998/)
Часть 4. Продвинутые возможности OpenGL
1. [Тест глубины](https://habrahabr.ru/post/342610/)
2. [Тест трафарета](https://habrahabr.ru/post/344238/)
3. [Смешивание цветов](https://habrahabr.ru/post/343096/)
4. [Отсечение граней](https://habrahabr.ru/post/346964/)
5. [Кадровый буфер](https://habrahabr.ru/post/347354/)
6. [Кубические карты](https://habrahabr.ru/post/347750/)
7. [Продвинутая работа с данными](https://habrahabr.ru/post/350008/)
8. [Продвинутый GLSL](https://habrahabr.ru/post/350156/)
9. [Геометричечкий шейдер](https://habrahabr.ru/post/350782/)
10. [Инстансинг](https://habrahabr.ru/post/352962/)
11. [Сглаживание](https://habrahabr.ru/post/351706/)
Часть 5. Продвинутое освещение
1. [Продвинутое освещение. Модель Блинна-Фонга.](https://habrahabr.ru/post/353054/)
2. [Гамма-коррекция](https://habrahabr.ru/post/353632/)
3. [Карты теней](https://habrahabr.ru/post/353956/)
4. [Всенаправленные карты теней](https://habr.com/post/354208/)
5. [Normal Mapping](https://habr.com/post/415579/)
6. [Parallax Mapping](https://habr.com/post/416163/)
7. [HDR](https://habr.com/post/420409/)
8. [Bloom](https://habr.com/post/420375/)
9. [Отложенный рендеринг](https://habr.com/post/420565/)
10. [SSAO](https://habr.com/post/421385/)
Часть 6. PBR
1. [Теория](https://habr.com/post/426123/)
2. [Аналитические источники света](https://habr.com/post/424453/)
3. [IBL. Диффузная облученность.](https://habr.com/post/426987/)
4. [IBL. Зеркальная облученность.](https://habr.com/post/429744/)
Parallax Mapping относится к семейству техник *Displacement Mapping* или рельефного текстурирования, которые *смещают* вершины геометрии на основе значений, хранящихся в специальных текстурных картах. Для примера представьте плоскость, составленную из порядка тысячи вершин. Каждую из них можно сместить согласно величине, считанной из текстуры, представляющую собой высоту плоскости в данной точки. Такая текстура, содержащая значения высоты в каждом текселе, называется *картой высот*. Примером такой карты, полученной на основе геометрических характеристик поверхности кирпичной кладки, может служить следующее изображение:
Осуществляя выборки из данной карты и смещая каждую вершину согласно значению высоты, можно из идеальной плоскости получить выпуклую поверхность, повторяющую геометрические параметры исходной поверхности. Так, взяв плоскость с достаточным количеством вершин и применив карту высот из примера, можно получить следующий результат:
Описанный подход прост и легок в реализации, но требует большой плотности вершин в обрабатываемом объекте, иначе результат смещения будет слишком грубым. И если на каждую плоскую поверхность начать отпускать по тысяче с лишком вершин, то очень скоро мы просто не будем успевать рендерить все, что нам требуется. Может быть найдется алгоритм, позволяющий качественно сымитировать качество наивного алгоритма Displacement Mapping, но при этом не требуя таких затрат на геометрию? Если стоите – сядьте, поскольку на изображении выше на самом деле присутствует всего шесть вершин (два треугольника)! Рельеф кирпичной кладки отлично сымитирован благодаря использованию Parallax Mapping, техники рельефного текстурирования, не требующей множества вершин для правдоподобной передачи рельефа поверхности, а, как и Normal Mapping, использующей оригинальный подход для обмана глаз наблюдателя.
Основная идея реализации в том, чтобы на основе направления взгляда и данных карты высот исказить текстурные координаты для текущего фрагмента так, чтобы создать иллюзию, будто этот фрагмент принадлежит участку поверхности, лежащей выше или ниже, чем есть на самом деле. Для лучшего понимания принципа посмотрите на схему нашего примера с кирпичами:
Здесь грубая красная линия представляет собой значения из карты высот, отражающие геометрические характеристики имитируемой поверхности кирпичной кладки. Вектор  представляет собой направление от поверхности на наблюдателя (*viewDir*). Если бы плоскость действительно была рельефной, то наблюдатель увидел бы точку поверхности . Однако, по факту мы имеем идеальную плоскость и луч по направлению взгляда пересекает плоскость в точке , что очевидно. Задача Parallax Mapping сместить текстурные координаты в точке  так, чтобы они стали идентичны координатам, соответствующим точке . Далее для текущего фрагмента (соответствует точке ) мы используем полученные координаты точки  для всех необходимы текстурных выборок, что и создает иллюзию, будто наблюдатель видит точку .
Основная сложность заключена в том, как вычислить текстурные координаты точки  находясь в точке . Parallax Mapping предлагает приближенное решение, применяя простое масштабирование вектора направления от поверхности  к наблюдателю на величину высоты для фрагмента . Т.е. просто меняем длину  так, чтобы она соответствовала величине выборки из карты высот , соответствующей фрагменту . На схеме ниже показан результат масштабирования – вектор :
Далее результирующий вектор  раскладывается на компоненты в соответствии с системой координат самой плоскости, которые используются как смещения для исходных текстурных координат. При этом, поскольку вектор  вычисляется с использованием величины из карты высот, то чем больше значение высоты соответствует текущему фрагменту, тем сильнее для него будет смещение.
Этот простой прием дает неплохие результаты в ряде случаев, но все же является очень грубой оценкой положения точки . Если карта высот содержит участки с резко меняющимися значениями, то результат смещения становится некорректным: скорее всего вектор  даже близко не будет попадать в окрестность точки :
Исходя из вышеописанного, остается еще один вопрос: каким же образом определить, как корректно спроецировать вектор  на произвольно сориентированную поверхность, чтобы получить компоненты для смещения текстурных координат? Было бы неплохо вести расчеты в некой системе координат, где разложение вектора  на компоненты *x* и *y* всегда бы соответствовало базису текстурной системы координат. Если вы внимательно проработали урок по [Normal Mapping](https://habr.com/post/415579/), то уже догадались, что речь идет о расчетах в касательном пространстве.
Переведя вектор от поверхности к наблюдателю  в касательное пространство мы получим измененный вектор , покомпонентное разложение которого всегда будет вестись в соответствии с векторами касательной и бикасательной для данной поверхности. Поскольку касательная и бикасательная всегда сонаправлены с осями текстурной системы координат поверхности, то, независимо от ориентации поверхности, можно спокойно использовать компоненты *x* и *y* вектора  как смещения для текстурных координат.
Однако, довольно теории и, закатав рукава, перейдем к непосредственной реализации.
### Parallax Mapping
Для реализации мы будем использовать простую плоскость с рассчитанными для нее касательной и бикасательной – это мы уже умеем делать по уроку о Normal Mapping. Плоскости мы назначим ряд текстурных карт: [диффузную](https://learnopengl.com/img/textures/bricks2.jpg), [нормалей](https://learnopengl.com/img/textures/bricks2_normal.jpg) и [смещения](https://learnopengl.com/img/textures/bricks2_disp.jpg), файл каждой из которых доступен по соответствующей ссылке. В уроке мы также применим и Normal Mapping, поскольку Parallax Mapping создает иллюзию рельефа поверхности, которая легко нарушается, если освещение не будет изменяться соответственно рельефу. Поскольку карты нормалей зачастую создаются на основе карт высот, то их совместное применение гарантирует корректную связь освещения с учетом рельефа.
Вы, вероятно, уже заметили, что карта смещения, приведенная по ссылке выше, по факту представляет собой инверсию карты, приведенной в начале урока. Реализация Parallax Mapping обычно ведется как раз с использованием таких карт, обратным к картам высот – *карт глубин*. Так получается, поскольку имитация углублений на плоскости осуществляется несколько легче, чем имитация возвышения. В соответствии с этим изменением меняется и схема работы Parallax Mapping:
Снова мы видим знакомые точки  и , однако, в этот раз вектор  получается вычитанием вектора  из текстурных координат в точке . Значения глубины вместо высоты можно получить просто вычитая выборку глубины из единицы или инвертировав цвета текстуры в любом редакторе изображений.
Parallax Mapping реализуется в фрагментном шейдере, поскольку данные о рельефе отличаются для каждого фрагмента внутри треугольника. Код фрагментного шейдера потребует расчета вектора от фрагмента к наблюдателю , так что понадобится передать ему положение фрагмента и наблюдателя в касательном пространстве. По результатам урока о Normal Mapping у нас на руках остался вершинный шейдер, который передает все эти вектора уже приведенными к касательному пространству, воспользуемся им:
```
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec2 aTexCoords;
layout (location = 3) in vec3 aTangent;
layout (location = 4) in vec3 aBitangent;
out VS_OUT {
vec3 FragPos;
vec2 TexCoords;
vec3 TangentLightPos;
vec3 TangentViewPos;
vec3 TangentFragPos;
} vs_out;
uniform mat4 projection;
uniform mat4 view;
uniform mat4 model;
uniform vec3 lightPos;
uniform vec3 viewPos;
void main()
{
gl_Position = projection * view * model * vec4(aPos, 1.0);
vs_out.FragPos = vec3(model * vec4(aPos, 1.0));
vs_out.TexCoords = aTexCoords;
vec3 T = normalize(mat3(model) * aTangent);
vec3 B = normalize(mat3(model) * aBitangent);
vec3 N = normalize(mat3(model) * aNormal);
mat3 TBN = transpose(mat3(T, B, N));
vs_out.TangentLightPos = TBN * lightPos;
vs_out.TangentViewPos = TBN * viewPos;
vs_out.TangentFragPos = TBN * vs_out.FragPos;
}
```
Из важного отмечу только то, что конкретно под нужды Parallax Mapping необходимо передать во фрагментный шейдер *aPos* и положение наблюдателя *viewPos* в касательном пространстве.
Внутри шейдера реализуем алгоритм Parallax Mapping, что выглядит примерно так:
```
#version 330 core
out vec4 FragColor;
in VS_OUT {
vec3 FragPos;
vec2 TexCoords;
vec3 TangentLightPos;
vec3 TangentViewPos;
vec3 TangentFragPos;
} fs_in;
uniform sampler2D diffuseMap;
uniform sampler2D normalMap;
uniform sampler2D depthMap;
uniform float height_scale;
vec2 ParallaxMapping(vec2 texCoords, vec3 viewDir);
void main()
{
vec3 viewDir = normalize(fs_in.TangentViewPos - fs_in.TangentFragPos);
// получить смещенные текстурные координаты с помощью Parallax Mapping
vec2 texCoords = ParallaxMapping(fs_in.TexCoords, viewDir);
// делаем выборку из использующихся текстур
// с использованием смещенных координат
vec3 diffuse = texture(diffuseMap, texCoords);
vec3 normal = texture(normalMap, texCoords);
normal = normalize(normal * 2.0 - 1.0);
// далее – обычный расчет модели освещения
[...]
}
```
Мы объявили функцию ParallaxMapping, которая принимает текстурные координаты фрагмента и вектор от фрагмента на наблюдателя  в касательном пространстве. Результатом функции становятся смещенные текстурные координаты, которые уже и используются для выборок из диффузной текстуры и карты нормалей. В результате диффузный цвет пикселя и его нормаль корректно соответствуют измененной «геометрии» плоскости.
Что же скрывается внутри функции ParallaxMapping?
```
vec2 ParallaxMapping(vec2 texCoords, vec3 viewDir)
{
float height = texture(depthMap, texCoords).r;
vec2 p = viewDir.xy / viewDir.z * (height * height_scale);
return texCoords - p;
}
```
Данная относительно простая функция является буквальной реализацией метода, основные моменты которого мы обсудили выше. Берутся исходные текстурные координаты *texCoords*, с помощью них делается выборка высоты (или глубины)  из *depthMap* для текущего фрагмента. Для расчета вектора  берется вектор *viewDir* в касательном пространстве и пара его компонент *x* и *y* делится на компоненту *z*, а результат масштабируется считанным значением смещения *height*. Также введен юниформ *height\_scale* для дополнительной возможности управления степенью выраженности эффекта Parallax Mapping, поскольку обычно эффект смещения выходит слишком сильным. Для получения результата мы вычитаем полученный вектор  из исходных текстурных координат.
Разберемся с моментом деления *viewDir.xy* на *viewDir.z*. Поскольку вектор *viewDir* нормализован, то его компонента *z* лежит в интервале [0, 1]. Когда вектор практически параллелен поверхности компонента *z* близка к нулю, а операция деления возвращает вектор  гораздо большей длины, чем в случае если *viewDir* близок к перпендикуляру к поверхности. Другими словами, мы масштабируем вектор  так, чтобы он увеличивался при взгляде на поверхность под углом – это позволяет получить более реалистичный результат в таких случаях.
Некоторые разработчики предпочитают убирать масштабирование делением на *viewDir.z*, поскольку, в определенных случаях, такой подход дает некорректные результаты при взгляде под углом. Эта модификация техники называется *Parallax Mapping with Offset Limiting*. Выбор варианта подхода, по большей части, остается делом личных предпочтений – я, например, более лоялен к результатам работы обычного алгоритма Parallax Mapping.
Результирующие измененные текстурные координаты в итоге используются для выборки из диффузной карты и карты нормалей, что дает нам довольно неплохой эффект искажения поверхности (параметр *height\_scale* здесь выбран близким к 0.1):
На изображении можно сравнить эффект техник Normal Mapping и Parallax Mapping. Поскольку Parallax Mapping имитирует неровности поверхности, то для этой техники возможны ситуации, когда кирпичики действительно перекрывают друг друга, в зависимости от направления взгляда.
Также видны и странные артефакты вдоль границ оттекстурированной плоскости. Появляются они вследствие того, что смещенные алгоритмом Parallax Mapping текстурные координаты могут выпасть за пределы единичного интервала и, в зависимости от режима повторения текстуры (*wrapping mode*), вызвать появление нежелательных результатов. Простой способ избавления от таких артефактов – просто отбросить все фрагменты, для которых текстурные координаты оказались вне единичного интервала:
```
texCoords = ParallaxMapping(fs_in.TexCoords, viewDir);
if(texCoords.x > 1.0 || texCoords.y > 1.0 || texCoords.x < 0.0 || texCoords.y < 0.0)
discard;
```
В итоге все фрагменты, имеющие смещенные текстурные координаты, выпадающие из интервала [0, 1], будут отброшены и визуально результат действия Parallax Mapping станет приемлемым. Очевидно, что этот метод отбраковки не универсален и может быть неприменим для некоторых поверхностей или случаев текстурирования. Но на примере плоскости он работает идеально и помогает усилить эффект изменения рельефа плоскости:
Исходники примера находятся [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/5.advanced_lighting/5.1.parallax_mapping/parallax_mapping.cpp).
Выглядит неплохо, да и производительность метода отличная – всего то потребовалась одна дополнительная выборка из текстуры! Но простота метода имеет и значительные недостатки: эффект рельефности легко разрушается при взгляде на плоскость под углом (что верно и для Normal Mapping) или при наличии в карте высот участков с резкими перепадами значений:
Причина разрушения иллюзии кроется в том, что алгоритм является весьма грубым приближением реального Displacement Mapping. Однако, нас могут выручить несколько дополнительных приемов, которые позволяют получить практически идеальные результаты даже при взгляде под углом или при использовании карт высот с резкими перепадами. Например, мы можем использовать несколько выборок из карты высот, дабы найти точку, ближайшую к точке .
### Steep Parallax Mapping
Техника Steep Parallax Mapping является логическим развитием классического Parallax Mapping: используется такой же подход в алгоритме, но вместо единственной выборки берется несколько – для лучшей аппроксимации вектора , использующегося для расчета точки . За счет этих дополнительных выборок результат работы алгоритма визуально гораздо более правдоподобен, даже в условиях взгляда под острыми углами к поверхности.
Основа подхода Steep PM заключается в том, чтобы взять некоторый диапазон глубин и разбить его на равные по размеру слои. Далее мы итеративно проходим по слоям одновременно смещая исходные текстурные координаты в направлении вектора  и делая выборки из карты глубин, останавливаясь в тот момент, когда глубина из выборки оказывается меньше, чем глубина текущего слоя. Ознакомьтесь со схемой:
Как видно, мы движемся по слоям сверху вниз и для каждого слоя сравниваем его глубину со значением из карты глубин. Если глубина слоя оказывается меньше значения из карты глубин, это значит, что вектор , соответствующий этому слою, лежит выше поверхности. Этот процесс повторяется до тех пор, пока глубина слоя не оказывается больше выборки из карты глубин: в этот момент вектор  указывает на точку, лежащую под имитируемым рельефом поверхности.
В примере видно, что выборка из карты глубин на втором слое () все еще лежит «глубже» по отношению к величине глубины второго слоя равной 0.4, а значит процесс поиска продолжается. В следующем проходе глубина слоя равная 0.6 наконец оказывается лежащей «выше» значения выборки из карты глубин (). Отсюда мы делаем вывод, что вектор  полученный для третьего слоя является наиболее достоверным положением для искаженной геометрии поверхности. Можно использовать текстурные координаты , полученные из вектора , для смещения текстурных координат текущего фрагмента. Очевидно, что точность метода растет с количеством слоев.
Изменения в реализации затронут только функцию ParallaxMapping, поскольку в ней уже собраны все необходимые для работы алгоритма переменные:
```
vec2 ParallaxMapping(vec2 texCoords, vec3 viewDir)
{
// количество слоев глубины
const float numLayers = 10;
// размер каждого слоя
float layerDepth = 1.0 / numLayers;
// глубина текущего слоя
float currentLayerDepth = 0.0;
// величина шага смещения текстурных координат на каждом слое
// расчитывается на основе вектора P
vec2 P = viewDir.xy * height_scale;
vec2 deltaTexCoords = P / numLayers;
[...]
}
```
Сперва осуществим инициализацию: установим количество слоев, рассчитаем глубину каждого из них и, в итоге, найдем размер смещения текстурных координат вдоль направления вектора , на которое необходимо будет смещаться на каждом слое.
Далее идет проход по слоям, начиная с верхнего, до тех пор, пока не будет найдена выборка из карты глубин, лежащая «выше» значения глубины текущего слоя:
```
// начальная инициализация
vec2 currentTexCoords = texCoords;
float currentDepthMapValue = texture(depthMap, currentTexCoords).r;
while(currentLayerDepth < currentDepthMapValue)
{
// смещаем текстурные координаты вдоль вектора P
currentTexCoords -= deltaTexCoords;
// делаем выборку из карты глубин в текущих текстурных координатах
currentDepthMapValue = texture(depthMap, currentTexCoords).r;
// рассчитываем глубину следующего слоя
currentLayerDepth += layerDepth;
}
return currentTexCoords;
```
В данном коде мы осуществляем проход по всем слоям глубины и смещаем исходные текстурные координаты, до тех пор, пока выборка из карты глубин не станет меньше глубины текущего слоя. Смещение осуществляется вычитанием из исходных текстурных координат дельты, основанной на векторе . Результатом работы алгоритма становится смещенный вектор текстурных координат, определенный с гораздо большей точностью, нежели классический Parallax Mapping.
Используя порядка 10 сэмплов пример с кирпичной кладкой становится гораздо более реалистично выглядящим, даже при взгляде под углом. Но лучше всего достоинства Steep PM видны на поверхностях с картой глубин, имеющей резкие перепады значений. Например, как на этой, уже демонстрировавшейся ранее, деревянной игрушке:
Можно улучшить алгоритм еще немного, если немного проанализировать особенности техники Parallax Mapping. Если смотреть на поверхность примерно по нормали, то необходимость сильно смещать текстурные координаты нет, в то время как при взгляде под углом смещение стремится к максимуму (мысленно представьте направление взгляда в обоих случаях). Если параметризировать число выборок в зависимости от направления взгляда, то можно неплохо сэкономить там, где лишние выборки не нужны:
```
const float minLayers = 8.0;
const float maxLayers = 32.0;
float numLayers = mix(maxLayers, minLayers, abs(dot(vec3(0.0, 0.0, 1.0), viewDir)));
```
Результат скалярного произведения вектора *viewDir* и положительной полуоси Z используется для определения числа слоев в интервале [*minSamples*, *maxSamples*], т.е. направление взгляда определяет необходимое число итераций эффекта (в касательном пространстве положительная полуось Z направлена по нормали к поверхности). Если мы бы мы взглянули параллельно поверхности, то эффект бы использовал все 32 слоя.
Модифицированный исходный код находится [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/5.advanced_lighting/5.2.steep_parallax_mapping/steep_parallax_mapping.cpp). Также предлагаю к скачиванию текстуры деревянной игрушки: [диффузная](https://learnopengl.com/img/textures/wood.png), [карта нормалей](https://learnopengl.com/img/textures/toy_box_normal.png), [карта глубин](https://learnopengl.com/img/textures/toy_box_disp.png).
Не лишен подход и недостатков. Поскольку число сэмплов все равно конечно, то неизбежно появление эффектов алиасинга, что делает переходы между слоями бросающимися в глаза:
Можно снизить выраженность артефакта путем наращивания количества используемых сэмплов, но это довольно быстро сожрет всю доступную производительность видеопроцессора. Существует несколько дополнений к методу, которые возвращают как результат не первую же точку, оказавшуюся под мнимым рельефом поверхности, а интерполированное значение двух ближайших слоев, что позволяет еще немного уточнить положение точки .
Из этих методов чаще всего используются два: *Relief Parallax Mapping* и *Parallax Occlusion Mapping*, причем Relief PM дает наиболее достоверные результаты, но и является немного более требовательным к производительности, по сравнению с Parallax Occlusion Mapping. Поскольку Parallax Occlusion Mapping все же довольно близок по качеству к Relief PM и при этом работает быстрее, то его предпочитают использовать чаще всего. Далее будет рассмотрена реализация именно Parallax Occlusion Mapping.
### Parallax Occlusion Mapping
Метод Parallax Occlusion Mapping работает все на тех же базовых принципах, что и Steep PM, но вместо использования текстурных координат первого же слоя, где было обнаружено пересечение с мнимым рельефом, метод использует линейную интерполяцию между двумя слоями: слоем после и до пересечения. Весовой коэффициент для линейной интерполяции основывается на величине отношения текущей глубины рельефа к глубинам обоих рассматриваемых слоев. Посмотрите на схему, чтобы понять получше, как все работает:
Как видно, все очень схоже с Steep PM, добавляется лишь один дополнительный шаг интерполяции текстурных координат двух слоев глубины, соседствующих с точкой пересечения. Конечно, и такой метод является всего лишь приближением, но куда более точным, нежели Steep PM.
Код, отвечающий за дополнительные действия Parallax Occlusion Mapping является дополнением к коду Steep PM и не слишком сложен:
```
[...] // расчеты, относящиеся к методу Steep PM
// находим текстурные координаты перед найденной точкой пересечения,
// т.е. делаем "шаг назад"
vec2 prevTexCoords = currentTexCoords + deltaTexCoords;
// находим значения глубин до и после нахождения пересечения
// для использования в линейной интерполяции
float afterDepth = currentDepthMapValue - currentLayerDepth;
float beforeDepth = texture(depthMap, prevTexCoords).r - currentLayerDepth + layerDepth;
// интерполяция текстурных координат
float weight = afterDepth / (afterDepth - beforeDepth);
vec2 finalTexCoords = prevTexCoords * weight + currentTexCoords * (1.0 - weight);
return finalTexCoords;
```
В момент нахождения слоя, лежащего после точки пересечения с мнимым рельефом, мы также определяем текстурные координаты слоя, лежащего до точки пересечения. Далее находим смещения глубины мнимого рельефа относительно глубин двух рассматриваемых слоев и используем их отношение как весовой коэффициент дальнейшей линейной интерполяции текстурных координат, соответствующих двум рассмотренным слоям. Результат интерполяции возвращается функцией для дальнейшего использования.
Parallax Occlusion Mapping дает на удивление визуально достоверные результаты, пусть и с небольшими огрехами и артефактами алиасинга. Но для компромиссного по скорости и качеству варианта они незначительны и проявляются лишь при пристальном наблюдении поверхности вблизи от камеры или при очень острых углах взгляда.
Код примера находится [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/5.advanced_lighting/5.3.parallax_occlusion_mapping/parallax_occlusion_mapping.cpp).
Parallax Mapping воистину великолепная техника, позволяющая резко повысить визуальную детализацию вашей сцены, но, безусловно, имеет свои недостатки в виде артефактов, о чем стоит помнить при реализации техники в проекте. По большей части Parallax Mapping используется на плоских поверхностях типа стен или полов – там, где не так то просто определить очертания объекта целиком, а угол взгляда на поверхность часто близок к перпендикуляру. В таком случае огрехи Parallax Mapping практически незаметны, на фоне возросшей детальности поверхности.
Бонусы от переводчика:
----------------------
### Relief Parallax Mapping
Раз уж автор упомянул два метода уточнения результата Steep PM, то для полноты картины опишу и второй из подходов.
Как и Parallax Occlusion Mapping здесь используется результат выполнения Steep PM, т.е. нам известны глубины двух слоев между которыми лежит реальная точка пересечения вектора  с рельефом, а также соответствующие им текстурные координаты  и . Уточнение оценки точки пересечения в данном методе идет за счет применения бинарного поиска.
Шаги алгоритма уточнения:
* Выполняем расчет Steep PM и получаем текстурные координаты  и  – в этом интервале лежит точка пересечения вектора  с рельефом поверхности. Истинная точка пересечения отмечена красным крестиком.
* Разделить на два текущие значения смещения текстурных координат и высоты слоя глубины.
* Сместить текстурные координаты из точки  в направлении обратном вектору  на величину смещения. Уменьшить глубину слоя на текущее значение размера слоя.
* Непосредственно бинарный поиск. Повторяется заданное число итераций:
* 1. Осуществить выборку из карты глубин. Разделить на два текущие значения смещения текстурных координат и размера слоя глубины.
2. Если величина выборки оказалась больше текущей глубины слоя, то увеличить глубину слоя на текущий размер слоя, а текстурные координаты изменить вдоль вектора  на текущее смещение.
3. Если же величина выборки оказалась меньше текущей глубины слоя, то уменьшить глубину слоя на текущий размер слоя, а текстурные координаты изменить вдоль вектора обратного  на текущее смещение.
* Последние полученные текстурные координаты и есть результаты Relief PM.
На изображении видно, что после нахождения точек  и  мы уполовиниваем размер слоя и размер смещения текстурных координат, что дает нам первую точку итерации бинарного поиска (1). Так как величина выборки в ней оказалась больше, чем текущая глубины слоя, то мы еще раз уполовиниваем параметры и смещаемся вдоль , получая точку (2) с текстурными координатами , что и будет результатом Steep PM для двух итераций бинарного поиска.
Шейдерный код:
```
// входные параметры: inTexCoords - исходные текстурные координаты,
// inViewDir - вектор на наблюдателя в касательном пр-ве
// выходные параметры: lastDepthValue – глубина в найденной точке пересечения
// функция возвращает измененные текстурные координаты
vec2 reliefPM(vec2 inTexCoords, vec3 inViewDir, out float lastDepthValue) {
// ======
// код, повторяющий реализацию Steep PM
// ======
const float _minLayers = 2.;
const float _maxLayers = 32.;
float _numLayers = mix(_maxLayers, _minLayers, abs(dot(vec3(0., 0., 1.), inViewDir)));
float deltaDepth = 1./_numLayers;
// uDepthScale – юниформ для контроля выраженности PM
vec2 deltaTexcoord = uDepthScale * inViewDir.xy/(inViewDir.z * _numLayers);
vec2 currentTexCoords = inTexCoords;
float currentLayerDepth = 0.;
float currentDepthValue = depthValue(currentTexCoords);
while (currentDepthValue > currentLayerDepth) {
currentLayerDepth += deltaDepth;
currentTexCoords -= deltaTexcoord;
currentDepthValue = depthValue(currentTexCoords);
}
// ======
// код реализации Relief PM
// ======
// уполовиниваем смещение текстурных координат и размер слоя глубины
deltaTexcoord *= 0.5;
deltaDepth *= 0.5;
// сместимся в обратном направлении от точки, найденной в Steep PM
currentTexCoords += deltaTexcoord;
currentLayerDepth -= deltaDepth;
// установим максимум итераций поиска…
const int _reliefSteps = 5;
int currentStep = _reliefSteps;
while (currentStep > 0) {
currentDepthValue = depthValue(currentTexCoords);
deltaTexcoord *= 0.5;
deltaDepth *= 0.5;
// если выборка глубины больше текущей глубины слоя,
// то уходим в левую половину интервала
if (currentDepthValue > currentLayerDepth) {
currentTexCoords -= deltaTexcoord;
currentLayerDepth += deltaDepth;
}
// иначе уходим в правую половину интервала
else {
currentTexCoords += deltaTexcoord;
currentLayerDepth -= deltaDepth;
}
currentStep--;
}
lastDepthValue = currentDepthValue;
return currentTexCoords;
}
```
### Самозатенение
Также небольшое дополнение о добавлении в алгоритм вычисления затенения от выбранного источника света. Решил добавить, поскольку технически метод расчета идентичен рассмотренным выше, а эффект все же интересный и детальности добавляет.
По сути применяется тот же Steep PM, но с поиск идет не вглубь имитируемой поверхности вдоль линии взгляда, а из поверхности, вдоль вектора на источник света . Этот вектор также переносится в касательное пространство и используется для определения величины смещения текстурных координат. На выходе метода получится вещественный коэффициент освещенности в интервале [0, 1], который используется для модуляции диффузной и зеркальной компонент в расчетах освещения.
Для определения затенения с резкими краями достаточно пройтись вдоль вектора  до тех пор, пока не найдется точка, лежащая под поверхностью. Как только такая точка найдена – принимаем коэффициент освещенности 0. Если же мы достигли нулевой глубины, не встретив точки, лежащей под поверхностью, то коэффициент освещенности берем равным 1.
Для определения затенения с мягкими краями необходимо проверить несколько точек, лежащих на векторе  и находящиеся под поверхностью. Коэффициент затенения при этом берется равным разности глубины текущего слоя и глубины из карты глубин. Также учитывается удаление очередной точки от рассматриваемого фрагмента в виде весового коэффициента равного (*1.0 – stepIndex/numberOfSteps*). На каждом шаге определяется частичный коэффициент освещенности как:
Конечным же результатом является максимальный коэффициент освещенности из всех частичных:
Схема работы метода:
Ход работы метода для трех итераций в данном примере:
* Инициализируем итоговый коэффициент освещенности в ноль.
* Делаем шаг вдоль вектора , попадая в точку . Глубина точки явно меньше, чем выборка из карты  – она находится под поверхностью. Здесь мы сделали первую проверку и, помня об общем числе проверок, находим и сохраняем первый частичный коэффициент освещенности: (1.0 – 1.0/3.0).
* Делаем шаг вдоль вектора , попадая в точку . Глубина точки явно меньше, чем выборка из карты  – она находится под поверхностью. Вторая проверка и второй частичный коэффициент: (1.0 – 2.0/3.0).
* Делаем еще один шаг вдоль вектора и попадаем на минимальную глубину 0. Останавливаем движение.
* Определение результата: если точек под поверхностью не было найдено, то возвращаем коэффициент равный 1 (отсутствие затенения). Иначе результирующим коэффициентом становится максимальный из вычисленных частичных. Для использования в расчете освещения мы вычитаем это значение из единицы.
Пример шейдерного кода:
```
// входные параметры: inTexCoords - исходные текстурные координаты,
// inLightDir - вектор на источник света в касательном пр-ве
// выходные параметры: inLastDepth – глубина в точке пересечения,
// найденной одним из улучшенных методов PM
// функция возвращает коэффициент для модуляции компонент
// использующейся модели освещения
float getParallaxSelfShadow(vec2 inTexCoords, vec3 inLightDir, float inLastDepth) {
float shadowMultiplier = 0.;
// расчет будем делать только для поверхностей,
// освещенных используемым источником
float alignFactor = dot(vec3(0., 0., 1.), inLightDir);
if (alignFactor > 0.) {
// знакомая инициализация параметров: слои глубины, шаг
// слоя глубины, шаг смещения текстурных координат
const float _minLayers = 16.;
const float _maxLayers = 32.;
float _numLayers = mix(_maxLayers, _minLayers, abs(alignFactor));
float _dDepth = inLastDepth/_numLayers;
vec2 _dtex = uDepthScale * inLightDir.xy/(inLightDir.z * _numLayers);
// счетчик точек, оказавшихся под поверхностью
int numSamplesUnderSurface = 0;
// поднимаемся на глубину слоя и смещаем
// текстурные координаты вдоль вектора L
float currentLayerDepth = inLastDepth - _dDepth;
vec2 currentTexCoords = inTexCoords + _dtex;
float currentDepthValue = depthValue(currentTexCoords);
// номер текущего шага
float stepIndex = 1.;
// повторяем, пока не выйдем за слой нулевой глубины…
while (currentLayerDepth > 0.) {
// если нашли точку под поверхностью, то увеличим счетчик и
// рассчитаем очередной частичный и полный коэффициенты
if (currentDepthValue < currentLayerDepth) {
numSamplesUnderSurface++;
float currentShadowMultiplier = (currentLayerDepth - currentDepthValue)*(1. - stepIndex/_numLayers);
shadowMultiplier = max(shadowMultiplier, currentShadowMultiplier);
}
stepIndex++;
currentLayerDepth -= _dDepth;
currentTexCoords += _dtex;
currentDepthValue = depthValue(currentTexCoords);
}
// если точек под поверхностью не было, то точка
// считается освещенной и коэффициент оставим 1
if (numSamplesUnderSurface < 1)
shadowMultiplier = 1.;
else
shadowMultiplier = 1. - shadowMultiplier;
}
return shadowMultiplier;
}
```
Полученный коэффициент используется для модуляции результата работы используемой в примерах модели освещения Блинна-Фонга:
```
[...] // расчет отдельных компонент модели освещения
vec3 fullColorADS = ambientTerm + attenuation * (diffuseTerm + specularTerm);
// модулируем результат с помощью к-та самозатенения
fullColorADS *= pmShadowMultiplier;
return fullColorADS;
```
[Сравнение всех методов](https://habrastorage.org/webt/qn/x9/ac/qnx9ac0vksqns664zkifo5lf68a.jpeg) в одном коллаже, объем 3Мб.
Также видео-сравнение:
Дополнительные материалы
------------------------
* [Parallax Occlusion Mapping in GLSL](http://sunandblackcat.com/tipFullView.php?topicid=28): отличный урок по Parallax Mapping от **sunandblackcat.com**.
* [How Parallax Displacement Mapping Works](https://www.youtube.com/watch?v=xvOT62L-fQI): видеоурок, неплохо объясняющий детали работы Parallax Mapping от **TheBennyBox**.
**P.S.**: У нас есть [телеграм-конфа](https://t.me/joinchat/Cpb05A46UPpMWdNVVCb4Vg) для координации переводов. Если есть серьезное желание помогать с переводом, то милости просим! | https://habr.com/ru/post/416163/ | null | ru | null |
# Однострочники на Си/С++. Часть 2
Ранее я уже публиковал статью о [Однострочниках на С++](http://habrahabr.ru/post/146793/). Так в этом посте я хочу упомянуть ещё несколько алгоритмов, а также несколько реализаций алгоритма обмена двух чисел(с вычислением времени работы).
Всех заинтересовавшихся прошу под кат;)
#### 1. Проверка на простоту
Для вызова этой функции надо написать `prime(100, int(sqrt(100)));`
```
bool prime(int n, int div) {
return ( div == 1) ? true : (n % div != 0) && (prime(n, div-1));
}
```
Чтобы этого избежать можно создать функцию-оболочку:
```
bool prime(int n) {
return ( n == 1 )? 0 : ( prime( n, int(sqrt(n))) ) ;
}
```
и тепер для вызова функции достаточно написать `prime(100)`
#### 2. Код Грея
Кодом Грея называется такая система нумерования неотрицательных чисел, когда коды двух соседних чисел отличаются ровно в одном бите.
```
int codeGrey (int n) {
return n ^ (n >> 1);
}
```
А также нахождение обратного кода Грея
```
int revCodeGrey (int g) {
int n;
for (n=0; g; n ^=g, g>>=1);
return n;
}
```
Коды Грея имеют несколько применений в различных областях:
* битный код Грея соответствует гамильтонову циклу по n-мерному кубу
* в решении задачи о Ханойских башнях
* применение в теории генетических алгоритмов
#### 3. Вычисление биномиального коэффициента
Биномиальный коэффициент — это коэффициент в разложении бинома Ньютона  по степеням x.
```
int binomialCoefficient(int k, int n) {
return (n==k || k==0)?1:binomialCoefficient(k-1,n-1)+binomialCoefficient(k,n-1);
}
```
#### 4. Нахождение степени делителя факториала
Даны два числа: [n] и [k]. Требуется посчитать, с какой степенью делитель [k] входит в число [n].
```
int factPow(int n, int k) {
return (n)? (n/k + factPow(n/k, k)):0;
}
```
#### 5. Возведение числа [a] в степень [b] по модулю [p].
```
nt powM(int a, int b, int p) {
return b ? (a * powM(a-1, b, p) % p) : 1;
}
```
Также здесь можно использовать индийский алгоритм возведения в степень.
```
int powM(int a, int b, int p) {
return b ? ((b&1?a:1)*powM(a*a, b/2, p) % p) : 1;
}
```
---
#### Мое исследование SWAPa
Вот мне пришла мысль исследовать разнообразные SWAPи, какой из них самый быстрый.
Тест SWAPов будет вот такой программкой
```
int a=1, b=2;
for(int i=0; i<=300000000; i++) {
swap(&a, &b);
}
```
где вместо swap, будут различные алгоритмы обмена двух значений.
##### SWAP0
Итак начнем пожалуй из STLивского, стандартного алгоритма:
```
template void swap0 ( T& a, T& b ) {
T c(a); a=b; b=c;
}
```
его показатели были таковы:
```
1,996 sec.
1,986 sec.
1,996 sec.
```
##### SWAP1
Следующим SWAPом будет так называемый XOR SWAP:
```
void swap1(int *a, int *b) {
*a ^= ( *b ^= ( *a ^= *b ));
}
```
его показатели были таковы:
```
3,603 sec.
3,603 sec.
3,608 sec.
```
##### SWAP2
```
void swap2(int *a, int *b) {
*a += *b -= *a = *b - *a;
}
```
её показатели были таковы:
```
3.728 sec.
3.723 sec.
3.728 sec.
```
##### SWAP3
```
void swap3(int *a, int *b) {
*a /= *b = (*a= *a * (*b)) / (*b);
}
```
её показатели были таковы:
```
7.878 sec.
7.862 sec.
7.862 sec.
```
##### SWAP4
```
void swap4(int *a, int *b) {
*b= *a + *b - (*a = *b);
}
```
её показатели были таковы:
```
2.012 sec.
2.007 sec.
2.012 sec.
```
##### SWAP5
```
void swap5(int *a, int *b) {
*a=(*b=(*a=*b^*a)^*b)^*a;
}
```
её показатели были таковы:
```
3.198 sec.
3.213 sec.
3.198 sec.
```
##### SWAP6
Ну, и ассемблерная вставка для компилятора GCC
```
void swap7(int *a, int *b) {
asm volatile(
"XOR %%EAX, %%EBX; \n\t"
"XOR %%EBX, %%EAX; \n\t"
"XOR %%EAX, %%EBX; \n\t"
:"=a"(*a),"=b"(*b)
:"a"(*a),"b"(*b)
);
}
```
её показатели были таковы:
```
2.199 sec.
2.153 sec.
2.167 sec.
```
Как видим наша таблица исследований такова:
1. ```
SWAP0 - 1.992 sec.
```
2. ```
SWAP4 - 2.010 sec.
```
3. ```
SWAP6 - 2.173 sec.
```
4. ```
SWAP5 - 3.203 sec.
```
5. ```
SWAP1 - 3.604 sec.
```
6. ```
SWAP2 - 3.726 sec.
```
7. ```
SWAP3 - 7.867 sec.
``` | https://habr.com/ru/post/147277/ | null | ru | null |
# Практическая биоинформатика ч.3. Оценка значимости экспериментальных данных
На каждом этапе эксперимента, начиная от подготовки материала, продолжая проведением PCR и заканчивая секвенированием, происходит накопление ошибки. Нам нужен механизм оценки значимости результата. Какова вероятность, что риды, оказавшиеся на некотором участке генома, оказались там неслучайно? Подход, представленный в этой статье, применим для данных, полученных с помощью DNA-seq, и рассказывает о возможности применения распределения Пуассона для оценки значимости.
Эта иллюстрация схематично изображает процесс подготовки материала для секвенирования. На каждом этапе возможна ошибка, в результате дающая рид на произвольном участке генома.
* А.1 Клетка с ДНК обрабатывается формальдегидом для лучшего закрепления белка. Потом ДНК режется на фрагменты различными способами, в том числе [ультразвуком](http://en.wikipedia.org/wiki/Chromatin_immunoprecipitation).
* А.2-3 Добавляется антитело, которое чувствительно к белкам. Фрагменты отмеченные белком скрепляются с антителом. Некоторые фрагменты соединяются случайным образом.
* А.4 Происходит осаждение антител с фрагментами ДНК. Очистка фрагментов ДНК от антител и белков.
* B.1-4 Эти пункты показывают шаги по подготовке полученных фрагментов ДНК для секвенирования. Добавление специальных адаптеров. Умножение с помощью PCR. Размещение на слайде.
Полученный в результате этих операций слайд помещают в машину для секвенирования, например [Illumina](http://www.illumina.com/systems/hiseq_2000.ilmn). Итогом работы аппаратуры и прилагающихся к ней программ является FASTA/FASTQ файл. Вот пример содержимого FASTQ файла:
```
@HWI-XXXXX_0470:1:1:1761:946#0/1
NCCCTTTGGATTTGTCCTTTCAGATGCATTAGCCAT
+HWI-XXXXX_0470:1:1:1761:946#0/1
BKNNJMHHEJRTRRR_______________Y[[[Y_
```
Первая строка, начинающаяся с «@», и третья, начинающаяся с «+», — описательные, содержат в себе имя, номер слайда, и т.д. Вторая строчка — это считанная последовательность нуклеотидов, в нашем случае их 36. Четвертая строка — это вероятности считывания нуклеотидов. Ниже приведена ссылка на точное описание формата файла и способ получения чисел из буквенного представления <http://en.wikipedia.org/wiki/FASTQ_format>.
Файл со всеми ридами, которых миллионы в рамках одного секвенирования, передают в программу [bowtie](http://bowtie-bio.sourceforge.net), являющуюся на текущий момент самой быстрой. Строка выполнения программы bowtie может быть такой:
```
/usr/src/bowtie-0.12.7/bowtie -q -v 2 -m 1 --best --strata -p 8 -S \
/usr/src/bowtie-0.12.7/indexes/hg19 - |
samtools view -Sb - >${DIRNAME}/${SEQNAME}.bam
```
Параметры, указанные в примере, характеризуют следующее поведение программы:
-q — обрабатывает входной файл как FASTQ, а не FASTA
-v — количество допустимых ошибок в риде, в вышеприведенном примере их 2
-m — сколько вхождений (ридов) в геноме искать, в данном случае задано 1
-p — сколько threads задействовать, я исходил из количества ядер процессора — 8
-S — означает, что выходной файл будет записан в формате .sam
/usr/src/bowtie-0.12.7/indexes/hg19 — путь к заранее проиндексированному геному, выполненный программой bowtie-build. Также готовый путь можно скачать из интернета.
— (тире в конце второй строки) означает вывод в стандартный output для передачи программе samtools, которая на лету преобразует его в .bam.
В описании я пропустил параметры --best --strata, которые задают специальный режим работы bowtie: если программа находит более чем одно вхождение рида в геноме с разным количеством ошибок, то она выводит результат с наименьшей ошибкой. Если результатов с наименьшей ошибкой больше одного, то они не выводятся. Это увеличивает время работы программы, но в то же время позволяет повысить чувствительность нахождения ридов в геноме. Вот пример вывода .sam/.bam файла:
```
@HD VN:1.0 SO:unsorted
@SQ SN:chr10 LN:135374737
@SQ SN:chr11 LN:134452384
…
@PG ID:Bowtie VN:0.12.7 CL:"/usr/src/bowtie-0.12.7/bowtie -q -v 1 -m 1 --best --strata -p 8 -S"
USI-EAS21_8_3445_7_1_452_540 0 chr5 39195556 255 23M * 0 0 CTCCAGATTCTCTGGAAAGATGG SSSSSSPSSSSSSSSGNNSJSSL XA:i:0 MD:Z:23 NM:i:0
USI-EAS21_8_3445_7_1_170_242 0 chr14 73509925 255 23M * 0 0 CTGCATTAGACCTAGGCTTAGAA SSSSSSSSSSSSSSSSSSSGSNN XA:i:0 MD:Z:23 NM:i:0
USI-EAS21_8_3445_7_1_290_985 0 chr7 142613233 255 23M * 0 0 AGCTGACTGGCAAGCAACAGAGT JSSSSSSSSSSSPSSGSSLSNSL XA:i:0 MD:Z:23 NM:i:0
USI-EAS21_8_3445_7_1_881_711 4 * 0 0 * * 0 0 ATCGGAAGAGCTCGTATGCCGTC SSSSPSSSSSSSSSSSSSSSSNS XM:i:0
USI-EAS21_8_3445_7_1_897_318 0 chr3 50101427 255 23M * 0 0 GGGCGCAGAACCGCTGCTGCTGC SPSSSSSSSPPSSSSNSPPPLSL XA:i:1 MD:Z:15A7NM:i:1
```
Шапка (строки, начинающиеся на @SQ, @HD, @PG) содержит описания: имена хромосом и их длины, сортирован ли файл, команда, с помощью которой был получен файл. Тело состоит из строк, каждая строка — это рид, но уже с координатами в геноме. Более детально прочитать можно тут<http://genome.sph.umich.edu/wiki/SAM>.
Распределение по геному бывает разное, но в обогащенных участках считается, что эксперимент с большей степенью вероятности прошел удачно, если распределение обладает следующими свойствами: even coverage (равномерное покрытие), high complexity (высокая сложность), continuity of coverage (непрерывное покрытие). Примеры, как риды могут покрывают геном, изображены на рисунках сверху.
Для определения обогащенных участков, воспользуемся следующим рассуждением. Сложим все длины хромосом и вычтем длину повторяющихся участков (примерная длина 2282603114 для hg19), примем получившуюся длину за G. Разобьем длину G на окна шириной по W (для примера 500). Примем за N количество получившихся окон (G/W примерно 4565206.228). Подсчитаем количество ридов в эксперименте, которые были удачно найдены в геноме (пусть будет 4E6 из 4.5E6 всего), примем их количество за S. Тогда среднее количество ридов на окно, обозначим , будет =S\*W/G=S/N.
Пуассоновское распределение  выражает вероятность происхождения заданного числа k событий за промежуток времени при известном среднем происхождении событий. Кумулятивное пуассоновское распределение будет выражать вероятность происхождения событий численностью до k. Будем использовать кумулятивное распределение, так как нас интересует вероятность того, что кол-во ридов в окне меньше k. Нулевая гипотеза: k ридов в окне случайно. Альтернативная гипотеза: k ридов в окне не случайно. Вероятность того, что наша нулевая гипотеза верна ровна . Чем ближе P(k,) к 0, тем меньше вероятность, что риды попали в заданное окно случайно. В нашем примере получаем, что, если количество ридов в окне до 15, то 1-P(15,0.876193)=2.55351E-15, т.е. в окно шириной 500 количество ридов до 15 может попасть случайно с вероятностью 2.55351E-15. Это число ещё называют p value. Следовательно, если ридов больше 15, то они с ещё меньшей вероятностью попадают в окно случайно. Таким образом, в программе можно задать условие: если p value < = 1.e16, значит данные, попавшие в окно, следует оставить для рассмотрения, остальные — отбросить.
Ниже приводится пример программы, которая использует часть классов, описанных в [предыдущей статье](http://habrahabr.ru/blogs/bioinformatics/137082/), и дополняется новым классом PoissonHandler. Дополнительные файлы к [первому](https://sites.google.com/a/porter.st/porter/Home/src.tar.gz?attredirects=0&d=1) архиву можно скачать [тут](https://sites.google.com/a/porter.st/porter/Home/poisson.tar.gz?attredirects=0&d=1). В новой директории poisson набираем qmake, затем make. Собранная программа poisson строит таблицу значимости для окон в 500bp, расположенных за транскрипционным старт-сайтом каждого гена, аннотация выбирается из геном браузера. Более детальную работу с геном браузером рассмотрим в другой статье. Далее выбираются риды из .bam файла, попавшие в наши окна, для них строится пуассоновское распределение. Результат записывается в файл.
PoissonHandler.hpp
```
#ifndef PoissonHandler_H
#define PoissonHandler_H
#include
class PoissonHandler : public QState
{
Q\_OBJECT
private:
GenomeDescription \*sql\_input;
GenomeDescription \*sam\_input;
QSettings setup;
public:
PoissonHandler(GenomeDescription \*sql,GenomeDescription \*sam,HandledData &output,QState \*parent=0);
~PoissonHandler();
protected:
virtual void onEntry(QEvent\* event);
};
#endif //
```
PoissonHandler.cpp
```
#include "PoissonHandler.hpp"
//-------------------------------------------------------------
//-------------------------------------------------------------
PoissonHandler::~PoissonHandler()
{
}
//-------------------------------------------------------------
//-------------------------------------------------------------
PoissonHandler::PoissonHandler(GenomeDescription *sql,GenomeDescription *sam,HandledData &,QState * parent):
QState(parent),
sql_input(sql),
sam_input(sam)
{
}
//-------------------------------------------------------------
//-------------------------------------------------------------
void PoissonHandler::onEntry(QEvent*)
{
if(!setup.contains("AvgTagWindow"))
setup.setValue("AvgTagWindow",500);
if(!setup.contains("siteShift"))
setup.setValue("siteShift",75);
qint32 window=setup.value("AvgTagWindow").toInt();
qint32 half_window=0;//window/2;
qint32 shift=setup.value("siteShift").toInt();
int c=0;//sense count, even/odd c sense/nonsense
QMap poisson;
QMapIterator > > sense(sql\_input->genome);
while(sense.hasNext())
{
sense.next(); c++;
QMapIterator > dictionary(sense.value());
while(dictionary.hasNext())
{
dictionary.next();
QMapIterator s(dictionary.value()); //sql result for strand+chromosome
if((sam\_input->genome['+']).contains(dictionary.key())) //chromosome chr1,chr2...
{
QMapIterator k( (sam\_input->genome['+'])[dictionary.key()] );//+ strand,sam file, iteration over strand+chromosome
s.next(); //c++;
k.next();
while (k.hasNext()) // + strand, iteration over strand+chromosome+each position
{
//if align is inside of the segment of the start site
qint32 x1=k.key()- s.key() +half\_window +shift;
qint32 x2=x1-window;
if( (x1^x2) < 0 )
{//inside segment
poisson[((sql\_input->genome\_h[sense.key()])[dictionary.key()])[s.key()]]+=k.value();
k.next();
}
else
{
if((k.key() +shift)>(s.key()+half\_window))
{
if(!s.hasNext()) break;
s.next();// c++;
}
else
{
k.next();
}
}
}//while k.hasNext
}//if + strand sam input
if((sam\_input->genome['-']).contains(dictionary.key()))
{
QMapIterator j( (sam\_input->genome['-'])[dictionary.key()] );//- strand,sam file
s.toFront();
s.next();
j.next();
while (j.hasNext()) // - strand
{
//if align is inside of the segment of the start site
qint32 x1=j.key()- s.key() +half\_window -shift;
qint32 x2=x1-window;
if( (x1^x2) < 0 )
{//inside segment
poisson[((sql\_input->genome\_h[sense.key()])[dictionary.key()])[s.key()]]+=j.value();
j.next();
}
else
{
if((j.key() -shift)>(s.key()+half\_window))
{
if(!s.hasNext()) break;
s.next();
}
else
{
j.next();
}
}
}
}//if - strand sam file
}//while dictionary
}//while sense
//Poisson
{
qreal lamda=(qreal)(window\*(sam\_input->total-sam\_input->notAligned))/(sam\_input->tot\_len\*0.741);
QFile \_outFile;
\_outFile.setFileName(setup.value("outFileName").toString());
\_outFile.open(QIODevice::WriteOnly|QIODevice::Truncate);
qreal exp\_l=qExp(-lamda);
QString str;
foreach(str,poisson.keys())
{
//P(x,L)=(e\*\*-1)\*(L\*\*x)/x!
// qreal pois=exp\_l; //qExp(-lamda)\*qPow(lamda,poisson[str]);
// for(int i=2; i<= poisson[str];i++)
// pois=pois\*lamda/i;
//P(x,L)=(e\*\*-1)\*E(1-k)(L\*\*x(i))/x(i)!
qreal pois=exp\_l;
qreal delim=1.0;
qreal sum=1.0;
for(int i=1; i<= poisson[str];i++)
{
delim\*=lamda/i;
sum+=delim;
}
pois\*=sum;
\_outFile.write( (QString("%1\t%2\t%3\n").arg(str).arg(poisson[str]).arg(pois,0,'e',20)).toLocal8Bit() );
}
\_outFile.flush();
\_outFile.close();
}//if(1)
}//end of function
//-------------------------------------------------------------
//-------------------------------------------------------------
```
Эти небольшие алгоритмы в дальнейшем пригодятся для реализации более сложных, например, таких как [ZINBA](http://code.google.com/p/zinba/) или [SICER](http://home.gwu.edu/~wpeng/Software.htm). О них мы поговорим в другой статье. Часто задача состоит в нахождении обогащенных участков без использования аннотации. И тогда шаг за шагом нужно отбирать данные, попавшие в окна и прошедшие через фильтр.
**Comprehensive comparative analysis of strand-specific RNA sequencing methods**
Nat Methods. 2010 September; 7(9): 709–715.
Joshua Z. Levin,1,6 Moran Yassour,1,2,3,6 Xian Adiconis,1 Chad Nusbaum,1Dawn Anne Thompson,1 Nir Friedman,3,4 Andreas Gnirke,1 and Aviv Regev1,2,5
[www.ncbi.nlm.nih.gov/pmc/articles/PMC3005310](http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3005310/)
**Genomic Location Analysis by ChIP-Seq**
J Cell Biochem. 2009 May 1;107(1):11-8.
Artem Barski\* and Keji Zhao\*
Laboratory of Molecular Immunology, National Heart, Lung and Blood Institute, NIH, Bethesda, MD 20892
[www.ncbi.nlm.nih.gov/pubmed/19173299](http://www.ncbi.nlm.nih.gov/pubmed/19173299)
**An integrated strategy for identification of both sharp and broad peaks from next-generation sequencing data.**
Genome Biol. 2011 Jul 25;12(7):120.
Peng W, Zhao K.
Department of Physics, The George Washington University, 725 21st Street NW, Washington, DC 20052, USA. wpeng@gwu.edu
[www.ncbi.nlm.nih.gov/pubmed/21787381](http://www.ncbi.nlm.nih.gov/pubmed/21787381)
**A clustering approach for identification of enriched domains from histone modification ChIP-Seq data.**
Bioinformatics. 2009 Aug 1;25(15):1952-8. Epub 2009 Jun 8.
Zang C, Schones DE, Zeng C, Cui K, Zhao K, Peng W.
Department of Physics, The George Washington University, Washington, DC 20052, USA.
[www.ncbi.nlm.nih.gov/pubmed/19505939](http://www.ncbi.nlm.nih.gov/pubmed/19505939)
**ZINBA integrates local covariates with DNA-seq data to identify broad and narrow regions of enrichment, even within amplified genomic regions.**
Genome Biol. 2011 Jul 25;12(7):R67.
Rashid NU, Giresi PG, Ibrahim JG, Sun W, Lieb JD.
Department of Biostatistics, Gillings School of Global Public Health, The University of North Carolina at Chapel Hill, Chapel Hill, NC 27599, USA.
[www.ncbi.nlm.nih.gov/pubmed/21787385](http://www.ncbi.nlm.nih.gov/pubmed/21787385)
Review is prepared by Andrey Kartashov, Cincinnati OH, mail: porter@porter.st | https://habr.com/ru/post/137267/ | null | ru | null |
# Уязвимость связки PHP+nginx с кривым конфигом
#### Summary
###### Announced: 2010-05-20
Credits: [80sec](http://www.80sec.com/nginx-securit.html)
Affects: сайты на ngnix+php с возможностью загрузки файлов в директории с fastcgi\_pass
#### Background
Зачастую How-To по настройке связки nginx с php-fpm / php-cgi есть подобные строчки:
```
location ~ \.php$ {
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;
include fastcgi_params;
}
```
#### Problem Description
Однако если попросить у сервера отдать [example.com/1px.gif/test.php](http://example.com/1px.gif/test.php), то URI примет вид `1px.gif/test.php`, что подойдёт под `location \.php$`, а `SCRIPT_FILENAME` станет равным `/scripts/1px.gif/test.php`.
Далее, если `cgi.fix_pathinfo == 1` (по дефолту), то `SCRIPT_FILENAME` станет равным `/scripts/1px.gif`, а `PATH_INFO` будет равен `test.php`
**NB!** В некоторых конфигурациях уязвимость триггерит URL вида `1px.gif%00test.php`
В итоге php интерпретатор обработает `/scripts/1px.gif`. То есть,
#### Impact
Любой пользователь будет иметь возможность заливать файлы на сервер (например, аватары) то создав особенное изображение, которое будет одновременно проходить валидацию размеров GD и исполняться php интерпретатором, будет иметь права на исполнение произвольного кода на сервере с правами php процесса.
#### Workaround
Через в `php.ini`
```
cgi.fix_pathinfo=0
```
или же через конфиг nginx.conf
```
location ~ \.php$ {
try_files $fastcgi_script_name =404;
fastcgi_index index.php;
fastcgi_param script_FILENAME /scripts$fastcgi_script_name;
include fastcgi_params;
}
```
это фактически закроет доступ ко всем не существующим файлам `.php` | https://habr.com/ru/post/100961/ | null | ru | null |
# ORB_SLAM3 на raspberry pi 4
Рассматриваются нюансы установки ORB\_SLAM3 на одноплатном пк — raspberry pi 4 c ОС Raspbian buster, проводится поверхностный анализ возможностей алгоритма с учетом ограничений raspberry, показаны возможные пути оптимизации производительности, используется помимо прочего ROS noetic как связующее звено между imu, csi камерой raspberry pi и ORB\_SLAM3. Статья не претендует на научность, излагается мнение автора с опорой на экспериментальную базу.
### Вступление
Появилась интересная задача: построить маршрут в помещении, здании и т.п., да так, чтобы по этому маршруту можно было «пройти и назад вернуться». Сверхточность не важна, сколько понимание пространства и маршрута. Под «пройти» подразумевается перемещение слабовидящего человека с неким прибором в руке.
Первое что пришло на ум — это конечно же лидары и камеры глубины. Однако эти решения были отложены как дорогостоящие и/или неудобные.
Было решено посмотреть в сторону [ORB\_SLAM](https://github.com/UZ-SLAMLab/ORB_SLAM3), у которого «поспела» 3-я версия (с обновлениями 2021г.).
Так как ранее доводилось работать с ORB\_SLAM2, но производительность оставляла желать лучшего на слабом железе (raspberry pi3), то сложилось впечатление, что на raspberry pi4 обновленный ORB\_SLAM3 должен завестись.
Посмотрим, что из этого получилось.
Но для начала —
### Установим ROS noetic
ROS — robot operation system понадобится, чтобы связать данные, поступающие от гироскопа/акселерометра, камеры raspberry pi и ORB\_SLAM.
Как установить ROS подробно здесь описываться не будет, приведем только ссылку на статью-источник, следуя которой можно установить ROS на raspbian buster — [здесь](https://varhowto.com/install-ros-noetic-raspberry-pi-4/),
а также краткое изложение команд из статьи по приведенной ссылке.
Небольшие уточнения, далее будут приводиться со знаком "\*".
ROS различается наименованиями, каждое из которых «привязано» к определенным дистрибутивам. Так для raspbian buster подходит — ROS noetic.
**Список команд для установки ROS согласно приводимой статье**
```
sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu buster main" > /etc/apt/sources.list.d/ros-noetic.list'
sudo apt-key adv --keyserver 'hkp://keyserver.ubuntu.com:80' --recv-key C1CF6E31E6BADE8868B172B4F42ED6FBAB17C654
sudo apt update
sudo apt-get install -y python-rosdep python-rosinstall-generator python-wstool python-rosinstall build-essential cmake
sudo rosdep init
rosdep update
mkdir ~/ros_catkin_ws && cd ~/ros_catkin_ws
sudo apt install -y python3-rosdep python3-rosinstall-generator python3-wstool python3-rosinstall build-essential cmake
rosinstall_generator desktop --rosdistro noetic --deps --wet-only --tar > noetic-ros_comm-wet.rosinstall
*rosinstall_generator ros_comm --rosdistro noetic --deps --wet-only --tar > noetic-ros_comm-wet.rosinstall
wstool init src noetic-ros_comm-wet.rosinstall
rosdep install -y --from-paths src --ignore-src --rosdistro noetic -r --os=debian:buster
sudo src/catkin/bin/catkin_make_isolated --install -DCMAKE_BUILD_TYPE=Release --install-space /opt/ros/noetic -j1 -DPYTHON_EXECUTABLE=/usr/bin/python3
check:
source /opt/ros/noetic/setup.bash
roscd
roscore
```
\*команда
```
rosinstall_generator ros_comm --rosdistro noetic --deps --wet-only --tar > noetic-ros_comm-wet.rosinstall
```
заменена на другую (предшествующую команду) и выполняться не должна.
\*\*swap file можно не увеличивать, если у вас raspberry pi c 8 Гб RAM.
Также создадим рабочее окружение, в которое в дальнейшем будем устанавливать пакеты ROS:
```
cd ~
mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/
catkin_make
source devel/setup.bash
echo $ROS_PACKAGE_PATH
*outputs: /home/pi/catkin_ws/src:/opt/ros/noetic/share
```
### Usb camera node
Чтобы общаться с камерой на raspberry через ROS, нужна ее(камеры), так называемая, нода (node). Установим ее, хотя этот шаг можно и пропустить, так как в дальнейшем мы установим «специализированную» именно для raspberry ноду — raspicam node.
Однако usb camera node более универсальна, и, если не получится с raspicam node, эта точна должна заработать.
```
cd ~/catkin_ws/src
git clone https://github.com/bosch-ros-pkg/usb_cam.git
git clone https://github.com/ros-perception/image_common.git
git clone https://github.com/ros-perception/image_pipeline.git
git clone https://github.com/ros-perception/vision_opencv.git
cd ..
catkin_make
```
Пакетов несколько, так как нода требует дополнительные зависимости.
### Imu node (mpu650)
Этот шаг можно пропустить, для ORB\_SLAM будет достаточно и одной камеры (без параллельно работающего imu), однако точность будет хромать и невозможно будет запустить пример с суффиксом inertial.
На данном этапе подразумевается, что будет установлена нода, отвечающая за гироскоп/акселерометр GY-521 (mpu-650). Данный imu дешев и достаточно распространен. Его легко купить и он так же необязателен в своих показаниях. Этот факт мы учтем в дальнейшем. Хорош imu также тем, что неприхотлив и подключается напрямую к raspberry pi gpio, используя 5V, вместо положенных 3.
Чтобы imu заработал необходимо добавить
```
sudo nano /etc/modules
```
две строки:
```
i2c-bcm2708
i2c-dev
```
Перезагрузить систему и можно посмотреть на адрес imu:
```
sudo apt-get install i2c-tools python-smbus
i2cdetect -y -r 1
sudo i2cget -y 1 0x68 0x75
```
Как правило, это 0x68.
Также здесь пригодится статья, которая прояснит отдельные моменты, связанные с imu, а также позволит его проверить на работоспособность — [здесь](https://www.electronicwings.com/raspberry-pi/mpu6050-accelerometergyroscope-interfacing-with-raspberry-pi).
Случается иногда ошибка с imu:
```
Error: Could not set address to 0x68: Device or resource busy
```
Причины ее могут быть различны, но одна из них, может быть наличие rtc часов, которые когда-то были подключены и о которых «забыли». Чтобы выгрузить часы, пригодится:
```
lsmod | grep rtc
sudo rmmod rtc-ds1307
```
После этого, imu должен заработать.
Убедившись, что imu работает и может что-то отдавать в serial или иной порт, установим ROS ноду для него.
За основу будет взят пакет ноды mpu6050 — [отсюда](https://github.com/chrisspen/ros_mpu6050_node).
Внимание! Порядок установки будет отличаться от описанного в readme на github.
Далее по readme репо.
Здесь без изменений:
```
sudo mkdir -p /usr/share/arduino/libraries
cd /usr/share/arduino/libraries
sudo git clone https://github.com/chrisspen/i2cdevlib.git
```
\*В этом шаге понадобится patch, который можно взять отсюда — [скачать](https://disk.yandex.ru/d/VZJKP4KkvVlfkg).
```
cd /tmp
wget http://www.airspayce.com/mikem/bcm2835/bcm2835-1.59.tar.gz
cd bcm2835-1.59
tar zxvf bcm2835-1.59.tar.gz
patch -lNp1 --input=bcm2835_rpi4.patch
./configure
make
make check
sudo make install
```
Далее непосредственно установим саму ноду для imu:
```
cd ~/catkin_ws
source devel/setup.bash
cd ~/catkin_ws/src
git clone https://github.com/chrisspen/ros_mpu6050_node
cd ..
catkin_make --pkg ros_mpu6050_node
```
Ошибки, которые могут поджидать:
—
```
Initializing I2C...
bcm2835_init: gpio mmap failed: Cannot allocate memory
[mpu6050_node-2] process has died [pid 3427, exit code -11,
```
Возможные пути решения изложены [здесь](https://groups.google.com/g/bcm2835/c/BwZXVsDRtwI) и [здесь](https://groups.google.com/g/bcm2835/c/ZQnleyhLWiE?pli=1).
—
```
error FIFO overflow!
```
Решение: увеличить параметр в launch файле imu:
Как правило, достаточно изменить на 100 или 200 с 10.
**Надо ли дополнительно калибровать сам imu?**
Здесь мнения в источниках расходятся, одни говорят, что достаточно взять показания из datasheet и для дешевых imu умножить на 10, другие предлагают пройти процесс калибровки. Для последних оставлю [ссылку](https://github.com/inaciose/ros_mpu6050_calibration).
Теперь, когда ROS установлена, а также установлены ноды imu и камеры, можно проверить, что они работают.
Понадобится открыть 3и терминала, и выполнить отдельно команды:
```
bash -c "source /opt/ros/noetic/setup.bash; roscore"
```
\*запустили мастер ноду
```
bash -c "source /home/pi/catkin_ws/devel/setup.bash; roslaunch usb_cam usb_cam-test.launch"
```
\*запустили ноду камеры
```
sudo bash -c "source /home/pi/catkin_ws/devel/setup.bash; roslaunch ros_mpu6050_node mpu6050.launch"
```
\*запустили ноду imu
Если все работает, отлично! Движемся дальше.
### Raspicam-node
Raspicam нода менее требовательна к ресурсам по сравнению с usb camera нодой, которую установили ранее. Поэтому ее рекомендуется (автором) использовать.
Вот сравнение потребления вычислительных мощностей нодами-побратимами при одинаковых настройках:
Установка базируется на репо — [github.com/UbiquityRobotics/raspicam\_node](https://github.com/UbiquityRobotics/raspicam_node), однако отличается.
```
sudo apt-get install libogg-dev libvorbis-dev libtheora-dev
cd catkin_ws/src
git clone https://github.com/ros-perception/image_transport_plugins
git clone https://github.com/UbiquityRobotics/raspicam_node.git
cd ..
catkin_make
```
Нода запускается командой:
```
roslaunch raspicam_node camerav2_1280x960.launch
```
Картинку не выводит, т.к. в launch файле нет image\_viewer, и, чтобы убедиться, что все работает, можно либо послушать топик
```
rostopic echo rostopic echo /raspicam_node/image_raw
```
либо посмотреть в rviz, подписавшись на соответствующий топик.
### Установка ORB\_SLAM3
Пакет устанавливается не в catkin\_ws!
В целях экономии места и терпения опишем порядок установки тезисно:
---libraries---
```
sudo apt-get install libboost-all-dev libboost-dev libssl-dev libpython2.7-dev libeigen3-dev
```
---Pangolin---
```
cd ~
git clone https://github.com/stevenlovegrove/Pangolin
cd Pangolin
./scripts/install_prerequisites.sh recommended
cmake -B build -GNinja
cmake --build build
```
---opencv---
\*https://qengineering.eu/install-opencv-4.5-on-raspberry-pi-4.html
```
wget https://github.com/Qengineering/Install-OpenCV-Raspberry-Pi-32-bits/raw/main/OpenCV-4-5-5.sh
sudo chmod 755 ./OpenCV-4-5-5.sh
./OpenCV-4-5-5.sh
```
---ORB\_SLAM3---
```
git clone https://github.com/UZ-SLAMLab/ORB_SLAM3.git ORB_SLAM3
cd ORB_SLAM3
chmod +x build.sh
sed -i 's/++11/++14/g' CMakeLists.txt
./build.sh
```
ORB\_SLAM установлен, но необходимо еще собрать для него ROS ноды, которые не устанавливаются автоматически при инсталляции (при запуске ./build.sh):
1. Изменим CMakeLists.txt:
```
cd /home/pi/ORB_SLAM3/Examples_old/ROS/ORB_SLAM3
sed -i 's/++11/++14/g' CMakeLists.txt
```
здесь же закомментируем AR nodes, т.к. они не собираются:
```
# Node for monocular camera (Augmented Reality Demo)
#rosbuild_add_executable(MonoAR
#src/AR/ros_mono_ar.cc
#src/AR/ViewerAR.h
#src/AR/ViewerAR.cc
#)
#target_link_libraries(MonoAR
#${LIBS}
#)
```
здесь же в начало файла CMakeLists.txt добавим:
```
project(ORB_SLAM3)
```
2. Изменим build\_ros.sh (/home/pi/ORB\_SLAM3):
```
echo "Building ROS nodes"
cd Examples_old/ROS/ORB_SLAM3
mkdir build
cd build
cmake .. -DROS_BUILD_TYPE=Release -DPYTHON_EXECUTABLE=/usr/bin/python3
make -j
```
3.установим библиотеки:
```
---Sophus---
cd ~
git clone https://github.com/strasdat/Sophus.git
cd Sophus
mkdir build && cd build && cmake .. && sudo make install
---fmt---
sudo apt install libfmt-dev
```
Заменим Sophus из /home/pi/ORB\_SLAM3/Thirdparty/Sophus
на Sophus /home/pi/Sophus
\*Удалить директорию и скопировать ту, что сбилдили выше.
4. Изменить топики, которые будет «слушать» ORB\_SLAM3, чтобы камера(raspicam\_node) и ORB\_SLAM общались в одном топике:
```
nano /home/pi/ORB_SLAM3/Examples_old/ROS/ORB_SLAM3/src/ros_mono.cc
ros::Subscriber sub = nodeHandler.subscribe("/camera/image", 1, &ImageGrabber::GrabImage,&igb);
```
\*это можно не делать именно здесь, но потом сделать remap в launch файле с камерой. Ниже будет пометка.
5. Собрать ORB\_SLAM3 ноды:
```
export ROS_PACKAGE_PATH=${ROS_PACKAGE_PATH}:/home/pi/ORB_SLAM3/Examples_old/ROS/ORB_SLAM3
source /opt/ros/noetic/setup.bash
cd ~/ORB_SLAM3
./build_ros.sh
```
Теперь, когда все готово, можно запустить все необходимые ноды, совместно с нодами ORB\_SLAM3, используя уже 4-е терминала:
```
bash -c "source /opt/ros/noetic/setup.bash; roscore"
```
```
bash -c "source /home/pi/catkin_ws/devel/setup.bash; roslaunch usb_cam usb_cam-test.launch"
```
\*либо
```
bash -c "source /home/pi/catkin_ws/devel/setup.bash; roslaunch raspicam_node camerav2_1280x960.launch"
```
```
bash -c "source /home/pi/catkin_ws/devel/setup.bash;cd /home/pi/ORB_SLAM3/Examples_old/ROS/ORB_SLAM3;
./Mono /home/pi/ORB_SLAM3/Vocabulary/ORBvoc.txt /home/pi/ORB_SLAM3/Examples/Monocular/TUM1.yaml"
```
```
sudo bash -c "source /home/pi/catkin_ws/devel/setup.bash; roslaunch ros_mpu6050_node mpu6050.launch"
```
### Строим карту с ORB\_SLAM3
ORB\_SLAM строит своеобразные карты и к ним поначалу сложно привыкнуть. Особенно, если вы привыкли к картам, построенным лидаром или иным «дорогостоящим» прибором.
На изображении видно несколько десятков «почтовых конвертов» — это камера. При ее перемещении также можно наблюдать облако точек (на картинке выше его нет), point cloud.
Однако, чтобы перемещаться по помещению, нужен худо-бедно какой-нибудь мобильный прибор.
Можно взять за образец следующую модель, собранной на фанере от мобильного робота:
Двух аккумуляторов 18650 хватает на 2-3 часа.
Перед тем как строить карту необходимо поработать с настройками launch файлов как самого ORB\_SLAM3 так и нод камеры и imu.
**Начнем с камеры.**
```
nano /home/pi/catkin_ws/src/raspicam_node/launch/camerav2_512x512_fish.launch
```
Поправим launch файл raspicam\_node, снизив fps до 20, и выставим параметр enable\_raw в true, так как ORB\_SLAM3 не переваривает сжатые (image\_compressed) изображения, которые по умолчанию шлет raspicam\_node.
**camerav2\_512x512\_fish.launch**
```
```
Разрешение лучше не трогать, так как далее в ORB\_SLAM файле параметров будет использоваться файл с настройками калибровки камеры именно под картинку 512х512.
\***Теперь, если планируется использовать гироскоп/акселерометр, поправим соответствующую ноду.**
nano /home/pi/catkin\_ws/src/ros\_mpu6050\_node/launch/mpu6050.launch
Здесь надо выставить частоту — 100-200 Гц, а также сделать remap (перенаправление) топиков, чтобы imu публиковал данные в топик, который будет слушать ORB\_SLAM3.
**mpu6050.launch**
```
```
**Остались настройки ORB\_SLAM3**
Здесь немного посложнее.
Параметры хранятся в файлах формата yaml, поэтому править необходимо их. Что мы и сделаем.
Если у вас камера типа Pinhole, то правим TUM1.yaml:
```
nano /home/pi/ORB_SLAM3/Examples/Monocular/TUM1.yaml
```
если fish-eye, в понятиях ORB\_SLAM3 это тип KannalaBrandt8, то TUM-VI.yaml:
```
nano /home/pi/ORB_SLAM3/Examples/Monocular/TUM-VI.yaml
```
В целом у приведенных TUM файлов разницы немного в части содержимого.
Необходимо снизить ORBextractor.nLevels, обратить внимание на fps, разрешение 512х512, а также ORBextractor.nFeatures — количество извлекаемых фич (здесь необходим баланс производительности/ качества — меньше фич — быстрее работает, но хуже позиционируется и наоборот).
**TUM-VI.yaml**
```
%YAML:1.0
#--------------------------------------------------------------------------------------------
# Camera Parameters. Adjust them!
#--------------------------------------------------------------------------------------------
File.version: "1.0"
Camera.type: "KannalaBrandt8"
# Camera calibration and distortion parameters (OpenCV)
Camera1.fx: 190.978477
Camera1.fy: 190.973307
Camera1.cx: 254.931706
Camera1.cy: 256.897442
# Equidistant distortion 0.0034823894022493434, 0.0007150348452162257, -0.0020532361418706202, 0.0002029$
Camera1.k1: 0.003482389402
Camera1.k2: 0.000715034845
Camera1.k3: -0.002053236141
Camera1.k4: 0.000202936736
# Camera resolution
Camera.width: 512
Camera.height: 512
# Camera frames per second
Camera.fps: 20
# Color order of the images (0: BGR, 1: RGB. It is ignored if images are grayscale)
Camera.RGB: 1
#--------------------------------------------------------------------------------------------
# ORB Parameters
#--------------------------------------------------------------------------------------------
# ORB Extractor: Number of features per image
ORBextractor.nFeatures: 1000 # Tested with 1250
# ORB Extractor: Scale factor between levels in the scale pyramid
ORBextractor.nLevels: 3 #8
# ORB Extractor: Fast threshold
# Image is divided in a grid. At each cell FAST are extracted imposing a minimum response.
# Firstly we impose iniThFAST. If no corners are detected we impose a lower value minThFAST
# You can lower these values if your images have low contrast
ORBextractor.iniThFAST: 20
ORBextractor.minThFAST: 7
#--------------------------------------------------------------------------------------------
# Viewer Parameters
#--------------------------------------------------------------------------------------------
Viewer.KeyFrameSize: 0.05
Viewer.KeyFrameLineWidth: 1.0
Viewer.GraphLineWidth: 0.9
Viewer.PointSize: 2.0
Viewer.CameraSize: 0.08
Viewer.CameraLineWidth: 3.0
Viewer.ViewpointX: 0.0
Viewer.ViewpointY: -0.7
Viewer.ViewpointZ: -3.5
Viewer.ViewpointF: 500.0
Viewer.imageViewScale: 0.3
```
Запустим все (пока без ноды imu):
1-st terminal:
```
bash -c "source /opt/ros/noetic/setup.bash; roscore"
```
2-d:
```
bash -c "source /home/pi/catkin_ws/devel/setup.bash; roslaunch usb_cam usb_cam-test.launch"
```
либо
```
bash -c "source /home/pi/catkin_ws/devel/setup.bash; roslaunch raspicam_node camerav2_512x512_fish.launch"
```
3d:
```
bash -c "source /home/pi/catkin_ws/devel/setup.bash;cd /home/pi/ORB_SLAM3/Examples_old/ROS/ORB_SLAM3;
./Mono /home/pi/ORB_SLAM3/Vocabulary/ORBvoc.txt /home/pi/ORB_SLAM3/Examples/Monocular/TUM-VI.yaml"
```
В целом, raspberry неплохо справляется:
Однако, при резких поворотах мощностей явно не хватает.
Тем не менее, если двигаться неспеша и не дергать камерой, то можно построить «маршрут»:
Так выглядит пройтись туда и обратно с плавным разворотом камеры.
Сохранить карту, нажав на кнопку gui не получится. Такой кнопки нет. Чтобы карта записалась необходимо перед стартом ORB\_SLAM3 добавить строку в TUM.yaml файл:
```
System.SaveAtlasToFile: "my_01"
```
, где my\_01 — название карты.
При этом карта будет сохраняться в /home/pi/ORB\_SLAM3/Examples\_old/ROS/ORB\_SLAM3 и называться my\_01.osa.
Чтобы загрузить карту при старте ORB\_SLAM, которая ранее была построена в том же TUM файле указать:
```
System.LoadAtlasFromFile: "my_01"
```
### ORB\_SLAM3 c imu.
Пример запуска с учетом imu будет выглядеть так:
```
bash -c -E "source /home/pi/catkin_ws/devel/setup.bash;cd /home/pi/ORB_SLAM3/Examples_old/ROS/ORB_SLAM3;
./Mono_Inertial /home/pi/ORB_SLAM3/Vocabulary/ORBvoc.txt /home/pi/ORB_SLAM3/Examples/Monocular-Inertial/TUM-VI_far.yaml"
```
\*с учетом уже ранее запущенных нод в других терминалах roscore, raspicam\_node и собственно imu:
Не лишним будет убедиться, что imu шлет сообщения в топик imu:
```
rostopic echo /imu
```
Содержимое
**TUM-VI\_far.yaml**
```
%YAML:1.0
#------------------------------------------------------------------------------$
# Camera Parameters. Adjust them!
#------------------------------------------------------------------------------$
File.version: "1.0"
Camera.type: "KannalaBrandt8"
# Camera calibration and distortion parameters (OpenCV)
Camera1.fx: 190.978477
Camera1.fy: 190.973307
Camera1.cx: 254.931706
Camera1.cy: 256.897442
# Equidistant distortion 0.0034823894022493434, 0.0007150348452162257, -0.00205$
#Camera.bFishEye: 1
Camera1.k1: 0.003482389402
Camera1.k2: 0.000715034845
Сamera1.k3: -0.002053236141
Camera1.k4: 0.000202936736
# Camera resolution
Camera.width: 512
Camera.height: 512
# Camera frames per second
Camera.fps: 3
# Color order of the images (0: BGR, 1: RGB. It is ignored if images are grayscale)
Camera.RGB: 1
# Color order of the images (0: BGR, 1: RGB. It is ignored if images are grayscale)
Camera.RGB: 1
# Transformation from body-frame (imu) to camera
IMU.T_b_c1: !!opencv-matrix
rows: 4
cols: 4
dt: f
data: [-0.9995250378696743, 0.0075019185074052044, -0.02989013031643309, 0.045574835649698026,
0.029615343885863205, -0.03439736061393144, -0.998969345370175, -0.071161801837997044,
-0.008522328211654736, -0.9993800792498829, 0.03415885127385616, -0.044681254117144367,
0.0, 0.0, 0.0, 1.0]
# IMU noise (Use those from VINS-mono)
IMU.NoiseGyro: 0.004 # 0.00016 (TUM) # 0.00016 # rad/s^0.5
IMU.NoiseAcc: 0.04 # 0.0028 (TUM) # 0.0028 # m/s^1.5
IMU.GyroWalk: 0.000022 #(VINS and TUM) rad/s^1.5
IMU.AccWalk: 0.0004 # 0.00086 # 0.00086 # m/s^2.5
IMU.Frequency: 100.0
System.thFarPoints: 3.0
#--------------------------------------------------------------------------------------------
# ORB Parameters
#--------------------------------------------------------------------------------------------
# ORB Extractor: Number of features per image
ORBextractor.nFeatures: 1000 # Tested with 1250
# ORB Extractor: Scale factor between levels in the scale pyramid
ORBextractor.scaleFactor: 1.2
# ORB Extractor: Number of levels in the scale pyramid
ORBextractor.nLevels: 3 #8
# ORB Extractor: Fast threshold
# Image is divided in a grid. At each cell FAST are extracted imposing a minimum response.
# Firstly we impose iniThFAST. If no corners are detected we impose a lower value minThFAST
# You can lower these values if your images have low contrast
ORBextractor.iniThFAST: 20
ORBextractor.minThFAST: 7
#--------------------------------------------------------------------------------------------
# Viewer Parameters
#--------------------------------------------------------------------------------------------
Viewer.KeyFrameSize: 0.05
Viewer.KeyFrameLineWidth: 1.0
Viewer.GraphLineWidth: 0.9
Viewer.PointSize: 2.0
Viewer.CameraSize: 0.08
Viewer.CameraLineWidth: 3.0
Viewer.ViewpointX: 0.0
Viewer.ViewpointY: -0.7
Viewer.ViewpointZ: -3.5
Viewer.ViewpointF: 500.0
```
Здесь необходимо обратить внимание на IMU.Frequency: 100.0 и System.thFarPoints: 3.0.
Частоту imu необходимо будет поменять в launch файле imu ноды с 200 на 100.
System.thFarPoints — это расстояние, дальше которого ORB\_SLAM не будет извлекать фичи из изображения.
На этом пока все. | https://habr.com/ru/post/689168/ | null | ru | null |
# Делаем красивый Progress Bar в iOS приложении
Добрый день, дорогой Хабрахабр!
В этой статье я хочу описать способ, при помощи которого мы сделали такой красивый кастомный progress bar — на иллюстрации — в одном из последних проектов.
Задача была поставлена следующим образом:
* Картинки были нарисованны дизайнером.
* Progress bar должен перекрывать и блокировать весь UI.
* Элемент должен вызываться нотификацией в NSNotificationCenter.
* Должна быть возможность досрочно завершить действие элемента.
* Progress bar должен быть один, вне зависимости от количества посланных нотификаций.
Заинтересовавшихся в реализации прошу под кат.
Первым делом создаем синглтон BSBeautifulProgressBarManager и прописываем в *BSBeautifulProgressBarManager.h*:
**Жми меня!**
```
#import
#define kShouldShowBeautifulProgressBar @"kShouldShowBeautifulProgressBar"
#define kShouldHideBeautifulProgressBar @"kShouldHideBeautifulProgressBar"
#define beautifulProgressBarManager [BSBeautifulProgressBarManager sharedManager]
@interface BSBeautifulProgressBarManager : NSObject
+ (BSBeautifulProgressBarManager \*)sharedManager;
@end
```
На работе мы часто используем трюк с define, чтобы избавиться от постоянного обращения к синглтонам по названию класса. Здесь, вместо [BSBeautifulProgressBarManager sharedManager], мы можем писать просто BSBeautifulProgressBarManager. Заголовчный файл мы трогать больше не будем.
Дефайны нотификаций мы обычно выносим в какой-нибудь Config.h — тогда не нужно импортировать хедер менеджера для отправки нотификаций. Однако в данном примере мы добавим трюк с избавлением от магических констант прямо в хедер синглтона.
Обратимся к реализации синглтона в файле *BSBeautifulProgressBarManager.m*:
**Жми меня!**
```
+ (BSBeautifulProgressBarManager *)sharedManager
{
static BSBeautifulProgressBarManager *sharedManager = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedManager = [self new];
[[NSNotificationCenter defaultCenter] addObserver:sharedManager selector:@selector(showProgressBar) name:kShouldShowBeautifulProgressBar object:nil];
[[NSNotificationCenter defaultCenter] addObserver:sharedManager selector:@selector(hideProgressBar) name:kShouldHideBeautifulProgressBar object:nil];
});
return sharedManager;
}
```
Ничего особенного пока что не произошло — обычная реализация thread-safe синглтона. Единственное примечательное в этом методе — это подписка на нотификации показа/скрытия progress bar'a у NSNotificationCenter.
Перейдем к реализации методов showProgressBar и hideProgressBar:
**Жми меня!**
```
- (void)showProgressBar
{
if (isShown) return;
isShown = YES;
}
- (void)hideProgressBar
{
if (!isShown) return;
isShown = NO;
}
```
Пока что они ничего не делают. Однако два условия работы элемента мы уже выполнили: progress bar будет только один, и вызываться он будет через NSNotificationCenter. Соответственно, добавим в имплементацию приватную переменную:
**Жми меня!**
```
@implementation BSBeautifulProgressBarManager
{
BOOL isShown;
}
```
Идея наша будет такой:
* Первым слоем будет полупрозрачный черный UIView, который мы наложим на UIWindow. Таким образом мы перекроем весь UI, который есть. Оставим ссылку на этот UIView, чтобы потом убрать его по необходимости.
* Сверху на него добавим белый UIView, который будет выполнять роль основной верхней полосы. Тоже сохраним ссылку — нам нужно будет красиво убрать этот UIView по необходимости.
* Добавим статичную картинку серой молнии на белый UIView.
* Добавим картинку оранжевой молнии на белый UIView. Ширину выставим равной 0, при помощи блока анимации расширим эту картинку до натуральных размеров. Таким образом мы добьемся красивого визуального эффекта.
Начнем реализацию! Первым делом сменим метод showProgressBar:
**Жми меня!**
```
- (void)showProgressBar
{
if (isShown) return;
isShown = YES;
[self addGreyView];
[self addWhiteView];
[self addGreyZip];
[self addOrangeZip];
}
```
Все идет по плану — мы инкапсулировали функционал добавления элементов в отдельные методы. Пройдемся по этим методам, комментарии дам чуть ниже:
**Жми меня!**
```
@implementation BSBeautifulProgressBarManager
{
BOOL isShown;
// 1
UIView *mainView;
UIView *whiteView;
}
<...>
- (void)addGreyView
{
// 2
UIWindow *window = [[[UIApplication sharedApplication] windows] lastObject];
mainView = [[UIView alloc] initWithFrame:window.bounds];
mainView.backgroundColor = [UIColor colorWithWhite:0.0 alpha:0.5];
mainView.alpha = 0.0;
[window addSubview:mainView];
// 3
[UIView animateWithDuration:0.3 animations:^{
mainView.alpha = 1.0;
}];
}
- (void)addWhiteView
{
// 4
whiteView = [[UIView alloc] initWithFrame:CGRectMake(0, -64, 320, 64)];
whiteView.backgroundColor = [UIColor whiteColor];
[mainView addSubview:whiteView];
// 5
[UIView animateWithDuration:0.3 animations:^{
CGRect frame = whiteView.frame;
frame.origin.y = 0;
whiteView.frame = frame;
}];
}
- (void)addGreyZip
{
// 6
CGRect frame = CGRectMake(0, 39, 320, 14.5);
UIImageView *greyImageView = [[UIImageView alloc] initWithFrame:frame];
greyImageView.image = [UIImage imageNamed:@"grey"];
[whiteView addSubview:greyImageView];
}
- (void)addOrangeZip
{
// 7
CGRect frame = CGRectMake(0, 0, 320, 14.5);
CGRect frameSmaller = CGRectMake(1, 39, 0, 14.5);
// 8
UIView *container = [[UIView alloc] initWithFrame:frameSmaller];
container.clipsToBounds = YES;
// 9
UIImageView *redImageView = [[UIImageView alloc] initWithFrame:frame];
redImageView.image = [UIImage imageNamed:@"red"];
[container addSubview:redImageView];
// 10
[whiteView addSubview:container];
// 11
[UIView animateWithDuration:15. animations:^{
CGRect frame = container.frame;
frame.size.width = 320;
container.frame = frame;
}];
}
```
Пойдем по-порядку:
1. Добавляем ссылки на фон (mainView) и на белую вьюху (whiteView). Фон нам нужно будет показать и скрыть (fade-in и fade-out), а белую вьюху сначала красиво опустить, а потом красиво поднять.
2. Создаем наш фон, который будет главным superview элемента, делаем его черным, получпрозрачным, и кладем на окно приложения, дабы перекрыть весь UI.
3. Делаем fade-in для нашего фона, а вместе с ним и для всех его потомков — остальных частей элемента.
4. Создаем нашу белую вьюху-фон для остальных элементов, кладем ее на главную вьюху, прячем ее за верхними краями предка.
5. Красиво, анимированно спускаем белую вьюху со всеми потомками вниз. Потомками, кстати, будут молнии.
6. Добавляем статичную картинку серой молнии на белую вьюху — ничего сложного.
7. С оранжевой молнией все сложнее. Мы создаем две вьюхи — UIView-контейнер и UIImageView-молнию. Идея такая: добавим UIImageView внутрь вьюхи с шириной равной 0 и анимированно расширим контейнер до нужных размеров. Получим некий эффект «растущей» вправо оранжевой молнии. Для этого подготовим два фрейма: для картинки (frame) и контейнера (frameSmaller).
8. Создаем контейнер и делаем так, чтобы его потомки не выходили за рамки.
9. Добавляем картинку оранжевой молнии в контейнер — ничего сверхъестественного.
10. Добавляем наш контейнер на белую вьюху.
11. Анимируем расширение контейнера.
Замечательно! Теперь мы можем показать прогресс бар, когда нужно. Перейдем к реализации методов прятания прогресс-бара:
**Жми меня!**
```
- (void)hideProgressBar
{
if (!isShown) return;
isShown = NO;
[self hideGreyView];
[self hideWhiteView];
[self finish];
}
```
Идея проста: прячем основную вьюху (черную-полупрозрачную или, просто, серую), в это время убираем вверх белую вьюху со всеми ее внутренностями, да еще и оранжевую молнию доводим мгновенно до конца — ведь, если она не расширена до конца, значит нужно довести, чтобы показать юзеру, мол, действие завершено.
Приступим к реализации, комментарии ниже:
**Жми меня!**
```
- (void)hideGreyView
{
// 1
[UIView animateWithDuration:0.3 animations:^{
mainView.alpha = 0.0;
} completion:^(BOOL finished){
[mainView removeFromSuperview];
}];
}
- (void)hideWhiteView
{
// 2
[UIView animateWithDuration:0.3 animations:^{
CGRect frame = whiteView.frame;
frame.origin.y = -64;
whiteView.frame = frame;
}];
}
- (void)finish
{
// 3
CGRect frame = CGRectMake(0, 39, 320, 14.5);
UIImageView *greyImageView = [[UIImageView alloc] initWithFrame:frame];
greyImageView.backgroundColor = [UIColor whiteColor];
greyImageView.image = [UIImage imageNamed:@"grey"];
[whiteView addSubview:greyImageView];
// 4
frame = CGRectMake(1, 39, 320, 14.5);
UIImageView *redImageView = [[UIImageView alloc] initWithFrame:frame];
redImageView.image = [UIImage imageNamed:@"red"];
[whiteView addSubview:redImageView];
}
```
Все просто:
1. Делаем fade-out с удалением с предка для главной вьюхи и всех ее внутренностей, соответственно.
2. Убираем вверх белую вьюху со всеми внутренностями
3. Самый жестокий и «влоб» метод — кладем сверху новую серую молнию
4. Кладем сверху новую оранжевую молнию — это создаст ощущение, что молния, спрятанная снизу, исчезла
Кстати, вот и нужные картинки:
**Жми меня!**
Вот и все! Вы познали кусочек реальной, работающей социальной сети. Фактически, окунулись в код из продакшна. Мы можем вызывать кастомный, красивый progress bar при помощи посылки нужных нотификаций.
#### Заключение
Спасибо, что дочитали до конца! Я с радостью отвечу на любые ваши вопросы. Если вы нашли какие-нибудь опечатки или неточности — смело пишите в мой Хабрацентр!
Обязательно напишите, что же вы хотите увидеть в следующей статье. | https://habr.com/ru/post/231117/ | null | ru | null |
# Связь биллинга и Cisco Catalyst 2960 через SNMP. Изменение скорости портов, подсчет трафика
Как и обещали, после [приветствия](http://habrahabr.ru/company/serverclub/blog/115169/), начинаем немножко раскрывать технические подробности.
#### Задача
Дать пользователям возможность выбирать скорость подключения и способ тарификации для каждого из их серверов. Дать администраторам возможность переключать скорость канала или вовсе тушить порт через админскую панель.
#### Железо
В каждой стойке стоит как минимум один свич Cisco Catalyst 2960. Конкретная модель — WS-C2960G-48TC-L with LANBASE SPF. На вход к нему идет 4x SFP, а к серверам обращены 48 гигабитных Ethernet портов. При живой нагрузке в несколько гигабит никаких проблем не возникало. На фото различные представители семейства 2960.
#### Скорость и статус порта
Со стороны пользователя все [выглядит](https://serverclub.com/order_R210_SAS) довольно просто:
В случае выбора подключения 10 мбит, нижние опции пропадают, так как трафик в этом случае бесплатный. Опция лимитирования трафика по израсходованию предоплаченного объема обусловлена заботой о пользователях, ведь по 95th policy, если вы качали на скорости гигабит 36 часов, а после этого вообще не пользовались каналом, то счет будет как раз за полный гигабит. Представляете, пока вы уезжали на выходные на рыбалку, вам устроили Хабра-эффект и тысячи пользователей непрерывно скачивают образ вашей виртуальной машины, который был выложен вами на своем сервере и может помочь многим разработчикам, a в понедельник обнаружите -$2000 на счете в хостинге. Такой понедельник будет особенно тяжелым. В нашем случае через 24 часа порт переключится на 10 мегабит, либо через 36 часов трафик будет докупаться равными порциями до достижения финансового лимита конкретного пользователя.
Со стороны бекенда всю работу за нас, на самом деле, уже сделали инженеры Cisco, а для управления их устройствами мы воспользуемся протоколом SNMP (Simple Network Management Protocol), который был создан еще в 1988 году, а закреплен в 1990 ([RFC 1157](http://www.rfc-editor.org/rfc/rfc1157.txt)) группой хэкеров (в оригинальном значении этого слова), во главе которой был J.D. Case, за что ему отдельное спасибо.
Для работы этой функции необходимо включить поддержку SNMP на вашем свиче, а также не забыть указать communtity и разрешить для этого community выполнять операции не только на чтение, но и на запись. Функция на PHP выглядит так:
`function set_switch_port_speed ($host, $community, $port_no, $speed, $model='2960'){
// use SNMP to set speed. $speed can be 10, 100, 1000 or 0 to shutDown port.
if(!in_array($speed, array(10, 100, 1000))){
//echo 'Wrong port speed! '.$speed."\n";
return false;
}
$oid = '';
if(stristr($model, '2960')){ // magic smtp strings, path to
$oid = '1.3.6.1.4.1.9.5.1.4.1.1.9.1.'.$port_no;
}else{
$oid = '1.3.6.1.4.1.9.9.87.1.4.1.1.33.0.'.$port_no; // c2900PortAdminSpeed
}
$speed *= 1000000;
echo "setting new speed...\n";
return snmpset($host, $community, $oid, 'i', $speed);
}`
Соответственно, вызывается при сетапе сервера, достижении лимита, окончании аренды итд.
Порт можно выключать двумя способами — установкой скорости равной порта 0, либо воспользовавшись отдельной функцией:
`function set_switch_port_status($host, $community, $port_no, $status, $model=''){
// use SNMP to set status. $status can be 0 or 1
$status = (int) $status;
if(!in_array($status, array(0, 1))){
echo 'Wrong port status! '.$status."\n";
return false;
}
// decode status, 1 means UP 2 means down
if($status == 0){
$status = 2;
}
$oid = '';
// for 2960 set oid = 'IF-MIB::ifAdminStatus.101'.$port_no;
if(stristr($model, '2960')){
if($port_no < 10){
$port_no = '0'.$port_no;
}
$oid = 'IF-MIB::ifAdminStatus.101'.$port_no;
}else{
$oid = 'IF-MIB::ifAdminStatus.'.($port_no + 1); // first interface on 2900xl is VLAN1
}
return snmpset($host, $community, $oid, 'i', $status);
}`
#### Подсчет трафика
Что видит пользователь:
Виджет сервера, на нем искрографика, показывающая тренд трафика за последние 48 часов без значения шкал (на то она и искроргафика — в виджетах места мало). Цифра показывает текущее использование канала.
Под списком серверов выводится общий график для всех серверов (к биллингу отношения не имеет, трафик биллится индивидуально для каждого сервера)
Ну и график конкретного сервера — это уже полноценное отображение в более крупном формате, с возможностью выбора промежутка времени. По этим показателям уже формируется счет за bandwidth.
Красная линия отмеряет 95%. Все, что выше, не тарифицируется. Как видим этот пользователь пережил Хабраэффект бесплатно и без единого разрыва :). Ну и кто не видел — наша [панель](https://serverclub.com/panel.png) целиком.
Для сбора статистики с портов свчитча мы используем пакет [cacti](http://www.cacti.net/). После того как cacti снял и обработал информацию, он записывает данные в rrd файл по каждому порту. В этом файле накапливается статистика за весь период работы порта. В дальнейшем мы можем извлечь эту информацию и проводить любые операции, будь то подсчет трафика за определенный период или отрисовка графика для клиента. Ниже приведена функция, для извлечения данных из этого файла для дальнейшей пост-обработки c помощью утилиты rrdtool:
`function getRRDData($rrd_file, $start, $end = ''){
$str_end = '';
if($end)
$str_end = ' -e '.$end;
$res = exec('/usr/local/bin/rrdtool fetch '.$rrd_file.' AVERAGE -s '.$start.$str_end, $output);
if(!$res || (count($output) < 1)){
return array(); // smth is wrong
}
// we need only 3 ... N-1 elements
$rrd_data = array();
for($i = 2; $i < (count($output) ); $i++){
// replace NAN with 0
if(stristr($output[$i], 'nan'))
$output[$i] = str_ireplace('nan', '0', $output[$i]);
$values = explode(' ', str_replace(':', '', $output[$i]));
// check timestamp
if($end && ($values[0] > $end))
break;
$rrd_data[] = $output[$i];
}
return $rrd_data;
}`
Чтобы не получалось совсем простыни из кода, массивные функции подсчета трафика и рисования здесь приводить не будем. При подсчете трафика определяется начало и конец временного отрезка, вызывается функция извлечения данных (код выше), эти данные подсчитываются и в конце выдается цифра по 95 процентов или кол-во гигабайт. 95% считается усредненными пятиминутными отрезками, 1 мегабит равняется 1000\*1000 бит в секунду, а гигабайт это 1024\*1024\*1024 байт. Внушительный процент обывателей сбивается при назывании этих цифр, да и не мудрено :).
В предвкушении конструктивной критики,
[ServerClub Dedicated Servers](https://serverclub.com). | https://habr.com/ru/post/115539/ | null | ru | null |
# Всё, что вы хотели знать о МАС адресе
Всем известно, что это шесть байт, обычно отображаемых в шестнадцатеричном формате, присвоены сетевой карте на заводе, и на первый взгляд случайны. Некоторые знают, что первые три байта адреса – это идентификатор производителя, а остальные три байта им назначаются. Известно также, что можно поставить себе *произвольный* адрес. Многие слышали и про "рандомные адреса" в Wi-Fi.
Разберемся, что это такое.
МАС адрес (media access control address) – уникальный идентификатор, назначенный сетевому адаптеру, применяется в сетях стандартов IEEE 802, в основном Ethernet, Wi-Fi и Bluetooth. Официально он называется «идентификатором типа EUI-48». Из названия очевидно, что адрес имеет длину в 48 бит, т.е. 6 байт. Общепринятого стандарта на написание адреса нет (в противоположность IPv4 адресу, где октеты всегда разделяют точками).Обычно он записывается как шесть шестнадцатеричных чисел, разделенных двоеточием: 00:AB:CD:EF:11:22, хотя некоторые производители оборудования предпочитают запись вида 00-AB-CD-EF-11-22 и даже 00ab.cdef.1122.
Исторически адреса прошивались в ПЗУ чипсета сетевой карты без возможности их модификации без флеш-программатора, но в настоящее время адрес может быть изменен программно, из операционной системы. Задать вручную МАС адрес сетевой карте можно в Linux и MacOS (всегда), Windows (почти всегда, если позволит драйвер), Android (только рутованный); с iOS (без рута) подобный трюк невозможен.
### Структура адреса
Адрес состоит из части идентификатора производителя, OUI, и идентификатора, присваиваемого производителем. Назначением идентификаторов OUI (Organizationally Unique Identifier) [занимается](https://standards.ieee.org/products-services/regauth/oui/index.html) организация IEEE. На самом деле его длина может быть не только 3 байта (24 бита), а 28 или 36 бит, из которых формируются блоки (MAC Address Block, МА) адресов типов Large (MA-L), Medium (MA-M) и Small (MA-S) соответственно. Размер выдаваемого блока, в таком случае, составит 24, 20, 12 бит или 16 млн, 1 млн, 4 тыс. штук адресов. В настоящий момент распределено порядка 38 тысяч блоков, их можно посмотреть многочисленными онлайн-инструментами, например у [IEEE](https://regauth.standards.ieee.org/standards-ra-web/pub/view.html) или [Wireshark](https://www.wireshark.org/tools/oui-lookup.html).
### Кому принадлежат адреса
Несложная обработка публично доступной [базы данных выгрузки](https://code.wireshark.org/review/gitweb?p=wireshark.git;a=blob_plain;f=manuf;hb=HEAD) IEEE даёт довольно много информации. Например, некоторые организации забрали себе много OUI блоков. Вот наши герои:
| Вендор | Число блоков/записей | Число адресов, млн. |
| --- | --- | --- |
| Cisco Systems Inc | 888 | 14208 |
| Apple | 772 | 12352 |
| Samsung | 636 | 10144 |
| Huawei Technologies Co.Ltd | 606 | 9696 |
| Intel Corporation | 375 | 5776 |
| ARRIS Group Inc. | 319 | 5104 |
| Nokia Corporation | 241 | 3856 |
| Private | 232 | 2704 |
| Texas Instruments | 212 | 3392 |
| zte corporation | 198 | 3168 |
| IEEE Registration Authority | 194 | 3072 |
| Hewlett Packard | 149 | 2384 |
| Hon Hai Precision | 136 | 2176 |
| TP-LINK | 134 | 2144 |
| Dell Inc. | 123 | 1968 |
| Juniper Networks | 110 | 1760 |
| Sagemcom Broadband SAS | 97 | 1552 |
| Fiberhome Telecommunication Technologies Co. LTD | 97 | 1552 |
| Xiaomi Communications Co Ltd | 88 | 1408 |
| Guangdong Oppo Mobile Telecommunications Corp.Ltd | 82 | 1312 |
У Google их всего 40, и это не удивительно: они сами производят не так много сетевых устройств.
Блоки МА не предоставляются бесплатно, их можно приобрести за разумные деньги (без абонентской платы) за $3000, $1800 или $755 соответственно. Интересно, что за дополнительные деньги (в год) можно приобрести «сокрытие» публичной информации о выделенном блоке. Таких сейчас, как видно выше, 232.
### Когда закончатся МАС-адреса
Мы все порядком устали от не прекращающихся уже лет 10 историй о том, что «IPv4 адреса вот-вот кончатся». Да, новые блоки IPv4 получить уже непросто. При этом известно, что IP адреса [распределены крайне неравномерно](https://habr.com/ru/company/globalsign/blog/355006/); существуют гигантские и мало использованные блоки, принадлежащие крупным корпорациям и государственным учреждением США, впрочем, без особой надежды на их перераспределение в пользу нуждающихся. Распространение NAT, CG-NAT и IPv6 сделало проблему нехватки публичных адресов не такой острой.
В МАС адресе 48 бит, из которых «полезными» можно считать 46 (почему? читай дальше), что даёт 246 или 1014 адресов, что в 214 раз больше IPv4 адресного пространства.
В настоящий момент распределено примерно полтриллиона адресов, или лишь 0.73% от всего объёма. До исчерпания MAC адресов ещё очень, очень далеко.
### Случайность бит
Можно предположить, что OUI распределены случайно, а вендор затем также случайно назначает адреса индивидуальным сетевым устройствам. Так ли это? Посмотрим на распределение бит в имеющихся в моём распоряжении базах МАС адресов 802.11-устройств, собранных работающими системами авторизации в беспроводных сетях [WNAM](https://www.netams.com/wnam/). Адреса принадлежат реальным устройствам, подключавшихся к Wi-Fi на протяжении нескольких лет в трех странах. В дополнение идет маленькая база 802.3-устройств проводной ЛВС.
Разобьем каждый МАС-адрес (шесть байт) каждой из выборок на биты побайтово, и посмотрим на частоту появления бита «1» в каждой из 48 позиций. Если бит выставлен совершенно произвольным образом, то вероятность получить «1» должна быть 50%.
| | Выборка Wi-Fi №1 (РФ) | Выборка Wi-Fi №2 (Беларусь) | Выборка Wi-Fi №3 (Узбекистан) | Выборка LAN (РФ) |
| --- | --- | --- | --- | --- |
| Число записей в базе | 5929000 | 1274000 | 366000 | 1000 |
| Номер бита: | % бит "1" | % бит "1" | % бит "1" | % бит "1" |
| 1 | 48.6% | 49.2% | 50.7% | 28.7% |
| 2 | 44.8% | 49.1% | 47.7% | 30.7% |
| 3 | 46.7% | 48.3% | 46.8% | 35.8% |
| 4 | 48.0% | 48.6% | 49.8% | 37.1% |
| 5 | 45.7% | 46.9% | 47.0% | 32.3% |
| 6 | 46.6% | 46.7% | 47.8% | 27.1% |
| 7 | **0.3%** | **0.3%** | **0.2%** | **0.7%** |
| 8 | **0.0%** | **0.0%** | **0.0%** | **0.0%** |
| |
| 9 | 48.1% | 50.6% | 49.4% | 38.1% |
| 10 | 49.1% | 50.2% | 47.4% | 42.7% |
| 11 | 50.8% | 50.0% | 50.6% | 42.9% |
| 12 | 49.0% | 48.4% | 48.2% | 53.7% |
| 13 | 47.6% | 47.0% | 46.3% | 48.5% |
| 14 | 47.5% | 47.4% | 51.7% | 46.8% |
| 15 | 48.3% | 47.5% | 48.7% | 46.1% |
| 16 | 50.6% | 50.4% | 51.2% | 45.3% |
| |
| 17 | 49.4% | 50.4% | 54.3% | 38.2% |
| 18 | 49.8% | 50.5% | 51.5% | 51.9% |
| 19 | 51.6% | 53.3% | 53.9% | 42.6% |
| 20 | 46.6% | 46.1% | 45.5% | 48.4% |
| 21 | 51.7% | 52.9% | 47.7% | 48.9% |
| 22 | 49.2% | 49.6% | 41.6% | 49.8% |
| 23 | 51.2% | 50.9% | 47.0% | 41.9% |
| 24 | 49.5% | 50.2% | 50.1% | 47.5% |
| |
| 25 | 47.1% | 47.3% | 47.7% | 44.2% |
| 26 | 48.6% | 48.6% | 49.2% | 43.9% |
| 27 | 49.8% | 49.0% | 49.7% | 48.9% |
| 28 | 49.3% | 49.3% | 49.7% | 55.1% |
| 29 | 49.5% | 49.4% | 49.8% | 49.8% |
| 30 | 49.8% | 49.8% | 49.7% | 52.1% |
| 31 | 49.5% | 49.7% | 49.6% | 46.6% |
| 32 | 49.4% | 49.7% | 49.5% | 47.5% |
| |
| 33 | 49.4% | 49.8% | 49.7% | 48.3% |
| 34 | 49.7% | 50.0% | 49.6% | 44.9% |
| 35 | 49.9% | 50.0% | 50.0% | 50.6% |
| 36 | 49.9% | 49.9% | 49.8% | 49.1% |
| 37 | 49.8% | 50.0% | 49.9% | 51.4% |
| 38 | 50.0% | 50.0% | 49.8% | 51.8% |
| 39 | 49.9% | 50.0% | 49.9% | 55.7% |
| 40 | 50.0% | 50.0% | 50.0% | 49.5% |
| |
| 41 | 49.9% | 50.0% | 49.9% | 52.2% |
| 42 | 50.0% | 50.0% | 50.0% | 53.9% |
| 43 | 50.1% | 50.0% | 50.3% | 56.1% |
| 44 | 50.1% | 50.0% | 50.1% | 45.8% |
| 45 | 50.0% | 50.0% | 50.1% | 50.1% |
| 46 | 50.0% | 50.0% | 50.1% | 49.5% |
| 47 | 49.2% | 49.4% | 49.7% | 45.2% |
| 48 | 49.9% | 50.1% | 50.7% | 54.6% |
Откуда такая несправедливость в 7 и 8 битах? Там почти всегда нули.
Действительно, стандарт определяет эти биты как специальные ([Википедия](https://ru.wikipedia.org/wiki/MAC-%D0%B0%D0%B4%D1%80%D0%B5%D1%81)):
Восьмой (с начала) бит первого байта МАС адреса называется Unicast/Multicast битом и определяет, какого типа кадр (фрейм) передается с этим адресом, обычный (0) или широковещательный (1) (мультикаст или броадкаст). Для обычного, unicast взаимодействия сетевого адаптера, этот бит выставлен в «0» во всех пакетах, им отправляемых.
Седьмой (с начала) бит первого байта МАС адреса называется U/L (Universal/Local) битом и определяет, является ли адрес глобально уникальным (0), или локально уникальным (1). По умолчанию, все «прошитые изготовителем» адреса глобально уникальны, поэтому подавляющее число собранных МАС адресов содержат седьмой бит выставленным в «0». В таблице присвоенных идентификаторов OUI только порядка 130 записей имеет U/L бит «1», и по всей видимости это блоки МАС адресов для специальных нужд.
С шестого по первый биты первого байта, биты второго и третьего байта в OUI идентификаторах, и тем более биты в 4-6 байтах адреса, назначаемые производителем, распределены более-менее равномерно.
Таким образом, в реальном МАС-адресе сетевого адаптера биты фактически равноценны и не несут технологического смысла, за исключением двух служебных бит старшего байта.
### Распространенность
Интересно, какие производители беспроводного оборудования наиболее популярны? Объединим поиск по базе OUI с данными выборки №1.
| Вендор | Доля устройств, % |
| --- | --- |
| Apple | 26,09 |
| Samsung | 19,79 |
| Huawei Technologies Co. Ltd | 7,80 |
| Xiaomi Communications Co Ltd | 6,83 |
| Sony Mobile Communications Inc | 3,29 |
| LG Electronics (Mobile Communications) | 2,76 |
| ASUSTek COMPUTER INC. | 2,58 |
| TCT mobile ltd | 2,13 |
| zte corporation | 2,00 |
| не найден в базе IEEE | 1,92 |
| Lenovo Mobile Communication Technology Ltd. | 1,71 |
| HTC Corporation | 1,68 |
| Murata Manufactuaring | 1,31 |
| InPro Comm | 1,26 |
| Microsoft Corporation | 1,11 |
| Shenzhen TINNO Mobile Technology Corp. | 1,02 |
| Motorola (Wuhan) Mobility Technologies Communication Co. Ltd. | 0,93 |
| Nokia Corporation | 0,88 |
| Shanghai Wind Technologies Co. Ltd | 0,74 |
| Lenovo Mobile Communication (Wuhan) Company Limited | 0,71 |
Практика показывает, что чем зажиточнее контингент абонентов беспроводной сети в данном месте, тем больше доля устройств Apple.
### Уникальность
Уникальны ли МАС адреса? В теории да, поскольку каждый из производителей устройств (владельцев блока МА) обязан обеспечивать уникальный адрес для каждого из выпускаемых им сетевых адаптеров. Однако некоторые производители чипов, а именно:
* 00:0A:F5 Airgo Networks, Inc. (сейчас Qualcomm)
* 00:08:22 InPro Comm (сейчас MediaTek)
выставляют последние три байта МАС адреса в случайное число, по всей видимости, после каждой перезагрузки устройства. Таких адресов в моей выборке №1 нашлось 82 тысячи.
Поставить себе чужой, не уникальный адрес можно, конечно, путем целенаправленной его установки «как у соседа», определив его сниффером, или выбрав наугад. Также возможно случайно поставить себе не уникальный адрес, выполнив, например, восстановление бэкапа конфигурации какого-нибудь маршрутизатора вроде Mikrotik или OpenWrt.
Что будет, если в сети будет присутствовать два устройства с одним МАС адресом? Все зависит от логики сетевого оборудования (проводного роутера, контроллера беспроводной сети). Скорее всего, оба устройства или не будут работать, или будут работать с перебоями. С точки зрения стандартов IEEE, защиту от подделки МАС адресов предлагается решать при помощи, например, MACsec или 802.1Х.
Что, если поставить себе МАС с выставленным в «1» седьмым или восьмым битом, т.е. local или multicast-адрес? Скорее всего, ваша сеть на это не обратит внимания, но формально такой адрес не будет соответствует стандарту, и лучше так не делать.
### Как работает рандомизация
Мы знаем, что с целью предотвратить отслеживание перемещения людей путем сканирования эфира и сбора МАС-операционные системы смартфонов уже несколько лет применяют технологию рандомизации. Теоретически, при сканировании эфира в поиске известных сетей смартфон отправляет пакет (группу пакетов) типа 802.11 probe request с МАС-адресом в качестве источника:
Включенная рандомизация позволяет указывать не «прошитый», а какой-то другой адрес источника пакета, меняющийся при каждом цикле сканирования, во времени или ещё как-то. Работает ли это? Посмотрим на статистику собранных МАС-адресов из эфира так называемым «Wi-Fi Радаром»:
| | Вся выборка | Выборка только с нулевым 7м битом |
| --- | --- | --- |
| Число записей в базе | 3920000 | 305000 |
| Номер бита: | % бит "1" | % бит "1" |
| 1 | 66.1% | 43.3% |
| 2 | 66.5% | 43.4% |
| 3 | 31.7% | 43.8% |
| 4 | 66.6% | 46.4% |
| 5 | 66.7% | 45.7% |
| 6 | 31.9% | 46.4% |
| 7 | **92.2%** | 0.0% |
| 8 | 0.0% | 0.0% |
| | | |
| 9 | 67.2% | 47.5% |
| 10 | 32.3% | 45.6% |
| 11 | 66.9% | 45.3% |
| 12 | 32.3% | 46.8% |
| 13 | 32.6% | 50.1% |
| 14 | 33.0% | 56.1% |
| 15 | 32.5% | 45.0% |
| 16 | 67.2% | 48.3% |
| | | |
| 17 | 33.2% | 56.9% |
| 18 | 33.3% | 56.8% |
| 19 | 33.3% | 56.3% |
| 20 | 66.8% | 43.2% |
| 21 | 67.0% | 46.4% |
| 22 | 32.6% | 50.1% |
| 23 | 32.9% | 51.2% |
| 24 | 67.6% | 52.2% |
| | | |
| 25 | 49.8% | 47.8% |
| 26 | 50.0% | 50.0% |
| 27 | 50.0% | 50.2% |
| 28 | 50.0% | 49.8% |
| 29 | 50.0% | 49.4% |
| 30 | 50.0% | 50.0% |
| 31 | 50.0% | 49.7% |
| 32 | 50.0% | 49.9% |
| | | |
| 33 | 50.0% | 49.7% |
| 34 | 50.0% | 49.6% |
| 35 | 50.0% | 50.1% |
| 36 | 50.0% | 49.5% |
| 37 | 50.0% | 49.9% |
| 38 | 50.0% | 49.8% |
| 39 | 50.0% | 49.9% |
| 40 | 50.0% | 50.1% |
| | | |
| 41 | 50.0% | 50.2% |
| 42 | 50.0% | 50.2% |
| 43 | 50.0% | 50.1% |
| 44 | 50.0% | 50.1% |
| 45 | 50.0% | 50.0% |
| 46 | 50.0% | 49.8% |
| 47 | 50.0% | 49.8% |
| 48 | 50.1% | 50.9% |
Картина совсем другая.
8й бит первого байта МАС адреса по-прежнему соответствует Unicast-природе SRC-адреса в probe request пакете.
7й бит в 92.2% случаев установлен в Local, т.е. с достаточной долей уверенности можно считать, что именно столько собранных адресов относится к рандомизированным, а менее 8% — к реальным. При этом распределение бит в OUI для таких реальных адресов примерно совпадает с данными предыдущей таблицы.
Какому производителю, по OUI, принадлежат рандомизированные адреса (т.е. с 7м битом в «1»)?
| Производитель по OUI | Доля среди всех адресов |
| --- | --- |
| не найден в базе IEEE | 62.45% |
| Google Inc. | 37.54% |
| остальные | 0.01% |
При этом все рандомизированные адреса, отнесенные к Google, принадлежат одному OUI c префиксом **DA:A1:19**. Что это за префикс? Давайте посмотрим в [исходники Android](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/net/MacAddress.java;l=366;bpv=1;bpt=0).
```
private static final MacAddress BASE_GOOGLE_MAC = MacAddress.fromString("da:a1:19:0:0:0");
```
Стоковый андроид в поиске беспроводных сетей использует специальный, зарегистрированный OUI, один из немногих с установленным седьмым битом.
### Вычислить реальный МАС из рандомного
Посмотрим там же:
```
private static final long VALID_LONG_MASK = (1L << 48) - 1;
private static final long LOCALLY_ASSIGNED_MASK = MacAddress.fromString("2:0:0:0:0:0").mAddr;
private static final long MULTICAST_MASK = MacAddress.fromString("1:0:0:0:0:0").mAddr;
public static @NonNull MacAddress createRandomUnicastAddress(MacAddress base, Random r) {
long addr;
if (base == null) {
addr = r.nextLong() & VALID_LONG_MASK;
} else {
addr = (base.mAddr & OUI_MASK) | (NIC_MASK & r.nextLong());
}
addr |= LOCALLY_ASSIGNED_MASK;
addr &= ~MULTICAST_MASK;
MacAddress mac = new MacAddress(addr);
if (mac.equals(DEFAULT_MAC_ADDRESS)) {
return createRandomUnicastAddress(base, r);
}
return mac;
}
```
Адрес целиком, либо его младшие три байта, это чистый *Random.nextLong()*. «Патентованное восстановление реального МАС» — надувательство. С большой долей уверенности можно ожидать, что производители Android-телефонов применяют и другие, не зарегистрированные OUI. Исходников iOS у нас нет, но скорее всего там применен схожий алгоритм.
Вышесказанное не отменяет работу других механизмов деанонимизации Wi-Fi абонентов, основанных на анализе других полей probe request фрейма, или корреляции относительной частоты посылаемых устройством запросов. Однако достоверно отследить абонента внешними средствами крайне проблематично. Собираемые данные больше подойдут для анализа средней/пиковой нагрузки по местоположению и времени, на основе больших чисел, без привязки к конкретным устройствам и людям. Точные данные есть только у тех, кто "внутри", у самих производителей мобильных ОС, у установленных приложений.
Что может быть опасного в том, что кто-то другой узнает МАС-адрес вашего устройства? Для проводных и беспроводных сетей можно организовать атаку "отказ в обслуживании". Для беспроводного устройства, к тому же, с некоторой вероятностью можно зафиксировать момент появления в месте, где установлен сенсор. Подменой адреса можно попробовать "представиться" вашим устройством, что может сработать, только если не применяется дополнительных средств защиты (авторизация и/или шифрование). 99.9% людей здесь не о чем волноваться.
МАС-адрес сложнее, чем кажется, но проще, чем мог бы быть. | https://habr.com/ru/post/483670/ | null | ru | null |
# Использование Intel HAXM при разработке приложений для Android Wear и TV
За плечами платформы Android долгий путь. Всё началось со смартфонов, потом были планшеты, дальше – устройства, работающие под управлением Google TV, Android Wear, Android TV (вместо Google TV), и, наконец – Android Auto. Сборка и тестирование приложений, которые предназначены для всего этого разнообразия, могут стать непростыми задачами для разработчиков. А если добавить сюда различные форм-факторы и разрешения экранов устройств, можно быстро столкнуться с проблемой всесторонней проверки и тестирования программ. Как же быть? К счастью, у нас есть **Intel HAXM**.
[](http://habrahabr.ru/company/intel/blog/265791/)
Предварительные сведения
------------------------
[Intel Hardware Accelerated Execution Manager](https://software.intel.com/en-us/android/articles/intel-hardware-accelerated-execution-manager) (HAXM) – это Android-эмулятор, который поддерживает аппаратную виртуализацию. Он создаёт невысокую нагрузку на систему, обладает отличной производительностью и быстрым интерфейсом.
Используя Intel HAXM, можно запустить несколько экземпляров Android-эмулятора на одном компьютере, не особо беспокоясь о производительности, о нагрузке на систему или о «тормозах» интерфейса. Подобный подход может быть весьма полезным в итеративном процессе создания и тестирования приложений, он способен дать огромный прирост производительности труда разработчиков.
Образы Android-эмуляторов, рассчитанные на архитектуры, отличные от x86, могут медленно запускаться и с задержкой откликаться на команды пользователя. Кроме того, в отличие от некоторых Android-эмуляторов сторонних производителей, с помощью Intel HAXM вы получаете возможность работать с последними версиями API и платформ Android сразу же после их выпуска.
[Здесь](https://software.intel.com/en-us/android/articles/speeding-up-the-android-emulator-on-intel-architecture) вы можете найти подробное руководство по работе с HAXM.
В этом материале мы поговорим о том, как пользоваться возможностями Intel HAXM при создании приложений, рассчитанных на всевозможные варианты платформы Android. Такие приложения могут работать на обычных смартфонах разных форм-факторов, и на устройствах, несущих на борту Android Wear и Android TV.
Работа с универсальным приложением-примером для Android
-------------------------------------------------------
Компания Google недавно выпустила [приложение](https://github.com/googlesamples/android-UniversalMusicPlayer), на примере которого показано, как охватить одной кодовой базой множество различных Android-устройств.
В примере продемонстрированы передовые подходы к разработке универсальных приложений. Для сборки проекта воспользуйтесь инструкциями, которые можно найти по вышеупомянутой ссылке. Мы, в данном практическом руководстве, будем испытывать пример на x86 HAXM-эмуляторах Android TV, Wear и смартфона.
Проект можно импортировать в Android Studio и воспользоваться возможностями этой среды по сборке и запуску приложения на эмуляторе. Если вы предпочитаете работать с другой IDE, то, о чём пойдёт речь дальше, так же окажется полезным.
Если вам близок интерфейс командной строки, можете просто запустить Gradle-скрипт для сборки приложения из папки с исходным кодом примера.
```
gradlew assembleDebug
```
Результирующий APK-файл можно найти в папке «mobile/build/outputs/apk/mobile-debug.apk».
Создание AVD для Android TV и Wear
----------------------------------
Для начала нужно удостовериться в том, что у нас имеются самые свежие образы эмуляторов для платформ Android TV, Wear, а так же – для обычных смартфонов.
Откроем Android SDK Manager. Его можно запустить из интерфейса Android Studio или из командной строки (папка /tools должна быть указана в переменных среды) с помощью такой команды:
```
> android
```
*Окно Android SDK Manager. Образы систем, которые нужно загрузить, выделены*
После того, как необходимые пакеты загружены, нужно, для использования соответствующих образов систем, настроить конфигурации эмуляторов (то есть, создать набор AVD). Для этого нам понадобится Android Virtual Device Manager. Запустим его из командной строки:
```
> android avd
```
*Окно Android Virtual Device Manager, здесь можно создавать новые AVD и настраивать существующие*
Эмуляция Android Wear
---------------------
Создадим конфигурацию виртуального устройства для Android Wear так, как показано на рисунке ниже.
*Настройка конфигурации эмулятора для Android Wear*
После того, как настройки выполнены, нажмём кнопку OK, после чего – запустим эмулятор. Для этого его нужно выделить в окне AVD Manager и нажать на кнопку Start. Вот как выглядит окно эмулятора.
*Окно эмулятора Android Wear*
Для того чтобы смартфон мог взаимодействовать с устройством, работающим под управлением Android Wear (или с соответствующим эмулятором), нужно [дополнительное приложение](https://play.google.com/store/apps/details?id=com.google.android.wearable.app). Единственный способ установить это приложение на устройство – загрузка из Магазина Google Play. Соответственно, нам понадобится Android-смартфон, который имеет доступ к Магазину.
Устройство должно быть доступно для ADB. Для того чтобы оно смогло подключиться к эмулятору, нужно, чтобы и смартфон, и эмулятор, присутствовали в списке устройств, который можно получить следующей командой:
```
> adb devices
```
*Список подключенных устройств*
Теперь перенаправим TCP-порты такой командой:
```
> adb -d forward tcp:5601 tcp:5601
```
Теперь всё готово для сопряжения эмулятора Android Wear и аппаратного устройства. Осталось лишь запустить на смартфоне приложение Android Wear, и, из его меню, выполнить команду подключения к эмулятору. Если подключение удалось, экран эмулятора будет выглядеть так, как показано в левой части рисунка. В правой части показан экран эмулятора, не подключенного к смартфону.
*Экраны эмулятора Android Wear в подключенном (слева) и неподключенном (справа) состоянии*
Подробные сведения о создании приложений для Android Wear можно найти [здесь](http://developer.android.com/training/wearables/apps/creating.html). APK-файл тестового приложения ничем не отличается от других APK, его можно установить на эмулятор Android Wear с использованием ADB.
```
> adb -s emulator-5554 install -r mobile\build\outputs\apk\mobile-debug.apk
```
Проверить, установлено ли приложение на эмуляторе, можно с помощью такой команды:
```
> adb -s emulator-5554 shell pm list packages | grep example
```
*Установка приложения на эмулятор и проверка установки*
Имя пакета приложения-примера (com.example.android.uamp) присутствует в списке. Из командной строки можно и запустить приложение:
```
> adb -s emulator-5554 shell monkey -p com.example.android.uamp -c android.intent.category.LAUNCHER 1
```
Теперь приложение запущено на эмуляторе Android Wear
Эмуляция Android TV
-------------------
Создадим конфигурацию виртуального устройства для Android TV так, как показано на рисунке ниже.
*Настройка конфигурации эмулятора для Android TV*
После настройки нажмём на кнопку OK и запустим эмулятор кнопкой Start в окне ADV Manager.
Проверить доступность эмулятора для ADB можно такой командой:
```
> adb devices
```
Запишите или запомните идентификатор эмулятора (что-то вроде emulator-55xx). Он понадобится для указания целевого устройства при работе с эмулятором с помощью ADB. Для установки приложения на эмулятор можно воспользоваться такой командой:
```
> adb -s emulator-55xx install -r mobile/build/outputs/apk/mobile-debug.apk
```
Запустить приложение на эмуляторе Android TV можно так:
```
> adb -s emulator-55xx shell monkey -p com.example.android.uamp -c android.intent.category.LAUNCHER 1
```
Вот как приложение выглядит на экране эмулятора.
*Приложение, запущенное на эмуляторе Android TV*
Создание и запуск необходимого количества экземпляров эмуляторов
----------------------------------------------------------------
Если в ходе разработки и тестирования приложения возникает необходимость создания и запуска нескольких экземпляров эмуляторов – всё это достижимо с использованием Intel HAXM. При установке HAXM можно настроить размер оперативной памяти, который отводится для его работы. Вот набор конфигураций AVD для Android Wear, TV и смартфона.
*Список виртуальных устройств Android*
Ниже вы можете видеть приложение-пример, запущенное одновременно на трёх виртуальных устройствах (Android TV, Wear и эмулятор смартфона). Здесь же показаны сведения об использовании CPU. Как видно, все эти экземпляры эмулятора не создают чрезмерной нагрузки на систему.
*Три одновременно запущенных эмулятора и сведения о нагрузке на систему, которую они создают*
В ходе работы можно настраивать выделение памяти для эмуляторов, оптимизируя потребление ими системных ресурсов. Для того, чтобы перенастроить параметры выделения памяти, заданные при установке HAXM, нужно повторно запустить его установку и указать нужные параметры.
Итоги
-----
В этом материале мы продемонстрировали основные возможности Intel HAXM. [Здесь](http://developer.android.com/tools/help/emulator.html) вы можете найти подробности об использовании и настройке Android-эмуляторов. Для того чтобы проверить правильность установки HAXM, а так же то, используется ли он при работе с эмуляторами, обратитесь к [этому материалу](https://software.intel.com/ru-ru/blogs/2014/10/20/how-to-ensure-you-are-using-intel-haxm-for-android-emulator). Надеемся, Intel HAXM станет вашим надёжным помощником в деле разработки Android-приложений для самых разных устройств, работающих на этой платформе. | https://habr.com/ru/post/265791/ | null | ru | null |
# COUNT(*)
У меня есть подборка простеньких вопросов, которые я люблю задавать при собеседовании. Например, как посчитать общее число записей к таблице? Вроде бы ничего сложного, но если копнуть глубже, то можно много интересных нюансов рассказать собеседнику.
Давайте начнем с простого… Эти запросы отличаются чем-то друг от друга с точки зрения конечного результата?
```
SELECT COUNT(*) FROM Sales.SalesOrderDetail
SELECT COUNT_BIG(*) FROM Sales.SalesOrderDetail
```
Большинство отвечали: «Нет».
Реже старались долее детально формировать ответ: «Запросы вернут идентичный результат, но *COUNT* вернет значение типа *INT*, а *COUNT\_BIG* – тип *BIGINT*».
Если проанализировать план выполнения, то можно заметить различия, которые многие упускают из вида. При использовании *COUNT* на плане будет операция *Compute Scalar*:
Если посмотреть в свойства оператора, то мы увидим там:
```
[Expr1003] = Scalar Operator(CONVERT_IMPLICIT(int,[Expr1004],0))
```
Это происходит потому, что при вызове *COUNT* неявно используется *COUNT\_BIG* после чего результат преобразуется в *INT*.
Не сказал бы, что существенно, но преобразования типов увеличивает нагрузку на процессор. Многие, конечно, могут сказать, что этот оператор ничего не стоит при выполнении, но нужно отметить простой факт – *SQL Server* очень часто недооценивает *Compute Scalar* операторы.
Еще я знаю людей, которые любят использовать *SUM* вместо *COUNT*:
```
SELECT SUM(1) FROM Sales.SalesOrderDetail
```
Такой вариант примерно равнозначен *COUNT*. Мы также получим лишний *Compute Scalar* на плане выполнения:
```
[Expr1003] = Scalar Operator(CASE WHEN [Expr1004]=(0) THEN NULL ELSE [Expr1005] END)
```
Теперь более детально затронем вопросы производительности.…
Если использовать запросы выше, то чтобы посчитать количество записей *SQL Server* необходимо выполнить *Full Index Scan* (или *Full Table Scan* если таблица является кучей). В любом случае, эти операции далеко не самые быстрые. Лучше всего для получения количества записей использовать системные представления: [sys.dm\_db\_partition\_stats](https://msdn.microsoft.com/en-us/library/ms187737%28v=sql.110%29.aspx) или [sys.partitions](https://msdn.microsoft.com/en-us/library/ms175012%28v=sql.110%29.aspx) (есть еще [sysindexes](https://msdn.microsoft.com/en-us/library/ms190283.aspx), но оставлен для обратной совместимости с *SQL Server 2000*).
```
USE AdventureWorks2012
GO
SET STATISTICS IO ON
SET STATISTICS TIME ON
GO
SELECT COUNT_BIG(*)
FROM Sales.SalesOrderDetail
SELECT SUM(p.[rows])
FROM sys.partitions p
WHERE p.[object_id] = OBJECT_ID('Sales.SalesOrderDetail')
AND p.index_id < 2
SELECT SUM(s.row_count)
FROM sys.dm_db_partition_stats s
WHERE s.[object_id] = OBJECT_ID('Sales.SalesOrderDetail')
AND s.index_id < 2
```
Если сравнить планы выполнения, то доступ к системным представлениям менее затратный:
На *AdventureWorks* преимущество от применения системных представлений явно не проявляется:
```
Table 'SalesOrderDetail'. Scan count 1, logical reads 276, ...
SQL Server Execution Times:
CPU time = 12 ms, elapsed time = 26 ms.
Table 'sysrowsets'. Scan count 1, logical reads 5, ...
SQL Server Execution Times:
CPU time = 4 ms, elapsed time = 4 ms.
Table 'sysidxstats'. Scan count 1, logical reads 2, ...
SQL Server Execution Times:
CPU time = 2 ms, elapsed time = 1 ms.
```
Время выполнения на секционированной таблице с 30 миллионами записей:
```
Table 'big_test'. Scan count 6, logical reads 114911, ...
SQL Server Execution Times:
CPU time = 4859 ms, elapsed time = 5079 ms.
Table 'sysrowsets'. Scan count 1, logical reads 25, ...
SQL Server Execution Times:
CPU time = 0 ms, elapsed time = 2 ms.
Table 'sysidxstats'. Scan count 1, logical reads 2, ...
SQL Server Execution Times:
CPU time = 0 ms, elapsed time = 2 ms.
```
В случае если нужно проверить наличие записей в таблице, то использование метаданных как было показано выше не даст особых преимуществ…
```
IF EXISTS(SELECT * FROM Sales.SalesOrderDetail)
PRINT 1
IF EXISTS(
SELECT * FROM sys.dm_db_partition_stats
WHERE [object_id] = OBJECT_ID('Sales.SalesOrderDetail')
AND row_count > 0
) PRINT 1
```
```
Table 'SalesOrderDetail'. Scan count 1, logical reads 2,...
SQL Server Execution Times:
CPU time = 1 ms, elapsed time = 3 ms.
Table 'sysidxstats'. Scan count 1, logical reads 2,...
SQL Server Execution Times:
CPU time = 4 ms, elapsed time = 5 ms.
```
И на практике будет даже капельку медленнее, поскольку *SQL Server* генерирует более сложный план выполнения для выборки из метаданных.
Еще интереснее становиться, когда нужно посчитать количество записей по всем таблицам сразу. На практике встречал несколько вариантов, которые можно обобщить.
Вариант #1 с применением недокументированной процедуры, которая курсором обходит все пользовательские таблицы:
```
IF OBJECT_ID('tempdb.dbo.#temp') IS NOT NULL
DROP TABLE #temp
GO
CREATE TABLE #temp (obj SYSNAME, row_count BIGINT)
GO
EXEC sys.sp_MSForEachTable @command1 = 'INSERT #temp SELECT ''?'', COUNT_BIG(*) FROM ?'
SELECT *
FROM #temp
ORDER BY row_count DESC
```
Вариант #2 – динамический SQL которые генерирует запросы *SELECT COUNT(\*)*:
```
DECLARE @SQL NVARCHAR(MAX)
SELECT @SQL = STUFF((
SELECT 'UNION ALL SELECT ''' + SCHEMA_NAME(o.[schema_id]) + '.' + o.name + ''', COUNT_BIG(*)
FROM [' + SCHEMA_NAME(o.[schema_id]) + '].[' + o.name + ']'
FROM sys.objects o
WHERE o.[type] = 'U'
AND o.is_ms_shipped = 0
FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'), 1, 10, '') + ' ORDER BY 2 DESC'
PRINT @SQL
EXEC sys.sp_executesql @SQL
```
Вариант #3 – быстрый вариант на каждый день:
```
SELECT SCHEMA_NAME(o.[schema_id]), o.name, t.row_count
FROM sys.objects o
JOIN (
SELECT p.[object_id], row_count = SUM(p.row_count)
FROM sys.dm_db_partition_stats p
WHERE p.index_id < 2
GROUP BY p.[object_id]
) t ON t.[object_id] = o.[object_id]
WHERE o.[type] = 'U'
AND o.is_ms_shipped = 0
ORDER BY t.row_count DESC
```
Уж очень много я выдал дифирамбов, что системные представления такие хорошие. Однако, при работе с ними нас могут подстерегать «приятные» неожиданности.
Помнится, был такой веселый баг, когда при миграции с *SQL Server 2000* на *2005* некоторые системные представления некорректно обновлялись. Особо везучим людям, в таком случае, из метаданных возвращались неверные значения о количестве записей в таблицах. Лечилось это все командой [DBCC UPDATEUSAGE](https://msdn.microsoft.com/ru-ru/library/ms188414%28v=sql.110%29.aspx).
Вместе с *SQL Server 2005 SP1* этот баг исправили и все бы ничего… Но подобную ситуацию я наблюдал еще один раз, когда восстановил бекап с *SQL Server 2005 SP4* на *SQL Server 2012 SP2*. Воспроизвести проблему на реальном окружении увы не смогу, поэтому немного обманув оптимизатор:
```
UPDATE STATISTICS Person.Person WITH ROWCOUNT = 1000000000000000000
```
расскажу на простом примере.
Самый безобидный запрос начал выполняться дольше чем обычно:
```
SELECT FirstName, COUNT(*)
FROM Person.Person
GROUP BY FirstName
```
Посмотрел на план запроса и увидел там явно неадекватное значение *Estimated number of rows*:
Заглянул в статистику по кластерному индексу:
```
DECLARE @SQL NVARCHAR(MAX)
DECLARE @obj SYSNAME = 'Person.Person'
SELECT @SQL = 'DBCC SHOW_STATISTICS(''' + @obj + ''', ' + name + ') WITH STAT_HEADER'
FROM sys.stats
WHERE [object_id] = OBJECT_ID(@obj)
AND stats_id < 2
EXEC sys.sp_executesql @SQL
```
Все было в норме:
Но в системных представления о которых мы говорили ранее:
```
SELECT rowcnt
FROM sys.sysindexes
WHERE id = OBJECT_ID('Person.Person')
AND indid < 2
SELECT SUM([rows])
FROM sys.partitions p
WHERE p.[object_id] = OBJECT_ID('Person.Person')
AND p.index_id < 2
```
была печаль:
В запросе не было предикатов для фильтрации и оптимизатор выбрал *Full Index Scan*. При *Full Index/Table Scan* ожидаемое количество строк оптимизатор не берет из статистики, а обращается к метаданным (точно не уверен всегда ли это происходит).
Не секрет, что на основе *Estimated number of rows* *SQL Server* генерирует план выполнения и вычисляет сколько нужно памяти чтобы его выполнить. Если оценка будет неверной, то может быть выделено больше памяти на выполнение запроса, чем нужно на самом деле.
```
SELECT session_id, query_cost, requested_memory_kb, granted_memory_kb, required_memory_kb, used_memory_kb
FROM sys.dm_exec_query_memory_grants
```
Вот к чему приводит неверная оценка количества строк:
```
query_cost requested_memory_kb granted_memory_kb required_memory_kb used_memory_kb
----------- -------------------- -------------------- -------------------- --------------
1133156839 769552 769552 6504 6026
```
Проблема решилась достаточно просто:
```
DBCC UPDATEUSAGE(AdventureWorks2012, 'Person.Person') WITH COUNT_ROWS
DBCC FREEPROCCACHE
```
После рекомпиляции запроса все пришло в норму:
```
query_cost requested_memory_kb granted_memory_kb required_memory_kb used_memory_kb
----------- -------------------- -------------------- -------------------- --------------
0,2919 1168 1168 1024 952
```
Если системные представления уже не кажутся «спасительной палочкой», то какие варианты у нас остаются? Можно делать все по-старинке:
```
SELECT COUNT_BIG(*) FROM ...
```
Но при интенсивной вставке в таблицу я бы не доверял результатам. «Волшебный» хинт *NOLOCK* тем более не гарантирует правильного значения:
```
SELECT COUNT_BIG(*) FROM ... WITH(NOLOCK)
```
По сути, чтобы получить правильное значение количества строк в таблице, нужно выполнять запрос под уровнем изоляции *SERIALIZABLE* либо используя хинт *TABLOCKX*:
```
SELECT COUNT_BIG(*) FROM ... WITH(TABLOCKX)
```
И что мы получаем в итоге… монопольную блокировку таблицы на период выполнении запроса. И тут каждый должен решать сам, что ему лучше использовать. Мой выбор — метаданные.
Еще интереснее, когда нужно быстро подсчитать число строк по условию:
```
SELECT City, COUNT_BIG(*)
FROM Person.[Address]
--WHERE City = N'London'
GROUP BY City
```
Если в таблице не происходят частые операции вставки-удаления, то можно создать индексированное представление:
```
IF OBJECT_ID('dbo.CityAddress', 'V') IS NOT NULL
DROP VIEW dbo.CityAddress
GO
CREATE VIEW dbo.CityAddress
WITH SCHEMABINDING
AS
SELECT City, [Rows] = COUNT_BIG(*)
FROM Person.[Address]
GROUP BY City
GO
CREATE UNIQUE CLUSTERED INDEX IX ON dbo.CityAddress (City)
```
Для этих запросов оптимизатор будет генерировать идентичный план на основе кластерного индекса вьюхи:
```
SELECT City, COUNT_BIG(*)
FROM Person.[Address]
WHERE City = N'London'
GROUP BY City
SELECT *
FROM dbo.CityAddress
WHERE City = N'London'
```
План выполнения с индексным представлением и без:
Этим постом я хотел показать, что идеальных решений на все случаи жизни не бывает. И в каждом конкретной ситуации нужно действовать с индивидуальным подходом.
Все тестировалось на *SQL Server 2012 SP3 (11.00.6020)*.
**В качестве выводов**… Когда нужно подсчитать общее число строк по таблице, то я использую метаданные — это самый быстрый способ. И пусть Вас не пугает ситуация с старым багом, который я привел выше.
Если нужно быстро подсчитать количество строк в разрезе какого-то поля или по условию — то я стараюсь использовать индексированные представления либо фильтрованные индексы. Все зависит от ситуации.
Когда таблица маленькая или вопросы с производительностью не стоят так остро, то проще уж действительно по-старинке написать *SELECT COUNT(\*)*…
Если хотите поделиться этой статьей с англоязычной аудиторией:
[What is the fastest way to calculate the record COUNT?](http://blog.devart.com/fastest_way_to_calculate_the_record_count.html) | https://habr.com/ru/post/271797/ | null | ru | null |
# PVS-Studio, Blender: цикл заметок о пользе регулярного использования статического анализа
В статьях мы регулярно повторяем важную мысль: статический анализатор должен использоваться регулярно. В этом случае многие ошибки выявляются на самом раннем этапе, а их исправление максимально дёшево. Однако теория – это одно, но намного лучше подкреплять слова практическими примерами. Рассмотрим несколько свежих ошибок, появившихся в новом коде проекта Blender.
Недавно мы настроили регулярную проверку проекта [Blender](https://ru.wikipedia.org/wiki/Blender), о чём мой коллега рассказал в статье "[Just for fun: команда PVS-Studio придумала мониторить качество некоторых открытых проектов](https://habr.com/ru/company/pvs-studio/blog/541922/)". В дальнейшем планируем начать мониторить ещё некоторые интересные проекты.
Сразу скажу, что мы не ставим перед собой задачу найти как можно больше ошибок. Целью является периодическое написание небольших заметок (таких как эта), в которых мы будем на практике показывать достоинства регулярного анализа кода. Другими словами, мы иногда будем описывать некоторые интересные ошибки в новом коде, найденные при очередном ночном запуске PVS-Studio, и тем самым популяризировать **правильное** использование методологии статического анализа кода.
Итак, давайте посмотрим, что найдено в свежем коде проекта Blender.
**Фрагмент первый: double-checked locking**
```
typedef struct bNodeTree {
....
struct NodeTreeUIStorage *ui_storage;
} bNodeTree;
static void ui_storage_ensure(bNodeTree &ntree)
{
/* As an optimization, only acquire a lock if the UI storage doesn't exist,
* because it only needs to be allocated once for every node tree. */
if (ntree.ui_storage == nullptr) {
std::lock_guard lock(global\_ui\_storage\_mutex);
/\* Check again-- another thread may have allocated the storage
while this one waited. \*/
if (ntree.ui\_storage == nullptr) {
ntree.ui\_storage = new NodeTreeUIStorage();
}
}
}
```
Предупреждение PVS-Studio. [V1036](https://www.viva64.com/ru/w/v1036/): Potentially unsafe double-checked locking. node\_ui\_storage.cc 46
Перед нами неправильная реализация блокировки с двойной проверкой. Для пояснения проблемы процитирую фрагмент статьи "[C++ and the Perils of Double-Checked Locking](https://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf)", написанной Scott Meyers и Andrei Alexandrescu ещё в 2004 году. Как видите, проблема давно известна, но это не защищает разработчиков от того, чтобы наступать на одни и те же грабли. Хорошо, что анализатор PVS-Studio помогает выявлять подобные проблемы :). Итак, фрагмент из статьи:
> Consider again the line that initializes *pInstance*: pInstance = newSingleton;
>
>
>
> This statement causes three things to happen:
>
>
>
> Step 1: Allocate memory to hold a *Singleton* object.
>
>
>
> Step 2: Construct a *Singleton* object in the allocated memory.
>
>
>
> Step 3: Make *pInstance* point to the allocated memory.
>
>
>
> Of critical importance is the observation that compilers are not constrained to perform these steps in this order! In particular, compilers are sometimes allowed to swap steps 2 and 3. Why they might want to do that is a question we'll address in a moment. For now, let's focus on what happens if they do.
>
>
>
> Consider the following code, where we've expanded *pInstance's* initialization line into the three constituent tasks we mentioned above and where we've merged steps 1 (memory allocation) and 3 (*pInstance* assignment) into a single statement that precedes step 2 (*Singleton* construction). The idea is not that a human would write this code. Rather, it's that a compiler might generate code equivalent to this in response to the conventional DCLP source code (shown earlier) that a human would write.
Если вы хотите подробнее разобраться с написанием блокировки с двойной проверкой, то отсылаю вас к описанию диагностики и статьи, ссылки на которые были даны выше. Для нас важно другое.
Подобные ошибки очень коварны! Они могут очень редко проявлять себя. Программа вроде как работает, проходит все тесты и так далее. Но время от времени она неожиданно падает у пользователей, и понять причину может быть крайне проблематично. Воспроизвести такую ошибку может быть очень сложно. Другим словами, исправление этой ошибки по жалобе от пользователей может обойтись в 1000 раз дороже, чем правка кода, сделанная по результату анализа кода с помощью PVS-Studio или аналогичного инструмента.
Примечание 1. Ошибка может и не существовать сейчас в двоичном коде, и всё зависит от компилятора, и ключей оптимизации. Однако, даже если сейчас всё работает хорошо, это не значит, что так будет всегда. Ошибка может проявить себя при смене компилятора/ключей оптимизации.
Примечание 2. Читатели обратили внимание, что описание проблемы блокировки с двойной проверкой устарело. В C++17 язык гарантированно выполняет все побочные эффекты, связанные с выражением *new T* перед выполнением эффектов самого присваивания (operator =). Другими словами, начиная с C++17, эту часть можно назвать "уже пофиксили, это не баг". Однако, запись всё равно не является атомарной, и возможно возникновение [состояния гонки](https://www.viva64.com/ru/t/0042/). Чтобы этого избежать, указатель должен быть объявлен как атомарный: *std::atomic ui\_storage\*.
**Фрагмент второй: realloc**
```
static void icon_merge_context_register_icon(struct IconMergeContext *context,
const char *file_name,
struct IconHead *icon_head)
{
context->read_icons = realloc(context->read_icons,
sizeof(struct IconInfo) * (context->num_read_icons + 1));
struct IconInfo *icon_info = &context->read_icons[context->num_read_icons];
icon_info->head = *icon_head;
icon_info->file_name = strdup(path_basename(file_name));
context->num_read_icons++;
}
```
Анализатор PVS-Studio выдаёт здесь два предупреждения, и это правильно. Здесь действительно допущено сразу две ошибки различного плана.
Первая: [V701](https://www.viva64.com/ru/w/v701/): realloc() possible leak: when realloc() fails in allocating memory, original pointer 'context->read\_icons' is lost. Consider assigning realloc() to a temporary pointer. datatoc\_icon.c 252
Если память не удастся выделить, функция *realloc* вернёт значение *NULL*. Нулевой указатель будет записан в переменную *context->read\_icons*, а её предыдущее значение будет потеряно. Раз предыдущее значение указателя потеряно, то и невозможно освободить ранее выделенный блок памяти, на который ссылался этот указатель. Произойдёт утечка памяти.
Вторая: [V522](https://www.viva64.com/ru/w/v522/): There might be dereferencing of a potential null pointer 'context->read\_icons'. Check lines: 255, 252. datatoc\_icon.c
Описанная выше ошибка – в каком-то смысле и не ошибка с точки зрения автора кода. Он и не собирался писать код, который будет продолжать работу в случае невозможности увеличения блока выделенной памяти. Такой случай просто не рассматривается. Автор предполагает, что, если память выделить не удалось, программа просто аварийно завершится при разыменовании нулевого указателя. И поэтому смело работает с указателем, не выполняя его предварительную проверку. Оставим в стороне вопрос, насколько красивым является такое поведение программы. На мой взгляд, такое поведение библиотек недопустимо.
Интереснее другое. На самом-то деле падение может и не произойти. Запись производится вовсе не по нулевому указателю, а куда-то дальше. Теоретически возможна ситуация, когда этот адрес уже не находится в странице памяти, защищенной от записи, и никакого падения не будет. Будут испорчены какие-то случайные данные в памяти, и программа продолжит своё выполнение. Последствия работы с испорченными данными непредсказуемы. Подробнее всё это разобрано в статье "[Почему важно проверять, что вернула функция malloc](https://habr.com/ru/company/pvs-studio/blog/348098/)".
**Фрагмент третий: разыменование указателя до проверки**
```
static int node_link_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
....
bNodeLinkDrag *nldrag = node_link_init(bmain, snode, cursor, detach);
nldrag->last_picked_multi_input_socket_link = NULL;
if (nldrag) {
op->customdata = nldrag;
....
}
```
Предупреждение PVS-Studio: [V595](https://www.viva64.com/ru/w/v595/): The 'nldrag' pointer was utilized before it was verified against nullptr. Check lines: 1037, 1039. node\_relationships.c
Один из самых частых паттернов ошибок ([proof](https://www.viva64.com/ru/examples/v595/)). В начале указатель *nldrag* разыменовывается. Но из следующего условного оператора становится видно, что на самом деле этот указатель может быть нулевым.
Всё просто и понятно. Но, согласитесь, намного лучше поправить такую ошибку сразу, ещё на этапе написания кода, а не после того, когда на неё наткнётся тестировщик или пользователь.
Кстати, нашлась ещё одна такая-же ошибка, но описывать её неинтересно. Приведу только сообщение: V595: The 'seq' pointer was utilized before it was verified against nullptr. Check lines: 373, 385. strip\_add.c
**Заключение**
Используйте статические анализаторы кода регулярно. От этого выиграют как разработчики, так и пользователи. Вы можете скачать и попробовать PVS-Studio [здесь](https://www.viva64.com/ru/pvs-studio-download/?promo=pvs_ak). Спасибо за внимание.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [PVS-Studio, Blender: Series of Notes on Advantages of Regular Static Analysis of Code](https://habr.com/en/company/pvs-studio/blog/545352/). | https://habr.com/ru/post/545354/ | null | ru | null |
# PHPixie против Laravel
Главной причиной написания этой статьи является то что этот вопрос мне задают практически регулярно и было бы хорошо просто иметь под рукой ссылку. Сразу же скажу что холивора в силе Emacs против Vi тут не будет, как и любой попытки сильно упрекнуть Laravel. Уже никто не сомневаются что он работает, на нем крутятся сайты и ничего плохого с ними не происходит, так что глупо утверждать что он чем-то плох. Я же хочу показать какую нишу старается занять [PHPixie](https://phpixie.com) и Laravel тут просто как пример, так что я надеюсь что читатель воспримет статью как обзор в стиле HTC против Samsung, призванную показать преимущества и разницу в парадигме, но никак не постулировать кто лучше.
### Система версий
Стоит заметить что оба фреймворка прошли долгий путь, и если вы были знакомы с ними 2 года назад, то скорее всего совсем не узнаете их сегодня. В этом они оба отличаются от Symfony, который меняется намного медленнее, и даже разница между версиями 2.7 и 3.0 не очень большая. Впрочем если сравнивать с дистрибутивами линукса, то Symfony похож на Debian, Laravel на Ubuntu а PHPixie на Arch. PHPixie использует rolling-release подход, и все новые фичи и багфиксы сразу попадают в мастер и получают тег версии, что делает их доступными максимально быстро. Но «composer update» придется делать более аккуратно, и следить за изменениями. Тут сразу напомню что если вы используете «composer install» то устанавливаете всегда одну и ту же версию, и никаких сюрпризов ждать не приходится. Такой подход заставляет разработчика фреймворка думать о обратной совместимости, и не ломать существующее API. Как результат вы апгрейдите свой код по чуть-чуть вместе с фреймворком, и вам не надо потом думать о прыжках в стиле Laravel 4 к Laravel 5, где в один момент поменялось все, а код на Laravel 4 теперь считается legacy.
### Скорость работы
Со скоростью в PHPixie все осталось по старому, она дальше столь же быстра, так как код роутинга и самого ядра практически не изменялся, она лишь обросла новыми библиотеками, которые влияют на скорость только тогда когда вы их используете. Бенчмарки от Techempower показывают что [Laravel даже на HHVM не может догнать PHPixie на PHP](https://www.techempower.com/benchmarks/#section=data-r12&hw=peak&test=fortune&l=27wq9r). В принципе я редко слышу чтобы Laravel хвалили за скорость работы, её больше хвалят за скорость разработки, так что скорее всего производительность просто никогда не была в ней приоритетом.
### Порог входа
Тут несомненно выигрывает Laravel, ларакасты, фасады, всяческие сниппеты с туториалов и готовые бандлы позволяют даже новичкам сделать сайт за минимальное количество времени, да и задеполить его теперь тоже можно прямо с artisan. Все это благодаря монолитности самого фреймворка, который хоть он состоит из компонентов, но сам Laravel сливает их в одно целое. PHPixie же строго модульный, поэтому даже нет единого DI контейнера, а все зависимости строятся через отдельные фабрики, и как результат надо больше понимать что происходит за кулисами. Но вот со временем, я бы сказал так за пол года, кривая обучения меняется. PHPixie построен с нуля, и все компоненты созданы по единой парадигме, что делает отладку кода намного проще, поняв одну часть фреймоврка легче понять другую. В то время с Laravel вы проведете много времени в коде разных разработчиков с разными подходами и разного качества. Впрочем если фасады и все такое для вас действительно важно, то опциональний DI компонент позволит вам получить тот-же результат.
### Работа с БД
Компоненты Database и ORM развивались наиболее сильно и являются одними из лучших частей фреймворка. Только несколько месяцев назад ORM начал поддерживать Nested Sets, при этом применяя техники оптимизации. Модели четко распределены на репозитории, запросы и сами сущности. Вместо наследования какого-то базового класса модели расширение осуществляется путем паттерна Декоратор что делает ваш код совсем независимым от самой логики работы с базой и элементарно тестируемым. Даже для построения запросов можно использовать несколько вариантов синтаксиса. Ну и конечно киллер фича что все это работает как с SQL базами данных, так и с Mongo, включая связи между сущностями в разных базах. Тут Laravel сильно проигрывает, так как Eloquent не ушел далеко от Kohana ORM и PHP ActiveRecord. Большинство опытных разработчиков при работе с Laravel используют либо Doctrine, либо Propel. Опять же это все зависит от ваших задач, для большинства CRUD приложений Eloquent работает весьма хорошо.
### Сообщество
Laravel разработчиков несомненно намного больше, как и митапов и фриланс заказов для них. Единственное чем может крыть PHPixie это наш чат, в котором меня можно найти каждый день и большинство проблем решается прям там на месте. Кстати если пользователей в чате после написания этой статьи прибудет, то я буду очень рад. Даже если вы не используете PHPixie, все равно заходите к нам, даже с Laravel сумеем помочь если что.
### Тесты
PHPixie известна своим 100% покрытием тестами. Это число недавно чуть уменьшилось для фреймворка в целом так как вышли 3 новых компонента, к которым пока еще и документации нет, и тесты там только в процессе, но через короткое время вновь будет 100%. Тут кстати важно не только само покрытие кода, но и его тестируемость. Отсутствие магии и фасадов как раз и позволяет писать короткие и быстрые юнит тесты к отдельным классам без необходимости поднимать кучу зависимостей на каждый тест. В Laravel тесты конечно тоже есть, но гораздо меньше, и кстати на гитхаб странице проекта нет бейджа с процентом покрытия, и даже нагуглить этот процент мне не удалось, так что его явно не афишируют. Я не поленился, и сам запустил тесты и сгенерил статистику, вот результат:
Кстати при попытке запустить тест на свежем PHPUnit при включении генерации покрытия просто выкидывает ошибку.
### Роутинг
Тут у нас вновь разница парадигм. Laravel как более монолитный фреймворк предоставляет возможности байндинга к моделям, позволяя полностью пропустить код контроллера, например:
```
$router->bind('user', function ($value) {
return App\User::where('name', $value)->first();
});
```
Также большинство роутов имеют имя а динамический роутинг полностью отсутствует (но его можно симулировать). Компонент роутинга PHPixie более автономный, и даже понятия контролера в нем самом нет, все что он делает это парсит запрос в набор параметров и передает их пользователю. В свою очередь это позволяет более гибкую настройку с вложенными правилами и префиксами. Еще одно отличие в том что в PHPixie роуты хранятся в файле конфигурации массивом а в Laravel задаются программно что более удобно если есть IDE с подсказками.
### Шаблонизатор
PHPixie использует ПХП как шаблонизатор, а это означает что все привычные функции например *ucwords*, *substr*, *trim* итд. уже доступны и новый язык учить не придется. PHPixie сумела получить все преимущества популярных шаблонизаторов не прибегая к компиляции, так что с ней вам тоже будут доступны как и наследование шаблонов так и поддержка блоков. В добавок у вас будет полная подсветка синтаксиса в любом IDE и отладка с Xdebug. Кстати как я показывал в предидущих статьях, этот шаблонизатор позволяет прикрутить любой синтаксис, например HAML, в считанные минуты. Laravel Blade же сам по себе ничем особо не отличается от Twig, только синтакс чуть отличается, но ничего нового он не приносит.
### HTTP
PHPixie построен на PSR-7, он расширяет его функционал добавляя свои врапперы, но вы всегда можете получить доступ к чистому PSR-7 запросу. Также он может принимать запросы из вне, что позволяет запустить фреймворк например на ReactPHP безо всяких усилий. Это также стало возможно благодаря stateless архитектуре, вместе с ReactPHP это означает что после выполнения запроса фреймворк остается таким как был до него и может сразу обрабатывать следующий без перезапуска. Laravel построен на HTTP компоненте Symfony, который строит свои запросы, и превратить их в PSR-7 можно только используя *symfony/psr-http-message-bridge*, что как минимум добавит оверхеда на каждом запросе. Хотя скорее всего в следующей версии Laravel перейдет на PSR-7 полностью.
### Аутентификация
Добавить аутентификацию в Laravel очень просто, конфигурация доступна фактически из-коробки, но вот имплементация до сих пор оставляет желать лучшего. Уже была статья о том как Laravel просто проверяла зашифрованную айдишку пользователя в кукисах, и как это удалось эксплуатирвать. Проблема была не так в шифровании а в нестрогой проверке результата используя '=='. Дыру починили, но теперь сделали другую. В [документации по «remember\_me»](https://laravel.com/docs/5.3/authentication#remembering-users) вы увидите что токен авторизации хранится один для всей учетной записи, то есть если его украсть можно логинится с ним до тех пор пока он валиден. В PHPixie имплементация «remember\_me» построена на лучших практиках, когда у каждого девайса для одной учетной записи хранится свой токен, и при этом он еще и обновляется при каждом использовании. Красть такой токен смысла нет как раз ввиду его одноразовости. Если вам интересна полная процедура, то она описана в известно [ответе на Stacokverflow](http://stackoverflow.com/a/244907/1135771). Также настройка авторизации в PHPixie намного гибче, вы можете создавать несколько токенов, использовать сессию или только кукисы и теперь так же социальную авторизацию, все в одном конфиге.
### Компоненты
Laravel как и PHPixie состоит из компонентов, и использовать например Eloquent без самого фреймворка очень просто. Но вот другие компоненты, например той же аутентификации завязаны на сам фреймворк гораздо больше, и использовать их с другим фреймворком так легко не получится. PHPixie же изначально задумывалась как независимые компоненты, показательно что на гитхабе каждый компонент PHPixie в отдельном репозитории, в то время как Laravel хранит все в одном проекте и предоставляет read-only репозитории для компонент.
На этом я наверное закончу, а то и так уже слишком длинно получается. На конец только замечу что ни в коем случае не считаю Laravel плохим или даже хуже. Я хотел лишь показать нишу PHPixie как более cutting-edge фреймворка, как и в сравнении с дистрибутивами Линукса в начале статьи. PHPixie это компоненты которые стараются быть на шаг впереди и нацелены больше на опытных разработчиков чем на новичков и скорость разработки.
Чуть ближе познакомится с фреймворком можно с моим вступительным видео в котором я показываю настройку проекта и работу с главными компонентами: | https://habr.com/ru/post/309176/ | null | ru | null |
# Material Design и AngularJS
Ни для кого не секрет, что Google повсюду в своих продуктах внедряет так называемый material design. Как и любой другой стиль он имеет сторонников и противников. Не буду касаться этих споров. Если вам нравится данный подход, Google подготовил полную спецификацию и описание особенностей: [Material Design](http://www.google.com/design/spec/material-design/introduction.html).
Для любителей angularjs появилась [библиотека](https://material.angularjs.org/#/) с набором директив, реализующих графические компоненты и позволяющих создавать разметку в соответствии с принципами material design. О ней и пойдет рассказ.
Я постараюсь кратко показать некоторые особенности и недостатки, а также покажу небольшое [приложение](http://nesterione.github.io/md-angular-demo/) для демонстрации.
#### Что мы имеем?
*1. Готовые компоненты:*
Множество готовых angularjs директив для различных компонентов: кнопок, переключателей, вкладок. Все перечислять не буду, все это хорошо освещено в [документации](https://material.angularjs.org/#/demo/material.components.button), покажу лишь основной принцип:
Вам нужна круглая кнопка?
Используем готовую директиву, т.е. пишем:
```
```
Если нужно добавить всплывающую подсказку, тоже все предусмотрено:
```
Photos
```
Нужны переключатели?
```
Switch 1: {{ data.cb1 }}
Switch 2 (md-warn): {{ data.cb2 }}
Switch (Disabled)
Switch (Disabled, Active)
Switch (md-primary): No Ink
```
Все это удобным образом связывается с данными:
```
.controller('SwitchDemoCtrl', function($scope) {
$scope.data = {
cb1: true,
cb4: true
};
});
```
Удобно? Конечно!.. Но только когда вам достаточно стандартных опций, которых не так уж и много. Заходите сделать какую-то особенность — и сразу все плюсы теряются.
*2. Разметка*
Для того, чтобы создавать адаптивную разметку, предусмотрено почти все необходимое. Вы можете создавать колонки, строки, вкладывать эти элементы друг в друга. Можно указывать как отображаться элемента при разных размерах экранов, все это реализовано вполне удобно. Рекомендую ознакомиться с [примерами](https://material.angularjs.org/#/layout/grid).
*3. Темы*
Еще одна особенность — возможность описывать темы. Темы можно менять динамически с помощью директив или в контроллере. Изначально темы уже описаны для всех основных цветов используемых в Material Design. [Подробнее](https://material.angularjs.org/#/Theming/01_introduction).
#### Пример приложения
Лучший способ понять преимущества и недостатки чего-либо — использовать это. Я сделал небольшой демонстрационный проект. Это небольшое приложение, здесь я не использовал удаленный REST сервис [соответственно, вносимые изменения нигде не отобразятся], чтобы сосредоточиться непосредственно на angularjs и возможностях material-angular.
Я сделаю простой редактор, в котором можно, нажав на плавающую кнопку, добавить задание, выбрав которые можно отметить, после чего они будут перенесены в архив.
[live demo](http://nesterione.github.io/md-angular-demo/)
[проект на github](https://github.com/nesterione/material-angular-demo-project/tree/habr)
Для начала создадим angular проект на базе angular-seed. Здесь я не буду рассказывать про ngRroute и ngView, кто работал с angularjs — это знают (если не знакомы с angularjs, прошу [сюда](https://angularjs.org/)).
Нам понадобится верхний toolbox:
Для этих целей предусмотрен соответствующий элемент:
```
Меню
Список задач
```
Также нужно сделать слева выдвижное меню, для этого тоже все предусмотрено:
```
Меню
====
{{page.discription}}
```
Для управления открытием можем использовать следующий код:
```
.controller('MainCtrl', function($scope, $timeout, $mdSidenav) {
$scope.toggleRight = function() {
$mdSidenav('left').toggle();
};
...
});
```
Таким образом, мы получили основной каркас. Теперь наполнение — это часть, которая будет изменятся при переходе между страницами. Наш view, в котором я буду отображать список задач:
Можно либо сразу отметить задачу как выполненную, либо при наведении на кружок появляется checkbox и мы можем отметить несколько записей одновременно, после выделения хотя бы одной записи верхний toolbox меняет свой вид. Поскольку основной toolbox находится не во view, то было принято решение просто выводить другой toolbox поверх заданного в каркасе.
Добавление новых элементов. Было принято решение вызывать диалоговое окно, в котором можно задать параметры.
Тут я поясню некоторую особенность, которая позволяет очень гибко управлять окнами. Данным фреймворком можно создавать как простые окна, так и сложные: для этого создается отдельная html страница, которая является шаблоном для модального окна.
При создании своего окна для управления создается контроллер, который будет обрабатывать и передавать данные из окна.
```
Отмена
Добавить
```
Код контроллера управляющего окном:
```
function DialogController($scope, $mdDialog) {
...
$scope.hide = function() {
$mdDialog.hide();
};
$scope.cancel = function() {
$mdDialog.cancel();
};
$scope.answer = function(answer) {
$mdDialog.hide(answer);
};
}
```
Тогда само окно может вызываться в коде следующим образом:
```
$mdDialog.show({
controller: DialogController,
// вот здесь указывается путь к странице описывающей вид нашего модального окна
templateUrl: 'dialog.tmpl.html',
targetEvent: ev,
})
.then(function(answer) {
// answer это то что было передано из нашего окна
// и здесь происходит вся последующая обработка данных
});
```
Я не стал подробно описывать как все реализовано, чтобы не нагромождать кучей довольно простого кода, только выделил моменты, касающиеся material angular. Все остальное вы можете посмотреть на [github](https://github.com/nesterione/material-angular-demo-project/tree/habr).
#### Впечатления и выводы
Изначально я подумал, что появилась замечательная возможность разрабатывать angular приложения с material design, однако немного поработав могу однозначно сказать: использовать еще рано (на момент написания версия 0.6). Содержится множество мелких багов, некоторые элементы отображаются по-разному в различных браузерах и постоянно приходится подстраивать стили вручную.
На данный момент множество проблем с отображением в различных браузерах. Проблем много (столкнулся при написании демонстрационного проекта), покажу только несколько (это примеры с официального сайта проекта, открытые в разных браузерах).
Значки на кнопках:
(Google Chrome):
(Internent Exprorer 11):
Диалоговые окна:
(Google Chrome):
(Internent Exprorer 11):
Дальше показывать косяки, думаю, не имеет смысла, они есть, и их много, а это значит, что вам придется вручную все поправлять.
Также к недостаткам можно отнести, что не сделано ничего дня поддержки различных анимаций. В Material Design много уделяют этому [вопросу](http://www.google.com/design/spec/animation/authentic-motion.html) . Но все это придется делать именно вам.
Пока сложно сказать, как скоро будут исправлены недостатки, но на данном этапе для использования angular material явно не готов.
#### Ссылки
* [Мой демо проект](http://nesterione.github.io/md-angular-demo/)
* [Исходный код демо проекта](https://github.com/nesterione/material-angular-demo-project/tree/habr)
* [Сайт проекта Material Angular](https://material.angularjs.org)
* [Официальное описание принципов Material Design](http://www.google.com/design/spec/material-design/introduction.html) | https://habr.com/ru/post/247719/ | null | ru | null |
# Unit тестирование в Laravel
Я часто слышу среди обсуждений в сообществе мнение, что unit тестирование в Laravel неправильное, сложное, а сами тесты долгие и не дающие никакой пользы. Из-за этого эти тесты мало кто пишет, ограничиваясь лишь feature тестами, а польза unit тестов стремится к 0.
Я тоже так считал когда-то, но, однажды я задумался и спросил себя — может быть я не умею их готовить?
Некоторое время я разбирался и на выходе у меня сформировалось новое понимание о unit тестах, а тесты стали понятными, дружелюбными, быстрыми и стали мне помогать.
Я хочу поделиться с сообществом своим пониманием, и еще лучше разобраться в этой теме, сделать мои тесты еще лучше.
Немного философии и ограничений
-------------------------------
Laravel — местами своеобразный фреймворк. Особенно в части фасадов и Eloquent. Я не буду касаться обсуждений или осуждений этих моментов, но покажу, как я совмещаю их с юнит тестами.
Я пишу тесты после (или одновременно) написания основного кода. Возможно мой подход не будет совместим с подходом TDD или потребуют частичных корректировок.
Самый главный вопрос, который я задаю себе перед написанием теста — «что именно я хочу протестировать?». Это важный вопрос. Именно эта мысль позволила мне пересмотреть взгляды на написание unit тестов и самого кода проекта.
Тесты должны быть стабильными и минимально зависеть от окружения. Если при внесении мутаций, ваши тесты падают, скорее всего они хорошие. И наоборот, если не падают, вероятно они не очень хорошие.
Из коробки Laravel поддерживает 3 типа тестов:
* Browser
* Feature
* Unit
Я буду говорить преимущественно о Unit тестах.
Я не тестирую весь код через unit тесты (возможно, это не правильно). Некоторый код я не тестирую совсем (об этом ниже подробнее).
Если в тестах используются моки, не забывайте делать Mockery::close() на tearDown.
Некоторые примеры тестов «взяты из интернета».
Как я тестирую
--------------
Ниже сгруппирую примеры тестов по группам классов и постараюсь привести примеры тестов под каждую группу классов. Для большинства групп классов я не буду приводить примеры самого кода.
### Middleware
Для unit теста middleware я создаю объект класса Request, объект нужного Middleware, далее вызываю метод handle и выполняю нужные asserts. Middleware по выполняемым действиям можно разделить на 3 группы:
* меняющие объект request (меняющие body request, либо сессии)
* делающие редирект (меняющие статус ответа)
* ничего не делающие с объектом request
Попробуем привести пример теста для каждой группы:
Предположим, что у нас есть следующий Middleware, задачей которого является модификация поля title:
```
class TitlecaseMiddleware
{
public function handle($request, Closure $next)
{
if ($request->title) {
$request->merge([
'title' => title_case($request->title)
]);
}
return $next($request);
}
}
```
Тест на подобный Middleware может выглядеть следующим образом:
```
public function testChangeTitleToTitlecase()
{
$request = new Request;
$request->merge([
'title' => 'Title is in mixed CASE'
]);
$middleware = new TitlecaseMiddleware;
$middleware->handle($request, function ($req) {
$this->assertEquals('Title Is In Mixed Case', $req->title);
});
}
```
Тесты для 2 и 3 группы будут такого плана соответственно:
```
$response = $middleware->handle($request, function () {});
$this->assertEquals($response->getStatusCode(), 302); // для редиректа
$this->assertEquals($response, null); // ничего не делаем с объектом request
```
### Request class
Основная задача этой группы классов — авторизация и валидация запросов.
Я не тестирую данные классы через unit тесты (допускаю, что это может быть не верно), только через feature тесты. На мой взгляд, unit тесты избыточны для этих классов, но я нашел несколько интересных примеров, как это можно делать. Возможно, они помогут вам, если вы решите протестировать свой request класс unit тестами:
* <https://medium.com/@daaaan/a-guide-to-unit-testing-laravel-form-requests-in-a-different-way-f1bdb6d86053>
* <https://stackoverflow.com/questions/36978147/unit-test-laravels-formrequest>
### Controller
Контроллеры я также не тестирую через unit тесты. Но при их тестировании я использую одну особенность, о которой я хотел бы рассказать.
Контроллеры, на мой взгляд, должны быть легкими. Их задача — получить правильный запрос, вызвать нужные сервисы и репозитории (так как оба этих термина для Laravel являются «чуждыми», ниже я дам пояснение по моей терминологии), вернуть ответ. Иногда вызвать событие, Job и т.п.
Соответственно, при тестировании через feature тесты нам нужно не просто вызвать контроллер с нужными параметрами и проверить ответ, но и замокать нужные сервисы и проверить, что они действительно вызываются (или не вызываются). Иногда — создать запись в БД.
Пример теста контроллера с моком класса сервиса:
```
public function testProductCategorySync()
{
$service = Mockery::mock(\App\Services\Product::class);
app()->instance(\App\Services\Product::class, $service);
$service->shouldReceive('sync')->once();
$response = $this->post('/api/v1/sync/eventsCallback', [
"eventType" => "PRODUCT_SYNC"
]);
$response->assertStatus(200);
}
```
Пример теста контроллера с моком фасадов (в нашем случае, событие, но по аналогии делается и для других фасадов Laravel):
```
public function testChangeCart()
{
Event::fake();
$user = factory(User::class)->create();
Passport::actingAs(
$user
);
$response = $this->post('/api/v1/cart/update', [
'products' => [
[
// our changed data
]
],
]);
$data = json_decode($response->getContent());
$response->assertStatus(200);
$this->assertEquals($user->id, $data->data->userId);
// and assert other data from response
Event::assertDispatched(CartChanged::class);
}
```
### Service и Repositories
Данных типов классов «из коробки» нет. Я стараюсь контроллеры держать тонкими, поэтому выношу всю дополнительную работу в одну из этих групп классов.
Разницу между ними я определил следующим образом:
* Если мне требуется реализовать некоторую бизнес логику, то я выношу это в соответствующий сервисный слой (класс).
* Во всех остальных случаях я выношу это в группу классов репозитория. Как правило, туда уходит фунционал работы с Eloquent. Я понимаю, что это не совсем верное определение уровня репозитория. Также я слышал, что некоторые выносят все, что связано с Eloquent в модели. Мой подход является неким компромиссом, на мой взгляд, хотя и «академически» не совсем верен.
Для классов Repository я почти не пишу тестов.
Пример теста Service класса ниже:
```
public function testUpdateCart()
{
Event::fake();
$cartService = resolve(CartService::class);
$cartRepo = resolve(CartRepository::class);
$user = factory(User::class)->make();
$cart = $cartRepo->getCart($user);
// set data
$data = [
];
$newCart = $cartService->updateForUser($user, $data);
$this->assertEquals($data, $newCart->toArray());
Event::assertDispatched(CartChanged::class, 1);
}
```
### Event-Listener, Jobs
Данные классы тестируются практически по общему принципу — мы готовим данные, необходимые для тестирования; вызываем нужный класс из фреймворка и проверяем результат.
Пример для Listener:
```
public function testHandle()
{
$user = factory(User::class)->create();
$cart = Cart::create([
'userId' => $user->id,
// other needed data
]);
$listener = new CreateTaskForSyncCart();
$listener->handle(new CartChanged($cart));
$job = // get our job
$this->assertSame(json_encode($cart->products), $job->payload);
$this->assertSame($user->id, $job->user_id);
// some additional asserts. Work with this data simplest for example
$this->assertTrue($updatedAt->equalTo($job->last_updated_at));
}
```
### Console Commands
Консольные команды я рассматриваю как некоторый контроллер, который дополнительно умеет выводить (и производить более сложные манипуляции с консольным вводом-выводом, описанным в документации) данные. Соответственно, тесты получаются аналогичные контроллеру: мы проверяем, что нужные методы сервисов вызываются, срабатывают (или нет) события, а также проверяем взаимодействие с консолью (вывод или запрос данных).
Пример подобного теста:
```
public function testSendCartSyncDataEmptyJobs()
{
$service = m::mock(CartJobsRepository::class);
app()->instance(CartJobsRepository::class,
$service);
$service->shouldReceive('getAll')
->once()->andReturn(collect([]));
$this->artisan('sync:cart')
->expectsOutput('Get all jobs for sending...')
->expectsOutput('All count for sending: 0')
->expectsOutput('Empty jobs')
->assertExitCode(0);
}
```
### Отдельные внешние библиотеки
Как правило, если отдельные библиотеки имеют особенности для unit тестов, то они описаны в документации. В остальных случаях, работа с этим кодом тестируется аналогично сервисному слою. Сами библиотеки покрывать тестами смысла нет (только если вы хотите отправить PR в эту библиотеку) и следует их рассматривать как некоторый black box.
На многих проектах мне приходится взаимодействовать через АПИ с другими сервисами. В Laravel для этих целей часто используется библиотека Guzzle. Мне показалось удобным вынести всю работу с другими сервисами в отдельный класс сервиса NetworkService. Это упростило мне написание и тестирование основного кода, помогло стандартизировать ответы и обработку ошибок.
Привожу примеры нескольких тестов для моего класса NetworkService:
```
public function testSuccessfulSendNetworkService()
{
$mockHandler = new MockHandler([
new Response(200),
]);
$handler = HandlerStack::create($mockHandler);
$client = new Client(['handler' => $handler]);
app()->instance(\GuzzleHttp\Client::class, $client);
$networkService = resolve(NetworkService::class);
$response = $networkService->sendRequestToSite('GET', '/');
$this->assertEquals('200', $response->getStatusCode());
}
public function testUnsupportedMethodSendNetworkService()
{
$networkService = resolve(NetworkService::class);
$this->expectException('\InvalidArgumentException');
$networkService->sendRequestToSite('PUT', '/');
}
public function testUnsetConfigUrlNetworkService()
{
$networkService = resolve(NetworkService::class);
Config::shouldReceive('get')
->once()
->with('app.api_url')
->andReturn('');
Config::shouldReceive('get')
->once()
->with('app.api_token')
->andReturn('token');
$this->expectException('\InvalidArgumentException');
$networkService->sendRequestToApi('GET', '/');
}
```
Выводы
------
Данный подход позволяет мне писать более качественный и понятный код, использовать преимущества подходов SOLID и SRP при написании кода. Мои тесты стали быстрее, а главное — они начали приносить мне пользу.
При активном рефакторинге при расширении или изменении функционала, мы сразу видим, что именно падает и можем быстро и точечно исправлять ошибки не выпуская их из локального окружения. Это делает исправление ошибок максимально дешевом.
Я надеюсь, что описанные мною принципы и подходы помогут вам разобраться с unit тестированием в Laravel и сделают unit тесты вашими помощниками в разработке кода.
Пишите ваши дополнения и комментарии. | https://habr.com/ru/post/457866/ | null | ru | null |
# Как переписать большой проект или безболезненный для бизнеса рефакторинг
> Вопрос, который мне задают чаще всего, — как разговаривать о рефакторинге с руководителем?
>
> В таких случаях я даю несколько спорный совет: не говорите ему ничего!
>
>
*Мартин Фаулер, «Рефакторинг. Улучшение существующего кода»*
Устаревание кода, трудности с поддержкой, непредсказуемые баги — эти термины один за другим появляются в жизни разработчика по мере разработки продукта. И если первое — это скорее интересы разработчика, то последнее — это прямая проблема бизнеса.
В этой статье я хочу поделиться опытом переписывания большого проекта и как бонус привести пару кусков кода, которые помогли нам и, надеюсь, помогут вам начать этот интересный путь.
Разбор полетов
==============
Проблемы
--------
Они обычно начинаются по известному сценарию:
1. Прибегает начальник с воплями «У нас ничего не работает, главный клиент под угрозой!»;
2. или менеджер с просьбой прикрутить нереализуемую фишку;
3. реже мы, разработчики, настолько устаем копаться в ~~говне~~ «легаси»-коде, что решаем переписать всё.
И обычно это заканчивается всеобщим негодованием и разладом, потому что фишка нужна срочно, клиенты тоже ждать не могут, а из-за печального наследия команда стремится разбежаться. Ситуацию портит отсутствие «денег на рефакторинг» (бездействие команды в понятиях бизнеса)
Насчет последнего пункта нужно добавить, что ситуацию с новым человеком в команде, который рвется всё переписать, я не рассматриваю, однако он может запросто аргументировать описанный подход для развития проекта.
Задачи
------
1. Перевести проект на современную архитектуру
2. Обеспечить минимальные затраты на рефакторинг
Принципиальная схема реализации
-------------------------------
Наш проект был изначально написан на Kohana, переписывали мы его на Symfony2, поэтому все примеры приведены в контексте этих систем. Однако, данный подход можно применять с любыми фреймворками. Необходимое требование — единая точка входа в приложение.
Изначально приложение обрабатывает запросы пользователя через точку входа «app\_kohana.php»
Мы будем оборачивать начальную точку входа в новой системе, организовывая своеобразный «прокси».
Рефакторинг
===========
Контроллер — обертка для старой системы
---------------------------------------
Идея довольно проста и заключается в следующем:
1. Разворачиваем параллельно две системы (kohana + symfony)
2. Меняем точку входа на новую (symfony)
3. Организуем универсальный контроллер, который по умолчанию будет пробрасывать все запросы в старую систему
И если с первыми двумя пунктами проблем возникнуть не должно, то третий представляет интерес, потому как в нем могут обнаружиться подводные камни.
Первое, что приходит в голову — обернуть инклюд в ob\_start. Так и сделаем:
```
class PassThroughController extends Symfony\Bundle\FrameworkBundle\Controller\Controller {
public function kohanaAction()
{
ob_start();
$kohanaPath = $this->container->getParameter('kernel.root_dir') . '/../app_kohana.php';
include $kohanaPath;
$response = ob_get_clean();
return new Response($response);
}
}
```
**Роутинг для универсального контролера**
```
application.passthrough_kohana:
path: /{slug}
defaults:
_controller: ApplicationBundle:PassThrough:kohana
requirements:
slug: .*
```
В таком формате система уже работает, но спустя какое-то время прилетает первый баг. Например, некорректная обработка ajax-ошибок. Или на сайте ошибки отдаются с кодом 200 вместо 404.
Тут мы понимаем, что буфер проглатывает заголовки, поэтому их нужно обрабатывать явным образом
```
class PassThroughController extends Symfony\Bundle\FrameworkBundle\Controller\Controller {
public function kohanaAction()
{
ob_start();
$kohanaPath = $this->container->getParameter('kernel.root_dir') . '/../app_kohana.php';
include $kohanaPath;
$headers = headers_list();
$code = http_response_code();
$response = ob_get_clean();
return new Response($response, $code, $headers);
}
}
```
После этого полёт нормальный.
Проблемы старой системы, влияющие на функционирование новой
-----------------------------------------------------------
### exit()
У нас в системе нашлись места, где в конце работы контроллера радостно вызывался exit(). Это практикуется, например, в Yii (CApplication::end()). Особой головной боли это не доставляет до тех пор, пока не начинаешь использовать событийную модель в новой системе и обрабатывать события, случающиеся после выполнения контроллера. Самый яркий пример — Symfony Profiler, который прекращает работать для запросов с exit'ом.
Данный случай нужно иметь в виду и при необходимости предпринимать соответствующие меры.
### ob\_end\_\*()
Необдуманное использование функций ob\_end легко может поломать работу новой системы, очистив буфер нового прокси-контроллера. Следует так же иметь в виду.
### Kohana\_Controller\_Template::$auto\_render
Переменная отвечает за автоматическую отрисовку полученных из контроллера данных в глобальном шаблоне (может сильно зависеть от используемого шаблонизатора). Во время адаптации новой системы это может сэкономить время на отладку в местах, где, например, json выводится простым *echo $json; exit();*. Контроллер примет примерно следующий вид:
```
$this->auto_render = false;
echo $json;
return;
```
О чем еще стоит позаботиться
----------------------------
Описанные выше точки входа — это идеальная ситуация. У нас изначально точка входа была app.php и требовалось, чтобы после рефакторинга она же и осталась (переконфигурирование многочисленных серверов выглядело бесперспективным). Выбран был следующий алгоритм:
1. Переименовываем app.php в app\_kohana.php
2. Точку входа симфони размещаем в app.php
3. Profit
И все, казалось бы, завелось, кроме консольных команд, которые в кохане запускались через тот же файл. Поэтому в начале нового app.php родился следующий костылик для обратной совместимости:
```
if (PHP_SAPI == 'cli') {
include 'app_kohana.php';
return;
}
```
Жизнь после рефакторинга
========================
Новые контроллеры
-----------------
Все новые контроллеры мы стараемся писать в symfony. Разделение происходит на уровне роутинга, перед «универсальным» маршрутом дописывается нужный, и Kohana дальше не загружается. Пока мы пишем в новой системе только ajax-контроллеры, поэтому вопрос с переиспользованием шаблонов (Twig) остается открытым.
БД и Конфигурация
-----------------
Для доступа к БД были сгенерированы модели из текущей базы стандартными методами Doctrine. В репозитории по мере необходимости добавляются новые методы работы с БД. Однако, конфигурация подключения к БД используется существующая из коханы. Для этого написан конфигурационный файл, который подтягивает данные из конфига коханы и преобразует их в параметры конфигурации симфони. Логика поиска конфига в зависимости от платформы, увы, продублирована, чтобы не подключать классы коханы в новой системе.
**Application/Resources/config/kohana.php**
```
/** @var \Symfony\Component\DependencyInjection\ContainerBuilder $container */
$kohanaDatabaseConfig = [];
$kohanaConfigPath = $container->getParameter('kernel.root_dir') . '/config';
if (!defined('SYSPATH')) {
define('SYSPATH', realpath($container->getParameter('kernel.root_dir') . '/../vendor/kohana/core') . '/');
}
$mainConfig = $kohanaConfigPath . '/database.php';
if (file_exists($mainConfig)) {
$kohanaDatabaseConfig = include $mainConfig;
}
if (isset($_SERVER['PLATFORM'])) {
$kohanaEnvConfig = $kohanaConfigPath . '/' . $_SERVER['PLATFORM'] . '/database.php';
if (file_exists($kohanaEnvConfig)) {
$kohanaDatabaseConfig = array_merge($kohanaDatabaseConfig, include $kohanaEnvConfig);
}
}
if (empty($kohanaDatabaseConfig['default'])) {
throw new \Symfony\Component\Filesystem\Exception\FileNotFoundException('Could not load database config');
}
$dbParams = $kohanaDatabaseConfig['default'];
$container->getParameterBag()->add([
'database_driver' => 'pdo_mysql',
'database_host' => $dbParams['connection']['hostname'],
'database_port' => null,
'database_name' => $dbParams['connection']['database'],
'database_user' => $dbParams['connection']['username'],
'database_password' => $dbParams['connection']['password'],
]);
```
Подключается конфиг стандартным способом
**Application/DependencyInjection/ApplicationExtension.php**
```
class ApplicationExtension extends Symfony\Component\HttpKernel\DependencyInjection\Extension {
public function load(array $configs, ContainerBuilder $container) {
$loader = new Loader\PhpFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
$loader->load('kohana.php');
}
}
```
Как продолжать: вынесение функционала в сервисы
-----------------------------------------------
Дальнейшей движение из коханы в симфони очень хорошо укладывается в вынесение функционала в сервисы симфони и использовании их в старой системе через DI-контейнер. Так сложилось, что DI-компонент мы начали использовать до подключения симфони в проект, поэтому этот процесс прошел довольно гладко, но ничто не мешает делать это с нуля. Основной задачей будет прокинуть DI-контейнер из симфони в кохану. Мы сделали это в кохана-стиле через статическое свойство, в другом фреймворке можно найти соответствующий подход.
**Переопределяем системный класс коханы, добавляем туда свойство для контейнера.**
```
class Kohana extends Kohana_Core {
/**
* @var Symfony\Component\DependencyInjection\ContainerBuilder
*/
public static $di;
}
```
А дальше нужно провернуть еще пару махинаций, чтобы положить в этой свойство DI-контейнер между инициализацией коханы и выполнением кода контроллера. Для этого разделим наш файл инициализации app\_kohana.php на две части, выделив непосредственно инициализацию системы и сам запуск контроллера.
```
/** app_kohana_init.php */
// тут инициализация фреймворка, включая системные константы и bootstrap
/** app_kohana_run.php */
echo Request::factory(TRUE, array(), FALSE)
->execute()
->send_headers(TRUE)
->body();
/** app_kohana.php */
include 'app_kohana_init.php';
include 'app_kohana_run.php';
```
Модифицируем наш контроллер, проделывая похожие с app\_kohana.php операции, но добавляя между инклюдами проброс контейнера
```
public function kohanaAction() {
ob_start();
$kohanaPath = $this->container->getParameter('kernel.root_dir') . '/..';
include $kohanaPath . '/app_kohana_init.php';
\Kohana::$di = $this->container;
include $kohanaPath . '/app_kohana_run.php';
$headers = headers_list();
$code = http_response_code();
$response = ob_get_clean();
return new Response($response, $code, $headers);
}
```
После этого мы в старой системе можем использовать DI-контейнер и все объявленные в новой системе сервисы, включая EntityManager и новые модели доктрины.
Напоследок
==========
Плюсы реализации
----------------
* Мы сделали первый шаг для дальнейшего развития системы.
* Новая система независима от старой. Весь новый код работает без участия старого
* Минимум потраченного времени
Минусы реализации
-----------------
* Дополнительные накладные ресурсы на «обертку» во время работы со старой частью системы. Однако, по сравнению с задержками в старой системе, оверхедом (как по памяти, так и по процессору) можно пренебречь.
* Новая система независима от старой. Мы не можем использовать старый код в новой, но это скорее плюс, раз уж мы решились переписывать.
* Приходится поддерживать модели в двух местах.
Спасибо, что дочитали до конца, желаю успехов в рефакторинге, смахните накопившуюся пыль со старого кода!
И простите за ужасные шрифты на диаграммах :( | https://habr.com/ru/post/252405/ | null | ru | null |
# Вышла библиотека PyWhat для автоматического парсинга трафика
[](https://habrastorage.org/webt/lh/4q/kv/lh4qkvcjrcirr35oqzeeuxmkoqm.png)
Разработана удобная библиотека [PyWhat](https://github.com/bee-san/pyWhat), которая помогает классифировать данные в неструктурированном массиве. Например, у вас несколько мегабайт трафика, записанного в стандартном формате .pcap. Что с ним делать? PyWhat спарсит все строки, выделит:
* кошельки криптовалют,
* номера социального страхования,
* кредитные карточки,
* заголовки видеороликов Youtube ID,
* любые хэши,
* другие известные типы данных.
Так в трафике гораздо проще ориентироваться. Увидев нужный пакет, затем в Wireshark можно выбрать остальные пакеты конкретно из этого потока в реальном времени.
В принципе, всё то же самое можно сделать фильтрами в Wireshark, если искать в трафике что-то конкретное, но эта библиотека автоматизирует процесс и экономит время.
Иди другой пример. Посреди кода или в каком-то файле встречается таинственная строка `5f4dcc3b5aa765d61d8327deb882cf99`. Нет проблем. Запускаем PyWhat — и смотрим, что это такое, с помощью команды `what "5f4dcc3b5aa765d61d8327deb882cf99"`.
Задача команды `what` — выяснить происхождение строки символов, фрагмента, текста внутри файла или какого-то hex-значения.
Автор библиотеки [приводит такой пример](https://github.com/bee-san/pyWhat). Вы столкнулись с новым вариантом вредоносного ПО под названием WantToCry. Вспоминаете, что оригинальный Wannacry удалось остановить, потому что никому не известный паренёк [обнаружил в коде «выключатель»](https://habr.com/ru/post/357342/) с триггером на появление сайта по указанному адресу. Парень зарегистрировал этот домен — и остановил распространение Wannacry во всём мире.
«Итак, запускаем `what` — находим все домены во вредоносной программе — и через API регистратора доменов все их регистрируем. Если Wannacry появится снова, вы сможете остановить его за считанные минуты», — пишет автор.
В общем, библиотека помогает найти структурированные данные в любом файле, поддерживает рекурсивный поиск файлов в директориях, [работает с API](https://github.com/bee-san/pyWhat/wiki/API).
PyWhat относится к классу «вероятностных библиотек» на Python (probabilistic library), созданных в процессе машинного обучения моделей. В каком-то смысле, такие модели после обучения распознают форматы строк примерно как системы машинного обучения распознают лица конкретных людей, сверяясь с базой паттернов.
Из других полезных вероятностных библиотек/пакетов на Python можно назвать следующие:
* [probablepeople](https://parserator.datamade.us/probablepeople/): парсер неструктурированных западных имён с разбиением их по полям (имя, фамилия и другие компоненты)
* [usaddress](https://github.com/datamade/usaddress): парсер американских адресов с разбиением из одной строки на шесть полей
* [chardet](https://github.com/chardet/chardet): автоматическое определение кодировки символов
* [Gen.jl](https://www.gen.dev/): система вероятностного программирования общего назначения с программируемым выводом. Например, позволяет наводить порядок в таблицах с плохо структурированными данными
* [DataProfiler](https://capitalone.github.io/DataProfiler): инструмент, похожий по функциональности на PyWhat. Принимает на входе файлы и данные любых форматов, а на выходе выдаёт структурированную информацию по следующим полям:
+ UNKNOWN
+ ADDRESS
+ BAN (bank account number, 10-18 digits)
+ CREDIT\_CARD
+ EMAIL\_ADDRESS
+ UUID
+ HASH\_OR\_KEY (md5, sha1, sha256, random hash, etc.)
+ IPV4
+ IPV6
+ MAC\_ADDRESS
+ PERSON
+ PHONE\_NUMBER
+ SSN
+ URL
+ US\_STATE
+ DRIVERS\_LICENSE
+ DATE
+ TIME
+ DATETIME
+ INTEGER
+ FLOAT
+ QUANTITY
+ ORDINAL
Возможно переобучение модели [DataProfiler](https://capitalone.github.io/DataProfiler) на новые типы данных.
---
[](http://miran.ru/) | https://habr.com/ru/post/563206/ | null | ru | null |
# Mattermost self-hosted хак групповых уведомлений
Недавно мы с командой переехали в мессенджер Mattermost на замену Slack, но мы столкнулись с одной неприятной проблемой. мы не можем в бесплатной версии уведомлять пользователей через тег группы `@groupname` в бесплатной версии этой возможности нет, и групп не предусмотрено.
Покопавшись в настройках, заметили что у каждого пользователя есть ключевые слова для упоминаний.
Настройки пользователяПосле мы проверили еще одну идею если мы создадим пользователя @devops и упомянем его где нибудь то он будет подсвечиваться как пользователь:
Но самое интересное то, что у всех пользователей у которых есть в ключевых словах упоминаний @devops тоже получат уведомление. Так родилась идея это автоматизировать и как то структурировать.
Подключаемся к БД Mattermost нас интересует 3 таблицы:
```
table usergroups
(
id varchar(26) not null primary key,
name varchar(64) unique,
displayname varchar(128),
description varchar(1024),
source varchar(64),
remoteid varchar(48),
createat bigint,
updateat bigint,
deleteat bigint,
allowreference boolean,
unique (source, remoteid)
);
table groupmembers
(
groupid varchar(26) not null,
userid varchar(26) not null,
createat bigint,
deleteat bigint,
primary key (groupid, userid)
);
table users
(
id varchar(26) not null
primary key,
createat bigint,
updateat bigint,
deleteat bigint,
username varchar(64) unique,
password varchar(128),
authdata varchar(128) unique,
authservice varchar(32),
email varchar(128) unique,
emailverified boolean,
nickname varchar(64),
firstname varchar(64),
lastname varchar(64),
roles varchar(256),
allowmarketing boolean,
props jsonb,
notifyprops jsonb,
lastpasswordupdate bigint,
lastpictureupdate bigint,
failedattempts integer,
locale varchar(5),
mfaactive boolean,
mfasecret varchar(128),
position varchar(128),
timezone jsonb,
remoteid varchar(26)
);
```
Первые 2 таблицы **usergroups**, **groupmembers** были пустыми и так как у нас бесплатная версия и мы их не используем решил сделать на их базе.
Создаем 2х пользователей в Mattermost, **devops** и **developers.**
Создаем группы с названием таким же как пользователи:
```
INSERT INTO usergroups (id, name, displayname, description, source, remoteid, createat, updateat, deleteat,allowreference)
VALUES ('1', 'devops', 'devops', null, null, null, null, null, null, null)
INSERT INTO usergroups (id, name, displayname, description, source, remoteid, createat, updateat, deleteat,allowreference)
VALUES ('2', 'developers', 'developers', null, null, null, null, null, null, null)
```
Привязываем пользователя **testuser** к группе **devops** и **developers:**
```
INSERT INTO groupmembers (groupid, userid, createat, deleteat)
VALUES (
(select id from usergroups where
usergroups.name = 'devops'),
(select id from users where
users.username = 'testuser'),
null,null);
INSERT INTO groupmembers (groupid, userid, createat, deleteat)
VALUES (
(select id from usergroups where
usergroups.name = 'developers'),
(select id from users where
users.username = 'testuser'),
null,null);
```
Проверяем, к каким группам привязаны пользователи:
```
select string_agg(concat('@', usergroups.name), ',') as groups, users.username
from groupmembers
left join users on groupmembers.userid = users.id
left join usergroups on groupmembers.groupid = usergroups.id
group by users.username;
```
| | |
| --- | --- |
| groups | username |
| @developers,@devops | testuser |
Также нам пригодится еще один запрос, который делает такую же табличку, но теперь какие пользователи в каких группах состоят:
```
select string_agg(concat('@', users.username), ',') as users, usergroups.name as groupname
from groupmembers
left join users on groupmembers.userid = users.id
left join usergroups on groupmembers.groupid = usergroups.id
group by usergroups.name;
```
| | |
| --- | --- |
| users | groupname |
| @testuser | developers |
| @testuser | devops |
В таблице **users** есть столбец **notifyprops** в нем содержится jsonb нас интересует там **mention\_keys,** который как раз отвечает за **"**ключевые слова для упоминаний" из первого скриншота.
Идея следующая. Зная, к каким группам привязаны пользователи, мы можем найти их в таблице **users** и заменить у них поле **mention\_keys** на результат выполнения из из первой таблицы:
```
UPDATE users
SET notifyprops = jsonb_set(notifyprops, '{mention_keys}', to_jsonb(subq.groups), true)
from (select string_agg(concat('@', usergroups.name), ',') as groups, users.username as un
from groupmembers
left join users on groupmembers.userid = users.id
left join usergroups on groupmembers.groupid = usergroups.id
group by users.username) as subq
where username = subq.un
```
Теперь для всех пользователей которые находятся в группах добавятся ключевые слова для упоминаний с тегами этих групп.
Но удобно было бы видеть, кто состоит в наших "группах", если нажать на пользователя.
У каждого пользователя есть поле **position,** в которой записана занимаемая должность, мы решили складывать информацию о пользователях туда.
Находим всех пользователей у которых название группы совпадает с названием пользователя и записываем в **position** данные из о пользователях которые состоят в этой группе.
```
UPDATE users
SET position = subq.users
from (select string_agg(concat('@', users.username), ',') as users, usergroups.name as groupname
from groupmembers
left join users on groupmembers.userid = users.id
left join usergroups on groupmembers.groupid = usergroups.id
group by usergroups.name) as subq
where username = subq.groupname
```
На этом собственно все. После нехитрых манипуляций получаем очень нужную функцию, которая изначально отсутствовала. | https://habr.com/ru/post/673036/ | null | ru | null |
# Забавляемся с хешами
Привет. Я хочу показать вам небольшой фокус. Для начала вам потребуется скачать [архив с двумя файлами](http://dl.dropbox.com/u/10864844/ge.rar). Оба имеют одинаковый размер и одну и ту же md5 сумму. Проверьте никакого обмана нет. Md5 хеш обоих равен ecea96a6fea9a1744adcc9802ab7590d. Теперь запустите программу good.exe и вы увидите на экране следующее.
Попробуйте запустить программу evil.exe. 
Что-то пошло не так? Хотите попробовать сами?
#### О хешах и колллизиях
На самом деле ничего нового во всем этом нет. В действительности данный эффект достигается за счет методов быстрого поиска коллизий для хеш функции разработанных еще в 2004-2006 годах. Если кто не знает, коллизия это два разных набора данных, имеющих одно и тоже хеш-значение. Так вот, в 2004 году группа китайских исследователей разработала алгоритм, основанный на дифференциальном криптоанализе, позволяющий за относительно небольшое время находить два различных случайных блока данных, размером по 128 байт каждый, имеющих одну и ту же md5 сумму. И хотя алгоритм этот в свое время произвел эффект взорвавшейся бомбы быстродействие его оставляло желать лучшего. Но уже в 2006 году чешский криптограф Властимил Клима предложил для поиска коллизий новый метод, позволяющий найти разную пару случайных 128 байтных блоков с одной md5 суммой на персональном компьютере меньше чем за минуту.
Вы спросите, но что нам даст обладание такой парой сообщений, мало того что они короткие(всего 128 байт), так еще, в добавок, и случайные, т.е. метод не позволяет для заданного сообщения подобрать другое, с идентичным хешем. Однако это открывает огромный простор для различного рода атак на выполняемые файлы. И виной тому служит следующая особенность работы любой хеш функции: Хеш функция по своей природе итеративна. Это означает, что при подсчете хеша сообщение разбивается на блоки, к каждому блоку применяется функция сжатия, зависящая от некоторой переменной, называемой вектор инициализации. Результат этой функции будет являться вектором инициализации для следующего блока. Результат функции после работы с последним блоком и будет окончательным хеш значением нашего сообщения.
Схематично это можно представить следующим образом:
si+1 = f(si, Mi), где si вектор инициализации для i-го блока.
Метод Властимила Клима позволяет для любого заданного значения si подобрать два 128-байтных блока M,M` и N,N` таких, что f(f(s, M), M') = f(f(s, N), N').
Таким образом, с помощью данной методики можно сконструировать два файла с одинаковой md5 суммой, но имеющих различные 128 байт в середине.
M0, M1, ..., Mi-1, **Mi, Mi+1**, Mi+2, ..., Mn,
M0, M1, ..., Mi-1, **Ni, Ni+1**, Mi+2, ..., Mn.
Обратите внимание что хеши обоих этих файлов совпадут, т.к. различающиеся блоки Mi, Mi+1 и
Ni, Ni+1 вернут в качестве si+2 одно и тоже значение, т.к. f(f(s, Mi), Mi+1) = f(f(s, Ni), Ni+1), а поскольку все последующие данные идентичны то последующие значения функции сжатия для обоих файлов будут совпадать.
#### Что это нам дает
Теперь перейдем от вещей абстрактных и отдаленных к вопросу практическому. Предположим, что у нас есть исполняемый файл M0, M1, X, X, …, Mn. Но его основе мы можем создать два разных файла M0, M1, **N1, N1**, …, Mn и M0, M1, **N2, N1**,…, Mn(просто меняем блоки X на N1 и N2). Если блоки N1 и N2 – это коллизии то хеш-сумма этих файлов будет совпадать.
Теперь представим, что этот исполняемый файл имеет следующую структуру:
if (X == X) then { good\_program } else { evil\_program }
Вот собственно и весь секрет данного фокуса.
#### Как сделать самостоятельно
Теперь немного поговорим о том как это сделать самому.
**Шаг первый:** пишем программу с двойным дном.
> `#include
>
> #include
>
> #include <string>
>
> using namespace std;
>
> //переменные str1 и str2 в данном примере являются теми самыми элементами X.
>
> static char \*str1="qwertyuioplkjhgfdaszxcvbnmkjhgfdsaqwertyuikjh"\
>
> "gbvfdsazxdcvgbhnjikmjhbgfvcdsazxdcfrewqikolkjnhgfqwertyuioplkjh"\
>
> "gfdaszxcvbnmkjhgfdsaqwertyuikjhgbvfdsazxdcvgbhnjikmjhbgfvcdsa"\
>
> "zxdcfrewqikolkjnhgfq123";
>
> static char \*str2="qaswderftgyhujikolpmnbvcxzasxdcfvgbhnjmkijuy"\
>
> "gtfdeswaqscfvgyjqaswderftgyhujikolpmnbvcxzasxdcfvgbhnjmkijuyg"\
>
> "tfdeswaqscfvgyjqaswderftgyhujikolpmnbvcxzasxdcfvgbhnjmkijuygt"\
>
> "fdeswaqscfvgyjqwertyuikja2";
>
>
>
> int good()
>
> {
>
> int a;
>
> std::cout<<"Good, nice programme!";
>
> std::cin>>a;
>
> return 0;
>
> }
>
> int bed()
>
> {
>
> int a;
>
> for(int i=0; i<1000; i++)
>
> {
>
> std::cout<<"Evil, evil code!";
>
> }
>
> std::cin>>a;
>
> return 0;
>
> }
>
> int \_tmain(int argc, \_TCHAR\* argv[])
>
> {
>
> //строки s и s2 содержат только блоки с коллизиями без лишних элементов
>
> string s=str1;
>
> string s2=str2;
>
> s.erase(0,56);
>
> s.erase(128,8);
>
> s2.erase(0,64);
>
> if (s==s2) {
>
> return good();
>
> } else {
>
> return bed();
>
> }
>
> return 0;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Особое внимание прошу обратить на переменные str1 и str2. Они служат для того, чтобы их можно было быстро найти в hex-редакторе и заменить нужными данными.
Функция main в зависимости от содержимого переменных s вызывает хорошую или плохую версию программы.
**Шаг второй:** После компиляции программы нужно будет немного поработать с hex-редактором для того чтобы найти в .exe файле наши строки str1 и str2. Скопируй полученный .exe файл. Пусть копия будет называется «обрезанная версия». Откройте копию в hex-редакторе и найди в ней строки str1 и str2. Удалите все данные идущие после первых 64 байт первой из строк. Последние строки полученного файла будут выглядеть вот таким образом: . Сохраните данный файл.
**Шаг третий:** Созданный на втором шаге файл будет служить так называемым префиксом для поиска коллизий. Чтобы найти коллизию с заданным префиксом нужно скачать [отсюда](http://www.win.tue.nl/hashclash/fastcoll_v1.0.0.5.exe.zip) программу fastcoll(Спасибо ее автору Marc Stevens). Исходники лежат [тут](http://www.win.tue.nl/hashclash/fastcoll_v1.0.0.5_source.zip).
Запустите программу с параметром –p. В качестве префикса укажите «обрезанную версию». В результате работы программы будут созданы два файла «обрезанная версия\_msg1» и «обрезанная версия\_msg2».
**Шаг четвертый:** создайте еще одну копию вашей программы. Пусть оригинал будет называться good.exe, а копия evil.exe. Откройте файлы msg1 и msg2 в hex редакторе. Сперва замените блок в котором хранится str2 данными из блока str1. Пусть теперь в них будет одинаковая информация. После этого скопируйте из файла msg1 последние 128 байт и вставьте их в ваш good файл так как показано на рисунке.
Обратите внимание, отступы должны соответствовать следующим параметрам: первый блок вставляется прямо в том месте где заканчивается файл «обрезанная версия», второй блок располагается в 96 байтах от первого. Важно: блоки вставлять одни и те же. Это будет доброй версией нашей программы. Сохраняем файл good.exe и открываем файл evil.exe. Блоки в файл evil.exe нужно будет вставить в те же места, что и в good.exe, единственное отличие заключается в том, что первый блок мы берем из файла msg2, а второй из файла msg1. Это различие и обеспечит нам невыполнение условия программы if (s==s2) и соответственно запустит злую версию программы.
**Шаг пятый:** Profit! Сравниваем md5 суммы файлов, наслаждаемся полученным результатом.
**Список литературы:**
1. [Замечательный сайт с описанием данного метода](http://www.mscs.dal.ca/~selinger/md5collision/)
2. [Сайт Властимила Клима](http://cryptography.hyperlink.cz/MD5_collisions.html)
3. [Сайт автора программы findcoll](http://www.win.tue.nl/hashclash/) | https://habr.com/ru/post/113127/ | null | ru | null |
# Визуализация использования GIL в CPython
Интересно, как ведут себя потоки, когда борются за GIL, или немного информации [отсюда](http://www.dabeaz.com/python/GIL.pdf) только для Python3.
Сразу оговорюсь, что использую `Ubuntu 16.04` c ядром `4.15.0-115-generic`, на машине стоит 4-х ядерный процессор `Intel(R) Core(TM) i5-4200U CPU @ 1.60GHz` с 4 GB RAM.
Теория
------
Ни для кого не секрет, что в Linux библиотека потоков реализует стандарт POSIX threads. Реализация потоков в CPython использует данные потоки, из-за чего управление ими полностью осуществляется операционной системой.
GIL в Python3 это булевская переменная `locked`, доступ к которой защищен мьютексом `mutex`, и при изменении которой в `false`, ОС «сигнализирует» какому-то потоку, который ожидает условную переменную `cond`.
#### Как это работает
В главном цикле (см. файл `ceval.c`) в зависимости от некоторых условий вызывается функция `eval_frame_handle_pending`, в которой, если установлена пременная `gil_drop_request`, текущий поток освобождает GIL, давая шанс другим потокам его захватить.
```
/* GIL drop request */
if (_Py_atomic_load_relaxed(&ceval2->gil_drop_request)) {
/* Give another thread a chance */
if (_PyThreadState_Swap(&runtime->gilstate, NULL) != tstate) {
Py_FatalError("tstate mix-up");
}
drop_gil(ceval, ceval2, tstate);
/* Other threads may run now */
take_gil(tstate);
if (_PyThreadState_Swap(&runtime->gilstate, tstate) != NULL) {
Py_FatalError("orphan tstate");
}
}
```
Переменная `gil_drop_request` устанавливается в функции `take_gil` (см. файл `ceval_gil.h`). Она устанавливается после ожидания потоком `interval` миллисекунд условной переменной `cond`. Этот приём не гарантирует, что через данный промежуток времени другой поток получит управление, так как некоторые атомарные операции могут выполняться гораздо дольше. **С другой стороны, гарантируется, что после установки переменной `gil_drop_request`, другой поток (кроме текущего) получит управление.**
```
while (_Py_atomic_load_relaxed(&gil->locked)) {
unsigned long saved_switchnum = gil->switch_number;
unsigned long interval = (gil->interval >= 1 ? gil->interval : 1);
int timed_out = 0;
COND_TIMED_WAIT(gil->cond, gil->mutex, interval, timed_out);
/* If we timed out and no switch occurred in the meantime, it is time
to ask the GIL-holding thread to drop it. */
if (timed_out &&
_Py_atomic_load_relaxed(&gil->locked) &&
gil->switch_number == saved_switchnum)
{
if (tstate_must_exit(tstate)) {
MUTEX_UNLOCK(gil->mutex);
PyThread_exit_thread();
}
assert(is_tstate_valid(tstate));
SET_GIL_DROP_REQUEST(interp);
}
}
```
В функции `drop_gil`, после установки переменной `locked` в `false`, «сигнализируется» условная переменная `cond`.
```
MUTEX_LOCK(gil->mutex);
_Py_ANNOTATE_RWLOCK_RELEASED(&gil->locked, /*is_write=*/1);
_Py_atomic_store_relaxed(&gil->locked, 0);
COND_SIGNAL(gil->cond);
MUTEX_UNLOCK(gil->mutex);
```
Для изменения значения `interval`, можно воспользоваться функцией `sys.setswitchinterval`. По умолчанию это значение равно 5 миллисекундам (можно получить через `sys.getswitchinterval`).
Если поток пишет в файл или работает с сетью (или выполняет ещё какие-то I/O операции), то в таких случаях GIL отпускается. Так же он не используется в реализации некоторых библиотек, таких как Numpy.
Визуализация
------------
#### Реализация
Добавим логирование в функции `take_gil` и `drop_gil` и счётчик `ATOMIC_COUNT`.
```
// В ceval.c
volatile int ATOMIC_COUNT = 0;
...
main_loop:
ATOMIC_COUNT++;
for (;;) {
...
// В ceval_gil.h
extern volatile int ATOMIC_COUNT;
...
static void
take_gil(PyThreadState *tstate)
{
...
while (_Py_atomic_load_relaxed(&gil->locked)) {
unsigned long saved_switchnum = gil->switch_number;
unsigned long interval = (gil->interval >= 1 ? gil->interval : 1);
int timed_out = 0;
COND_TIMED_WAIT(gil->cond, gil->mutex, interval, timed_out);
fprintf(stdout, "busy gil: %d %d %d\n", pthread_self(), ATOMIC_COUNT, interval);
...
}
...
fprintf(stdout, "take gil: %d %d\n", pthread_self(), ATOMIC_COUNT);
}
static void
drop_gil(struct _ceval_runtime_state *ceval, struct _ceval_state *ceval2,
PyThreadState *tstate)
{
...
fprintf(stdout, "drop gil: %d %d\n", pthread_self(), ATOMIC_COUNT);
}
```
Можно было бы сохранять данные в массиве и выводить в файл в конце работы скрипта, но в данной реализации логи выводяться на стандартный поток вывода сразу во время выполнения.
По оси абсцисс обозначены просто тики, а не время. Стоит заметить, что нет возможности показать, в какое время потоки вообще работают, так как их запуском и остановкой управляет ОС.
Зелёные полоски — расстояние (в тиках) от тика, когда поток взял управления, до тика, когда — отдал. Красные полоски — расстояние от тика, когда поток установил `gil_drop_request`, до тика, когда либо установил эту переменную повторно, либо взял управление.
**Пример сборки**
```
git clone https://github.com/python/cpython.git
mkdir debug_python
cd debug_python
../cpython/configure
make
cd ..
```
#### Примеры
1. Атомарные операции могут выполняться долго.
Запустим:
```
debug_python/python main.py --type="cpu-bound" 1>logs
python drawing.py
```
На рисунке ниже в узких полосках время выполнения больше 5 миллисекунд, из-за чего успевает выполнится только один тик (сортировка массива).
2. Не обязательно тот поток, что установил `gil_drop_request`, получит управление.
Запускаем аналогично.
В примере ниже главный поток ждёт 4 раза по около 5 миллисекунд, прежде чем получит управление.
3. Попробуем установить значение `interval` в 30 миллисекунд.
Запускаем аналогично.
**Код из main.py**
```
import sys
import threading
import random
import argparse
text = """
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque id mi tortor. Pellentesque habitant morbi
tristique senectus et netus et malesuada fames ac turpis egestas. Mauris arcu neque, tempor interdum magna non,
fringilla maximus ex. Proin a mollis elit. Nunc lacinia mollis sem, eget sodales ligula vulputate at. In euismod
elit vel mi suscipit, in pellentesque velit tempor. Nullam eleifend ornare risus ac ultricies. Nam interdum velit
sit amet eros dapibus euismod. Proin non orci imperdiet, interdum velit in, cursus justo. Nullam fringilla, tortor
quis sollicitudin pretium, erat felis porta odio, dictum sodales massa nisi id magna. Integer vitae ipsum ac lectus
imperdiet tristique ac a nibh. Interdum et malesuada fames ac ante ipsum primis in faucibus. Maecenas suscipit id mi
ac eleifend. Interdum et malesuada fames ac ante ipsum primis in faucibus.
"""
def func_cpu_bound(n):
for _ in range(n):
[random.randint(1, 1000000) for _ in range(10000)].sort()
def func_io_bound(n):
while n > 0:
with open(f"{threading.get_ident()}", "w") as f:
f.write(text)
n -= 1
def run_threads(type):
if type == "cpu-bound":
t1 = threading.Thread(target=func_cpu_bound, args=(10000000,))
t2 = threading.Thread(target=func_cpu_bound, args=(10000000,))
elif type == "io-bound":
t1 = threading.Thread(target=func_io_bound, args=(50,))
t2 = threading.Thread(target=func_io_bound, args=(50,))
t1.start()
t2.start()
t1.join()
t2.join()
def run_without_threads(type):
if type == "cpu-bound":
func_cpu_bound(10000000)
func_cpu_bound(10000000)
elif type == "io-bound":
func_io_bound(50)
func_io_bound(50)
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("-wt", "--without-threads", dest="without_threads", action="store_true")
parser.add_argument("-t", "--type", dest="type", choices=["cpu-bound", "io-bound"])
args = parser.parse_args()
return args
def main():
args = parse_args()
if args.without_threads:
run_without_threads(args.type)
else:
run_threads(args.type)
if __name__ == "__main__":
main()
```
**Код из drawing.py**
```
from collections import defaultdict
import matplotlib.pyplot as plt
import matplotlib.patches as patches
with open("logs", "r") as f:
fig, ax = plt.subplots(1, figsize=(20, 10))
lines = defaultdict(list)
for line in f:
if ":" not in line:
continue
name, tokens = line.split(":")
name = name.strip()
if "gil" in name:
ident, num_op, *other = tokens.strip().split()
ident = int(ident)
num_op = int(num_op)
lines[ident].append((num_op, name))
def get_color(name):
if name == "take gil":
return "g"
elif name == "busy gil":
return "r"
elif name == "drop gil":
return "y"
for idx, (key, items) in enumerate(lines.items()):
for i in range(len(items)):
if items[i][1] in ["take gil", "busy gil"]:
if i + 1 < len(items):
rect = patches.Rectangle((items[i][0], idx), items[i + 1][0] - items[i][0], 1, color=get_color(items[i][1]), fill=True)
ax.add_patch(rect)
else:
rect = patches.Rectangle((items[i][0], idx), num_op - items[i][0], 1, color=get_color(items[i][1]), fill=True)
ax.add_patch(rect)
plt.xlim(9950, num_op)
plt.ylim(0, 3)
plt.show()
```
Заключение
----------
В примерах видно, что все отрезки примерно равны, что позволяет предположить, что все эти отрезки примерно по 5 миллисекунд. Из чего следует, что в Python3 невозможна ситуация, когда один поток надолго захватит управление, как это было в Python2. И не считая ситуации с «длительными» атомарными инструкциями, в общем, каждый поток через небольшие промежутки времени «с большой вероятностью» снова будет получать квант времени. Выходит, что выполнение хоть и не параллельное, но всё же. | https://habr.com/ru/post/523944/ | null | ru | null |
# RAM with Simple direct-mapped cache simulation on FPGA in Verilog
Simple direct-mapped cache simulation on FPGA
=============================================
---
This article is a part of a course work for first year bachelor students of Innopolis University. All work is done in a team. The purpose of this article is to show an understanding of the topic, or to help to understand it using simulation.
---
[Git repository link](https://github.com/GamingJam/SimpleCache)
---
Principle of work but from the user side should look like:
* To write any data in memory, you need to access the RAM with data and address in which we want to write.
* To access the data, we have to adress to cache. If the cache cannot find the necessary data, then it accesses the RAM by copying data from there.
When working with Verilog, it should be understood that each individual block of the program is represented as a module. As you know, the cache is not an independent part of fast memory, and for its proper operation it needs to take data from another memory block — RAM. Therefore, in order to simulate the work of the cache at the FPGA, we have to simulate whole RAM module which includes cache as well, but the main point is cache simulation.
The implementation consists of such modules:
* ram.v — RAM memory module
* cache.v — Cache memory module
* cache\_and\_ram.v — module that operates with data and memory.
* testbench.v and testbench2.v — module to show that main modules work perfectly.
### RAM module:
**Code**
```
module ram();
parameter size = 4096; //size of a ram in bits
reg [31:0] ram [0:size-1]; //data matrix for ram
endmodule
```
**Description**Module represents memory which is used as RAM. It has 4096 32-bit addressable cells to store some data.
---
### Cache module:
**Code**
```
module cache();
parameter size = 64; // cache size
parameter index_size = 6; // index size
reg [31:0] cache [0:size - 1]; //registers for the data in cache
reg [11 - index_size:0] tag_array [0:size - 1]; // for all tags in cache
reg valid_array [0:size - 1]; //0 - there is no data 1 - there is data
initial
begin: initialization
integer i;
for (i = 0; i < size; i = i + 1)
begin
valid_array[i] = 6'b000000;
tag_array[i] = 6'b000000;
end
end
endmodule
```
**Description**So the cache contains more than just copies of the data in
memory; it also has bits to help us find data within the cache and
verify its validity.
---
### Cache and RAM module:
**Code**
```
module cache_and_ram(
input [31:0] address,
input [31:0] data,
input clk,
input mode, //mode equal to 1 when we write and equal to 0 when we read
output [31:0] out
);
//previous values
reg [31:0] prev_address, prev_data;
reg prev_mode;
reg [31:0] temp_out;
reg [cache.index_size - 1:0] index; // for keeping index of current address
reg [11 - cache.index_size:0] tag; // for keeping tag of ceurrent address
ram ram();
cache cache();
initial
begin
index = 0;
tag = 0;
prev_address = 0;
prev_data = 0;
prev_mode = 0;
end
always @(posedge clk)
begin
//check if the new input is updated
if (prev_address != address || prev_data != data || prev_mode != mode)
begin
prev_address = address % ram.size;
prev_data = data;
prev_mode = mode;
tag = prev_address >> cache.index_size; // tag = first bits of address except index ones (In our particular case - 6)
index = address % cache.size; // index value = last n (n = size of cache) bits of address
if (mode == 1)
begin
ram.ram[prev_address] = data;
//write new data to the relevant cache block if there is such one
if (cache.valid_array[index] == 1 && cache.tag_array[index] == tag)
cache.cache[index] = data;
end
else
begin
//write new data to the relevant cache's block, because the one we addressing to will be possibly addressed one more time soon
if (cache.valid_array[index] != 1 || cache.tag_array[index] != tag)
begin
cache.valid_array[index] = 1;
cache.tag_array[index] = tag;
cache.cache[index] = ram.ram[prev_address];
end
temp_out = cache.cache[index];
end
end
end
assign out = temp_out;
endmodule
```
**Description**Represents operations for work with data in memory modules. Gets input on each clock positive edge. Checks if there are new inputs — depending on the mode (1 for write/0 for read) executes relevant operations. If mode is 1(write):
•Write data to address then check whether input address exists in cache, if so — replace the data, else standstill.
If mode is 0(read):
•Check whether input address exists in cache, If so — return the data, else get the data from ram. Refresh the address in the cache with new data.
### Testbenches:
**Code1**
```
module testbench;
reg [31:0] address, data;
reg mode, clk;
wire [31:0] out;
cache_and_ram tb(
.address(address),
.data(data),
.mode(mode),
.clk(clk),
.out(out)
);
initial
begin
clk = 1'b1;
address = 32'b00000000000000000000000000000000; // 0
data = 32'b00000000000000000011100011000000; // 14528
mode = 1'b1;
#200
address = 32'b10100111111001011111101111011100; // 2816867292 % size = 3036
data = 32'b00000000000010000000100001010101; // 526421
mode = 1'b1;
#200
address = 32'b00000000000011110100011111010001; // 1001425 % size = 2001
data = 32'b00000001100000110001101100010110; // 25369366
mode = 1'b1;
#200
address = 32'b10100111111001011111101111011100; // 2816867292 % size = 3036
data = 32'b00000000000000000011100011000000; // 14528
mode = 1'b1;
#200
address = 32'b00000000000011110100011111010001; // 1001425 % size = 2001
data = 32'b00000000000000000011100011000000; // 14528
mode = 1'b1;
#200
address = 32'b00000000000011110100011111010001; // 1001425 % size = 2001
data = 32'b00000000000000000000000000000000; // 0
mode = 1'b0;
#200
address = 32'b10100111111001011111101111011100; // 2816867292 % size = 3036
data = 32'b00000000000000000000000000000000; // 0
mode = 1'b0;
#200
address = 32'b00000000000000000000000000000000; // 0
data = 32'b00000000000000000011100011000000; // 14528
mode = 1'b0;
end
initial
$monitor("address = %d data = %d mode = %d out = %d", address % 4096, data, mode, out);
always #25 clk = ~clk;
endmodule
```
**Code2**
```
module testbench2;
reg [31:0] address, data;
reg mode, clk;
wire [31:0] out;
cache_and_ram tb(
.address(address),
.data(data),
.mode(mode),
.clk(clk),
.out(out)
);
initial
begin
clk = 1'b1;
address = 32'b00000000000000000000000000000000; // 0
data = 32'b00000000000000000011100011000000; // 14528
mode = 1'b1;
#200
address = 32'b10100111111001011111101111011100; // 2816867292 % size = 3036
data = 32'b00000000000010000000100001010101; // 526421
mode = 1'b1;
#200
address = 32'b00000000000000000000000000000000; // 0
data = 32'b00000000000000000011100011000000; // 14528
mode = 1'b0;
#200
address = 32'b10100111111001011111101111011100; // 2816867292 % size = 3036
data = 32'b00000000000010000000100001010101; // 526421
mode = 1'b0;
#200
address = 32'b00000000000011110100011111010001; // 1001425 % size = 2001
data = 32'b00000001100000110001101100010110; // 25369366
mode = 1'b1;
#200
address = 32'b00000000000011110100011111010001; // 1001425 % size = 2001
data = 32'b00000001100000110001101100010110; // 25369366
mode = 1'b0;
#200
address = 32'b10100111111001011111101111011100; // 2816867292 % size = 3036
data = 32'b00000000000000000011100011000000; // 14528
mode = 1'b1;
#200
address = 32'b00000000000011110100011111010001; // 1001425 % size = 2001
data = 32'b00000000000000000011100011000000; // 14528
mode = 1'b1;
#200
address = 32'b00000000000011110100011111010001; // 1001425 % size = 2001
data = 32'b00000000000000000000000000000000; // 0
mode = 1'b0;
#200
address = 32'b10100111111001011111101111011100; // 2816867292 % size = 3036
data = 32'b00000000000000000000000000000000; // 0
mode = 1'b0;
end
initial
$monitor("address = %d data = %d mode = %d out = %d", address % 4096, data, mode, out);
always #25 clk = ~clk;
endmodule
```
**Description**To run a testbench, load all files into the ModelSim project and run a simulation of one of the testbench files. | https://habr.com/ru/post/432320/ | null | ru | null |
# Еще раз о Code Review
Не так давно сидел я делал ревью кода одного из коллег. Это было не первое мое ревью, но в этот раз я задался вопросом как все таки формализовать подход и на что конкретно стоит обращать внимание и как аргументировать и формулировать предложения и замечания. Сформулировал я для себя вот такие пункты:
### Соблюдение принципов SOLID
На всякий случай напомню, SOLID - это аббревиатура для 5 основных принципов ООП:
**S**ingle Responsibility Principle- принцип единой ответственности. Этот принцип говорит, что для класса должна быть определена единственная ответственность. Или еще его иногда формулируют как “для внесения изменений в класс должна быть только одна причина”
**O**pen Closed Principle - принцип открытости-закрытости. Этот принцип говорит, что программные сущности должны быть открыты для расширения, но закрыты для модификации.
**L**iskov Substitution Principle - принцип подстановки Барбары Лисков. Роберт Мартин формулирует этот принцип так: “Функции, которые используют базовый тип, должны иметь возможность использовать подтипы базового типа, не зная об этом.”
**I**nterface Segregation Principle - принцип разделения интерфейсов. Этот принцип говорит, что “много интерфейсов специального назначения лучше, чем один интерфейс общего назначения”.
**D**ependency Inversion Principle - принциц инверсии зависимостей. Этот принцип говорит, что абстракции не должны зависеть от реализаций, наоборот, реализации должны зависеть от абстракций.
### Отсутствие дурных запахов
Обычно выделяют около 20 запахов и в идеале бы, конечно, знать и отслеживать их все. Их все я здесь перечислять не буду, но вот наиболее часто встречающиеся и сильнее других бросающиеся в глаза:
* Его величество дублирование кода
* Магические числа
* Операторы типа switch
* Длинный метод
* Длинный список параметров
* Неинформативные имена переменных
Дурные запахи (не все) и принципы SOLID взаимосвязаны и иногда наличие запаха может сигнализировать о нарушении одного из принципов, к примеру дублирование кода может говорить о нарушении принципа единой ответственности. Однако, на мой взгляд все равно стоит оставлять комменты и о запахе и о нарушении.
### Правильное использование языка
Сюда я отнес использование условных языковых идиом, хороший практик и рекомендаций из документации. Приведу пару примеров. Я пишу на питоне, так что примеры тоже будут на питоне.
Использовать литеральную форму задания словаря, вместо циклов, когда это возможно:
```
chars = ['a', 'b', 'c']
# Bad
d = {}
for i in range(len(chars)):
d[i] = chars[i]
# Good
d = {i: char for i, char in enumerate(chars)}
```
Пример выше нужен лишь для иллюстрации, он искусственный и создать такой словарь можно конечно же по другому
Использовать подходящие методы встроенный типов:
```
colors_codes = {
'red': '#FF0000',
'green': '#008000'
}
white_name = 'white'
white_code = '#FFFFFF'
# Bad
if white_name not in colors_codes:
colors_codes[white_name] = white_code
print(colors_codes[white_name])
# Good
print(colors_codes.setdefault(white_name, white_code))
```
Использовать менеджеры контекста:
```
#Bad
...
fin = open(path, 'rt')
text = fin.read()
print(text)
...
# Good
...
with open(path) as fin:
text = fin.read()
print(text)
...
```
и т.д.
### Покрытие кода тестами
В этом пункте проверяю не количество тестов, а их качество: есть ли тесты для граничных случаев и есть ли непокрытые кейсы.
Конечно, есть и другие моменты, о которых можно задуматься: архитектура и вопросы производительности, к примеру, но их я еще не формализовал.
SOLID принципы конечно же не для всех случаев актуальны, да и с некоторыми запахами в определенных ситуациях можно не бороться. Пункты выше относятся к проектам, где они имеют смысл. | https://habr.com/ru/post/576826/ | null | ru | null |
# Мой восьмилетний квест по оцифровке 45 видеокассет. Часть 1
За последние восемь лет я перевозил эту коробку с видеокассетами в четыре разные квартиры и один дом. Семейные видеозаписи из моего детства.
Спустя более 600 часов работы я, наконец, оцифровал и нормально их организовал, так что кассеты можно выбросить.
#### **[Часть 2](https://habr.com/ru/company/dcmiran/blog/524738/)**
Вот как сейчас выглядит отснятый материал:
*Все семейные видео оцифрованы и доступны для просмотра с приватного медиасервера*
Получилось 513 отдельных видеоклипа. У каждого название, описание, дата записи, теги для всех участников с указанием возраста на момент записи. Всё лежит на приватном медиасервере, доступ к которому есть только у членов семьи, а хостинг стоит меньше 1 доллара в месяц.
Эта статья рассказывает обо всём, что я сделал, почему для этого понадобилось восемь лет — и как добиться аналогичного результата гораздо проще и быстрее.
Первая наивная попытка
======================
Примерно в 2010 году моя мама купила какой-то конвертер VHS в DVD и прогнала через него все наши домашние видео.
*Оригинальные DVD, которые записала мама (не знаю, что случилось с пропавшими буквами)*
Проблема в том, что мама сделала только один комплект DVD. Все родственники живут в разных штатах, так что было делало неудобно передавать диски по кругу.
В 2012 году сестра подарила мне эти DVD-диски. Я скопировал видеофайлы и выложил всё в облачное хранилище. Проблема решена!
*DVD-рипы семейных видео в хранилище Google Cloud*
Через несколько недель я спросил, смотрел ли кто эти записи. Оказалось, что никто не смотрел. Даже я не смотрел. В эпоху YouTube глупо скачивать трёхчасовые файлы неизвестного содержания в поисках интересных кадров.
Только моя мама обрадовалась: «Отлично, — сказала она, — теперь можно, наконец, выбросить все эти кассеты?»
Ой-ёй. Это страшный вопрос. А если мы пропустили какие-то записи? Что, если кассеты можно оцифровать с более высоким качеством? Что, если на этикетках важная информация?
Мне всегда было неудобно выбрасывать оригиналы, пока нет абсолютной уверенности, что видео скопировано с максимально возможным качеством. Таким образом, пришлось самому взяться за дело.
Я даже не подозревал, во что ввязываюсь.
Звучит не так уж и сложно
=========================
Если вы не понимаете, почему это заняло у меня восемь лет и сотни часов, я вас не виню. Я тоже думал, что всё будет легко.
Вот как выглядит процесс оцифровки от начала до конца:
Точнее, так он выглядит в теории. Вот как получилось на практике:
Большую часть времени заняли переделки уже сделанного. Я заканчивал один этап, а потом через один или два этапа находил какой-то недостаток в технике. Приходилось возвращаться и переделывать. Например, я снял видео с 20 лент, прежде чем понял, что звук немного не синхронизирован. Или после нескольких недель редактирования обнаружил, что экспортирую видео в формате, который не поддерживает стриминг в интернете.
Чтобы сохранить рассудок читателя, я излагаю процесс так, будто он планомерно двигался вперед, чтобы не заставлять вас постоянно отпрыгивать назад и всё переделывать, как приходилось мне.
Шаг 1. Захват видео
===================
Ладно, вернёмся в 2012 год. Маме очень хотелось выбросить кассеты, которые она хранила двадцать лет, поэтому при первой встрече она сразу вручила мне огромную картонную коробку. Так начался мой квест по оцифровке.
Очевидным решением было поручить работу профессионалам. Множество компаний занимаются оцифровкой, а некоторые специализируются именно на домашнем видео.
Но я довольно чувствительно отношусь к приватности и мне не хотелось, чтобы незнакомые люди рассматривали наше семейное видео с интимными моментами личной жизни, включая моё обучение горшку (в соответствующем возрасте; ничего странного!). И ещё я думал, что в оцифровке нет ничего сложного.
Спойлер: это оказалось действительно трудно.
### Первая попытка захвата видео
У отца всё ещё хранился старый семейный видеомагнитофон, поэтому я попросил к следующему семейному ужину откопать его из подвала. Я купил [дешёвый адаптер RCA-USB](https://www.amazon.com/gp/product/B00M7T8T1E/) на Amazon и приступил к делу.
*[Устройство захвата видео TOTMC](https://www.amazon.com/gp/product/B00M7T8T1E/), первое из множества устройств A/V, которые я купил во время многолетнего квеста*
Для обработки видео с устройства захвата USB я использовал программу VirtualDub, версия 2012 года немного устарела, но не критично.
*Кадры в программе VirtualDub, как я в возрасте четырёх лет читаю книгу своему отцу*
### Напасть с искажением звука
Когда я начал процесс редактирования, то заметил небольшой рассинхрон аудио и видео. Ладно, без проблем. Я могу немного сдвинуть звук.
Через десять минут он снова рассинхронизировался. Разве я мало сдвинул его в первый раз?
До меня постепенно дошло, что аудио и видео не просто рассинхронизированы, они реально записываются с разной скоростью. На протяжении всей ленты они расходятся всё больше и больше. Для синхронизации приходилось вручную настраивать звук каждые несколько минут.
*Если ваша установка захватывает звук и видео с разной скоростью, то единственным решением является коррекция звука вручную каждые несколько минут*
Представляете, как трудно отличить звук на 10 миллисекунд раньше или на 10 миллисекунд позже? Это действительно трудно! Судить сами.
На этом видео я играю со своим бедным, терпеливым котёнком, которого звали Black Magic. Звук немного не синхронизирован. Определите, он опережает картинку или идёт с опозданием?
*Пример видеоклипа с рассинхроном звука и картинки*
В этом месте Black Magic прыгает, фрагмент с замедлением в пять раз:
*Рассинхрон звука и картинки, замедление в пять раз*
> **Ответ**: звук идёт с опозданием в несколько миллисекунд.
### Может, потратить лишнюю сотню долларов вместо сотен часов личного времени?
Одна только коррекция звука потребовала многих часов утомительной, сводящей с ума работы. В конце концов мне пришло в голову, что можно избежать рассинхрона, если использовать более качественное и дорогое устройство видеозахвата. После некоторого исследования я купил новое на Amazon:
*Моя вторая попытка приобрести [устройство для видеозахвата](https://www.amazon.com/gp/product/B00428BF1Y/)*
Даже с новым устройством рассинхрон никуда не исчез.
### Видеомагнитофон с приставкой «супер»
Может, проблема в видеомагнитофоне. На [форумах по оцифровке](http://www.digitalfaq.com/guides/video/capture-playback-hardware.htm) говорили, что рассинхрона не будет на видеомагнитофоне с «корректором времени» (time-based corrector, TBC), эта функция есть на всех видеомагнитофонах Super VHS (S-VHS).
Ну конечно! Зачем я возился с дурацким *обычным* видеомагнитофоном, когда есть **супер**-VCR, который решает проблему?
Никто уже не производит видеомагнитофоны S-VHS, но они по-прежнему доступны на eBay. За 179 долларов я купил модель JVC SR-V10U, которая вроде хорошо подходит для оцифровки VHS:
*Винтажный видеомагнитофон JVC SR-V10U, который я купил на eBay за 179 долларов*
«Супер»-видеомагнитофон пришёл по почте. После нескольких месяцев борьбы с рассинхроном звука я был вне себя от радости, что появилось оборудование, которое решит все мои проблемы.
Я открыл коробку, всё подключил — но звук по-прежнему записывался с другой скоростью. Эх.
### Утомительный поиск, устранение неисправностей и многолетняя борьба
Я приступил к жалким попыткам устранить неполадки. На это было больно смотреть. Каждый раз я вытаскивал всё оборудование из шкафа, заползал на коленях за рабочий стол, чтобы всё подключить, пытался захватить видео — и опять наблюдал, что ничего не получается.
Вот мне попался случайный пост на форуме от 2008 года, где говорится об установке какого-то странного китайского драйвера без подписи… Это ужасная идея, но я в отчаянии. Впрочем, он не помог.
Я пробовал разные программы для оцифровки. Купил [специальную кассету VHS](https://smile.amazon.com/gp/product/B000001ON6), чтобы прочистить магнитные головки видеомагнитофона. Купил [третье устройство видеозахвата](https://www.amazon.com/gp/product/B00EAS14KI/). Ничего не помогло.
Я неизменно сдавался, всё отключал и прятал оборудование в шкаф ещё на несколько месяцев.
### Сдаёмся и отдаём кассеты профессионалам
Наступил 2018 год. Я перетаскал видеокассеты и тонны оборудования по четырём разных квартирам и собирался переехать из Нью-Йорка в Массачусетс. Я не мог найти силы снова их везти, потому что уже понял, что самостоятельно никогда не закончу этот проект.
Я спросил семью, можно ли отдать кассеты в фирму по оцифровке. К счастью, никто не возражал — всем хотелось снова увидеть записи.
> **Я**: Но это значит, что какая-то компания получит доступ ко всем нашим домашним видео. Тебя это устраивает?
>
> **Сестра**: Да мне по барабану. Тебя одного это беспокоит. Погоди, так ты с самого начала мог просто заплатить кому-то?
>
> **Я**: Э-э-э...
Оцифровка всех 45-ти кассет стоит $750. Кажется дорого, но к тому моменту я бы заплатил сколько угодно, лишь бы больше не разбираться с этим оборудованием.
Когда они отдали файлы, качество видео было однозначно лучше. На моих кадрах всегда были видны искажения на краях кадра, но специалисты всё оцифровали вообще без искажений. Самое главное, что аудио и видео идеально синхронизированы.
Вот видео со сравнением профессиональной оцифровки и моих доморощенных попыток:
*Сравнение профессиональной и самодельной оцифровки в видеоролике, где мама снимает мою первую попытку программирования*
Шаг 2. Редактирование
=====================
В домашних съёмках около 90% материала скучны, 8% интересны, а 2% потрясающие. После оцифровки у вас ещё много работы.
### Редактирование в Adobe Premiere
На кассете VHS длинный поток видеоклипов перемежается пустыми участками. Чтобы отредактировать ленту, вы должны определить, где начинается и заканчивается каждый клип.
Для редактирования я использовал Adobe Premiere Elements, которая стоит меньше $100 за пожизненную лицензию. Его важнейшая фича — масштабируемая временная шкала. Она позволяет быстро найти границы сцены, а затем увеличить масштаб, чтобы найти точный видеокадр, где начинается или заканчивается клип.
*Важнейшая временная шкала с масштабированием в Adobe Premiere Elements*
Проблема с Premiere заключается в том, что процесс требует постоянных действий вручную, но при этом оцифровка и экспорт занимают много времени. Вот моя последовательность операций:
1. Открыть сырой файл, который содержит 30-120 минут видео.
2. Отметить границы отдельного клипа.
3. Экспортировать клип.
4. Подождать 2-15 минут, пока завершится экспорт.
5. Повторять шаги 2-4, пока не закончится лента.
Долгое ожидание означало, что я постоянно переключался между редактированием видео и какой-то другой задачей, переводя внимание туда-сюда в течение нескольких часов.
Другим недостатком была невоспроизводимость. Исправить небольшую ошибку было почти так же трудно, как сделать всё с нуля. Это сильно ударило по мне, когда дело дошло до публикации видео. Только тогда я понял, что для стриминга в интернете нужно было изначально экспортировать видео в формат, который нативно поддерживают веб-браузеры. Передо мной встал выбор: перезапустить утомительный процесс экспорта сотен клипов или перекодировать экспортированные видео в другой формат с ухудшением качества.
### Автоматизация редактирования
После кучи времени, потраченного на ручную работу, я подумал, можно ли здесь как-то применить ИИ. Кажется, определение границ клипов — подходящая задача для машинного обучения. Я знал, что точность будет не идеальной, но пусть он выполнит хотя бы 80% работы, а я исправлю последние 20%.
Я экспериментировал с инструментом под названием [pyscenedetect](https://pyscenedetect.readthedocs.io/en/latest/), который анализирует видеофайлы и выдаёт временные метки, где происходят изменения сцены:
```
$ docker run \
--volume "/videos:/opt" \
handflucht/pyscenedetect \
--input /opt/test.mp4 \
--output /opt \
detect-content --threshold 80 \
list-scenes
[PySceneDetect] Output directory set:
/opt
[PySceneDetect] Loaded 1 video, framerate: 29.97 FPS, resolution: 720 x 480
[PySceneDetect] Downscale factor set to 3, effective resolution: 240 x 160
[PySceneDetect] Scene list CSV file name format:
$VIDEO_NAME-Scenes.csv
[PySceneDetect] Detecting scenes...
[PySceneDetect] Processed 55135 frames in 117.6 seconds (average 468.96 FPS).
[PySceneDetect] Detected 33 scenes, average shot length 55.7 seconds.
[PySceneDetect] Writing scene list to CSV file:
/opt/test-Scenes.csv
[PySceneDetect] Scene List:
-----------------------------------------------------------------------
| Scene # | Start Frame | Start Time | End Frame | End Time |
-----------------------------------------------------------------------
| 1 | 0 | 00:00:00.000 | 1011 | 00:00:33.734 |
| 2 | 1011 | 00:00:33.734 | 1292 | 00:00:43.110 |
| 3 | 1292 | 00:00:43.110 | 1878 | 00:01:02.663 |
| 4 | 1878 | 00:01:02.663 | 2027 | 00:01:07.634 |
...
```
Инструмент действительно показал точность около 80%, но проверка его работы заняла больше времени, чем он сэкономил. Тем не менее, pyscenedetect сделал одно из самых важных открытий для всего проекта: определение границ сцены и экспорт клипов — это отдельные задачи.
### Я вспомнил, что я программист
До этого момента я считал «редактированием» всё, что делал в Adobe Premiere. Вырезание клипов из необработанных кадров казалось неразрывно связанным с поиском границ клипа, потому что именно так Premiere представлял эту задачу. Когда pyscenedetect распечатал таблицу метаданных, это заставило меня понять, что я могу отделить поиск сцен от экспорта видео. Это был прорыв.
Причина, по которой редактирование было таким утомительным и трудоёмким, заключалась в том, что мне приходилось ждать, пока Premiere экспортирует каждый клип. Если бы я записал метаданные в электронную таблицу и написал скрипт, который автоматически экспортирует видео, процесс редактирования пролетел бы незаметно.
Более того, электронные таблицы значительно расширили объём метаданных. Изначально я впихивал метаданные в название файла, но это их ограничивает. Наличие целой электронной таблицы позволило каталогизировать гораздо больше сведений о клипе, например, кто в нём присутствует, когда он записан и любые другие данные, которые я хочу показать во время демонстрации видео.
[](https://mtlynch.io/digitizing-1/spreadsheet.png)
*Гигантская электронная таблица с метаданными о моих домашних видео*
Позже я смог использовать эти метаданные, чтобы добавить информацию к клипам, например, сколько нам всем было лет и подробное описание того, что происходит в клипе.
*Функциональность электронных таблиц позволяет записывать метаданные, которые дают больше информации о клипах и облегчают их просмотр*
### Успех автоматизированного решения
Имея электронные таблицы, я написал [скрипт](https://github.com/mtlynch/process-home-videos), который нарезал сырое видео на клипы на основе данных в CSV.
Вот запись как это выглядит в действии:
К этому моменту я потратил **сотни** часов, нудно выбирая границы клипа в Premiere, нажимая экспорт, ожидая несколько минут, чтобы он закончился, а затем всё сначала. Мало того, процесс повторялся несколько раз на одних и тех же клипах, когда позже обнаруживались проблемы с качеством.
Как только я автоматизировал часть нарезки на клипы, с моих плеч свалился огромный груз. Больше не нужно было беспокоиться, что я забуду метаданные или выберу неправильный формат вывода. Если позже вылезет ошибка, можно просто подправить скрипт и всё повторить.
[Часть 2](https://habr.com/ru/company/dcmiran/blog/524738/)
===========================================================
Оцифровка и редактирование видеоматериалов — только половина дела. Нам ещё нужно найти удобный вариант публикации в интернете, чтобы все родственники смотрели семейное видео в удобном формате со стримингом как на YouTube.
Во второй части статьи я подробно расскажу, как поднять опенсорсный медиасервер со всеми видеоклипами, который стоит мне всего 77 центов в месяц.
Продолжение, #### **[Часть 2](https://habr.com/ru/company/dcmiran/blog/524738/)**
---
[](http://miran.ru/) | https://habr.com/ru/post/524724/ | null | ru | null |
# Функции для документирования баз данных PostgreSQL. Часть третья
Это третья часть статьи, которая описывает пользовательские функции для работы с системными каталогами: pg\_class, pg\_attribute, pg\_constraints и т.д.
В этой части статьи обсуждаются функции, возвращающие **характеристики последовательностей, унаследованных таблиц**, а также **особенные характеристики атрибутов таблиц**.
**Смотрите также**
**[Функции для документирования баз данных PostgreSQL. Часть первая](https://habr.com/post/415575/);**
**[Функции для документирования баз данных PostgreSQL. Часть вторая](https://habr.com/post/415897/);**
**[Функции для документирования баз данных PostgreSQL. Окончание(часть четвертая)](https://habr.com/post/419749/).**
В первой половине статьи изложены комментарии к реализации функций. Во второй- исходные тексты функций. Тем из читателей, кого интересуют только исходные тексты, предлагаем сразу перейти к [Приложению](#Script2).
### Структура функции, возвращающей список характеристик последовательностей таблицы
*Рис. 2. Функции, от которых зависит admtf\_Table\_Sequences функции*
**Таблица 11. Назначение функций.**
| № | Название | Назначение |
| --- | --- | --- |
| 1 | admtf\_Sequence\_Features | Функция возвращает список характеристик последовательности таблицы |
| 2 | admtf\_Table\_Sequences | Функция возвращает список последовательностей таблицы базы данных и их характеристик |
### Функция **admtf\_Sequence\_Features** — список характеристики последовательности базы данных
Функция admtf\_Sequence\_Features возвращает список характеристик последовательности (SEQUENCE) базы данных. [Исходный код можно посмотреть и скачать здесь](#tfSeqF).
Функция **admtf\_Sequence\_Features** возвращает список характеристик последовательности (**SEQUENCE**) базы данных
.
В качестве параметров функция принимает название последовательности (**a\_SequenceName**) и название схемы, в пределах которой последовательность создана (**a\_SchemaName**).
Необходимость в функции **admtf\_Sequence\_Features** возникла из-за того, что основные характеристики последовательности хранятся фактически в таблице, название которой совпадает с названием последовательности, а данные из нее извлекаются с помощью оператора **SELECT**. При этом название последовательности, название схемы и комментарий к последовательности хранятся в каталогах **pg\_class**, **pg\_namespace** и **pg\_description**.
```
SELECT * FROM kr_road_network_vertices_pgr_id_seq;
```
***Замечание 6***
В 10 версии **PostgreSQL** разделили характеристики последовательности и характеристики ее состояний. Для этого введен каталог **pg\_sequence** с характеристиками последовательности, содержащий начальное значение (**start\_value**), приращение (**increment\_by**) и максимальное значение(**max\_value**) последовательности. Последнее возвращенное последовательностью значение (**last\_value**) так и оставили в «таблице» с названием последовательности.
**Конец замечания.**
Представление каждой последовательности в виде аналога таблицы, думаю, продиктовано необходимостью хранения последнего использованного значения последовательности (**last\_value**), которое является характеристикой состояния последовательности, но не последовательности как таковой.
Запись о последовательности в каталоге **pg\_class** отличается от записи о таблице значением вида отношения (relkind='S').
Для того, чтобы извлекать характеристики произвольной последовательности, приходится использовать динамический SQL.
```
EXECUTE 'SELECT last_value,start_value,increment_by,max_value FROM '||
LOWER(a_SchemaName)||'.'||LOWER(a_SequenceName)
INTO v_SequenceLastValue,v_SequenceStartValue,
v_SequenceIncrementBy,v_SequenceMaxValue ;
```
**Таблица 12. Результат выполнения функции admtf\_Sequence\_Features('public','kr\_road\_network\_vertices\_pgr\_id\_seq').**
| Название | Комментарий | Текущее | Начало | Приращение | Конец |
| --- | --- | --- | --- | --- | --- |
| kr\_road\_network
\_vertices\_pgr\_id
\_seq | Последо-вательность | 138023 | 1 | 1 | 9223372036854775807 |
### Функция admtf\_Table\_Sequences список последовательностей таблицы базы данных и их характеристик
Функция **admtf\_Table\_Sequences** возвращает список последовательностей (**SEQUENCE**) таблицы базы данных, генерирующих значения ее полей, и характеристики этих последовательностей.[Исходный код можно посмотреть и скачать здесь](#tfTableS), а [здесь приведена версия функции, в которой не используется курсор](#tfTableS_woc).
В качестве параметров функция принимает название исходной таблицы (**a\_TableName**) и название схемы, в пределах которой создана таблица (
a\_SchemaName
).
**исходный код оператора на рисунке**
```
SELECT pseq.relname AS SequenceName,snsp.nspname AS SequenceSchemaName,
COALESCE(dsc.description,'Последовательность, генерирующая значения поля '
||da.attname) AS SequenceDescription,
d.depType AS DependcyType,da.attname AS AttributeName
FROM pg_depend d
INNER JOIN pg_class pseq ON d.objid = pseq.oid
INNER JOIN pg_namespace snsp ON pseq.relnamespace=snsp.oid
LEFT OUTER JOIN pg_Description dsc ON pseq.oid=dsc.objoid
AND dsc.objsubid=0
INNER JOIN pg_class tbl ON d.refobjid = tbl.oid
INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid
INNER JOIN pg_attribute da ON da.attrelid= d.refobjid
AND da.attnum= d.refobjsubid
WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName)
AND LOWER(tbl.relname)=LOWER(a_TableOID)
AND tbl.relkind = 'r' AND pseq.relkind = 'S'
ORDER BY pseq.relname;
```
Описание отдельной последовательности представляет собой совокупность записи в **pg\_class**, описывающей его как физическое отношение, и условной таблицы с названием последовательности, содержащей данные о специфических характеристиках последовательности
Информация о связи последовательности и исходной таблицы хранится в системном каталоге **pg\_depend**.
**Таблица 13. Атрибуты каталога**pg\_depend**, необходимые для реализации функции.**
| Название | Описание |
| --- | --- |
| objid | OID последовательности в каталоге pg\_class |
| objsubid | Это поле содержит ноль |
| refobjid | OID таблицы, в заполнении полей которой используется последовательность |
| refobjsubid | Номер атрибута таблицы, значения которого заполняются с помощью последовательности |
Дополнительно функция обращается к данным каталогов **pg\_namespace** и **pg\_description**, для того чтобы извлечь схемы и комментарии как последовательности, так и исходной таблице.
Для определения атрибута таблицы, значения которой заполняются при помощи последовательности, функция обращается к каталогу **pg\_attribute** по условию: **attrelid= refobjid AND attnum= refobjsubid**. (В этом условии справа от знака равенства указаны названия атрибутов каталога **pg\_depend**).
Специальные характеристики последовательностей таблицы извлекаются в цикле вызовом функции **admtf\_Sequence\_Features**. Цикл применяется потому, что для заполнения полей таблицы может быть назначено более одной последовательности.
**Таблица 14. Результат выполнения функции admtf\_Table\_Sequences ('public','kr\_road\_network\_vertices\_pgr').**
| Название | Комментарий | Начало | При- ращение | Конец | Поле |
| --- | --- | --- | --- | --- | --- |
| kr\_road\_network
\_vertices\_pgr\_id
\_seq | Последователь-ность, генерирующая значения поля id | 1 | 1 | 9223372036854775807 | id |
#### Версия без курсора
В среде **PostgreSQL**, версия которой меньше 10, реализовать функцию **admtf\_Table\_Sequences** без использования курсора, скорее всего, невозможно.
Но счастливые обладатели 10 версии вполне могут обойтись без курсора, т.к. в их распоряжении есть каталог **pg\_sequence**. В этом случае все характеристики последовательности можно извлечь одним оператором **SELECT**.
В приведенной реализации функции с помощью оконной функции **RANK() OVER (PARTITION BY pseq.relname)** вычисляется порядковый номер последовательности, используемой для заполнения исходной таблицы.
**исходный код оператора на рисунке**
```
SELECT RANK() OVER (PARTITION BY pseq.relname) AS SequenceNo,
pseq.relname AS SequenceName,snsp.nspname AS SequenceSchemaName,
COALESCE(dsc.description,'Последовательность, генерирующая значения поля '
||da.attname) AS SequenceDescription,
seq.seqstart AS SequenceStartValue,seq.seqincrement AS SequenceIncrementBy,
seq.seqmax AS SequenceMaxValue,
d.depType AS DependcyType,da.attname AS AttributeName
FROM pg_depend d
INNER JOIN pg_class pseq ON d.objid = pseq.oid
INNER JOIN pg_sequence seq ON seq.seqrelid= pseq.oid
INNER JOIN pg_namespace snsp ON pseq.relnamespace=snsp.oid
LEFT OUTER JOIN pg_Description dsc ON pseq.oid=dsc.objoid
AND dsc.objsubid=0
INNER JOIN pg_class tbl ON d.refobjid = tbl.oid
INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid
INNER JOIN pg_attribute da ON da.attrelid= d.refobjid
AND da.attnum= d.refobjsubid
WHERE LOWER(nsp.nspname)=LOWER(a_SchemaName)
AND LOWER(tbl.relname)=LOWER(a_TableOID)
AND tbl.relkind = 'r' AND pseq.relkind = 'S'
ORDER BY pseq.relname;
```
**Замечание 7**
.
Эта версия функции не возвращает последнее сгенерированное последовательностью значение (**last\_value**).
**Конец замечания.**
### Функция admtf\_Table\_InheritanceChildrens – список характеристик унаследованных таблиц
Функция **admtf\_Table\_InheritanceChildrens** возвращает список характеристик унаследованных таблиц (**INHERITS**) таблицы базы данных. [Исходный код можно посмотреть и скачать здесь](#tfTableIC).
В качестве параметров функция принимает название исходной таблицы (**a\_TableName**) и название схемы, в пределах которой создана таблица (**a\_SchemaName**).
Описание отдельной унаследованной таблицы находится в записи в **pg\_class**. Но для поиска унаследованных таблиц по названию исходной таблицы приходится использовать системный каталог **pg\_depend**.
**Таблица 15. Атрибуты каталога**pg\_depend**, необходимые для реализации функции.**
| Название | Описание |
| --- | --- |
| objid | OID унаследованной таблицы в каталоге pg\_class |
| refobjid | OID исходной таблицы |
**исходный код оператора на рисунке**
```
SELECT rtbl.relname,rnspc.nspname,rdsc.description,rtbl.relnatts::INTEGER,
rtbl.relchecks::INTEGER,
rtbl.relhaspkey,rtbl.relhasindex,rtbl.relhassubclass,
rtbl.reltuples::INTEGER
FROM pg_class tbl
INNER JOIN pg_namespace nspc ON tbl.relnamespace = nspc.oid
LEFT OUTER JOIN pg_Description dsc ON tbl.oid=dsc.objoid
AND dsc.objsubid=0
INNER JOIN pg_depend dp ON tbl.oid=dp.refobjid
INNER JOIN pg_class rtbl ON rtbl.OID=dp.objid
INNER JOIN pg_namespace rnspc ON rtbl.relnamespace = rnspc.oid
LEFT OUTER JOIN pg_Description rdsc ON rtbl.oid=rdsc.objoid
AND rdsc.objsubid=0
WHERE LOWER(nspc.nspname)=LOWER(a_SchemaName)
AND LOWER(tbl.relname)=LOWER(a_TableOID)
AND tbl.relkind = 'r' AND rtbl.relkind = 'r'
ORDER BY rtbl.relname;
```
Дополнительно функция обращается к данным каталогов **pg\_namespace** и **pg\_description**, для того чтобы извлечь схемы и комментарии как к унаследованным, так и к исходной таблице.
**Таблица 16. Результат выполнения функции admtf\_Table\_InheritanceChildrens ('public','np\_house').**
| Название | Комментарий | Атрибуты | ? первичный ключ | ? индексы | ? потомки | Число записей |
| --- | --- | --- | --- | --- | --- | --- |
| np\_house 04201 000000 | Дома в населенных пунктах (Ачинский район) | 15 | f | f | f | 5651 |
| np\_house 4208 000000 | Дома в населенных пунктах (Боготольский район) | 15 | f | f | f | 4314 |
Количество записей в порожденной таблицы выбирается из атрибута reltuple каталога **pg\_class**. И хотя это значение часто в точности совпадает с действительным числом записей в таблице, все же это оценочное значение. А значит может возникнуть желание получить в результате точное значение. Например, так как показано на рисунке.
```
EXECUTE 'SELECT COUNT(*) FROM '||LOWER(a_SchemaName)||'.'||LOWER(a_TableName)
INTO v_TableNumberOfRowCalc;
```
Но, во-первых, для того чтобы выполнить это утверждение в тексте функция **admtf\_Table\_InheritanceChildrens** придется использовать курсор.
Во-вторых, хотелось бы, чтобы функция позволяла выводить как оценочное, так и точное количество записей таблицы.
Поэтому функция имеет еще одни необязательный параметр – режим получения количества записей таблицы (**a\_Mode**), который принимает значения «оценочно» (estimate) или «точно» (exactly).
Дополнительно создана функция [admfn\_Table\_RowCount](#fnTableRC), возвращающая точное число записей таблицы, а в списке возвращаемых значений **SELECT** атрибут reltuple заменен следующей конструкцией.
**исходный код оператора на рисунке**
```
CASE WHEN a_Mode = 'exactly' THEN admfn_Table_RowCount(rnspc.nspname,rtbl.relname)
ELSE reltuples END
```
В результате функция возвращает оценочное значение показателя «число записей таблицы», если параметром **a\_Mode** не задано требование возвращать точное значение.
### Структура функции, возвращающей список характеристик атрибута таблицы
*Рис. 3. Функции, которые вызывает admtf\_Attribute\_Features*
**текстовая версия таблицы на рисунке****Таблица 17. Назначение функций.**
| № | Название | Назначение |
| --- | --- | --- |
| 1 | admtf\_Attribute\_PKFeatures | Функция возвращает признак присутствия атрибута в первичном ключе (PRIMARY KEY), а также некоторые его характеристики в качестве части этого ключа. |
| 2 | admtf\_Attribute\_FKFeatures | Функция возвращает признак присутствия атрибута во внешнем ключе ключе (FOREIGN KEY), а также некоторые его характеристики в качестве части этого ключа. |
| 3 | admtf\_Attribute\_Features | Функция возвращает список характеристик атрибута таблицы. |
### Функция **admtf\_Attribute\_PKFeatures** — — присутствует ли атрибут в первичном ключе
Функция **admtf\_Attribute\_PKFeatures** возвращает признак присутствия атрибута таблицы в первичном ключе (PRIMARY KEY) таблицы, и, если он присутствует, каков его порядковый номер в этом ключе, т.к. первичный ключ может быть составным.
[Исходный код можно посмотреть и скачать здесь](#tfAttPK).
В качестве параметров функция принимает OID исходной таблицы (**a\_TableOID**) и порядковый номер искомого атрибута в ней (**a\_AttributeNo**).
Нужные данные функция извлекает из записи каталога **pg\_constraint**, содержащей ограничения (CONSTRAINT) исходной таблицы, в том числе, ограничение первичного ключа. OID искомой таблицы хранится в поле **conrelid**, описание первичного ключа хранится в записи, в которой поле contype содержит значение ''p'
.
```
SELECT INTO v_PKAttributeList,rs_isAttributePK conkey,ARRAY[a_AttributeNo]<@conkey
FROM pg_constraint c
WHERE c.contype='p' AND c.conrelid=a_TableOID;
```
Поле **conkey**, найденной таким образом записи, содержит массив порядковых номеров атрибутов, которые составляют первичный ключ. Поэтому, для того чтобы проверить присутствие исходного атрибута в первичном ключе, достаточно вычислить логическое выражение **ARRAY[a\_AttributeNo]<@conkey**.
Если атрибут присутствует в первичном ключе, то далее в цикле вычисляется его порядковый номер.
### Функция **admtf\_Attribute\_FKFeatures** -присутствует ли атрибут во внешнем ключе
Функция **admtf\_Attribute\_FKFeatures** возвращает признак присутствия атрибута таблицы в одном или нескольких внешних ключах (FOREIGN KEY) таблицы, и, если он присутствует, каковы его порядковые номера в этих ключах, т.к. внешний ключ может быть составным.
[Исходный код можно посмотреть и скачать здесь](#tfAttFK).
В качестве параметров функция принимает OID исходной таблицы (**a\_TableOID**) и порядковый номер искомого атрибута в ней (**a\_AttributeNo**).
Нужные данные функция извлекает из записи каталога **pg\_constraint**, содержащей ограничения (CONSTRAINT) исходной таблицы, в том числе, в том числе, ограничения внешних ключей. OID искомой таблицы хранится в поле **conrelid**, описание первичного ключа хранится в записи, в которой поле contype содержит значение ''f'
.
```
SELECT * FROM pg_constraint c
WHERE c.contype='f ' AND c.conrelid=a_TableOID AND ARRAY[a_AttributeNo]<@conkey
ORDER BY c.oid;
```
Поле **conkey**, найденной таким образом записи, содержит массив порядковых номеров атрибутов, которые составляют внешний ключ. Поэтому, для того чтобы проверить присутствие исходного атрибута во внешнем ключе, достаточно вычислить логическое выражение **ARRAY[a\_AttributeNo]<@conkey**.
Если атрибут присутствует во внешнем ключе, то далее в цикле формируется массив его порядковых номеров в содержащих его внешних ключах. Дополнительно формируется еще два массива из наименований таблиц и их атрибутов, на которые ссылается исходный атрибут в содержащих его внешних ключах.
Наименования таблиц извлекаются из записи каталога **pg\_class** по идентификатору (OID) извлеченному из поля confrelid записи о внешнем ключе.
Для получения наименования атрибута внешней таблицы используется массив порядковых номеров из поля
confkey
(он отличается о рассмотренного выше массива буквой «**f**» в названии). Из этого массива извлекается порядковый номер атрибута внешней таблицы, которому соответствует внешний атрибут. По этому порядковому номеру атрибута внешней таблицы и ее OID, находится в каталоге pg\_attribute находится записи о описание атрибута и извлекается его название.
### Функция **admtf\_Attribute\_Features** — список характеристик атрибута таблицы
Функции **admtf\_Attribute\_Features** возвращает список следующих характеристик атрибута таблицы.[Исходный код можно посмотреть и скачать здесь](#tfAttF).
**Текстовая версия таблицы на рисунке**
| № | Название | Тип | Назначение |
| --- | --- | --- | --- |
| 1 | AttributeName | name | Название исходного атрибута. |
| 2 | UserTypeName | VARCHAR(256) | Пользовательский тип исходного атрибута |
| 3 | TypeName | VARCHAR(256) | Базовый тип исходного атрибута |
| 4 | isNotNULL | BOOLEAN | ? Допустимость значения NULL |
| 5 | isAttributePK | BOOLEAN | ? участие в PK |
| 6 | ColumnPKNo | SMALLINT | Порядковый номер атрибута в PK |
| 7 | Description | TEXT | Комментарий к исходному атрибуту |
| 8 | isAttributeFK | BOOLEAN | ? участие в FK |
| 9 | FKeyName | name[] | Массив названий ограничений таблицы, в которых определен внешний ключ |
| 10 | ColumnFKNo | SMALLINT[] | Массив порядковых номеров атрибута во внешних ключах таблицы |
| 11 | FKTableName | name[] | Массив таблиц, на которые ссылаются внешние ключи |
| 12 | FKTableColumnName | name[] | Массив названий атрибутов в внешних таблицах, соответствующих исходному атрибуту |
В качестве параметров функция принимает OID исходной таблицы (**a\_TableOID**) и порядковый номер искомого атрибута в ней (**a\_AttributeNo**).
Значения полей **AttributeName** и **isNotNULL** извлекаются из записи каталога **pg\_attribute**, соответствующей значениям входных параметров.
```
SELECT attr.attname, attr.attnotnull FROM pg_attribute attr
WHERE attr.attrelid =a_TableOID AND attr.attnum=a_AttributeNo;
SELECT rs_isAttributePK,rs_ColumnPKNo
FROM admtf_Attribute_PKFeatures (a_TableOID,a_AttributeNo);
SELECT rs_isAttributeFK,rs_FKeyName,rs_ColumnFKNo,
rs_FKTableName,rs_FKTableColumnName
FROM admtf_Attribute_FKFeatures (a_TableOID,a_AttributeNo);
```
Значения полей **isAttributePK** и **ColumnPKNo** возвращаются функцией **admtf\_Attribute\_PKFeatures**.
Значения полей **isAttributeFK**, **FKeyName**, **ColumnFKNo**, **FKTableName**, **FKTableColumnName** возвращаются функцией **admtf\_Attribute\_FKFeatures**.
Вызов функции **admtf\_Attribute\_Features((SELECT OID FROM pg\_class WHERE relname='street'),2::SMALLINT)** приведет к следующему результату.
**Таблица 18. Результат выполнения функции admtf\_Attribute\_Features**
| AttributeName | UserTypeName | TypeName | isNotNULL | isAttributePK | ColumnPKNo |
| --- | --- | --- | --- | --- | --- |
| localityid | localityid | integer | integer | integer | integer |
| Description | isAttributeFK | FKeyName | ColumnFKNo | FKTableName | FKTableColumnName |
| --- | --- | --- | --- | --- | --- |
| ИД населенного пункта | t | {fk\_street\_locality} | {2} | {locality} | {localityid} |
ПРИЛОЖЕНИЕ 1. Скрипты
---------------------
### Создание функции admtf\_Sequence\_Features
[Комментарии к исходному коду функции можно посмотреть здесь.](#tfTableS_def)
**код функции**
```
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Sequence_Features (a_SchemaName NAME,a_SequenceName NAME);
/****************************************************************************/
/* Функция возвращает список характеристик последовательности, принадлежащей схеме */
/****************************************************************************/
CREATE OR REPLACE FUNCTION admtf_Sequence_Features
(a_SchemaName NAME default 'public', /* название схемы базы данных */
a_SequenceName NAME default NULL /* Название последовательности */
)
RETURNS TABLE (rs_SequenceName NAME,rs_SequenceDescription TEXT,rs_NumberOfAttribute INTEGER,rs_SequenceLastValue BIGINT,
rs_SequenceStartValue BIGINT,rs_SequenceIncrementBy BIGINT,rs_SequenceMaxValue BIGINT) AS
$BODY$
DECLARE
c_SequenceKind CONSTANT CHAR:='S';
v_SequenceOID OID; /* ИД последовательности */
v_SequenceName NAME; /* Название последовательности */
v_SequenceDescription TEXT; /* Описание последовательности */
v_SequenceStartValue BIGINT; /* Начальное значение последовательности */
v_SequenceIncrementBy BIGINT; /* Приращение последовательности */
v_SequenceMaxValue BIGINT; /* Максимальное значение последовательности */
v_SequenceLastValue BIGINT; /* Максимальное значение последовательности */
v_SequenceNumberOfRowCalc INTEGER; /* Число записей в таблице */
--************************************************************************
BEGIN
SELECT INTO rs_SequenceName,rs_SequenceDescription,rs_NumberOfAttribute
tbl.relname,
COALESCE(dsc.description,'Последовательность') AS r_SequenceDescription,
tbl.relnatts::INTEGER,tbl.relchecks::INTEGER,tbl.relhaspkey,
tbl.relhasindex,tbl.relhassubclass,tbl.reltuples::INTEGER
FROM pg_class tbl
INNER JOIN pg_namespace nspc ON tbl.relnamespace = nspc.oid
LEFT OUTER JOIN pg_Description dsc ON tbl.oid=dsc.objoid
AND dsc.objsubid=0
WHERE nspc.nspname=LOWER(a_SchemaName)
AND tbl.relkind=c_SequenceKind
AND tbl.relname =LOWER(a_SequenceName);
IF FOUND THEN
EXECUTE 'SELECT last_value,start_value,increment_by,max_value
FROM '||LOWER(a_SchemaName)||'.'||LOWER(a_SequenceName) INTO
v_SequenceLastValue,v_SequenceStartValue,
v_SequenceIncrementBy,v_SequenceMaxValue ;
RETURN QUERY SELECT rs_SequenceName,rs_SequenceDescription,
rs_NumberOfAttribute,v_SequenceLastValue,
v_SequenceStartValue,v_SequenceIncrementBy,
v_SequenceMaxValue;
END IF;
RETURN;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Sequence_Features(a_SchemaName NAME,a_SequenceName NAME) IS 'Функция возвращает список характеристик последовательности, принадлежащей схеме';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Sequence_Features (a_SchemaName VARCHAR(256),a_SequenceName VARCHAR(256));
/****************************************************************************/
/* Функция возвращает список характеристик последовательности, принадлежащей схеме */
/****************************************************************************/
CREATE OR REPLACE FUNCTION admtf_Sequence_Features
(a_SchemaName VARCHAR(256) default 'public', /* название схемы базы данных */
a_SequenceName VARCHAR(256) default NULL /* Название последовательности */
)
RETURNS TABLE (rs_SequenceName VARCHAR(256),rs_SequenceDescription TEXT,
rs_NumberOfAttribute INTEGER,rs_SequenceLastValue BIGINT,
rs_SequenceStartValue BIGINT,rs_SequenceIncrementBy BIGINT,
rs_SequenceMaxValue BIGINT) AS
$BODY$
DECLARE
c_SequenceKind CONSTANT CHAR:='S';
--********************************************************
BEGIN
RETURN QUERY SELECT sf.rs_SequenceName::VARCHAR(256),
sf.rs_SequenceDescription::TEXT,
sf.rs_NumberOfAttribute::INTEGER,
sf.rs_SequenceLastValue::BIGINT,
sf.rs_SequenceStartValue::BIGINT,
sf.rs_SequenceIncrementBy::BIGINT,
sf.rs_SequenceMaxValue::BIGINT
FROM admtf_Sequence_Features(a_SchemaName::NAME,a_SequenceName::NAME) sf;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Sequence_Features(a_SchemaName VARCHAR(256),a_SequenceName VARCHAR(256)) IS 'Функция возвращает список характеристик последовательности, принадлежащей схеме';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT * FROM admtf_Sequence_Features('public'::VARCHAR(255),'k_dorogi_dijkstra_seq_seq'::VARCHAR(255));
SELECT * FROM admtf_Sequence_Features('public'::NAME,'kr_road_network_vertices_pgr_id_seq'::NAME);
```
### Создание функции admtf\_Table\_Sequences
[Комментарии к исходному коду функции можно посмотреть здесь.](#tfTableS_def)
**код функции**
```
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Table_Sequences (a_SchemaName NAME, a_TableName NAME);
/*********************************************************************/
/* Функция возвращает список последовательностей, от которых зависит таблица */
/*********************************************************************/
CREATE OR REPLACE FUNCTION admtf_Table_Sequences
(a_SchemaName NAME default 'public', /* название схемы базы данных */
a_TableName NAME default NULL /* Название таблицы */
)
RETURNS TABLE (r_SequenceNumber SMALLINT,r_SequenceName NAME,
r_SequenceSchemaName NAME,r_SequenceDescription TEXT,
r_SequenceStartValue BIGINT,r_SequenceIncrementBy BIGINT,
r_SequenceMaxValue BIGINT,r_DependType NAME,
r_RefTableName NAME,r_RefTableSchemaName NAME,
r_RefAttributeName NAME) AS
$BODY$
DECLARE
v_TableOID INTEGER;/* OID таблицы*/
v_Sequence RECORD;/* Запись о последовательности*/
v_SequenceOID INTEGER;/* OID ограничения*/
v_SequenceName NAME; /* Название последовательности */
v_SequenceSchemaName NAME; /* Название схемы последовательности */
v_SequenceDescription TEXT; /* Описание последовательности */
v_SequenceStartValue BIGINT; /* Начальное значение последовательности */
v_SequenceIncrementBy BIGINT; /* Приращение последовательности */
v_SequenceMaxValue BIGINT; /* Максимальное значение последовательности */
v_DependcyType NAME; /* Буквенное обозначение типа зависимости */
/* таблицы от последовательности */
v_AttributeName NAME; /* Наименование аттрибута*/
v_SequenceNumber SMALLINT; /* Порядковый номер последовательности*/
c_Delimiter CONSTANT VARCHAR(2):=',';
--*********************************************************************
BEGIN
v_SequenceNumber:=0;
FOR v_Sequence IN SELECT pseq.relname AS SequenceName,
snsp.nspname AS SequenceSchemaName,
COALESCE(dsc.description,'Последовательность, генерирующая
значения поля '||da.attname) AS SequenceDescription,
d.depType AS DependcyType,da.attname AS AttributeName
FROM pg_depend d
INNER JOIN pg_class pseq ON d.objid = pseq.oid
INNER JOIN pg_namespace snsp ON pseq.relnamespace=snsp.oid
LEFT OUTER JOIN pg_Description dsc ON pseq.oid=dsc.objoid
AND dsc.objsubid=0
INNER JOIN pg_class tbl ON d.refobjid = tbl.oid
INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid
INNER JOIN pg_attribute da ON da.attrelid= d.refobjid
AND d.refobjsubid=da.attnum
WHERE tbl.relkind = 'r' AND pseq.relkind = 'S'
AND LOWER(nsp.nspname)=LOWER(a_SchemaName)
AND LOWER(tbl.relname)=LOWER(a_TableName)
ORDER BY pseq.relname
LOOP
v_SequenceNumber:=v_SequenceNumber+1;
v_SequenceName:=v_Sequence.SequenceName;
v_SequenceSchemaName:=v_Sequence.SequenceSchemaName;
v_DependcyType:=v_Sequence.DependcyType;
v_AttributeName:=v_Sequence.AttributeName;
v_SequenceDescription:=v_Sequence.SequenceDescription;
SELECT INTO v_SequenceStartValue,v_SequenceIncrementBy,
v_SequenceMaxValue
rs_SequenceStartValue,rs_SequenceIncrementBy,
rs_SequenceMaxValue
FROM admtf_Sequence_Features(v_SequenceSchemaName,v_SequenceName);
RETURN QUERY SELECT v_SequenceNumber,v_SequenceName,
v_SequenceSchemaName,v_SequenceDescription,
v_SequenceStartValue,v_SequenceIncrementBy,
v_SequenceMaxValue,v_DependcyType,
a_TableName,a_SchemaName,v_AttributeName;
END LOOP;
RETURN;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Table_Sequences(a_SchemaName NAME, a_TableName NAME) IS 'Возвращает список последовательностей, от которых зависит таблица';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Table_Sequences (a_SchemaName VARCHAR(256), a_TableName VARCHAR(256));
/**********************************************************************/
/* Функция возвращает список последовательностей, от которых зависит таблица */
/**********************************************************************/
CREATE OR REPLACE FUNCTION admtf_Table_Sequences
(a_SchemaName VARCHAR(256) default 'public', /* название схемы базы данных */
a_TableName VARCHAR(256) default NULL /* Название таблицы */
)
RETURNS TABLE (r_SequenceNumber SMALLINT,r_SequenceName VARCHAR(256),
r_SequenceSchemaName VARCHAR(256),r_SequenceDescription TEXT,
r_SequenceStartValue BIGINT,r_SequenceIncrementBy BIGINT,
r_SequenceMaxValue BIGINT,r_DependType VARCHAR(256),
r_RefTableName VARCHAR(256),r_RefTableSchemaName VARCHAR(256),
r_RefAttributeName VARCHAR(256)) AS
$BODY$
DECLARE
c_Delimiter CONSTANT VARCHAR(2):=',';
--******************************************************
BEGIN
RETURN QUERY SELECT ts.r_SequenceNumber::SMALLINT,
ts.r_SequenceName::VARCHAR(256),
ts.r_SequenceSchemaName::VARCHAR(256) ,
ts.r_SequenceDescription::TEXT,
ts.r_SequenceStartValue::BIGINT,
ts.r_SequenceIncrementBy::BIGINT,
ts.r_SequenceMaxValue::BIGINT,
ts.r_DependType::VARCHAR(256),
ts.r_RefTableName::VARCHAR(256),
ts.r_RefTableSchemaName::VARCHAR(256),
ts.r_RefAttributeName::VARCHAR(256)
FROM admtf_Table_Sequences(a_SchemaName::NAME,a_TableName::NAME) ts;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Table_Sequences(a_SchemaName VARCHAR(256), a_TableName VARCHAR(256)) IS 'Возвращает список последовательностей, от которых зависит таблица';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT * FROM admtf_Table_Sequences('public'::VARCHAR(255),'kr_road_network_vertices_pgr'::VARCHAR(255));
SELECT * FROM admtf_Table_Sequences('public'::NAME,'kr_road_network_vertices_pgr'::NAME);
```
### Создание функции admtf\_Table\_Sequences без курсора (PostgreSQL 10)
[Комментарии к исходному коду функции можно посмотреть здесь.](#tfTableS_woc_def)
**код функции**
```
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Table_Sequences (a_SchemaName NAME, a_TableName NAME);
/*********************************************************************/
/* Функция возвращает список последовательностей, от которых зависит таблица */
/**********************************************************************/
CREATE OR REPLACE FUNCTION admtf_Table_Sequences
(a_SchemaName NAME default 'public', /* название схемы базы данных */
a_TableName NAME default NULL /* Название таблицы */
)
RETURNS TABLE (r_SequenceNumber SMALLINT,r_SequenceName NAME,
r_SequenceSchemaName NAME,r_SequenceDescription TEXT,
r_SequenceStartValue BIGINT,r_SequenceIncrementBy BIGINT,
r_SequenceMaxValue BIGINT,r_DependType NAME,
r_RefTableName NAME,r_RefTableSchemaName NAME,
r_RefAttributeName NAME) AS
$BODY$
DECLARE
v_TableOID INTEGER; /* OID таблицы*/
v_Sequence RECORD; /* Запись о последовательности*/
v_SequenceOID INTEGER; /* OID ограничения*/
v_SequenceName NAME; /* Название последовательности */
v_SequenceSchemaName NAME; /* Название схемы последовательности */
v_SequenceDescription TEXT; /* Описание последовательности */
v_SequenceStartValue BIGINT; /* Начальное значение последовательности */
v_SequenceIncrementBy BIGINT; /* Приращение последовательности */
v_SequenceMaxValue BIGINT; /* Максимальное значение последовательности */
v_DependcyType NAME; /* Буквенное обозначение типа зависимости таблицы от последовательности */
v_AttributeName NAME; /* Наименование аттрибута*/
v_SequenceNumber SMALLINT; /* Порядковый номер последовательности*/
c_Delimiter CONSTANT VARCHAR(2):=',';
--******************************************************************
BEGIN
v_SequenceNumber:=0;
FOR v_Sequence IN SELECT pseq.relname AS SequenceName,
snsp.nspname AS SequenceSchemaName,
COALESCE(dsc.description,'Последовательность, генерирующая
значения поля '||da.attname) AS SequenceDescription,
d.depType AS DependcyType,da.attname AS AttributeName
FROM pg_depend d
INNER JOIN pg_class pseq ON d.objid = pseq.oid
INNER JOIN pg_namespace snsp ON pseq.relnamespace=snsp.oid
LEFT OUTER JOIN pg_Description dsc ON pseq.oid=dsc.objoid
AND dsc.objsubid=0
INNER JOIN pg_class tbl ON d.refobjid = tbl.oid
INNER JOIN pg_namespace nsp ON tbl.relnamespace=nsp.oid
INNER JOIN pg_attribute da ON da.attrelid= d.refobjid
ND d.refobjsubid=da.attnum
WHERE tbl.relkind = 'r' AND pseq.relkind = 'S'
AND LOWER(nsp.nspname)=LOWER(a_SchemaName)
AND LOWER(tbl.relname)=LOWER(a_TableName)
ORDER BY pseq.relname
LOOP
v_SequenceNumber:=v_SequenceNumber+1;
v_SequenceName:=v_Sequence.SequenceName;
v_SequenceSchemaName:=v_Sequence.SequenceSchemaName;
v_DependcyType:=v_Sequence.DependcyType;
v_AttributeName:=v_Sequence.AttributeName;
v_SequenceDescription:=v_Sequence.SequenceDescription;
SELECT INTO v_SequenceStartValue,v_SequenceIncrementBy,v_SequenceMaxValue
rs_SequenceStartValue,rs_SequenceIncrementBy,rs_SequenceMaxValue
FROM admtf_Sequence_Features(v_SequenceSchemaName,v_SequenceName);
RETURN QUERY SELECT v_SequenceNumber,v_SequenceName,
v_SequenceSchemaName,v_SequenceDescription,
v_SequenceStartValue,v_SequenceIncrementBy,
v_SequenceMaxValue,v_DependcyType,
a_TableName,a_SchemaName,v_AttributeName;
END LOOP;
RETURN;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Table_Sequences(a_SchemaName NAME, a_TableName NAME) IS 'Возвращает список последовательностей, от которых зависит таблица';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Table_Sequences (a_SchemaName VARCHAR(256), a_TableName VARCHAR(256));
/**********************************************************************/
/* Функция возвращает список последовательностей, от которых зависит таблица */
/**********************************************************************/
CREATE OR REPLACE FUNCTION admtf_Table_Sequences
(a_SchemaName VARCHAR(256) default 'public', /* название схемы базы данных */
a_TableName VARCHAR(256) default NULL /* Название таблицы */
)
RETURNS TABLE (r_SequenceNumber SMALLINT,r_SequenceName VARCHAR(256),
r_SequenceSchemaName VARCHAR(256),r_SequenceDescription TEXT,
r_SequenceStartValue BIGINT,r_SequenceIncrementBy BIGINT,
r_SequenceMaxValue BIGINT,r_DependType VARCHAR(256),
r_RefTableName VARCHAR(256),r_RefTableSchemaName VARCHAR(256),
r_RefAttributeName VARCHAR(256)) AS
$BODY$
DECLARE
c_Delimiter CONSTANT VARCHAR(2):=',';
--*******************************************************
BEGIN
RETURN QUERY SELECT ts.r_SequenceNumber::SMALLINT,
ts.r_SequenceName::VARCHAR(256),
ts.r_SequenceSchemaName::VARCHAR(256),
ts.r_SequenceDescription::TEXT,
ts.r_SequenceStartValue::BIGINT,
ts.r_SequenceIncrementBy::BIGINT,
ts.r_SequenceMaxValue::BIGINT,
ts.r_DependType::VARCHAR(256),
ts.r_RefTableName::VARCHAR(256),
ts.r_RefTableSchemaName::VARCHAR(256),
ts.r_RefAttributeName::VARCHAR(256)
FROM admtf_Table_Sequences(a_SchemaName::NAME,a_TableName::NAME) ts;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Table_Sequences(a_SchemaName VARCHAR(256), a_TableName VARCHAR(256)) IS 'Возвращает список последовательностей, от которых зависит таблица';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT * FROM admtf_Table_Sequences('public'::VARCHAR(255),
'kr_road_network_vertices_pgr'::VARCHAR(255));
SELECT * FROM admtf_Table_Sequences('public'::NAME,
'kr_road_network_vertices_pgr'::NAME);
```
### Создание функции admfn\_Table\_RowCount
[Комментарии к исходному коду функции можно посмотреть здесь.](#fnTableRC_def)
**код функции**
```
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_RowCount (a_SchemaName NAME,a_TableName NAME);
/******************************************************/
/* Функция возвращает число строк в таблице */
/******************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_RowCount
(a_SchemaName NAME default 'public',/* название схемы базы данных */
a_TableName NAME default NULL /* Название таблицы */
)
RETURNS BIGINT AS
$BODY$
DECLARE v_TableNumberOfRowCalc BIGINT; /* Количество */
v_Found BOOLEAN;
--***********************************************************
BEGIN
IF a_SchemaName ~ E'^[a-z_0-9]+$' AND a_TableName ~ E'^[a-z_0-9]+$' THEN
EXECUTE 'SELECT count(*) FROM ' ||a_SchemaName ||'.'|| a_TableName
INTO v_TableNumberOfRowCalc;
ELSE
SELECT INTO v_Found true
FROM pg_class tbl
INNER JOIN pg_namespace nspc ON tbl.relnamespace = nspc.oid
WHERE tbl.relkind='r' AND tbl.relname=a_TableName
AND nspc.nspname=a_SchemaName;
IF FOUND THEN
EXECUTE 'SELECT count(*) FROM ' ||
CASE WHEN a_SchemaName ~ E'^[a-z_0-9]+$' THEN
a_SchemaName
ELSE quote_ident(a_SchemaName) END
||'.'||
CASE WHEN a_TableName ~ E'^[a-z_0-9]+$' THEN
a_TableName
ELSE quote_ident(a_TableName) END
INTO v_TableNumberOfRowCalc;
ELSE
SELECT INTO v_Found true
FROM pg_class tbl
INNER JOIN pg_namespace nspc ON tbl.relnamespace = nspc.oid
WHERE tbl.relkind='r' AND LOWER(tbl.relname)= LOWER(a_TableName)
AND nspc.nspname=LOWER(a_SchemaName);
IF FOUND THEN
EXECUTE 'SELECT count(*) FROM ' || a_SchemaName ||'.'||a_TableName
INTO v_TableNumberOfRowCalc;
END IF;
END IF;
END IF;
RETURN v_TableNumberOfRowCalc;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_RowCount(a_SchemaName NAME,a_TableName NAME) IS 'Возвращает число строк в таблице';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admfn_Table_RowCount (a_SchemaName VARCHAR(256),a_TableName VARCHAR(256));
/********************************************************************/
/* Функция возвращает число строк в таблице */
/********************************************************************/
CREATE OR REPLACE FUNCTION admfn_Table_RowCount
(a_SchemaName VARCHAR(256) default 'public',/* название схемы базы данных */
a_TableName VARCHAR(256) default NULL /* Название таблицы */
)
RETURNS BIGINT AS
$BODY$
DECLARE v_TableNumberOfRowCalc BIGINT; /* Количество */
--*********************************************************
BEGIN
RETURN admfn_Table_RowCount(a_SchemaName::NAME,a_TableName::NAME);
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admfn_Table_RowCount(a_SchemaName VARCHAR(256),a_TableName VARCHAR(256)) IS 'Возвращает число строк в таблице';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECt admfn_Table_RowCount('public'::NAME,'Street'::NAME);
SELECt admfn_Table_RowCount('public'::VARCHAR(256),'Street'::VARCHAR(256));
```
### Создание функции admtf\_Table\_InheritanceChildrens
[Комментарии к исходному коду функции можно посмотреть здесь.](#tfTableIC_def)
**код функции**
```
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Table_InheritanceChildrens (a_SchemaName NAME,a_TableName NAME,a_Mode VARCHAR(10));
/************************************************************/
/* Функция возвращает список характеристик унаследованных таблиц */
/************************************************************/
CREATE OR REPLACE FUNCTION admtf_Table_InheritanceChildrens
(a_SchemaName NAME default 'public', /* название схемы базы данных */
a_TableName NAME default NULL, /* Название таблицы */
a_Mode VARCHAR(10) default 'estimate'
/*Режим вычисления количества записей в таблице*/
)
RETURNS TABLE (rs_TableName NAME,rs_TableDescription TEXT,
rs_NumberOfAttribute INTEGER,rs_NumberOfChecks INTEGER,
rs_hasPKey BOOLEAN,rs_hasIndex BOOLEAN,
rs_hasSubClass BOOLEAN,rs_NumberOfRow INTEGER) AS
$BODY$
DECLARE
c_TableKind CONSTANT CHAR:='r';
c_ExactlyMode CONSTANT VARCHAR(10):='exactly';
c_EstimateMode CONSTANT VARCHAR(10):='estimate';
v_TableOID OID; /* ИД таблицы */
v_SchemaName NAME; /* Название схемы таблицы */
v_TableName NAME; /* Название таблицы */
v_TableDescription TEXT; /* Описание таблицы */
v_TableNumberOfRowCalc INTEGER; /* Число записей в таблице */
v_InheritanceRECORD RECORD; /* Запись унаследованной таблицы */
v_InheritanceOID OID; /* ИД унаследованной таблицы */
BEGIN
RETURN QUERY SELECT rtbl.relname,rdsc.description,rtbl.relnatts::INTEGER,
rtbl.relchecks::INTEGER,rtbl.relhaspkey,rtbl.relhasindex,
rtbl.relhassubclass,
CASE WHEN a_Mode=c_ExactlyMode THEN
admfn_Table_RowCount(rnspc.nspname,rtbl.relname)::INTEGER
ELSE rtbl.reltuples::INTEGER END
FROM pg_class tbl
INNER JOIN pg_namespace nspc ON tbl.relnamespace = nspc.oid
LEFT OUTER JOIN pg_Description dsc ON tbl.oid=dsc.objoid
AND dsc.objsubid=0
INNER JOIN pg_depend dp ON tbl.oid=dp.refobjid
INNER JOIN pg_class rtbl ON rtbl.OID=dp.objid
INNER JOIN pg_namespace rnspc ON rtbl.relnamespace = rnspc.oid
LEFT OUTER JOIN pg_Description rdsc ON rtbl.oid=rdsc.objoid
AND rdsc.objsubid=0
WHERE nspc.nspname=LOWER(a_SchemaName)
AND tbl.relkind=c_TableKind AND rtbl.relkind=c_TableKind
AND tbl.relname =LOWER(a_TableName)
ORDER BY rtbl.relname;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Table_InheritanceChildrens(a_SchemaName NAME,a_TableName NAME,a_Mode VARCHAR(10)) IS 'Возвращает список характеристик унаследованных таблиц';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Table_InheritanceChildrens (a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_TableName NAME,a_Mode VARCHAR(10));
/************************************************************************/
/* Функция возвращает список характеристик унаследованных таблиц */
/************************************************************************/
CREATE OR REPLACE FUNCTION admtf_Table_InheritanceChildrens
(a_SchemaName VARCHAR(256) default 'public',/* название схемы базы данных */
a_TableName VARCHAR(256) default NULL,/* Название таблицы */
a_Mode VARCHAR(10) default 'estimate'
/*Режим вычисления количества записей в таблице*/
)
RETURNS TABLE (rs_TableName VARCHAR(256),rs_TableDescription TEXT,
rs_NumberOfAttribute INTEGER,rs_NumberOfChecks INTEGER,
rs_hasPKey BOOLEAN,rs_hasIndex BOOLEAN,
rs_hasSubClass BOOLEAN,rs_NumberOfRow INTEGER) AS
$BODY$
DECLARE
c_TableKind CONSTANT CHAR:='r';
BEGIN
RETURN QUERY SELECT tic.rs_TableName::VARCHAR(256),tic.rs_TableDescription::TEXT,
tic.rs_NumberOfAttribute::INTEGER,tic.rs_NumberOfChecks::INTEGER,
tic.rs_hasPKey::BOOLEAN,tic.rs_hasIndex::BOOLEAN,
tic.rs_hasSubClass::BOOLEAN,tic.rs_NumberOfRow::INTEGER
FROM admtf_Table_InheritanceChildrens(a_SchemaName::NAME,
a_TableName::NAME,a_Mode::VARCHAR(10)) tic;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Table_InheritanceChildrens(a_SchemaName VARCHAR(256),a_TableName VARCHAR(256),a_Mode VARCHAR(10)) IS 'Возвращает список характеристик унаследованных таблиц';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT * FROM admtf_Table_InheritanceChildrens('public'::NAME,'np_house'::NAME);
SELECT * FROM admtf_Table_InheritanceChildrens('public'::VARCHAR(256),'np_house'::VARCHAR(256));
```
### Создание функции admtf\_Attribute\_PKFeatures
[Комментарии к исходному коду функции можно посмотреть здесь.](#tfAttPK_def)
**код функции**
```
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Attribute_PKFeatures (a_TableOID OID,a_AttributeNo SMALLINT);
/***************************************************************************/
/* Функция возвращает признак присутствия колонки в первичном ключе. */
/* Если колонка присутствует, то возвращается и ее порядковый номер в списке колонок */
/* первичного ключа */
/***************************************************************************/
CREATE OR REPLACE FUNCTION admtf_Attribute_PKFeatures
(a_TableOID OID, /* ИД таблицы */
a_AttributeNo SMALLINT /* Порядковый номер атрибута в таблице*/
)
RETURNS TABLE (rs_isAttributePK BOOLEAN,rs_PKeyName name,rs_ColumnPKNo SMALLINT) AS
$BODY$
DECLARE C_PKAttributeList_NDims CONSTANT INTEGER:=1;
/* Размерность массива атрибутов первичного ключа*/
v_PKAttributeList SMALLINT[];
/* Список номеров атребутов в составе первичного ключа*/
v_PKAttributeIndx INTEGER;
/* Текущий индекс масссива атрибутов первичного ключа*/
v_PKAttributeLBound INTEGER;
/* Нижний индекс масссива атрибутов первичного ключа*/
v_PKAttributeUBound INTEGER;
/* Верхний индекс масссива атрибутов первичного ключа*/
--********************************************************************** BEGIN
rs_isAttributePK:=false;
rs_ColumnPKNo:=NULL;
SELECT INTO rs_PKeyName,v_PKAttributeList,rs_isAttributePK
conname,conkey,ARRAY[a_AttributeNo]<@conkey
FROM pg_constraint c
WHERE c.contype='p' and c.conrelid=a_TableOID;
IF FOUND AND rs_isAttributePK THEN -- колонка присутсвует в первичном ключе
v_PKAttributeLBound:=array_lower(v_PKAttributeList,C_PKAttributeList_NDims);
v_PKAttributeUBound:=array_upper(v_PKAttributeList,C_PKAttributeList_NDims);
v_PKAttributeIndx:=v_PKAttributeLBound;
WHILE v_PKAttributeIndx <= v_PKAttributeUBound
AND a_AttributeNo<>v_PKAttributeList[v_PKAttributeIndx]
LOOP
v_PKAttributeIndx:=v_PKAttributeIndx+1;
END LOOP;
IF v_PKAttributeIndx<=v_PKAttributeUBound THEN
rs_ColumnPKNo:=v_PKAttributeIndx;
END IF;
END IF;
RETURN QUERY SELECT rs_isAttributePK,rs_PKeyName,rs_ColumnPKNo;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Attribute_PKFeatures(a_TableOID OID,a_AttributeNo SMALLINT) IS 'Возвращает признак присутствия колонки в первичном ключе и порядковый номер в списке колонок первичного ключа';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT * FROM admtf_Attribute_PKFeatures((SELECT OID FROM pg_class WHERE relname='street'),3::SMALLINT);
```
### Создание функции admtf\_Attribute\_FKFeatures
[Комментарии к исходному коду функции можно посмотреть здесь.](#tfAttFK_def)
**код функции**
```
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Attribute_FKFeatures (a_TableOID OID,a_AttributeNo SMALLINT);
/****************************************************************************/
/* Функция возвращает признак присутсвия колонки во внешнем ключе. */
/* Если колонка присутствует, то возвращается и ее порядковый номер в списке */
/* колонок внешнего ключа. */
/****************************************************************************/
/****************************************************************************/
CREATE OR REPLACE FUNCTION admtf_Attribute_FKFeatures
(a_TableOID OID, /* ИД таблицы */
a_AttributeNo SMALLINT /* Порядковый номер атрибута в таблице*/
)
RETURNS TABLE (rs_isAttributeFK BOOLEAN,rs_FKeyName name[],rs_ColumnFKNo SMALLINT[],rs_FKTableName name[],rs_FKTableColumnName name[]) AS
$BODY$
DECLARE C_FKAttributeList_NDims CONSTANT INTEGER:=1;
/* Размерность массива атрибутов внешнего ключа*/
v_FKAttributeList SMALLINT[];
/* Список номеров атрибутов в составе внешнего ключа*/
v_RefAttributeList SMALLINT[];
/* Список номеров атрибутов в таблице, */
/* на которую ссылается внешний ключ*/
v_FKAttributeIndx INTEGER;
/* Текущий индекс масссива атрибутов внешнего ключа*/
v_RefAttributeListIndx INTEGER;
/* Текущий индекс масссива атрибутов таблицы, */
/* на которую ссылается внешний ключ*/
v_FKAttributeLBound INTEGER;
/* Нижний индекс масссива атрибутов внешнего ключа*/
v_FKAttributeUBound INTEGER;
/* Верхний индекс масссива атрибутов внешнего ключа*/
v_FKConstraintIndx INTEGER;
/* Текущий индекс ограничения внешнего ключа*/
v_FKeyName name;
/* Название ограничения таблицы, */
/* в котором определен внешний ключ*/
v_FKTableName name;
/* Название таблицы, на которую ссылается внешний ключ*/
v_FKTableColumnName name;
/* Название атрибута в таблице, */
/* на которую ссылается внешний ключ*/
v_RefAttributeNo SMALLINT;
/* Порядковый номер атрибута в таблице, */
/* на которую ссылается внешний ключ*/
v_Constraint pg_constraint%ROWTYPE;
/* Запись Системной таблицы описания */
/* ограничений (CONSTRANT) */
--******************************************************************************************************
BEGIN
rs_isAttributeFK:=false;
rs_ColumnFKNo:=NULL;
v_FKConstraintIndx:=0;
FOR v_Constraint IN SELECT * FROM pg_constraint c
WHERE c.contype='f' and c.conrelid=a_TableOID
AND ARRAY[a_AttributeNo]<@conkey
ORDER BY c.oid
LOOP
v_FKConstraintIndx:=v_FKConstraintIndx+1;
rs_isAttributeFK:=true;
v_FKeyName:=v_Constraint.conname;
v_FKAttributeList:=v_Constraint.conkey;
v_RefAttributeList:=v_Constraint.confkey;
v_FKAttributeLBound:=array_lower(v_FKAttributeList,C_FKAttributeList_NDims);
v_FKAttributeUBound:=array_upper(v_FKAttributeList,C_FKAttributeList_NDims);
v_FKAttributeIndx:=v_FKAttributeLBound;
WHILE v_FKAttributeIndx <= v_FKAttributeUBound
AND a_AttributeNo<>v_FKAttributeList[v_FKAttributeIndx]
LOOP
v_FKAttributeIndx:=v_FKAttributeIndx+1;
END LOOP;
rs_FKeyName[v_FKConstraintIndx]:=v_FKeyName;
rs_ColumnFKNo[v_FKConstraintIndx]:=v_FKAttributeIndx;
SELECT INTO v_FKTableName ftbl.relname
FROM pg_class ftbl WHERE ftbl.oid=v_Constraint.confrelid;
rs_FKTableName[v_FKConstraintIndx]:=v_FKTableName;
v_RefAttributeNo:=v_RefAttributeList[v_FKAttributeIndx];
v_FKTableColumnName:=NULL;
SELECT INTO v_FKTableColumnName attname
FROM pg_attribute a
WHERE a.attrelid=v_Constraint.confrelid AND a.attnum=v_RefAttributeNo;
rs_FKTableColumnName[v_FKConstraintIndx]:=v_FKTableColumnName;
END LOOP;
RETURN QUERY SELECT rs_isAttributeFK,rs_FKeyName,rs_ColumnFKNo,
rs_FKTableName,rs_FKTableColumnName;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Attribute_FKFeatures(a_TableOID OID,a_AttributeNo SMALLINT) IS 'Возвращает признак присутсвия колонки в первичном ключе и порядковый номер в списке колонок внешнего ключа';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT * FROM admtf_Attribute_FKFeatures((SELECT OID FROM pg_class WHERE relname='street'),4::SMALLINT);
```
### Создание функции admtf\_Attribute\_Features
[Комментарии к исходному коду функции можно посмотреть здесь.](#tfAttF_def)
**код функции**
```
BEGIN TRANSACTION;
DROP FUNCTION IF EXISTS admtf_Attribute_Features (a_TableOID OID,a_AttributeNo SMALLINT);
/****************************************************************************/
/* Функция возвращает характеристики колонки таблицы */
/****************************************************************************/
CREATE OR REPLACE FUNCTION admtf_Attribute_Features
(a_TableOID OID, /* ИД таблицы */
a_AttributeNo SMALLINT/* Порядковый номер атрибута в таблице*/
)
RETURNS TABLE (rsa_AttributeName name,rsa_UserTypeName VARCHAR(256),rsa_TypeName VARCHAR(256),rsa_isNotNULL BOOLEAN,rsa_isAttributePK BOOLEAN,
rsa_ColumnPKNo SMALLINT,rsa_Description Text,rsa_isAttributeFK BOOLEAN,rsa_FKeyName name[],rsa_ColumnFKNo SMALLINT[],rsa_FKTableName name[],rsa_FKTableColumnName name[]) AS
$BODY$
DECLARE
v_Return_Error Integer := 0; /* Код возврата*/
--*********************************************************************
BEGIN
SELECT INTO rsa_AttributeName,rsa_UserTypeName,rsa_TypeName,
rsa_isNotNULL,rsa_Description
attr.attname,
CASE WHEN COALESCE(typ.typbasetype,0)>0 THEN typ.typname::VARCHAR(100)
ELSE ''END AS r_UserTypeName,
FORMAT_TYPE(COALESCE(NULLIF(typ.typbasetype,0),typ.oid),
COALESCE(NULLIF(typ.typtypmod,-1),attr.atttypmod))::VARCHAR(256) AS r_TypeName,
attr.attnotnull AS r_isNotNULL,
dsc.description AS r_Description
FROM pg_attribute attr
LEFT OUTER JOIN pg_type typ ON attr.atttypid=typ.oid
LEFT OUTER JOIN pg_type btyp ON typ.typbasetype=btyp.oid
LEFT OUTER JOIN pg_description dsc ON dsc.objoid=attr.attrelid
AND dsc.objsubid=attr.attnum
WHERE attr.attrelid =a_TableOID AND attr.attnum=a_AttributeNo;
SELECT INTO rsa_isAttributePK,rsa_ColumnPKNo rs_isAttributePK,rs_ColumnPKNo
FROM admtf_Attribute_PKFeatures(a_TableOID,a_AttributeNo);
SELECT INTO rsa_isAttributeFK,rsa_FKeyName,rsa_ColumnFKNo,rsa_FKTableName,
rsa_FKTableColumnName rs_isAttributeFK,rs_FKeyName,
rs_ColumnFKNo,rs_FKTableName,rs_FKTableColumnName
FROM admtf_Attribute_FKFeatures(a_TableOID,a_AttributeNo);
RETURN QUERY SELECT rsa_AttributeName,rsa_UserTypeName,rsa_TypeName,rsa_isNotNULL,
rsa_isAttributePK,rsa_ColumnPKNo,rsa_Description,rsa_isAttributeFK,
rsa_FKeyName,rsa_ColumnFKNo,rsa_FKTableName,rsa_FKTableColumnName;
END
$BODY$
LANGUAGE plpgsql;
COMMENT ON FUNCTION admtf_Attribute_Features(a_TableOID OID,a_AttributeNo SMALLINT) IS 'Возвращает характеристики колонки таблицы';
--ROLLBACK TRANSACTION;
COMMIT TRANSACTION;
SELECT * FROM admtf_Attribute_Features ((SELECT OID FROM pg_class WHERE relname='street'),2::SMALLINT);
```
### Смотрите также
**[Функции для документирования баз данных PostgreSQL. Часть первая](https://habr.com/post/415575/);**
**[Функции для документирования баз данных PostgreSQL. Часть вторая](https://habr.com/post/415897/).**
**[Функции для документирования баз данных PostgreSQL. Окончание(часть четвертая)](https://habr.com/post/419749/).** | https://habr.com/ru/post/418597/ | null | ru | null |
# Пришло время бесплатных сайтов
Привет, %username%!
===================
Сегодня многие начинающие веб-разработчики делают большую ошибку, и не одну. Они что-нибудь сверстают, а потом покупают хостинг. Далее покупают домен. Регистрируют и подключают SSL-сертификат. Я, спасаясь от минус-кармы, просто расскажу как *не тратить деньги* на свои тестовые проекты.
Кстати, здесь абсолютно нет рекламы, даже если вам так покажется — это просто очередной туториал, с описанием нужных ресурсов и *максимально* понятно.
Рекомендую для каждого такого проекта создавать новую почту и везде регистрироваться с помощью нее, а не своего личного мейла.
Хостинг
=======
При запросе «[Бесплатный хостинг](https://ru.wikipedia.org/wiki/%D0%91%D0%B5%D1%81%D0%BF%D0%BB%D0%B0%D1%82%D0%BD%D1%8B%D0%B9_%D1%85%D0%BE%D1%81%D1%82%D0%B8%D0%BD%D0%B3)« гугл первым, естественно после рекламы, предлагает [000webhost.com](http://000webhost.com). Это весьма интересный хостинг — пользуясь им уже как два года, я заметил, что там все время меняется разрешенное количество бесплатных сайтов и другие условия, но главное, что он остается самым удобным.
Итак, на сегодня они предлагают:
* 1 бесплатный сайт
* 1 БД MySQL
* PHP Нескольких версий
* Подключение домена
* 300mb места на SSD (был гигабайт, жмоты!)
* FTP
Раньше было лучше, но и этого, я думаю, для наших тестовых проектов подойдет. Тем более, эти минусы компенсируются удобной панелью управления, чем могут похвастать не многие его конкуренты.
### Что делать?
1. Регистрируемся — это просто!
2. Нажимаем «Создать сайт», делаем, что там просят.
На этом — все. К 000webhost мы еще вернемся. А пока…
Доменное имя
============
Здесь нет идеального варианта для рабочих проектов. Но мы ведь собираемся заниматься мини-проектами и нам много не нужно — просто любой домен второго уровня. Нам в помощь — [Freenom](http://freenom.com), он также первый в результатах поиска, у него нет аналогов — они всех их купили и получили от некоторых стран монополию на продажу их доменов.
Вот мы и приблизились к проблеме - на [www.freenom.com](http://www.freenom.com) доступны только домены всяких дальних африканских стран, где решили продвигать интернет, бесплатно раздавая свои домены: «[.tk](https://ru.wikipedia.org/wiki/.tk)«, «[.ml](https://ru.wikipedia.org/wiki/.ml)«, «.gq», «.cf», «[.ga](https://ru.wikipedia.org/wiki/.ga)». Естественно, они такие же любители денег, как 000webhost и предоставляют домен бесплатно лишь на 12 мес. максимум, но его можно потом перерегистрировать.
Так что, выбираем.
### Последовательность действий #1
1. Регистрируемся — это просто!
2. Идем во вкладочку «Services» сверху, а потом — «Register a new domain».
3. После все подскажет сам сервис.
4. После успешной регистрации домена снова нажмите «Services», а там — «My domains». Не закрывайте эту вкладку.
Возвращаемся к нашему бесплатному хостингу…
### Последовательность действий #2
1. Снова заходим на 000webhost и видим наш сайт с некрасивым доменным именем третьего уровня (имясайта.000webhost.com). Исправим это.
2. Наводим курсор на красивую картинку — появл. надпись ‘»Управлять сайтом», нажимаем.
3. В левом сайдбаре видим «Инструменты», переходим по ссылке.
4. Интуитивно выбираем пункт «Указать веб-адрес»
5. Тут кнопочка — «+ Добавить домен», жмем!
6. Появляется прекрасное модальное окно, где выбираем первый пункт — будем «припарковывать» наш домен.
7. Вводим «Доменное имя», нажимаем на «волшебную кнопочку» [эту вкладку оставьте в фоне] и идем во вкладку, где оставили Freenom.
### Последовательность действий #3
1. Тут, в таблице, напротив домена нажимаем по кнопке «Manage domain».
2. При нажатии на вкладку «Management Tools», появится селект, где нужно выбрать Nameservers.
3. Переключаем «Use default nameservers (Freenom Nameservers)» на «Use custom nameservers (enter below)»
4. Вводим внизу сначала «ns01.000webhost.com», а в следующей строке — «ns02.000webhost.com», а потом — «Change nameservers»
5. Возвращаемся в «Вебхосту» и напротив нашего домена «в ожидании» выбираем в селекте «Управлять» «Проверить сервера имен»
6. Видим что наш домен стал активным, снова нажимаем «Управлять» и привязываем его к нашему имясайта.000webhost.com
Да, теперь у нас все готово, но мы не решили последнюю проблему, которую нужно решить бесплатно — SSL сертификат.
Cloudflare
==========
«[Рак Интернета](https://habr.com/ru/company/ruvds/blog/493852/)« - прекрасное альтернативное название — такому прекрасному бесплатному сервису. Я думаю, нам подходит. Кроме того, что [CloudFlare](https://cloudflare.com) защитит нас от DDOS-атак и прокэшиует наш сайт, ускоряя его, они нам подарят бесплатный сертификат. Это очень удобно.
### Легко
1. Регистрируемся в CloudFlare, выбирая бесплатный план.
2. Добавляем наш сайт: вам нужно снова пойти и изменить серверы имен во Freenom — удалите старые и поставьте те, что предлагает сервис.
3. Вам сразу предложат настроить SSL, рекомендую пункт «Flexible».
4. В настройках много интересного.
Вместо заключения
=================
Итак, ваш сайт настроен и ничем не хуже, чем если бы Вы заплатили за это деньги. Но рекомендую добавить в
вашего сайта, на все страницы, вот это:
```
img[alt="www.000webhost.com"] {display: none;}
```
Таким образом, Вы скроете надоедливое лого 000webhost. Многие движки, например [Эгея](https://blogengine.ru/), магическим образом сами его убирают.
При некоторой сноровке, возможно проделать все эти действия за ~45 мин. Так на свет появилась "[Пара Строк](https://parastrok.ml)".
Я не надеюсь, что эта статья сиюминутно принесла вам пользу, но Вы всегда можете поместить ее в закладки на Хабре :) Спасибо за прочтение! | https://habr.com/ru/post/495178/ | null | ru | null |
# Домашний сервер. Часть 2. FTP, Samba и rTorrent
Пришло время организовывать файловое хранилище, как внутри сети так и снаружи. Данная статья является продолжением [первой части, посвященной настройки WiFi роутера на Вашем домашнем сервере](http://habrahabr.ru/blogs/sandbox/127879/). Все жесткие диски с Вашего домашнего компьютера(кроме системного) можно перенести на сервер, поскольку скорость передачи данный колеблется в районе 10-20 мегабайт в секунду [данный параметр еще и очень сильно зависит от модели Вашего жесткого диска], да и кстати, давно уже пора для системного диска покупать SSD накопители.
**FTP Server.**
Существует множество ftp серверов для linux, много хороших, много плохих, но есть лучший ~~[естественно, что это субъективное мнение, и лучший он для меня]~~ и это **vsftpd**. Его мы и будем рассматривать.
Скачать его можно из стандартных репозитариев **OpenSUSE**, выполнив в терминале команду:
```
zypper in vsftpd
```
Теперь перейдем к описанию. Это консольный ftp server, у него нет GUI [графическая оболочка], поэтому вся настройка происходит в одном единственном конфиге, по адресу /etc/vsftpd.conf.
Вот пример рабочего конфига:
```
#разрешаем любые формы записи на FTP сервер
write_enable=YES
#разрешаем возможность отображения сообщений о переходах из папки в #папку.
dirmessage_enable=YES
#выбираем пользователя БЕЗ всяких привелегий (read-only)
nopriv_user=ftpsecure
#разрешаем локальных пользователей (локальные пользователи - это те, #которые зарегестрированы в системе, то есть на них есть учетные записи)
local_enable=YES
#запихиваем локального пользователя в chroot.
chroot_local_user=YES
#запрет анонимного входа на сервер
anonymous_enable=NO
#включаем логгирование
syslog_enable=YES
#разрешаем присоединятся по 20ому порту
connect_from_port_20=YES
#разрешаем аплоадить папки с киррилицей в названии
ascii_upload_enable=YES
#разрешаем скачивать папки с киррилицей в названии
ascii_download_enable=YES
#название PAM сервиса в системе
pam_service_name=vsftpd
#возможность работы в автономном режиме
listen=YES
#запрещаем SSL аутентификацию
ssl_enable=NO
#рейнж портов для режима PASV.
pasv_min_port=30000
pasv_max_port=30100
#привествие при заходе на ftp-server
ftpd_banner=Welcome to my ftp-server
#время, через сколько пользователя кикнут с сервера при его бездействии
idle_session_timeout=900
#максимальное количество юзеров
max_clients=10
#максимальное количество сессией с одного ip адреса
max_per_ip=3
#разрешение режима PASV(пассивный режим)
pasv_enable=YES
#маска разрешающих привелегий для локальных пользователей.
local_umask=0002
```
В приведенном выше конфиге нет заморочек для распределения прав доступа отдельным пользователям, отдельных папок. Всё довольно просто и лаконично, настроил один раз и пользуешься [пользуются]. Vsftpd был выбран, потому что у него лучшая система настройки прав доступа, которая подразделяется на два вида: внутренняя, системная аутентификация и внешняя, с отдельным конфигурационным файлом для распределения прав доступа, но при этом, пользователи всё также берутся из системы.
В данном примере и пользователи, и распределение прав доступа этих самых пользователей берется из системы, дополнительный конфиг-файл не используется.
Рисунок 1. Выставление прав
На этом собственно всё.
**Samba.**
Хотите всегда иметь под рукой файловое хранилище всех коллекций и всего прочего с ноутбука, с домашнего компьютера, с телефона, с планшета? Поехали.
Изначально, при стандартной установке системы OpenSUSE всё что нужно для установки и настройки samba на сервере уже предустановлено. Поэтому перейдем непосредственно к настройке. Поскольку доступ из под ОС Windows в качестве «Подключения сетевого диска» будет доступен только внутри Вашей локальной сети ~~[для интернета есть ftp сервер, да и к тому же, вывешивать самбу в интернет крайне не безопасно, а мы же, — «ЗА СЕКЬЮРНОСТЬ!!! УРА!»]~~ поэтому настройки будут крайне банальны и просты в понимании. Есть два [известных мне и адекватных на мой взгляд] настройки самбы, это через, всё тот самый, конфигурационный файл и при помощи утилиты — **WebMin**. Это дико-крутая штука, особенно для тех, кто не любит ковырять конфиги ~~[но и здесь есть свои ньюансы]~~. В данной статье не будем останавливаться на средствах "*для ленивых*", поэтому продолжаем. Мы будем рассматривать рабочий конфиг файл. Находится он по адресу: /etc/samba/smb.conf. Вот он:
```
[global]
# Указываем имя гостевого юзера.
guest account = nobody
# Указываем имя
netbios name = homeserver
# Включаем возможность прав "write"
writeable = yes
# Дополнительная опция, убирающая задержку.
socket options = TCP_NODELAY IPTOS_LOWDELAY
# При необходимости, указываем рабочую группу, где будут находится компьютеры
#(абсолютно не обязательный параметр)
workgroup = HOMENET
# Выбираем интерфейсы на которые будет "прослушивать" самба.
# (также, необязательная опция, по-умолчанию, будут прослушиваться все интерфейсы)
interfaces = eth1 wlan0
# Дома безопасность особо не нужна.
security = share
public = yes
[public]
# Разрешаем гостя
guest ok = yes
# Только гость? Да.
guest only = yes
# Путь до публичной папки
path = /cifs/pub
# Не запрещаем запись.
read only = no
# Также, если интересует возможность доступа к CD-ROM'у, то вставьте # в конфиг самбы следующие опции:
[cdrom]
fake oplocks = yes
guest ok = yes
guest only = yes
path = /mnt/cdrom
read only = yes
```
Также, дополнительную настройку можно выполнить через встроенный в YaST GUI samba.
Того пользователя, что мы указали в самом начале конфига, в данном примере это пользователь **nobody**, необходимо создать непосредственно в системе. Задать ему необходимые права (дома, имеет смысл поставить полные права, на создание, удаление, редактирование всех файлов и папок (т.е. права 777). Также, если Вы столкнетесь с ситуацией, когда по какой-то причине станет невозможным удаление/создание файлов в какой-либо из папок на сервере, то выполните команду:
```
chmod 777 -R /path
```
Разберем её, на всякий случай:
**chmod** — команда установки прав.
**777** — собственно права, в буквенном обозначении означают rwx, rwx, rwx — права чтение, запись, выполнение для владельца, группы(где состоит владелец), всех.
**-R** — ключ рекурсии, для того чтобы команда выполнилась не только для той папки(и файлов, находящихся в ней), которую Вы указали в /path, но и для всех под-папок и файлов в них тоже.
**/path** — путь до папки, на которую необходимо установить права. Аналогичная команда соответствует FTP серверу, если возникли похожие проблемы. Да, и надо оговориться, что если возникают подобные проблемы, то скорей всего проблема кроется в пользователях созданных в системе, а точнее в правах, выданных на использование их домашних директорий.
**rTorrent.**
Полу-автоматизированный торрент клиент.
На самом деле, это обычный торрент клиент, но, возможности настройки которого, очень богаты разнообразием. Сейчас мы с Вами разберём одну очень полезную функцию данного клиента. Представьте, Вы уже настроили самбу на Вашем домашнем сервере, файловое хранилище, находящееся на сервере подключена к Вашему компьютеру как Сетевой Диск, Вы открываете Ваш сетевой диск, открываете папку torrents, там открываете папку music и перемещаете туда все торрент файлы с музыкой, которые Вы хотите скачать и… всё, ложитесь спать. На утро уже будут скачены и проверены хеши всех торрентов, что Вы туда положили (тут конечно всё зависит от того сколько торрентов Вы хотите скачать, какой у них вес и какова ширина Вашего интернет канала). Нравится? Вот и я балдею уже как пол года, от этой функции.
Давайте разбираться.
Вам надо установить **rtorrent**, выполняем следующую команду в терминале:
```
zypper in rtorrent
```
После того, как Вы скачали и установили торрент-клиент rtorrent, необходимо произвести настройку клиента. Настройка программы осуществляется при помощи конфигурационного файла .rtorrent.rc, размещаемого в домашнем каталоге пользователя. (По умолчанию файл .rtorrent.rc отсутствует. Его нужно создавать самостоятельно. Привожу пример с подробными комментариями рабочего конфига:
```
#обмен пирами? Да!
peer_exchange = yes
#минимальное число пиров на торрент
min_peers = 1
#максимальное число пиров на торрент
max_peers = 1000
#максимальная скорость загрузки
download_rate = 0
#максимальная скорость отдачи. 1 - не ограничена
upload_rate = 0
#каталог для сохранения закачек или откуда будут сидироваться торренты.
directory = /files/torrents
#каталог куда будет сохраняться состояние торрентов.
#Здесь, в этом примере, они сохраняются в папку session
session = /files/torrents/session/
#rtorrent каждые 5 секунд проверяет этот каталог на новые *.torrent #файлы
#и если они есть то ставит их на закачку
#schedule = watch_directory,5,5,load_start=/home/user/torrent_auto_load/
#проверяет каталоги на новые *.torrent файлы и сохраняет закачки в #соответствующие папки
schedule = watch_directory,5,5,"load_start=/files/torrents/music/*.torrent,d.set_directory=/files/music"
schedule = watch_directory_2,5,5,"load_start=/files/torrents/video/*.torrent,d.set_directory=/files/video"
schedule = watch_directory_3,5,5,"load_start=/files/torrents/video/serial/*.torrent,d.set_directory=/files/video/serial"
schedule = watch_directory_4,5,5,"load_start=/files/torrents/progs/*.torrent,d.set_directory=/files/progs"
schedule = watch_directory_5,5,5,"load_start=/files/torrents/games/*.torrent,d.set_directory=/files/games"
schedule = watch_directory_6,5,5,"load_start=/files/torrents/unsorted/*.torrent,d.set_directory=/files/unsorted"
schedule = watch_directory_7,5,5,"load_start=/files/torrents/doc/*.torrent,d.set_directory=/files/doc"
schedule = watch_directory_8,5,5,"load_start=/files/torrents/doc/books/*.torrent,d.set_directory=/files/doc/books"
#Удаление торрент-файлов из директории music(потому что в данном #примере, папка music идет как "directory"(#1), которые уже скачаны.
schedule = untied_directory,7,5,remove_untied=
#номер порта (или нескольких портов) который открывает клиент для #обмена данными
port_range = 40890-40890
#случайный выбор порта для обмена данными. В данном случае он #отключён
port_random = no
#проверять хэш торрента после закачки
check_hash = yes
#сохранять сессию
session_save = yes
#принимать зашифрованные входящие соединения, устанавливать #незашифрованные исходящие соединения,
#если возвращает ошибку, повторять с шифрованием, предпочитать #открытый текст после установления
#зашифрованного соединения
encryption = allow_incoming,enable_retry,prefer_plaintext
#использовать udp
use_udp_trackers = yes
```
Рисунок 2. Главное окно программы rTorrent
Собственно и все. Далее хитрый приём, — открываем консоль и пишем(можно и по ssh зайти на сервер):
screen rtorrent
Далее, в терминале откроется торрент-клиент, там же Вы его можете настроить и отладить дополнительно. Теперь нажимаем волшебные комбинации клавиш Ctrl+A затем Ctrl+D и консоль радостно Вас оповестит, что:
[detached]
Рисунок 3. «Заскринивание» процесса программы rTorrent.
Это говорит о том, что процесс Вашего торрент-клиента «закринин», то есть выполняется, но его при этом не видно. Для тех, адептов, кому всегда, всё интересно, может прочесть вот здесь про данную утилиту обременять голову такими вещами (хотя, они очень интересные и познавательные, и применяются часто) принудительно я не хочу.
Если Вам понадобилось заного открыть клиент, пишем:
```
screen -r
```
**ВАЖНО:** Если Вы хотите запускать торрент-клиент под рутом(root, т.е. через команду sudo) то, необходимо конфиг файл создавать в корневом каталоге пользователя root, а также, screen -r необходимо выполнять также, под тем же пользователем, под которым Вы ее «заскринили».
Таким образом, у Вас в фоне всегда будет висеть торрент-клиент, который будет качать и раздавать ровно столько, сколько будет работать Ваш сервер.
На этой «важной» ноте, я хочу закончить данную статью. Спасибо за внимание, и да, пользуйтесь поисковиком **Google**, он молодец!
Если ошибся топиком, подскажите куда перенести. | https://habr.com/ru/post/128117/ | null | ru | null |
# Работа с формами, списками и «табами» в Samsung Bada
Доброго времени суток!
В топике кратко изложены основные сведения с примерами кода, иллюстрирующие работу с некоторыми пользовательскими элементами управления и формами на платформе Samsung Bada. Пример приложения с кнопками, полями ввода и надписями (Label) имеется [здесь](http://habrahabr.ru/blogs/mobiledev/111080/). Кому интересно — просим под кат.
##### Формы
В документации к Bada формой называют основную область экрана мобильного устройства, которую занимает приложение и делят на три части:
1. Область индикаторов (Indicator area) — предназначенная для функций системы, которые отображают её текущее состояние, а также уровень сигнала, заряда и т.д.
2. Клиентская область (Client area)- основная часть экрана, предназначенная для отображения графической составляющей приложения.
3. Командная область (Command area) — нижняя часть экрана, предназначенная для программных кнопок (Softkey) и опционального меню (Option menu)
Схема этого (картинка из документации) выглядит следующим образом:
В Samsung Bada есть несколько типов приложений (в том числе и основанные на Flash), но здесь пока рассматриваются только «form-based». Как же с ними работать?
Посмотрим на схему (тоже из документации):
Основой Bada-приложения является «Frame» — главное «окно» приложения, которое может быть только одно.
«Frame» управляет своим визуальным состоянием при помощи форм, которых может быть сколько угодно (вернее, сколько позволят аппаратные ресурсы смартфона). Исходя из этого, порядок работы с формами выглядит так:
* Получаем ссылку на Frame, чтобы иметь возможность добавить к нему форму и отобразить её
* Собственно, создаем форму
* Присоединяем к Frame, если надо, делаем её текущей и «просим отрисоваться»
Надо заметить, что формы в Bada можно создать двояко — либо при помощи GUI-дизайнера, либо из кода. Теплые воспоминания о Delphi заставляют начать меня с первого варианта.
Создав «form-based» приложение (там вполне очевидный мастер), вы сразу получите некую форму, на которой среда уже разместила кнопку. Добавим еще одну форму и визуально заполним её некими элементами управления — для этого в окне Resources среды найдите узел Forms, кликните по нему правой кнопкой мыши и в очевидном Insert Wizard выберите флажком размер новой создаваемой формы. Она отобразится в ресурсах как IDF\_FORM2 (с точностью до цифры). Изменить визуальные свойства формы можно во вкладке Properties среды разработки; перенесите на форму из GUI-дизайнера и какие-нибудь элементы управления, чтобы вторая форма как-то отличалась от первой — кнопку, допустим или таймер.
Теперь код.
В заголовочном файле класса формы добавим включение (include) в проект , чтобы располагать возможность работать с объектом Application и через него влиять на «Frame». Тут же в protected-секции добавим ссылку на новую форму:
```
Osp::Ui::Controls::Form *__newForm;
```
Вернемся в реализацию класса, там найдем метод ActionPerformed с шаблоном обработки идентификаторов событий (для деталей — вверху ссылка на мой первый топик для новичков) и там напишем следующий код:
```
switch(actionId)
{
case ID_BUTTON_OK:
{
Frame *pFrame = Application::GetInstance()->GetAppFrame()->GetFrame();
__newForm = new Form();
__newForm->Construct(L"IDF_FORM1");
pFrame->AddControl(*__newForm);
pFrame->SetCurrentForm(*__newForm);
__newForm->Draw();
__newForm->Show();
}
break;
default:
break;
}
```
Что там происходит? Получаем ссылку на «Frame» приложения, создаем форму из ресурсов проекта, используя её имя (можно было изменить на вкладке Properties), затем добавляем форму к «Frame», делаем её текущей и показываем.
Теперь запускаем симулятор, нажимаем на кнопку и видим новую «вторую» созданную вами форму (тут как бы все очевидно, кажется, поэтому позволю себе не прикладывать скриншотов). В показанной форме можно установить текущей первую форму (при помощи SetCurrentForm) и таким образом вернуться назад.
Второй вариант создания формы — «программно».
Приведу сразу код:
```
Form* pForm = new Form();
pForm->Construct(FORM_STYLE_TITLE | FORM_STYLE_INDICATOR | FORM_STYLE_SOFTKEY_0 | FORM_STYLE_OPTIONKEY);
Frame *pFrame = Application::GetInstance()->GetAppFrame()->GetFrame();
pFrame->AddControl(*pForm);
pForm->Draw();
pForm->Show();
```
Происходящие здесь действия похожи на предыдущие — сначала объявляем и создаем форму, затем задаем её визуальные свойства (тут мы просим, чтобы форма имела заголовок, индикатор (полоску с уровнем заряда и т.п.), хотим также, чтобы у формы была программная клавиша и опциональное меню), получаем ссылку на приложение и добавляем к нему форму.
##### Списки
Посмотрим как на форме создать простой текстовый список — крайне упрощенную версию телефонной книги, например. Для этого имеется GUI-компонент с соответствующим названием List — его и надо расположить на форме неким удобным для вас образом (все же обычно он занимает всю форму:). Имея список на форме, перейдите на вкладку его свойств в среде и измените их значения:
* List Style на LIST\_STYLE\_NORMAL, давая понять системе, что мы хотим видеть «обычный» список, а не числовой или с радиокнопками (впрочем, тут вполне можно экспериментирвоать)
* List Item Format на LIST\_ITEM\_SINGLE\_TEXT, это приведет с созданию простого списка, без картинок
* Column1 Width — очевидное свойство, я выставил его в 200, то есть в ширину формы
* Row 1 Height — не менее очевидное свойство, оно у меня равно 50, чтобы элемент списка не был слишком «толстым»
Получим на форме нечто вроде этого:
И, собственно, код, который надо добавить в метод инициализации формы OnInitializing(void):
```
// сам список, находящийся на форме
__pSimpleList = static_cast(GetControl(L"IDC\_LIST1"));
// добавляем элементы списка
\_\_pSimpleList->AddItem(&String("Item1"), null, null, null, 0);
\_\_pSimpleList->AddItem(&String("Item2"), null, null, null, 1);
\_\_pSimpleList->AddItem(&String("Item3"), null, null, null, 2);
\_\_pSimpleList->AddItem(&String("Item4"), null, null, null, 3);
\_\_pSimpleList->AddItem(&String("Item5"), null, null, null, 4);
```
Первая строка — получение ссылки на сам List, следующие строки — добавление пяти элементов к списку. Метод AddItem списка объявлен в SDK следующим образом:
```
result Osp::Ui::Controls::List::AddItem
( const Osp::Base::String * pText1,
const Osp::Base::String * pText2,
const Osp::Graphics::Bitmap * pBitmap1,
const Osp::Graphics::Bitmap * pBitmap2,
int itemId = 0
)
```
— здесь pText1 и pText2 — пара строк, pBitmap1 и pBitmap2 — пара картинок и itemId — идентификатор элемента списка, если требуется обрабатывать нажатие на него. Тут, кстати, кроется некая загадка разработчиков SDK — пара строк pText1 и pText2 может понадобиться для стиля списка, который называется **LIST\_ITEM\_DOUBLE\_FULLTEXT\_TEXT\_IMAGE**, который отображает две строки и некую картинку, а вот зачем нужен pBitmap2 — вопрос, так как никакого подходящего стиля (который бы одновременно отображал две картинки) я не нашел. Хотя, может я-таки чего-то и не понял ещё:)
Запускаем симулятор и любуемся на результат:
Конечно, если элементы списка не поместятся на форму, то их можно будет прокручивать.
##### «Табы»
Здесь все тоже довольно просто. Для формы, которую вы хотите снабдить «табами» в её свойствах надо установить Show Tab в одно из нужных значений Text Tab или Icon Tab (смысл свойств очевиден, не так ли?). Вверху формы появится пустое место под страницы-«табы», которые мы добавим «программно» в OnInitializing(void) формы.
```
// получаем ссылку на "табы"
Tab* pTab = GetTab();
// добавляем их, второй параметр - номер "таба"
pTab->AddItem(L"1st", 0);
pTab->AddItem(L"2nd", 1);
pTab->AddItem(L"3d", 2);
```
Запускам симулятор и видим:
По-моему, просто:) Но тут надо сделать замечание. Уже ясно, что «табы» могут иметь не только текстовые, но и графические заголовки, причем одновременно на экране могут быть видны 3 текстовых и 4 графических «таба». Если их больше, то рядом отображается кий («cue» — в терминах SDK), дающий возможность понять, что «табы» можно пролистать.
Спасибо за внимание! Надеюсь, этот топик кому-нибудь поможет, если возникнет необходимость поработать для Bada. Удачи;) | https://habr.com/ru/post/112781/ | null | ru | null |
# Тестирование флеш СХД. Huawei Dorado 2100 G2
Наша серия статей посвященная тестированию различных флеш систем хранения данных была бы не полной без продукта компании Huawei. Признаюсь честно, Dorado уже бывал в нашей лаборатории ранее, практически сразу после того, как стал доступен в России. В этот раз, следуя «пожеланиям трудящихся» мы собрали более чем достаточный объем данных и рады представить их вашему вниманию.
[](http://2.bp.blogspot.com/-60w5LcY4AqU/VciZnr6u4qI/AAAAAAAACfc/AeYnx8UE5Ec/s1600/OceanStor-Dorado2100-G2.jpg)
### **Методика тестирования**
В ходе тестирования решались следующие задачи:
* исследования процесса деградации производительности СХД при длительной нагрузке на запись (Write Cliff);
* исследование производительности СХД Huawei Dorado G2 при различных профилях нагрузки в различных конфигурациях (R5 и R0);
#### Конфигурация тестового стенда
| |
| --- |
| |
| Рисунок 1. Структурная схема тестового стенда. |
Тестовый стенд состоит из сервера IBM x3750 M4 подключенного напрямую к СХД Huawei Dorado 2100 G2 через 4 канала FC по 8Gb. СХД Huawei OceanStore Dorado 2100 G2
В качестве дополнительного программного обеспечения на тестовый сервер установлен Symantec Storage Foundation 6.2, реализующий:
* Функционал логического менеджера томов (Veritas Volume Manager);
* Функционал отказоустойчивого подключения к дисковым массивам (Dynamic Multi Pathing).
**Посмотреть утомительные подробности и всякие умные слова.**На тестовых серверах выполняются следующие настройки, направленные на снижение латентности дискового ввода-вывода:
* Изменен планировщик ввода-вывода с «cfq» на «noop» через присвоение значения noop параметру scheduler тома Symantec VxVolume
* Добавлен параметр в `/etc/sysctl.conf` минимизирующий размер очереди на уровне логического менеджера томов Symantec: `«vxvm.vxio.vol_use_rq = 0»`;
* увеличен предел одновременных запросов ввода-вывода на устройство до 1024, через присвоение значения 1024 параметру `nr_requests` тома Symantec VxVolume
* отключена проверка возможности слияния операций в/в (iomerge), через присвоение значения 1 параметру `nomerges` тома Symantec VxVolume
* Увеличен размер очереди на FC адаптерах, путем добавления в конфигурационный файл `/etc/modprobe.d/modprobe.conf` опции `ql2xmaxqdepth=64 (options qla2xxx ql2xmaxqdepth=64)`;
В ходе тестов производятся различные настройки на СХД:
* реализуется конфигурация SSD дисков RAID5 (для тестов СХД в R5) или RAID0 (для тестов СХД в конфигурации R0).
* создаются 8 LUN одинакового размера с суммарным объемом, покрывающим всю полезную емкость СХД (для тестов на полностью размеченной СХД) или 70% объёма (для тестов на не полностью размеченном СХД). Размер блока LUN — 512byte. Луны создаются таким образом, чтобы для половины из них (четырех LUN) владельцем был один контроллер СХД (A), а для другой половины — другой контроллер (B). Созданные LUN презентуются тестовому серверу.
* различные группы тестов могут проводиться со включенным на всех LUN кэшем на запись (Write Back) или отключенным (Write Through). Значение конфигурационного параметра приведено в описании тестов в программе тестирования (1.5).
#### Программное обеспечение, используемое в процессе тестирования
Для создания синтетической нагрузки (выполнения синтетических тестов) на СХД используется утилита Flexible IO Tester (fio) версии 2.1.10. При всех синтетических тестах используются следующие конфигурационные параметры fio секции [global]:
* thread=0
* direct=1
* group\_reporting=1
* norandommap=1
* time\_based=1
* randrepeat=0
* ramp\_time=3
Для снятия показателей производительности при синтетической нагрузке применяются следующие утилиты:
* iostat, входящая в состав пакета sysstat версии 9.0.4 с ключами txk;
* vxstat, входящая в состав Symantec Storage Foundation 6.2 c ключами svd;
* vxdmpadm, входящая в состав Symantec Storage Foundation 6.2 c ключами -q iostat;
* fio версии 2.1.10, для формирования сводного отчета по каждому профилю нагрузки.
Снятие показателей производительности во время выполнения теста утилитами iostat, vxstat, vxdmpstat производится с интервалом 5с.
#### Программа тестирования.
Тесты выполняются посредством создания синтетической нагрузки программой fio на блоковое устройство (block device), представляющее собой логический том типа `«stripe, 8 column, stripe unit size=1MiB»`, созданный с использованием Veritas Volume Manager из 8 LUN, презентованных с тестируемой системы.
**Поинтересоваться подробностями**##### **Группа 1: Тесты, реализующие длительную нагрузку на запись и длительную смешанную нагрузку с изменением размера блока операций ввода/вывода (в/в)**
При создании тестовой нагрузки используются следующие параметры программы fio (в дополнение к определенным в разделе 1.4):
* rw=randwrite
* blocksize=[4К 8К 16К 32К 64К 1М] (исследуются поведение СХД под нагрузкой различным размером блока операций ввода-вывода)
* numjobs=64
* iodepth=64
Группа тестов состоит из тестов, отличающихся суммарным объемом LUN презентуемых с тестируемой СХД, конфигурацией RAID, использованием кэша на запись и направлением нагрузки:
* Тесты на запись, выполняемые на полностью размеченной СХД в конфигурации R5 с изменяющимся размером блока (4,8,16,32,64,1024K). Для каждого LUN кэш на запись отключен. Длительность каждого теста 40 минут, промежуток между тестами 1 час.
* То-же, с включенным кэш на запись.
* Тесты на запись, выполняемые на не полностью размеченной СХД (суммарный объём LUN — 70% полезного объема) в конфигурации R5 с изменяющимся размером блока (4,8,16,32,64,1024K). Для каждого LUN кэш на запись отключен.
* Тесты с длительной смешанной нагрузкой (50% запись, 50% чтение), выполняемые на полностью размеченной СХД в конфигурации R5 с изменяющимся размером блока (4,8,16,32,64,1024K). Для каждого LUN кэш на запись отключен. Длительность каждого теста 20 минут, промежуток между тестами 40 минут.
* Тесты с длительной смешанной нагрузкой (70% запись, 30% чтение), выполняемые на полностью размеченной СХД в конфигурации R5 с изменяющимся размером блока (4,8,16,32,64,1024K). Для каждого LUN кэш на запись отключен. Длительность каждого теста 20 минут, промежуток между тестами 40 минут.
* Тесты на запись, выполняемые на полностью размеченной СХД в конфигурации R0 с изменяющимся размером блока (4,8,16,32,64,1024K). Для каждого LUN кэш на запись отключен. Длительность каждого теста 40 минут, промежуток между тестами 1 час.
Если для теста требуется изменение конфигурации RAID СХД, то после изменения уровня RAID, создания LUN на СХД и тома на сервере, производится заполнение тома утилитой fio 2.1.10 методом случайной записи блоком 16К на том, записываемый объем данных в 2 раза превышает объем тома.
По результатам тестов на основании данных выводимых командой vxstat формируются графики, совмещающие результаты тестов:
* IOPS, как функция времени;
* Пропускная способность (Bandwidth), как функция времени.
Проводится анализ полученной информации и делаются выводы о:
* наличие деградации производительности при длительной нагрузке на запись и при длительной смешанной нагрузке;
* производительности сервисных процессов СХД (garbage collection), ограничивающих производительность дискового массива на запись при длительной пиковой нагрузке в различных конфигурациях СХД (R5 и R0);
* влиянии кэша на запись на производительность сервисных процессов СХД (garbage collection);
* степени влияния размера блока операций ввода-вывода на производительность сервисных процессов СХД;
* объеме пространства, резервируемом на СХД для нивелирования сервисных процессов СХД;
* влиянии заполненности СХД на производительность сервисных процессов;
* влиянии процессов сервисных процессов СХД (garbage collection) на производительность операций чтения.
##### **Группа 2: Тесты производительности дискового массива при разных типах нагрузки, исполняемые на уровне блокового устройства, при конфигурации СХД R5.**
В ходе тестирования исследуются следующие типы нагрузок:
* профили нагрузки (изменяемые параметры ПО fio: randomrw, rwmixedread):
1. случайная запись 100%;
2. случайная запись 30%, случайное чтение 70%;
3. случайное чтение 100%.
* размеры блока: 1КБ, 8КБ, 16КБ, 32КБ, 64КБ, 1МБ (изменяемый параметр ПО fio: blocksize);
* способы обработки операций ввода-вывода: синхронный, асинхронный (изменяемый параметр ПО fio: ioengine);
* количество процессов, генерирующих нагрузку: 1, 2, 4, 8, 16, 32, 64, 128, 256 (изменяемый параметр ПО fio: numjobs);
* глубина очереди (для асинхронных операций ввода-вывода): 32, 64 (изменяемый параметр ПО fio: iodepth).
Группа тестов состоит из набора тестов, представляющего собой все возможные комбинации перечисленных выше типов нагрузки. Длительность каждого теста — 1 минута. Для нивелирования влияния сервисных процессов СХД (garbage collection) на результаты тестов, между тестами реализуется пауза равная объему записанной в ходе теста информации, разделенному на производительность сервисных процессов СХД (определяется по результатам выполнения 1-ой группы тестов).
Все вышеперечисленные тесты выполняются вначале при выключенном кэше на запись для всех LUN, презентованных с СХД.
По результатам тестов на основании данных, выводимых ПО fio по завершению каждого из тестов, формируются графики для каждой комбинации типов нагрузки (профиля нагрузки, способа обработки операций ввода-вывода, глубины очереди, совмещающие в себе тесты с разными значениями блока ввода-вывода):
* IOPS как функция от количества процессов, генерирующих нагрузку;
* Bandwidth как функция от количества процессов, генерирующих нагрузку;
* Latеncy (clat) как функция от количества процессов, генерирующих нагрузку;
Проводится анализ полученных результатов, делаются выводы о нагрузочных характеристиках дискового массива при latency меньше или около 1ms, о максимальных показателях производительности массива и о производительности массива при однопоточной нагрузке, а также о влиянии кэша на производительность СХД.
##### **Группа 3: Тесты производительности дискового массива при разных типах нагрузки, исполняемые на уровне блокового устройства, при конфигурации СХД R0.**
Тесты проводятся аналогично тестам группы 2. Тестируется конфигурация СХД R0. По результатам тестов на основании данных, выводимых ПО fio по завершению каждого из тестов, формируются графики для каждой комбинации типов нагрузки (профиля нагрузки, способа обработки операций ввода-вывода, глубины очереди, совмещающие в себе тесты с разными значениями блока ввода-вывода):
* IOPS как функция от количества процессов, генерирующих нагрузку;
* Bandwidth как функция от количества процессов, генерирующих нагрузку;
* Latеncy (clat) как функция от количества процессов, генерирующих нагрузку;
Проводится анализ полученных результатов, делаются выводы о нагрузочных характеристиках дискового массива в R0 при latency меньше или около 1ms, максимальных показателях производительности массива в R0 и производительности массива при однопоточной нагрузке.
**Результаты тестирования**
---------------------------
##### **Группа 1: Тесты, реализующие длительную нагрузку на запись и длительную смешанную нагрузку с изменением размера блока операций ввода/вывода (в/в).**
**Графики. (Все картинки кликабельны)**
| | |
| --- | --- |
| | График 1
Падение производительности при длительной пиковой нагрузке типа случайная запись на полностью размеченной СХД(R5) при выключенном кэше на запись. |
| | График 2
Падение производительности при длительной пиковой нагрузке типа случайная запись на полностью размеченной СХД(R5) при включенном кэше на запись. |
| | График 3
Падение производительности при длительной пиковой нагрузке типа случайная запись на не полностью размеченной СХД(R5) (70% объема) при выключенном кэше на запись. |
| | График 4
Падение производительности операций записи при длительной пиковой смешанной нагрузке (50% запись, 50% чтение) на полностью размеченной СХД(R5) при выключенном кэше на запись. |
| | График 5
Падение производительности операций чтения при длительной пиковой смешанной нагрузке (50% запись, 50% чтение) на полностью размеченной СХД(R5) при выключенном кэше на запись. |
| | График 6
Падение производительности операций записи при длительной пиковой смешанной нагрузке (70% запись, 30% чтение) на полностью размеченной СХД(R5) при выключенном кэше на запись. |
| | График 7
Падение производительности операций чтения при длительной пиковой смешанной нагрузке (70% запись, 30% чтение) на полностью размеченной СХД(R5) при выключенном кэше на запись. |
| | График 8
Падение производительности при длительной пиковой нагрузке типа случайная запись на полностью размеченной СХД(R0) в конфигурации RAID 0 при выключенном кэше на запись. |
**Таблицы 1-2. (Все картинки кликабельны)**
| |
| --- |
| |
| Таблица 1. Зависимость показателей производительности СХД от размера блока при длительной нагрузке на запись в конфигурации СХД — RAID 5. |
| |
| --- |
| |
| Таблица 2. Зависимость показателей производительности СХД от размера блока при длительной нагрузке на запись в конфигурации СХД — RAID 0. |
**Основные выводы:**
1. При заполнении массива данными замечено, что форматирование (инициализация RAID) происходит только при записи данных. Соответственно, первая запись происходит медленно.
2. При длительной нагрузке на запись в определенный момент времени фиксируется значительная деградация производительности СХД. Падение производительности ожидаемо и является особенностью работы SSD (write cliff), связанной с включением процессов garbage collection (GC) и ограниченной производительностью обозначенных процессов. Производительность дискового массива, фиксируемую после эффекта write cliff (после падения производительности), можно рассматривать как максимальную среднюю производительность дискового массива. Падение производительности наступает уже через 2-3 минуты пиковой нагрузки на запись, что является не очень хорошим показателем в сравнении с дисковыми массивами других производителей и свидетельствует о незначительности резерва дискового пространства для демпфирования пиковых нагрузок на запись.
3. Размер блока операций ввода-вывода влияет на производительность процесса garbage collection (GC).
В конфигурации RAID 5:
* Для маленьких блоков (4К) производительность GC — 180Мбайт/с (45000 IOPS);
* Для средних блоков (8-64К) производительность GC — 350Мбайт/с;
* Для больших блоков (1М) производительность GC — 800Мбайт/с.
В конфигурации RAID 0:
* Для маленьких блоков (4К) производительность GC — 575Мбайт/с (143750 IOPS);
* Для средних и больших блоков (8-64К) производительность GC — 1200Мбайт/с.
4. Кэш контроллеров не влияет на поведение СХД при длительной пиковой нагрузке на запись. Момент падения производительности (Write Cliff) наступает в одно и то же время независимо от использования кэша массива на запись (График 2). Производительность СХД после падения производительности так же не зависит от использования кэша.
5. Заполненность СХД не влияет на работу процессов GC (График 3).
6. В условиях профиля нагрузки на СХД с частой интенсивной записью длительностью 2-3 и более минут для работы наиболее эффективен блок размером 8К.
7. Из результатов тестов с длительной смешанной нагрузкой видно, что при падении производительности операций записи пропорционально падает и производительность операций чтения. Вызвано это, вероятнее всего тем, что процессы fio генерировали нагрузку именно в указанных пропорциях (70/30 или 50/50), то есть на практике подобное поведение дискового массива можно ожидать при наличии зависимости между процессами записи и чтения.
8. Тесты с длительной смешанной нагрузкой показали, что производительность операций записи на смешанной нагрузке такая же, как и при чистой нагрузке на запись. Можно сделать вывод, что операции чтения не влияют на производительность garbage collection.
9. Производительность операций записи (как до падения производительности, так и после), существенно выше в конфигурации СХД — RAID0.
##### **Группа 2: Тесты производительности дискового массива при разных типах нагрузки, исполняемые на уровне блокового устройства, при конфигурации СХД R5.**
**Графики. (Все картинки кликабельны)**
| | | | |
| --- | --- | --- | --- |
| | Синхронным способом в/в | Асинхронным способом в/в с глубиной очереди 32 | Асинхронным способом в/в с глубиной очереди 64 |
| При случайном чтении | | | |
| При случайной записи | | | |
| При смешанной нагрузке (70% чтение, 30% запись) | | | |
**Таблицы 3-5. (Все картинки кликабельны)**
| |
| --- |
| |
| Таблица 3. Производительность СХД в конфигурации RAID 5 при одном процессе, генерирующем нагрузку (jobs=1) |
| |
| --- |
| |
| Таблица 4. Максимальная производительность СХД в конфигурации RAID 5 при задержках меньше 1мс |
| |
| --- |
| |
| Таблица 5. Максимальная производительность СХД в конфигурации RAID 5 при различном профиле нагрузки. |
**Основные выводы:**
1. Максимально зафиксированные параметры производительности для СХД в конфигурации RAID 5 (из средних за время выполнения каждого теста — 1 мин):
Запись:
* 110 000 IOPS при latency 4,7ms (блок 4KB async qd32,64);
* при синхронном вводе-выводе — 88 000 IOPS при latency 2,5 ms (блоки 4К и 8К);
* Bandwidth: 2130МБ/c для больших блоков (1МБ), около 1000Мб/с для средних блоков (16-64К).
Чтение:
* 140 000 IOPS при latency 1,8ms (блоки 4 и 8K async qd64);
* при синхронном вводе-выводе — 91 000 IOPS при latency 0,7ms (блок 4К);
* Bandwidth: 3160МБ/с для больших блоков.\*
Смешанная нагрузка (70/30 rw):
* 132 000 IOPS при latency 1,9ms (блоки 4 и 8К async qd64);
* при синхронном вводе-выводе- 87 000 IOPS при latency 1,4ms (блоки 4, 8, 16К);
* Bandwidth 4100МБ/с для больших блоков (1Мбайт) и около 3000Мбайт/с для блоков 64, 32К.\*
**\*** *Учитывая тот факт, что дисковый массив подключен к тестовому серверу посредством 4-х 8Gb/s полученные значения с большой вероятностью не являются предельными для дискового массива, ограничивающим фактором явилась полоса пропускания канала подключения к серверу.*
Минимально зафиксированная latency:
* При записи – 0,9ms для блока 4K jobs=1,2 sync
* При чтении — 0,6ms для блоков 4K и 8К jobs=1-8 sync
2. СХД входит в режим насыщения при:
* асинхронном способе в/в при 2-4 jobs на блоках 32К, 64К и при 8 jobs на маленьких и средних блоках (4-16К).
* синхронном способе в/в при 128-192 jobs.
3. На блоках 1Мбайт получена максимальная пропускная способность в 2 раза превышающая максимальные показатели, полученные на средних блоках (16-64К).
4. Массив выдает одинаковое количество операций ввода-вывода на блоках 4 и 8К и чуть меньшую на блоке 16К. Оптимальными блоками для работы с массивом являются 8 и 16К.
##### **Группа 3: Тесты производительности дискового массива при разных типах нагрузки, исполняемые на уровне блокового устройства, при конфигурации СХД R0.**
**Графики. (Все картинки кликабельны)**
| | | | |
| --- | --- | --- | --- |
| | Синхронным способом в/в | Асинхронным способом в/в с глубиной очереди 32 | Асинхронным способом в/в с глубиной очереди 64 |
| При случайном чтении | | | |
| При случайной записи | | | |
| При смешанной нагрузке (70% чтение, 30% запись) | | | |
**Таблицы 6-8. (Все картинки кликабельны)**
| |
| --- |
| |
| Таблица 6. Производительность СХД в конфигурации RAID 0 при одном процессе, генерирующем нагрузку (jobs=1) |
| |
| --- |
| |
| Таблица 7. Максимальная производительность СХД в конфигурации RAID 0 при задержках меньше 1мс |
| |
| --- |
| |
| Таблица 8. Максимальная производительность СХД в конфигурации RAID 0 при различном профиле нагрузки. |
**Основные выводы:**
1. Максимально зафиксированные параметры производительности для СХД в конфигурации RAID 0 (из средних за время выполнения каждого теста — 1 мин):
Запись:
* 311 000 IOPS при latency 1,6ms (блок 4KB async qd32,64);
* при синхронном вводе-выводе — 190 000 IOPS при latency 0,7 ms (блоки 4К и 8К);
* Bandwidth: 3160МБ/c для больших блоков (1МБ), около 2500Мб/с для средних блоков (16-64К).\*
Чтение:
* 310 000 IOPS при latency 3,3ms (блок 4K async qd64);
* при синхронном вводе-выводе — 91 000 IOPS при latency 0,7ms (блок 4К);
* Bandwidth: 3260МБ/с для больших блоков.**\***
**\*** *Учитывая тот факт, что дисковый массив подключен к тестовому серверу посредством 4-х 8Gb/s полученные значения с большой вероятностью не являются предельными для дискового массива, ограничивающим фактором явилась полоса пропускания канала подключения к серверу.*
Смешанная нагрузка (70/30 rw)
* 305 000 IOPS при latency 1,2ms (блок 4К async qd64);
* при синхронном вводе-выводе — 225 000 IOPS при latency 0,95 ms (блоки 4К);
* Bandwidth 4140МБ/с для больших блоков (1Мбайт, 64К, 32К).
Минимально зафиксированная latency:
* При записи – 0,35ms для блока 4K jobs=1,2 sync
* При чтении — 0,6ms для блоков 4K и 8К jobs=1sync
2. СХД входит в режим насыщения при:
* асинхронном способе в/в при 2-4 jobs на блоках 32К, 64К и при 8 jobs на маленьких и средних блоках (4-16К).
* синхронном способе в/в при 64-128 jobs.
3. На блоках 1Мбайт получена максимальная пропускная способность в 2 раза превышающая максимальные показатели, полученные на средних блоках (16-64К)
4. Массив в конфигурации RAID0 выдает одинаковое количество операций ввода-вывода на блоках 4 и 8К и чуть меньшую на блоке 16К. Оптимальными блоками для работы с массивом являются 8 и 16К.
**Выводы**
----------
От работы с массивом остались приятные впечатления. Полученные результаты производительности оказались выше ожидаемых. Массив отличает классическая архитектура систем хранения с двумя контроллерами, стандартные уровни RAID и обычные eMLC SSD накопители. Следствием такой архитектуры являются низкая стоимость по сравнению с другими флэш-СХД и более высокие задержки обработки операций ввода-вывода.
Huawei Dorado G2 отлично подойдет для многопоточных нагрузок, не сильно критичных к задержкам. | https://habr.com/ru/post/265143/ | null | ru | null |
# Резервное копирование веб-проектов на Яндекс.Диск без ООП и натурщиц
Позавчера хабраюзер [vasiatka](https://habrahabr.ru/users/vasiatka/) в посте [№206752](http://habrahabr.ru/post/206752/) поделился с хабрасообществом, а следовательно и со всем остальным миром, продуманным и весьма развитым классом для работы с Яндекс.Диском. Некоторое время назад я тоже стал использовать этот сервис для хранения там бэкапов. Хочу поделиться значительно более коротким вариантом скрипта на php, который делает архивы базы данных и файлов сайта, и заливает их по WebDAV. Возможно кому-то и он придётся по душе.
*Если кто-то хочет сразу взглянуть на полный листинг — [он внизу](#source).*
Описание
--------
Скрипт, который я предлагаю вашему вниманию, довольно лаконичный. Если исключить задание параметров и вывод отчета, то останется что-то **около тридцати строк**. И хотя параметры и их названия говорят сами за себя, я всё же опишу их с комментариями.
С какими облаками работает этот скрипт
--------------------------------------
Так как загрузка файлов происходит по протоколу WebDAV, то скрипт должен уметь работать с любыми хранилищами такого рода.
Я протестировал только Яндекс и Mail.Ru, загрузка происходит успешно, но папку загрузки нужно создать на облаке заранее. На 2013.12.22 поддержка этого протокола у Mail.Ru нигде не афишируется, и заявлена только как работающая в тестовом режиме. Используйте с осторожностью.
Настройки
---------
###### Логин и пароль, и путь на облаке
Логин указывается в полной форме, т.е. с собачкой и доменом. Пароль указывается как и любой уважающий себя пароль — целиком.
```
$WebDAV = [
'login'=>'',
'password'=>'',
'url'=>'https://webdav.yandex.ru/backups/sites/',//для Яндекса
'url'=>'https://webdav.cloud.mail.ru/backups/sites/',//для Mail.Ru
];
```
Путь к облаку и путь к целевой папке надо указывать целиком. Папку, куда вы планируете складывать свои драгоценные архивы, стоит создать самостоятельно заранее. Я проверил, и это точно, что она не сможет появиться автоматически. Если этого не сделать, загрузка всё равно будет идти. В случае Яндекса, судя по весу результата, загруженные файлы просто склеиваются в один большой. В случае Mail.Ru не появится ничего. Обязателен закрывающий слеш.
###### Локальный путь для создания архивов
Хотя архивацию и заливку на сервис можно сделать одной строкой, в моём скрипте прежде чем загрузить файл, требуется его где-то создать. Путь для создания архивов задаётся в этой переменной.
```
$backupPath
```
Можно размещать хранилище локальных копий внутри сайта, а путь добавить в список исключенных из архивирования путей.
###### Список баз данных
Записывайте в массив $databases те базы, которые вы хотите архивировать. Вероятно стоит создать пользователя в БД без прав изменения и записи для такого использования.
```
$databases = [['login' => '', 'password' => '', 'dbname' => '']];
```
###### Список сайтов
Стандартный вид одного из членов массива $sites — списка архивируемых сайтов.
```
'name' => 'site1.ru',
'path' => '/var/www/site1.ru',
'exclude' => []
```
Первый параметр — название сайта. Просто строка, которая будет приписываться к имени архива вашего сайта.
Второй — путь к файлам сайта.
Третий — список директорий, которые стоит исключить из архивации. Исключение отдельных файлов я не предусмотрел, но вы можете легко это добавить самостоятельно. Если вы создаёте архивы внутри одного из своих сайтов, то можете исключить это хранилище.
Пример:
```
'exclude' => [
$backupPath, //Исключить папку с бэкапами, если она находится внутри одного из сайтов
'/var/www/site2.ru/temp' //Исключим что-нибудь еще
]
```
На этом конфигурация скрипта заканчивается, и он готов трудиться во благо ~~революции~~… ~~общества~~… вебадмина.
Если база данных небольшая, а файлы весят не слишком много, то можно вызывать скрипт кроном хоть каждый час. Файлы с одинаковыми именами будут перезаписываться и в локальном хранилище, и на Яндекс.Диске. На следющий день будет создаваться файл с новой датой и примерно таким именем:
`site1.ru.2013-12-20.zip`
Если же вы хотите давать архивам уникальное имя каждый раз, то стоит заменить строку
```
$date = date('Y-m-d');
```
на
```
$date = date('Y-m-d-H-i-s');
```
и тогда дата будет с указанием времени вплоть до секунд.
Слушайте, и не говорите, что не слышали
---------------------------------------
Хочу предупредить, что этот скрипт не претендует на надёжный метод бэкапа часто меняющихся сайтов, сайтов с тяжелой базой данных, или иных взрослых и серьёзных веб-проектов. Но для сайтов-визиток — самое то.
Важное замечание: ваш логин и пароль будет виден в списке запущенных процессов во время закачки.
Собственно всё
--------------
Спасибо, что уделили внимание и прочли этот пост. Надеюсь, кому-то моя поделка облегчит жизнь, душевное спокойствие, и даже возможно спасёт в тяжелую минуту. Удачи!
**UPD:** Спасибо [lolipop](https://habrahabr.ru/users/lolipop/) за [упоминание Mail.Ru](http://habrahabr.ru/post/206898/#comment_7127642). Изменил скрипт так, чтобы он работал и с их терабайтным хранилищем. Теперь будет, чем его забить! И хотя в ходе поисков поначалу я встречал информацию, что поддержки WebDAV у них нет, после я обнаружил упоминание нужного адреса [тут](http://mailblog.mail.ru/Облако-mail-ru-больше-чем-диск-100Гб-бесплатно/). Пока только в тестовом режиме. Жаль, что это выяснилось только сейчас — у меня топик уже уплыл из списка новых. И те, кто его уже прочел, наверное об этом не узнают. А в свете акции с целым терабайтом места это весьма актуально.
**UPD:** Спасибо [vk2](https://habrahabr.ru/users/vk2/) за [правильное замечание](http://habrahabr.ru/post/206898/#comment_7127738), что ваш пароль и логин будет виден на сервере в списке процессов.
**UPD:** Спасибо [kosenka](https://habrahabr.ru/users/kosenka/), указал, что обязателен закрывающий слеш в пути WebDAV. Действительно, это же папка. Упустил я, но теперь исправил и в примере, и в скрипте.
Так же подсказал, что если curl ругается на сертификат, ему надо указать ключ -k, что позволит ему подключаться к сайтам без или с неправильным сертификатом.
Еще он справедливо заметил, что zip есть далеко не на каждом хостинге. Постараюсь добавить в ближайшее время строчку для кошерного gzip.
**Полный листинг**
```
$WebDAV = [
'login'=>'',
'password'=>'',
//url включает в себя и путь к папке на облаке, в которую вы хотите залить свои файлы
//'url'=>'https://webdav.yandex.ru/backups/sites/',//Папку обязательно нужно создать руками заранее, иначе загрузит всё в один файл.
'url'=>'https://webdav.cloud.mail.ru/backups/sites/',//Папку обязательно нужно создать руками заранее, иначе загрузки не будет вообще.
];
$backupPath = 'path to backups'; //папка, куда складывать бэкапы локально на сервере, прежде чем залить по WebDAV
$databases = [['login' => '', 'password' => '', 'dbname' => '']];
$sites = [
//конфиг обычного сайта:
[
'name' => 'site1.ru',
'path' => '/var/www/site1.ru',
'exclude' => []
],
//конфиг с демонстрацией возможных вариантов
['name' => 'site2.ru',
'path' => '.', //Вы можете использовать 'path' => '.' чтобы архивировать сайт, внутри которого лежит данный скрипт.
'exclude' => [ //Если требуется исключить какие-то папки, то это можно сделать сдесь. Исключение отдельных файлов я не предусмотрел, но вы можете легко это добавить самостоятельно.
$backupPath, //Исключить папку с бэкапами, если она находится внутри одного из сайтов
'/var/www/site2.ru/temp' //Исключим что-нибудь еще
]
],
];
// Конфигурационная часть на этом заканчивается.
/////////////////////////////////////////////////////////////////////////////////////////
//Если не прописать в дату часы и минуты, то имена файлов будут совпадать, и файл на Яндекс.Диске будет перезаписан.
//Соотв. можно делать бэкап каждый час, при этом файлы не будут излишне плодиться.
//На следующий день будет создан новый файл.
$date = date('Y-m-d');
$errors = [];
$success = [];
$files_to_send = [];
foreach ($databases as $db) {
$filename = "$backupPath/bases/{$db['dbname']}.$date.sql.gz";
$output = `mysqldump --user={$db['login']} --password={$db['password']} {$db['dbname']} | gzip -f > $filename`;
if (!file_exists($filename)) {
$errors[] = 'Dump ' . $db['dbname'] . ' failed: ' . $output;
} else {
$success[] = 'DB ' . $db['dbname'] . ' dumped';
$files_to_send[] = $filename;
}
}
foreach ($sites as $site) {
$filename = "$backupPath/files/{$site['name']}.$date.zip";
$exclude = '';
if ($site['exclude']) {
$exclude = '-x ' . implode('\* -x ', $site['exclude']) . '\*';
}
$cmd = "zip -r \"$filename\" {$site['path']} $exclude";
echo $cmd . "
\n";
$output = `$cmd`;
if (!file_exists($filename)) {
$errors[] = 'Site backup ' . $site['name'] . ' failed: ' . $output;
} else {
$success[] = 'Site ' . $site['name'] . ' saved';
$files_to_send[] = $filename;
}
}
foreach ($errors as $e) {
echo 'Ошибка: ' . $e . "
\n";
}
echo "
\n";
foreach ($success as $s) {
echo 'ОК: ' . $s . "
\n";
}
echo "
\n";
echo "Следующие файлы будут загружены:
\n";
foreach ($files_to_send as $f) {
echo $f . "
\n";
}
echo "
\n";
if (!empty($files_to_send)) {
foreach ($files_to_send as $file) {
echo shell_exec("curl --user {$WebDAV['login']}:{$WebDAV['password']} -T \"$file\" {$WebDAV['url']}") . "
\n";//если ругается на сертификат, можно добавить ключ -k
}
}
``` | https://habr.com/ru/post/206898/ | null | ru | null |
# Поиск it компаний с аккредитацией минцифры и крупицы Big Data
Времени на раскачку нет - сразу к делу.
На сайте [digital.gov.ru](https://digital.gov.ru/ru/activity/govservices/1/?utm_referrer=https%3a%2f%2fwww.google.com%2f) можно найти документ со списком организаций, прошедших аккредитацию минцифры.
Давайте добавим в [@CryptedRobot](/users/cryptedrobot), который всегда можно найти в телеграме, возможность проверки по ИНН или названию организации - является ли эта организация аккредитованной.
```
import pandas as pd
import numpy as np
df = pd.read_excel('mobi.xls')
arr = np.array(df)
def find_organizations(search_string: str) -> list:
result = []
for item in arr:
if search_string.lower() in str(item).lower():
result = [item] if not len(result) else [*result, item]
return result
```
Это простая функция, которая осуществляет поиск по xls файлу, который предварительно загружен в оперативную память как np array.
Далее остается только вызвать эту функцию, передав в нее поисковую строку (ИНН или часть названия организации, которую вы хотите проверить):
```
na = find_organizations('7715004077') # numpy array
(
number,
insert_date,
full_name,
egrul,
inn,
revision_date,
revision_number,
change_date,
changes,
status,
) = na[0]
# this is how we can destruct numpy array to separate variables
```
Дальше остается только отправить значения через ТГ бот апи, чтобы получить красивое сообщение:
Как обычно, надеюсь, это кому-то окажется полезным. | https://habr.com/ru/post/690474/ | null | ru | null |
# Как сделать удобное взаимодействие с Kotlin из Swift: решение с помощью плагина MOKO KSwift
Привет! На связи Алексей Михайлов, технический директор компании IceRock Development. [В прошлой статье](https://habr.com/ru/post/697966/) я рассказывал о том, какие проблемы есть в работе с Kotlin со стороны Swift, и рассматривал способы их решения. В этой статье подробно остановлюсь на третьем решении, которое мы используем на практике. Это Gradle-плагины, а именно плагин, который мы разработали сами.
### В этой статье я расскажу:
1. [Gradle-плагин, который мы сделали](#Gradle-plagin-kotoryj-my sdelali)
2. [Klib’ы и с чем их едят](#Kliby-i s chem-ih edjat)
3. [Что еще за промежуточное представление](#Chto-eshhe-za promezhutochnoe-predstavlenie)
4. [Что делать с промежуточным представлением](#Chto-delat-s promezhutochnym-predstavleniem)
5. [Как решить проблемы, связанные с промежуточным представлением](#Kak-reshit-problemy-svjazannye-s promezhutochnym-predstavleniem)
6. [Итоги: что делать, чтобы со стороны Swift вам было удобнее и проще работать с тем, что сгенерировал Kotlin](#Itogi-chto-delat-chtoby-so storony-Swift-vam-bylo-udobnee-i proshhe-rabotat-s tem-chto-sgeneriroval-Kotlin)
### Gradle-плагин, который мы сделали
Это [MOKO KSwift](https://github.com/icerockdev/moko-kswift). Его главная особенность в том, что он генерирует Swift-код на основе промежуточного представления Kotlin. А промежуточное представление он берет уже из klib’ов, которые попадают в процессе компиляции Kotlin на этап линковки как раз в тот момент, когда создается бинарник для iOS. Сам плагин имеет потенциал для расширения. В нем есть сразу два сделанных нами генератора:
* поддержка sealed-интерфейсов и sealed-классов с созданием из них swift enum’ов;
* поддержка Kotlin extension’ов, с созданием из них нормальных extension’ов со стороны Swift.
*Пример работы генераторов*
На изображении выше вы можете видеть пример: у нас был sealed-интерфейс, мы получили enum, и все, что требовалось, сгенерировалось автоматически. Можно обрабатывать это в switch, тогда все будет без ветки default.
Покажу на схеме. Начало цепи точно такое же: Xcode → Gradle → компилятор. Но дальше, именно на этапе линковки, когда Kotlin-код уже весь скомпилирован, у нас просто имеется набор klib’ов. Все эти klib’ы передаются уже в отдельные таски опять же самого Kotlin на линковку.
В момент завершения линковки добавляется триггер для вызова нашего Gradle-плагина. Первым делом он читает все klib’ы, которые участвовали в линковке. И при чтении всех klib’ов он узнает о вообще всех тех типах, классах, методах... — в общем, обо всем, что у вас попало в бинарник. И, когда он прошелся по всему этому, плагин находит там именно то, что ему надо (sealed’ы или extension’ы), и на основе этой информации уже генерирует код, используя библиотеку SwiftPoet.
Когда генерация закончится и Gradle прекратит работу, в Xcode уже должен быть подключен не только сам Kotlin-фреймворк, но и сгенеренные Swift-файлы. Их тоже надо будет добавить в Xcode, и все это будет участвовать в итоговой компиляции.
### Klib’ы и с чем их едят
Я много раз упомянул klib’ы, самое время рассказать, что это такое.
Klib — это сокращение от Kotlin library, то есть это библиотека Kotlin. Компилятор Kotlin/Native работает только с klib’ами. Все, что компилятору надо для сборки итогового бинарника, неважно, будет это фреймворк или приложение, — это как раз klib’ы. Они тоже разбиваются по таргетам, поэтому для каждого таргета своя klib. И в каждой klib есть промежуточное представление.
Промежуточное представление содержит все, что вы написали в коде, за исключением комментариев. Поэтому из klib’ов мы можем узнать все важное для программы. И для чтения klib’ов мы используем официальную библиотеку от JetBrains. Они сами ее поддерживают и используют в инфраструктуре компилятора, и ее можно подключать к своим плагинам и использовать, что мы и сделали. Поэтому не будет такой ситуации, когда после выпуска новой версии Kotlin мы должны переделывать чтение klib’ов: этим занимаются сами JetBrains.
### Что еще за промежуточное представление
Про это понятие я расскажу кратко, потому что если вдаваться в детали, то вопросов будет больше, чем ответов. Можно посмотреть [статью на сайте НГУ](https://journals.nsu.ru/upload/iblock/027/%D0%91%D0%BE%D0%B3%D0%BE%D0%BB%D0%B5%D0%BF%D0%BE%D0%B2.pdf) про то, как это все придумали во времена начала Kotlin/Native и зачем.
Например, у нас есть Kotlin-код (см. изображение выше), и в процессе компиляции мы получаем как раз промежуточное представление, или intermediate representation (IR) (см. пример ниже). Это полное промежуточное представление кода с предыдущего изображения. Нас интересует в плагине именно то, что мы видим про саму функцию, то есть ее сигнатуру. Тут мы знаем ее имя, ее область видимости, аргументы, возвращаемое значение, типы, аннотации и generic’и, если они есть. То есть тут есть вообще все, что влияет на код.
```
FUN name:f visibility:public modality:FINAL <>
(x:kotlin.Boolean) returnType:kotlin.Int
annotations:
SSA
VALUE_PARAMETER name:x index:0 type:kotlin.Boolean
BLOCK_BODY
VAR name:a type:.A [val]
WHEN type=.A origin=IF
BRANCH
if: GET\_VAR 'x: kotlin.Boolean'
type=kotlin.Boolean
then: BLOCK type=.A
CONSTRUCTOR \_CALL 'public constructor
(arg: kotlin.Int) [primary]' type=.A
arg: CONST Int type=kotlin.Int value=5
BRANCH
if: CONST Boolean type=kotlin.Boolean value=true
then: BLOCK type=.A origin=null
CONSTRUCTOR\_CALL ‘public constructor
(arg: kotlin.Int) [primary]' type=.A
arg: CONST Int type=kotlin.Int value=6
CALL ‘public final fun print (): kotlin.Unit’
type=kotlin.Unit
$this: GET\_VAR ‘val a: .A [val]' type=.A
RETURN type=kotlin.Nothing
CONST Int type=kotlin.Int value=0
```
*Что такое IR*
Лично я разбирался с IR по тому, что удавалось нагуглить, а удавалось нагуглить не сильно много. Есть [статья](https://blog.bnorm.dev/writing-your-second-compiler-plugin-part-1), где рассказывается, откуда все взялось и как это примерно выглядит, но не более. Больше всего помогал дебагер.
Вообще klib’ы могут содержать в себе все, что вам надо. Есть [библиотека от JetBrains](https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-metadata-klib), которую мы используем, и вы тоже можете ее использовать. Я подцепил ее и передавал туда klib, которую сам скомпилил, и через отладчик смотрел, что он мне выдает. Там было очень много содержимого, и через отладчик я и узнал большую часть всего.
Как именно генерировать новый код, так, конечно, особо не научишься. Я пробовал сделать компиляторный плагин, который будет делать то же самое, что и KMP-NativeCoroutines, но тут все еще сложнее. Надо знать, что сгенерировать и куда что дописать в самом промежуточном представлении. В этом мне очень помогло [это выступление](https://www.youtube.com/watch?v=w-GMlaziIyo) и [этот вебинар](https://www.droidcon.com/2020/10/10/the-magic-of-compiler-extensions/?video=453613951) (на английском языке) про то, как сделать свой компиляторный плагин. Там объясняют на нескольких примерах: где-то просто генерация кода, где-то изменение написанного кода.
Это основные доступные материалы, которые я видел. Как мне рассказали, в JetBrains при разработке фичей, связанных с компиляторными плагинами, команды советуются между собой, как это лучше реализовать.
Стабильный API для компиляторных плагинов был запланирован для версии 1.7, но сейчас его отложили до версии 1.8-1.9. В общем, нам еще года два ждать стабильного API, чтобы и Compose не ломался между новыми версиями Kotlin и JetBrains могли написать документацию. В данный момент они даже не пытаются писать документацию, а просто передают способы решения друг другу, что называется, из уст в уста.
Также вы можете посмотреть [запись выступления Ильмира Усманова из JetBrains](https://www.youtube.com/watch?app=desktop&v=Qo7rvJkF_ag#menu&ab_channel=Mobius), который непосредственно занимается всем этим в компиляторе. Он более подробно рассказывает про промежуточное представление, а также почему к этому пришли и как это дальше будет развиваться.
Уже сейчас промежуточное представление используется не только в Kotlin/Native, но и в Kotlin/JS. И даже в Kotlin/JVM оно приходит — через IR-компилятор, о котором говорили с версии 1.5 и на который опирается Compose. Все это благодаря промежуточному представлению, которое является общим для всех таргетов Kotlin.
### Что делать с промежуточным представлением
Промежуточное представление нужно для того, чтобы, зная вообще всю информацию о том Kotlin-коде, который мы написали, сгенерить наиболее подходящий Swift-код, упрощающий работу со стороны Swift для iOS-разработчиков.
В этом подходе остается одна проблема, которая пока еще не решена, но в дальнейшем будет решена. После компиляции Kotlin-кода в klib’ы все попадает на этап линковки. На этапе линковки есть дополнительная процедура, которая влияет на то, как мы будем видеть Kotlin-код со стороны Swift. Это называется mangling.
В чем суть: так как у нас в Kotlin есть пакеты, мы можем написать там какой-нибудь класс user в пакете «Фича1» и в пакете «Фича2». И в зависимости от того, какой импорт мы написали в нашем файлике Kotlin, будет показываться либо один, либо другой класс. Но когда мы скомпилируем все это с помощью Kotlin/Native и будем смотреть уже со стороны Swift, то там никаких пакетов не будет. Там просто будет весь наш фреймворк под названием Shared, например, и в нем все, что было в Kotlin, уже без пакетов. И поэтому вот этот вот user, которой был с одним и тем же именем в разных пакетах, здесь станет уже user и user\_, с подчеркиванием в конце.
То же самое будет происходить с функциями внутри интерфейсов, которые пересекаются по сигнатуре. Причем в сигнатурах Kotlin не учитываются имена аргументов, там влияние оказывает тип, а в сигнатурах Objective-C и Swift — наоборот. Вот такая разница языков. Из-за того, что эти подчеркивания добавляются именно на этапе линковки, может получиться так, что мы сгенерируем новый Swift-код, который будет опираться на то, что к классу user добавили какой-то extension. А после линковки окажется, что Kotlin/Native назвал этот класс уже не user, а user\_, и код будет невалидным.
### Как решить проблемы, связанные с промежуточным представлением
Пока видится два варианта.
**Первый вариант** я видел в коммитах компиляторного плагина Jetpack Compose. Это, по сути, использование внутренностей самого компилятора Kotlin/Native, именно той логики, которая отвечает за добавление этих подчеркиваний. Вызвать ее, спросить у нее, какое там будет имя, и получить ответ. Но пока не было возможности проверить, насколько эта идея жизнеспособна.
**И второй вариант** — поступить как с Sourcery. Когда мы уже знаем, что сгенерированный header содержит такие-то имена, можно попробовать находить нужные нам классы уже в самом header’е, и понимать, надо нам добавлять там подчеркивание и сколько их будет, или не надо.
### Итоги: что делать, чтобы со стороны Swift вам было удобнее и проще работать с тем, что сгенерировал Kotlin
1. Если используете Flow и хотите использовать его со стороны Swift — подцепляйте плагин KMP-NativeCoroutines. Он точно облегчит вам задачу.
2. Если хотите использовать sealed-классы и sealed-интерфейсы, то цепляйте MOKO KSwift.
3. Если хотите использовать extension’ы для платформенных классов вроде UILabel, UITextView и прочих или для интерфейсов, то цепляйте MOKO KSwift либо Sourcery. И то, и то решает задачу.
4. Если хотите полностью собственный шаблон, то можно Sourcery, если вам вообще не нужна информация о Kotlin-классах и сигнатурах. Если же информация об оригинальном Kotlin-коде нужна, то придется сделать свой вариант фичи для MOKO KSwift.
5. Ну и можно постараться не использовать некоторые возможности в публичном API, например те же абстрактные классы. Так будет проще и надежнее.
Остались вопросы? Напишите в комментариях.
Мы пишем и другие статьи про KMM, подписывайтесь на [наш телеграм-канал](https://t.me/icerockdevclub), чтобы узнавать о них первыми. | https://habr.com/ru/post/700030/ | null | ru | null |
# Первые шаги с Netbeans и Wicket
Доброго времени суток. Недавно пришлось поюзать Java фреймворк по имени **Wicket**. На великом Хабре искал инфу про нее, но ее оказалось слишком мало и вот решил поделиться. Итак, пошли:
После того, как пару лет назад пересел на NetBeans, игры с командной строкой при создании веб-приложений меня особо не вдохновляют, поэтому, когда нужно использовать (проверить, протестить, посмотреть и т.п.) какой-нибудь фреймворк, то первым делом ищю Plugin для NetBeans, и только потом, в случае неудачи, обращаюсь к альтернативным (для меня) путям. В случае с Wicket-ом все оказалось хорошо. На официальном [сайте](http://wicket.apache.org) хоть и есть раздел [IDE Plugins](http://wicket.apache.org/learn/ides.html) и там даже есть и NetBeans в списке, но линки которые я там нашел толком не помогли найти плагин. Следующим шагом был поиск среди доступных плагинов NetBeans, но и там ждала меня неудача. Последняя попытка — поиск на сайте [NetBeans](http://netbeans.org/) в разделе [Plugins](http://plugins.netbeans.org/PluginPortal/). Ввел первые буквы в поисковом поле Name над таблицей плагинов и нашел — **Wicket 1.4 Support** (This plugin adds wicket support for NetBeans IDE 7.0.). Скачал его и установил (Tools -> Plugins -> Downloaded -> Add Plugins -> Install). Более подробно об этом шаге можно прочитать в [FAQ](http://wiki.netbeans.org/FaqPluginInstall)-е на сайте NetBeans-а.
После установки плагина NetBeans просит перезапуститься. Далее, нам нужно создать новый веб-проект и при выборе платформ выбираем Wicked 1.4.10, и идем дальше… (Java Web -> Web-Application -> -> -> Wicked 1.4.10 (ставим галочку) –>->). Итак, NetBeans сгенерировал нам проект с Hello World-ом. Теперь давайте разберемся с проектом, который ждет нас:
Не теряйтесь, когда, запустив приложение, увидите результат, но не увидите файлов в папке веб страницы. Зато в пакете com.myapp.wicket есть следующие файлы:
`Application.java
BasePage.html
BasePage.java
FooterPanel.html
FooterPanel. java
HeaderPanel.html
HeaderPanel.java
HomePage.html
HomePage.java`
Как вы успели заметить, все файлы идут парами, один только Application.java ~~неприлично~~ выделяется среди пар html-java файлов. В нем есть информация о том, какой файл (страницу) запускать первым. Так же можно прописать определенные конфиги, но это не входит в рамки данной статьи.
Как вы видите, «конфигуратор» возвращает в качестве домашней страницы класс HomePage. До того как будем рассматривать этот файл пару слов о структуре.
В данной диаграмме классы **WebPage** и **Panel** родные Wicket-овские, а все остальные созданы NetBeans-ом. Каждый из сгенерированных классов имеет пару с тем же именем, но с расширением html. В данном примере, файл BasePage.html определяет общую структуру страницы, а BasePage.java определяет функционал и сами данные которые размещяются. С помощью DOM Wicket находит нужные элементы из HTML файлов и заменяет их тем, что вы пишите в соответствующих java файлах. Это легко объяснить с помощью рисунка в котором приведены рядом HomePage.java (слева) и HomePage.html (справа):
Как видно из рисунка, в нашу домашнюю страничку добавляется новый **Label**. Он принимает два параметра, где первый это ключевое слово, по которому Wicket определить, куда вставить Label, а второе – это собственно содержимое. Разбор других страниц и панелей можно произвести аналогично, это я оставляю сделать читателю самому, а сам тем временем покажу вам, как создать простую форму, используя этот замечательный фреймворк. Для этого сначала нужно выбрать, где создать нашу форму. Пусть это будет **BasePage.java** и **BasePage.html**. Сначала создадим HTML-форму.
`/>`
Таким незамысловатым кодом мы создали простейшую форму авторизации.
Теперь перейдем к самому интересному – к файлу BasePage.java. Здесь все немножко сложнее. Алгоритм следующий:
Мы создаем объекты **TextField** и **PasswordTextField**, чтобы слинковать их с элементами страницы. Далее, создаем класс, который будет наследован от класса **Form**, он в свою очередь будет связан с нашей формой, в этом же классе переопределяем метод **onSubmit()**, который отвечает за то, что произойдет, когда пользователь нажмет на кнопку отправки данных. Потом остается только добавить объекты TextField и PasswordTextField в форму и саму форму добавить на страницу. Как видим, все логично, и нет ничего сверхъестественного. Ниже приведен код со страницы BasePage.java.
`public abstract class BasePage extends WebPage {
TextField login;
PasswordTextField password;
public BasePage() {
super();
add(new HeaderPanel("headerpanel", "Welcome To Wicket"));
add(new FooterPanel("footerpanel", "Powered by Wicket and the NetBeans Wicket Plugin"));
add(new footer("footer"));
login = new TextField("login", new Model(""));
password = new PasswordTextField("password", new Model(""));
Form form = new LoginForm("forma");
form.add(login);
form.add(password);
add(form);
}
class LoginForm extends Form{
public LoginForm(String id)
{
super(id);
}
public void onSubmit()
{
System.out.println("Login:"+login.getModelObject()+" -- Password:"+password.getModelObject());
}
}
}`
Вот и все. Теперь при нажатии на кнопку, в консоли можно увидеть введенные имя пользователя и пароль. Всем Успехов и счастья. | https://habr.com/ru/post/127047/ | null | ru | null |
# Ansible и Docker, почему и зачем?
Достаточно много интереса проявляется среди технического сообщества к [Docker](https://www.docker.io/) и [Ansible](https://github.com/ansible/ansible), я надеюсь, что после прочтения данной статьи, вы тоже разделите этот интерес. Вы так же получите навыки практического применения Ansible и Docker в настройке сервера и окружения для Rails приложения.
«Почему бы просто не взять и использовать Heroku?», спросите вы.
Прежде всего, я могу запустить Docker и Ansible на любой машине, с любым хостинг провайдером. Во вторых, я предпочитаю гибкость, удобству. Я могу, таким же образом, запускать все что угодно, не только web приложения. Ну и напоследок, потому что я эксперементатор в душе, я получаю удовольствие от понимания того как оно все вместе работает. Фундаментальная основа Heroku это Linux контейнер. Та же технология лежит и в основе Docker'a. На самом деле, одним из девизов Docker'a является «Контейнеризация это новая виртуализация»
#### Почему Ansible?
После 4 лет активного использования Chef, инфраструктура как код стала действительно утомительной для меня. Я проводил больше времени за кодом, который управлял моей инфраструктурой, но не за самой инфраструктурой. Любое изменение, не важно насколько маленькое, потребует большое количество усилий для незначительной выгоды.
С Ansible, с одной стороны есть данные описывающие инфраструктуру, с другой ограничения между взаимодействием других компонентов. Эта модель намного проще, она позволяет намного быстрее двигаться дальше, позволяя сосредоточится на том, что делает моя инфраструктура. Как и в Unix модели, Anisible предоставляет модули с единичной ответственностью, которые могут быть объедены бесконечным множеством способов.
Ansible не имеет зависимостей кроме как Python и SSH. Ей не нужно устанавливать агентов на удаленные машины, она не оставляет всякого рода мусора после своей работы. Более того, она поставляется со стандартной библиотекой модулей для управления всем чем угодно, начиная от пакетного менеджера в облаке, заканчивая базами данных.
#### Почему Docker?
Docker позиционирует себя как самый надежный и удобный способ развертывания процесса на машине. Это может быть все что угодно, от mysqld до redis, заканчивая Rails приложением. Таким же эффективным способом, как git снимки и распределение кода, Docker делает тоже самое с процессами. Он гарантирует, что будет предоставлено все, что нужно для запуска этого процесса, независимо от машины на которой он запущен.
Основная, но понятная ошибка, сравнивание Docker контейнера с VM. Здесь применяется принцип единственной ответственности, запуск одного процесса на контейнер дает простоту изменяемости и поддержки. Эта модель выдержала испытание временем в философии Unix, это дает прочный фундамент для действий.
#### Настройка
Не покидая свой терминал, я могу получить от Ansible настроенную машину на одном из следующих хостингов: AWS, Linode, Rackspace или DigitalOcean. Если быть более конкретным, я с помощью Ansible создаю новый дроплет с 2ГБ памяти на DigitalOcean в регионе Amsterdam 2 за 1 минуту 25 секунд. В течение еще 1 минуты и 50 секунд я могу получить настроенную систему с Docker'ом и некоторыми другими установками. Теперь, имея базовую систему, я могу развернуть свое приложение. Заметьте, я не настраивал какой либо язык программирования или базу данных. Docker сам позаботился об этом.
Ansible исполняет все команды на удаленных машинах через SSH. Мои SSH ключи, лежащие в локальном ssh-agent'е будут удаленно расшарены через SSH сессию Ansible. Когда, на удаленной машине, код моего приложения будет клонирован или обновлен никаких данных для авторизации в git не потребуется, для авторизации будет использован проброшенный ssh-agent с локальной машины.
#### Docker и зависимости приложения
Я нахожу забавным тот факт, что большинство разработчиков точно указывают версию ЯП, модули для Python, Ruby гемы или node.js модули, нужные для их приложения, но когда дело доходит до чегото важного, к примеру сервер БД или сервер очередей, они используют то что доступно на данный момент. Я думаю это одна из причин [DevOps](http://en.wikipedia.org/wiki/DevOps) движения, разработчики берут на себя ответственность за окружение в котором они запускают приложение. Docker делает эту задачу легче и проще, добавляя дольку прагматизма и уверенности к существующим практикам.
Мое приложение определяет зависимости от процессов, таких как MySQL 5.5 и Redis 2.8 включая `.docker_container_dependencies` файл
```
gerhard/mysql:5.5
gerhard/redis:2.8
```
Ansible playbook увидит этот файл и скажет Docker'у взять правильные образа из индекса образов и запустить их как контейнеры. Также эти контейнеры слинкуются в контейнер моего приложения. Если вы хотите подробностей о работе линковки контейнеров, загляните в [анонс Docker 0.6.5](http://blog.docker.io/2013/10/docker-0-6-5-links-container-naming-advanced-port-redirects-host-integration/)
Мое приложение так же идет с Dockerfile, который специфичен для Ruby Docker образа. Когда образ будет установлен, шаги в Dockerfile гарантируют, что будет установлена правильная версия Ruby.
```
FROM howareyou/ruby:2.0.0-p353
ADD ./ /terrabox
RUN \
. /.profile ;\
rm -fr /terrabox/.git ;\
cd /terrabox ;\
bundle install --local ;\
echo '. /.profile && cd /terrabox && RAILS_ENV=test bundle exec rake db:create db:migrate && bundle exec rspec' > /test-terrabox ;\
echo '. /.profile && cd /terrabox && export RAILS_ENV=production && rake db:create db:migrate && bundle exec unicorn -c config/unicorn.rails.conf.rb' > /run-terrabox ;\
# END RUN
ENTRYPOINT ["/bin/bash"]
CMD ["/run-terrabox"]
EXPOSE 3000
```
Первый шаг — это скопировать весь код моего приложения в образ Docker'a и загрузить глобальные переменные окружения, добавленные предыдущими образами. Образ Ruby Docker, например, добавляет в PATH пути для корректной загрузки правильной версии Ruby.
Далее, я удаляю историю git, поскольку она не нужна в данном контексте. Я устанавливаю все гемы и затем создаю /test-terrabox файл, который запускается только для тестов. Целью всего этого является иметь «canary» версию, которая проверяет приложение и все его зависимости, что все Docker контейнеры слинкованы правильно и все тесты пройдены успешно, перед актуальным запуском приложения.
Команда, которая вызывается при запуске нового контейнера, определена в шаге CMD.
Запуск /run-terrabox команды, определен как часть процесса сборки, сразу после процесса запуска тестов.
Последняя инструкция в Dockerfile пробрасывает порт 3000 изнутри Docker контейнера на хост машину из под которой запущен Docker. Который могут использовать сервер или балансировщик нагрузки для проксирования запросов в мое приложение контейнера.
#### Запуск Rails приложения внутри Docker контейнера
Для среднего Rails приложения, с где-то примерно 100 гемами и множеством интеграционных тестов, запускаемых из под Rails, запуск всего этого занимает 8 минут 16 секунд на 2GB и 2 ядерной машине, без каких либо локальных Docker образов. Если у меня уже есть Ruby, Mysql и Redis образа на этой машине, это займет 4 минуты 45 секунд. Более того, если у меня уже есть эталонный образ моего приложения, то это занимает 2 минуты 23 секунды. Если посмотреть, в перспективе, развертывание нового Rails приложения, включая такие зависимости как MySQL и Redis занимает не более 2 минут.
Так же следует заметить, что развертывание приложения включает в себя запуск всех тестов, которые занимают, впритык, минуту времени.
Без преувеличений, Docker становится простым средством непрерывной интеграции, которое оставляет за собой только тестовые контейнеры для исследования, если тесты не проходят, или стартует новый контейнер приложения с последней версией, когда тесты проходят. Внезапно, я могу проверить новый код с моими заказчиками за минуты, который гарантированно будет изолирован от других версий приложения на уровне операционной системы. В отличии от традиционных VM, которые загружаются за минуты, Docker на это тратит секунды. Более того, раз создав образ Docker'a и убедившись, что все тесты пройдены для специфичной версии моего приложения, я могу залить образ в приватный реестр, который в свою очередь, может быть загружен другими машинами с Docker'ом и запущен как новый контейнер, и все это за секунды.
#### Заключение
Ansible позволил мне взглянуть по новому на процесс управления инфраструктурой. Docker дал мне уверенность и стабильность, когда речь заходит об одном из важнейших шагов разработки, фазы доставки. В комбинации, они не имеют себе равных.
Получить с нуля полностью настроенное Rails приложение за каких то 12 минут это впечатляюще для любого стандарта. Получить базовую Continuous Integration систему бесплатно с возможностью предпросмотра разных версий приложении бок о бок, без затрагивания «рабочей» версии, запущенных на той же машине, это невероятно мощно. Это делает меня радостным, и достигнув конца статьи, я могу только надеяться, что вы разделите мою радость со мной. | https://habr.com/ru/post/217689/ | null | ru | null |
# Верстка писем и email рассылок. Немного магии Gmail
Автор изображения [Mike, Creative Mints](http://dribbble.com/shots/310396-Potion-2-0?list=searches&tag=magic)
Добрый день. Я уже не раз писал о том, что media\_queries в почтовых клиентах работают прекрасно. Даже outlook.com в браузере их адекватно воспринимает. Но вот gmail на яблоке и андроиде так не считает.
Если в случае остальных клиентов мы можем сделать, например так:
```
@media only screen and (max-width:480px) {
.big_img { display:none !important; } .small_img { display:block !important; }
}
@media only screen and (max-width:600px) {
.big_img { display:block !important; } .small_img { display:none !important; }
}
```
То в gmail на смартфонах и планшетах данный трюк не прокатит. Поясню. У нас есть две разные картинки для разных разрешений письма. И в зависимости от разрешения экрана мы показываем необходимое нам. Способ не претендует на правильность решения, а лишь показывает чего сделать нельзя. Ниже я покажу пару примеров того, как в gmail можно сделать все хорошо без особых усилий.
Допустим у нас есть письмо со следующим кодом:
```
| |
| --- |
| |
```
А так же media\_queries для него:
```
@media only screen and (max-width:480px) {
.wrapper { width:100% !important; }
}
```
В этом случае на десктопах везде мы получим письмо шириной в 600px. В мобильных клиентах 100%. Исключение — gmail, который будет вести себя немного иначе. И по разному в зависимости от контента внутри обертки.
В случае кучи текста в блоке контента или вот такой картинки
```
```
Письмо будет отображаться нормально, по всей ширине мобильного устройства. Gmail хоть и проигнорирует указанные нами media\_queries, но тем не менее подстроит резиновый контент под ширину экрана девайса.
А теперь давайте дадим ему вот такой контент.
```
| |
| --- |
| [fb](#)
[tw](#)
[vk](#)
[vk](#) |
```
Тут мы имеем четыре иконки соцсетей. Так вот мобильный gmail в таком случае эту табличку на всю ширину не растянет. Он сделает ее по ширине в размере места, которое занимают иконки внутри таблицы.
Как сделать хорошо? Очень просто. Объедините блок социальных иконок с блоком резинового контента вот так
```
| |
| --- |
| |
|
| |
| --- |
| [fb](#)
[tw](#)
[vk](#)
[vk](#) |
|
```
Резюмирую
---------
— Задавать фиксированные величины для обертки можно, gmail сам подстроит обертку под экран девайса
— Для элементов внутри обертки задаем процентные величины, либо фиксированные, но не более 320px по ширине.
— Мы не можем указывать разные стили отображения для разных разрешений экрана только в gmail клиентах.
Я изложил самые наболевшие примеры, которые встречаются в моей работе регулярно. Если у вас есть частные проблемы, описывайте их в комментариях, присылайте в личку или на dudeonthehorse собака gmail точка com. Я с удовольствием помогу решить проблему и, возможно, открою новые нюансы при верстке, о которых напишу в будущем. | https://habr.com/ru/post/193790/ | null | ru | null |
# Варианты создания интерактивной экскурсии для пользователей
(с) Freepik StorysetДоброго времени суток, уважаемые читатели!
Меня зовут Евгений Когтев, я ведущий разработчик в команде Web Core в ДомКлик. Мы уже [рассказывали](https://habr.com/ru/company/domclick/blog/520630/) подробнее о команде и стоящих перед ней задачах, если не читали, то рекомендую. А сегодня я расскажу, зачем нужен онбординг и как его реализовать в UI-kit.
Задача
------
Нужно адаптировать пользователей к продуктам компании, познакомить с функциями и показать основные преимущества. Это напрямую влияет на желание пользоваться этими инструментами в дальнейшем. Подобные задачи решает *онбординг (onboarding) — процесс знакомства пользователя с продуктом.*
Требования
----------
1. Каждый шаг может иметь вид подсказки (hint) или всплывающего окна (modal).
2. Подсказка должна полностью адаптироваться под видимую область окна браузера относительно подсвечиваемой области. Если не помещается ни с одной стороны, то показываем модальное окно.
3. Возможность анимированного перехода между элементами (плавная прокрутка страницы).
4. Полупрозрачный тёмный overlay.
5. Подсвечиваемая область должна быть с белой обводкой шириной 8 пикселей и радиусом закруглений в 5 пикселей.
Готовые инструменты
-------------------
Основные инструменты, которые удовлетворяют минимальным требованиям:
* Intro.js
* React-joyride
* Driver.js
* Shepherd
Больше всего меня интересовал вопрос подсветки элементов, и, признаюсь честно, разнообразие подходов удивило. Вкратце опишу каждый:
1. `box-shadow: rgba(0, 0, 0, 0.5) 0 0 0 5000px;` — огромная тень вокруг элемента.
2. `outline: 5000px solid rgba(0, 0, 0, .5);` — огромная рамка, не влияющая на размеры самого блока
3. `mix-blend-mode: hard-light;` — интересный и современный способ смешивания фоновых цветов overlay и элемента.
4. Накладываем на элемент overlay, внутри которого белая подложка. Затем циклично проходим скриптом по всем родителям элемента и убираем им z-index, тем самым поднимая подсвечиваемый контент выше всего остального.
5. Генерируем прозрачную SVG-картинкe с вырезом под выделяемый элемент.
Чтобы максимально уменьшить размер компонентов, решил писать свою реализацию. Вдохновлённый разнообразием интересных вариантов, захотел сделать нечто вроде SVG, только с использованием Canvas.
Реализация по пунктам
---------------------
1) С hint и modal проблем не возникло, так как они уже были в нашем UI kit'е со схожим API.
2) Здесь тоже не возникло проблем благодаря простому компоненту из kit'а — popper, в котором после вычисления расположения вызывается callback и передаётся параметром нужный флаг (удаётся ли расположить подсказку в видимой области), благодаря которому можем показать модальное окно.
3) Определяем по расположению компонента, надо ли до него пролистывать, и вызываем метод из внутренней библиотеки utils — функцию (она пролистывает вверх или вниз до ближайшей точки, в которой полностью виден hint + offset) с указанием цели, времени на анимацию и отступ от края экрана:
```
const { top, bottom } = nextElement.getBoundingClientRect();
if (!(top >= offset && bottom + offset <= document.documentElement.clientHeight)) {
animatedScrollTo({
element: nextElement,
duration,
offset,
});
}
```
4) Начнем с создания компонента:
```
import React, { useState, useEffect, useRef } from 'react';
import styles from './Onboarding.scss';
const Overlay = ({ targetStyles }) => {
const [scrollY, setScrollY] = useState(0);
const canvasRef = useRef();
const handleRepaint = () => {
const canvas = canvasRef.current;
const windowWidth = window.innerWidth;
const windowHeight = window.innerHeight;
canvas.width = windowWidth;
canvas.height = windowHeight;
};
useEffect(handleRepaint, [scrollY, targetStyles]);
useEffect(() => {
const handleScroll = () => setScrollY(window.scrollY);
window.addEventListener('scroll', handleScroll);
return () => {
window.removeEventListener('scroll', handleScroll);
};
}, []);
return (
);
};
export { Overlay };
```
Компонент рисуем через [createPortal](https://ru.reactjs.org/docs/portals.html), растягиваем на весь экран обёртку, а также сам canvas. Подписываемся на изменения расположения или размеров цели и прокрутки. Получаем контекст для отрисовки в canvas и рисуем само затемнение в виде прямоугольника `fillRect` с заливкой `fillStyle` и прозрачностью `globalAlpha`. В конце сбрасываем цвет заливки на белый и убираем прозрачность:
```
const handleRepaint = () => {
...
const context = canvas.getContext('2d');
context.fillStyle = overlayColor;
context.globalAlpha = overlayOpacity;
context.fillRect(0, 0, windowWidth, windowHeight);
context.fillStyle = '#ffffff';
context.globalAlpha = 1;
};
```
Вызываем нашу функцию для отрисовки прозрачного скруглённого прямоугольника с белой скруглённой обводкой:
```
// в targetStyles все свойства с учетом белой обводки
// для корректного расположения hint'а без сдвигов
const { width, height, top, left } = targetStyles;
const x = left - window.scrollX;
const y = top - window.scrollY;
roundClearRect({ ctx: context, x, y, width, height, radius });
```
Переходим к функции. Первым делом рисуем скругленный прямоугольник с белой заливкой, которую указывали выше, по размерам цели, включая внешнюю белую обводку:
```
// функция для рисования прямоугольника со скруглениями,
// путём отрисовки каждого угла по отдельности
// с помощью кривой линии методом quadraticCurveTo
const roundRect = ({ ctx, x, y, width, height, radius = 5, fill, stroke }) => {
const bottom = y + height;
const right = x + width;
ctx.beginPath();
ctx.moveTo(x + radius, y);
ctx.lineTo(right - radius, y);
ctx.quadraticCurveTo(right, y, right, y + radius);
ctx.lineTo(right, bottom - radius);
ctx.quadraticCurveTo(right, bottom, right - radius, bottom);
ctx.lineTo(x + radius, bottom);
ctx.quadraticCurveTo(x, bottom, x, bottom - radius);
ctx.lineTo(x, y + radius);
ctx.quadraticCurveTo(x, y, x + radius, y);
ctx.closePath();
if (fill) {
ctx.fill();
}
if (stroke) {
ctx.stroke();
}
};
const roundClearRect = ({ ctx, x, y, width, height, radius }) => {
roundRect({
ctx,
x,
y,
width,
height,
radius: 5,
fill: true,
});
...
};
```
Для прозрачной области применим композицию `globalCompositeOperation = 'destination-out'`. Остается нарисовать скруглённый прямоугольник, который будет отражать прозрачную область на текущем Canvas-слое. Для этого используем нашу функцию. Она корректно рисует скругления вплоть до радиуса в 25 пикселей. Поскольку кому-то может понадобиться выделить, например, круглую иконку, то будем считать, что всё более 25 пикселей — это круг. Реализуем его с помощью метода `arc`, который принимает первыми двумя параметрами `x` и `y` — центр элемента, — затем радиус, а также угол начала и конца окружности:
```
const roundClearRect = ({ ctx, x, y, width, height, radius }) => {
...
ctx.globalCompositeOperation = 'destination-out';
if (radius >= 25) {
ctx.beginPath();
ctx.arc(x + width / 2, y + height / 2, width / 2 - BORDER_WIDTH, 0, 2 * Math.PI);
ctx.closePath();
ctx.fill();
} else {
roundRect({
ctx,
x: x + BORDER_WIDTH,
y: y + BORDER_WIDTH,
width: width - BORDER_WIDTH * 2,
height: height - BORDER_WIDTH * 2,
radius,
fill: true,
});
}
};
```
На этом работа с canvas окончена, давайте посмотрим, что получилось:
Сразу бросаются в глаза две проблемы: размытость и артефакты.
1. Размытость на дисплеях с разрешением Retina.
2. Артефакты фоновой подложки.
Проблему размытости решаем с помощью функции, которая масштабирует слой canvas на соотношение физического пикселя к логическому:
```
const PIXEL_RATIO = (function () {
const ctx = document.createElement('canvas').getContext('2d');
const pixelRatio = window.devicePixelRatio || 1;
const backingStorePixelRatio = ctx.webkitBackingStorePixelRatio
|| ctx.mozBackingStorePixelRatio
|| ctx.msBackingStorePixelRatio
|| ctx.oBackingStorePixelRatio
|| ctx.backingStorePixelRatio || 1;
return pixelRatio / backingStorePixelRatio;
}());
function makeCanvasHiPPI(canvas) {
canvas.style.width = `${canvas.width}px`;
canvas.style.height = `${canvas.height}px`;
canvas.width *= PIXEL_RATIO;
canvas.height *= PIXEL_RATIO;
const context = canvas.getContext('2d');
context.scale(PIXEL_RATIO, PIXEL_RATIO);
return context;
}
```
Артефакты убираем с помощью добавления полупикселя к `x` и `y`.
Конфигурация
------------
Так как мы стараемся упростить коллегам из других команд жизнь, предоставляем им свойства для конфигурации визуальной части каждого шага (`title`, `subtitle`, `header`, `buttons` и т.п.), чтобы не тратили время на вёрстку:
```
const steps = [
target: document.getElementById('first-el'),
size: "large",
placement: "top",
align: "center",
title: Первый этап,
subtitle: Подзаголовок,
header:
];
}
```
Результат
---------
desktopmobileЗаключение
----------
Интерактивная экскурсия по вашему продукту (продуктам) — это мощный инструмент для увлечения пользователей, не пренебрегайте им. Реализация, как вы могли убедиться, ограничивается только вашим воображением. Также можно сделать CMS для управления экскурсиями по всему сайту, естественно, не злоупотребляя ими. Спасибо за внимание! | https://habr.com/ru/post/555228/ | null | ru | null |
# Обновление BIOS на сервере Dell PowerEdge R510
Производители серверного оборудования стараются следить за корректной работой своих продуктов. Одной из таких мер есть исправление и совершенствование [BIOS](http://en.wikipedia.org/wiki/BIOS)'a. В данной статье я расскажу как можно обновлять BIOS серверов Dell серии PowerEdge из дистрибутива [Fedora](http://fedoraproject.org/).
1. Узнаем версию текущей прошивки и модель сервера
```
[root@home ~]# smbios-sys-info
Libsmbios version: 2.2.28
Product Name: PowerEdge R510
Vendor: Dell Inc.
BIOS Version: 1.8.2
System ID: 0x02F1
Service Tag: XXXXXXX
Express Service Code: XXXXXXXXXXX
Asset Tag:
Property Ownership Tag:
```
Текущая версия BIOS'a 1.8.2.
2. На сайте [support.dell.com/support/DPP/Index.aspx?c=us&l=en&s=biz](http://support.dell.com/support/DPP/Index.aspx?c=us&l=en&s=biz)
Ищем по «Service Tag» наш сервер и переходим на вкладку «Drivers & Downloads». В выпадающем списке выбираем «Operating Systems: Red Hat Enterprise Linux 6». Скачиваем на сервер последнюю версию BIOS'a (файл с расширением .bin).
3. Существует два способа перепрошивки.
— запустив bin-файл
```
sh R510_BIOS_NGVY8_LN32_1.9.0.BIN
```
— через утилиту **smbios-rbu-bios-update**, но для этого необходимо выполнить подготовительные работы.
устанавливаем пакет **smbios-utils**
```
[root@home ~]# yum install smbios-utils
```
распаковываем bin-файл
```
[root@home ~]# mkdir firmware; sh R510_BIOS_NGVY8_LN32_1.9.0.BIN --extract firmware
```
смотрим инфо о новой версии прошивки
```
[root@home ~]# smbios-rbu-bios-update --hdr-info=firmware/payload/PER510-010900C.hdr
BIOS HDR file information dump.
Filename: firmware/payload/PER510-010900C.hdr
File magic header: $RBU
Header length: 84
Header major version: 2
Header minor version: 0
Number of supported systems: 6
Quick check field: Copyright 2011 Dell Inc.
BIOS Version (RAW):
BIOS Version: 1.9.0
Misc flags: 1
Compatibility flags: 91
System ID: 0x02f1 Hardware Revision: 0
System ID: 0x043c Hardware Revision: 0
System ID: 0x0460 Hardware Revision: 0
System ID: 0x0474 Hardware Revision: 0
System ID: 0x0475 Hardware Revision: 0
System ID: 0x048a Hardware Revision: 0
```
непосредственно сама перепрошивка и перезагрузка сервера
```
[root@home ~]# smbios-rbu-bios-update --hdr=PER510-010900C.hdr -u --reboot
```
после перезагрузки проверяем текущую версию прошивки
```
[root@home ~]# smbios-sys-info
Libsmbios version: 2.2.28
Product Name: PowerEdge R510
Vendor: Dell Inc.
BIOS Version: 1.9.0
System ID: 0x02F1
Service Tag: XXXXXXX
Express Service Code: XXXXXXXXXXX
Asset Tag:
Property Ownership Tag:
```
В итоге получаем обновленный BIOS версии 1.9.0.
Данным способом можно перепрошивать BIOS на всех серверах серии Dell PowerEdge. | https://habr.com/ru/post/144575/ | null | ru | null |
# Проектирование типами: Как сделать некорректные состояния невыразимыми
*Представляю вашему вниманию перевод статьи Scott Wlaschin ["Designing with types: Making illegal states unrepresentable"](https://fsharpforfunandprofit.com/posts/designing-with-types-making-illegal-states-unrepresentable/).*
В этой статье мы рассмотрим ключевое преимущество F# — возможность "сделать некорректные состояния невыразимыми" при помощи системы типов (фраза заимствована у [Yaron Minsky](https://blog.janestreet.com/effective-ml-revisited/)).
Рассмотрим тип `Contact`. В результате [проведённого рефакторинга](https://fsharpforfunandprofit.com/posts/designing-with-types-single-case-dus/) он сильно упростился:
```
type Contact =
{
Name: Name;
EmailContactInfo: EmailContactInfo;
PostalContactInfo: PostalContactInfo;
}
```
Теперь предположим, что существует простое бизнес-правило: "Контакт должен содержать адрес электронной почты или почтовый адрес". Соответствует ли наш тип этому правилу?
Нет. Из правила следует, что контакт может содержать адрес электронной почты, но не иметь почтового адреса, или наоборот. Однако в текущем виде тип требует, чтобы были заполнены оба поля.
Кажется, ответ очевиден — сделать адреса необязательными, например, так:
```
type Contact =
{
Name: PersonalName;
EmailContactInfo: EmailContactInfo option;
PostalContactInfo: PostalContactInfo option;
}
```
Но теперь наш тип допускает слишком многое. В этой реализации можно создать контакт вообще без адреса, хотя правило требует, чтобы хотя бы один адрес был указан.
Как же решить эту задачу?
Как сделать некорректные состояния невыразимыми
===============================================
Обдумав правило бизнес-логики можно прийти к выводу, что возможны три случая:
* указан только адрес электронной почты;
* указан только почтовый адрес;
* указан и адрес электронной почты, и почтовый адрес.
В такой формулировке решение становится очевидным — сделать тип-сумму с конструктором для каждого возможного случая.
```
type ContactInfo =
| EmailOnly of EmailContactInfo
| PostOnly of PostalContactInfo
| EmailAndPost of EmailContactInfo * PostalContactInfo
type Contact =
{
Name: Name;
ContactInfo: ContactInfo;
}
```
Эта реализация полностью соответствует требованиям. Все три случая выражены явно, при этом четвёртый случай (без какого-либо адреса) не допускается.
Обратите внимание на случай "адрес электронной почты и почтовый адрес". Пока что я просто использовал кортеж. В данном случае этого достаточно.
Создание `ContactInfo`
----------------------
Теперь давайте посмотрим, как использовать эту реализацию на примере. Для начала создадим новый контакт:
```
let contactFromEmail name emailStr =
let emailOpt = EmailAddress.create emailStr
// обработка случаев с корректным и некорректным адресом электронной почты
match emailOpt with
| Some email ->
let emailContactInfo =
{EmailAddress=email; IsEmailVerified=false}
let contactInfo = EmailOnly emailContactInfo
Some {Name=name; ContactInfo=contactInfo}
| None -> None
let name = {FirstName = "A"; MiddleInitial=None; LastName="Smith"}
let contactOpt = contactFromEmail name "abc@example.com"
```
В этом примере мы создаём простую вспомогательную функцию `contactFromEmail`, чтобы создать новый контакт, передав имя и адрес электронной почты. Однако адрес может быть некорректным, и функция должна обрабатывать оба этих случая. Функция не может создать контакт с некорректным адресом, поэтому она возвращает значение типа `Contact option`, а не Contact.
Изменение `ContactInfo`
-----------------------
Если надо добавить почтовый адрес к существующему `ContactInfo`, то придётся обработать три возможных случая:
* если у контакта был только адрес электронной почты, то теперь у него указаны оба адреса, поэтому надо вернуть контакт с конструктором `EmailAndPost`;
* если у контакта был только почтовый адрес, надо вернуть контакт с конструктором `PostOnly`, заменив почтовый адрес на новый;
* если у контакта были оба адрес, надо вернуть контакт с конструктором `EmailAndPost`, заменив почтовый адрес на новый.
Вспомогательная функция для обновления почтового адреса выглядит следующим образом. Обратите внимание на явную обработку для каждого случая.
```
let updatePostalAddress contact newPostalAddress =
let {Name=name; ContactInfo=contactInfo} = contact
let newContactInfo =
match contactInfo with
| EmailOnly email ->
EmailAndPost (email,newPostalAddress)
| PostOnly _ -> // существующий почтовый адрес игнорируется
PostOnly newPostalAddress
| EmailAndPost (email,_) -> // существующий почтовый адрес игнорируется
EmailAndPost (email,newPostalAddress)
// создать новый контакт
{Name=name; ContactInfo=newContactInfo}
```
А вот так выглядит использование этого кода:
```
let contact = contactOpt.Value // обратите внимание на предупреждение касательно option.Value ниже
let newPostalAddress =
let state = StateCode.create "CA"
let zip = ZipCode.create "97210"
{
Address =
{
Address1= "123 Main";
Address2="";
City="Beverly Hills";
State=state.Value; // обратите внимание на предупреждение касательно option.Value ниже
Zip=zip.Value; // обратите внимание на предупреждение касательно option.Value ниже
};
IsAddressValid=false
}
let newContact = updatePostalAddress contact newPostalAddress
```
*ПРЕДУПРЕЖДЕНИЕ: В этом примере я использовал `option.Value`, чтобы получить содержимое option. Это допустимо, когда вы экспериментируете в интерактивной консоли, но это ужасное решение для рабочего кода! Надо всегда использовать [сопоставление с образцом](https://docs.microsoft.com/ru-ru/dotnet/fsharp/language-reference/pattern-matching) и обрабатывать оба конструктора `option`.*
Зачем заморачиваться этими сложными типами?
===========================================
К этому времени вы могли решить, что мы всё слишком усложнили. Отвечу тремя тезисами.
Во-первых, бизнес-логика сложна сама по себе. Простого способа этого избежать нет. Если ваш код проще бизнес-логики, вы не обрабатываете все случаи, как надо.
Во-вторых, если логика выражена типами, то она самодокументируется. Можно посмотреть на конструкторы типа-суммы ниже и сразу понять бизнес-правило. Вам не придётся тратить время на анализ какого-либо другого кода.
```
type ContactInfo =
| EmailOnly of EmailContactInfo
| PostOnly of PostalContactInfo
| EmailAndPost of EmailContactInfo * PostalContactInfo
```
Наконец, если логика выражена типом, то любые изменения правил бизнес-логики сломают код, не учитывающий эти изменения, а это, как правило, хорошо.
Последний пункт раскрывается в [следующей статье](https://fsharpforfunandprofit.com/posts/designing-with-types-discovering-the-domain/). Пытаясь выразить правила бизнес-логики через типы, вы можете прийти к углублённому пониманию предметной области. | https://habr.com/ru/post/424895/ | null | ru | null |
# ConfigureAwait, кто виноват и что делать?
В своей практике я часто встречаю, в *различном* окружении, код вроде того, что приведен ниже:
```
[1] var x = FooWithResultAsync(/*...*/).Result;
//или
[2] FooAsync(/*...*/).Wait();
//или
[3] FooAsync(/*...*/).GetAwaiter().GetResult();
//или
[4] FooAsync(/*...*/)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
//или
[5] await FooAsync(/*...*/).ConfigureAwait(false)
//или просто
[6] await FooAsync(/*...*/)
```
Из общения с авторами таких строк, стало ясно, что все они делятся на три группы:
* Первая группа, это те, кому ничего не известно о возможных проблемах с вызовом `Result/Wait/GetResult`. Примеры (1-3) и, иногда, (6), типичны для программистов из этой группы;
* Ко второй группе относятся программисты, которым известно о возможных проблемах, но они не знают причин их возникновения. Разработчики из этой группы, с одной стороны, стараются избегать строк вроде (1-3 и 6), но, с другой, злоупотребляют кодом вроде (4-5);
* Третья группа, по моему опыту самая малочисленная, это те программисты, которые знают о том, как код (1-6) работает, и, поэтому, могут сделать осознанный выбор.
Возможен ли риск, и на сколько он велик, при использовании кода, как в приведенных выше примерах, зависит, как я отмечал ранее, от *окружения*.
Риски и их причины
------------------
Примеры (1-6) делиться на две группы. Первая группа — код с блокировкой вызывающего потока. К этой группе относятся (1-4).
Блокировка потока, чаще всего, плохая идея. Почему? Для простоты будем считать, что все потоки выделяются из некоторого пула потоков. Если в программе присутствует блокировка, то это может привести к выборке всех потоков из пула. В лучшем случае, это замедлит работу программы и приведет к неэффективному использованию ресурсов. В худшем же случае, это может привести к взаимоблокировке(deadlock), когда для завершения некоторой задачи, нужен будет дополнительный поток, но пул его не сможет выделить.
Таким образом, когда разработчик пишет код вроде (1-4), он должен задуматься, на сколько вероятна описанная выше ситуация.
Но все становится гораздо хуже, когда мы работаем в окружении, в котором существует контекст синхронизации, отличный от стандартного. При наличии *особого* контекста синхронизации блокировка вызывающего потока повышает вероятность возникновения взаимоблокировки многократно. Так, код из примеров (1-3), если он выполняется в UI-потоке WinForms, практически гарантированно создает deadlock. Я пишу "практически", т.к. есть вариант, когда это не так, но об этом чуть позже. Добавление `ConfigureAwait(false)`, как в (4), не даст 100% гарантии защиты от deadlock'a. Ниже приведен пример, подтверждающий это:
```
[7]
//Некоторая метод библиотечного / стороннего класса.
async Task FooAsync()
{
// Delay взять для простоты. Может быть любой асинхронный вызов.
await Task.Delay(5000);
//Остальную часть кода метода объединим в метод
RestPartOfMethodCode();
}
//Код в "конечной" точке использования, в данном случае, это WinForms приложение.
private void button1_Click(object sender, EventArgs e)
{
FooAsync()
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
button1.Text = "new text";
}
```
В статье ["Parallel Computing — It's All About the SynchronizationContext"](https://msdn.microsoft.com/en-us/magazine/gg598924.aspx) дается информация о различных контекстах синхронизации.
Для того, чтобы понять причину возникновения взаимоблокировки, нужно проанализировать код конечного автомата, в который преобразуется вызов async метода, и, далее, код классов MS. В статье ["Async Await and the Generated StateMachine"](https://www.codeproject.com/Articles/535635/Async-Await-and-the-Generated-StateMachine) приводится пример такого конечного автомата.
Не буду приводить полный исходный код, генерируемого для примера (7), автомата, покажу лишь важные для дальнейшего разбора строки:
```
//Внутри метода MoveNext.
//...
// переменная taskAwaiter определена выше по коду.
taskAwaiter = Task.Delay(5000).GetAwaiter();
if(tasAwaiter.IsCompleted != true)
{
_awaiter = taskAwaiter;
_nextState = ...;
_builder.AwaitUnsafeOnCompleted(ref taskAwaiter, ref this);
return;
}
```
Ветка `if` выполняется, если асинхронный вызов (`Delay`) еще не был завершен и, следовательно, текущий поток можно освободить.
Обратите внимание на то, что в `AwaitUnsafeOnCompleted` передается taskAwaiter полученный от **внутреннего** (относительно `FooAsync`) асинхронного вызова (`Delay`).
Если погрузиться в дебри исходников MS, которые скрываются за вызовом `AwaitUnsafeOnCompleted`, то, в конечном итоге, мы придем к классу [SynchronizationContextAwaitTaskContinuation](https://referencesource.microsoft.com/mscorlib/R/d8b8d04cc476b392.html), и его базовому классу [AwaitTaskContinuation](https://referencesource.microsoft.com/mscorlib/system/threading/Tasks/TaskContinuation.cs.html#3f97ac52ec881e24), где и находятся ответ на поставленный вопрос.
Код этих, и связанных с ними, классов довольно запутан, поэтому, для облегчения восприятия, я позволю себе написать сильно упрощенный "аналог" того, во что превращается пример (7), но без конечного автомата, и в терминах TPL:
```
[8]
Task FooAsync()
{
// Переменная methodCompleted вводится только для того, чтобы подчеркнуть,
// что метод завершается тогда, когда будет выполнен некоторый "маркирующий код".
// В конечном автомате функцию, аналогичную строчке methodCompleted.WaitOne() данного кода,
// выполняет метод SetResult класса AsyncTaskMethodBuilder,
// объект которого храниться в поле конечного автомата.
var methodCompleted = new AutoResetEvent(false);
SynchronizationContext current = SynchronizationContext.Current;
return Task.Delay(5000).ContinueWith(
t=>
{
if(current == null)
{
RestPartOfMethodCode(methodCompleted);
}
else
{
current.Post(state=>RestPartOfMethodCode(methodCompleted), null);
methodCompleted.WaitOne();
}
},
TaskScheduler.Current);
}
//
// void RestPartOfMethodCode(AutoResetEvent methodCompleted)
// {
// Тут оставшаяся часть кода метода FooAsync.
// methodCompleted.Set();
// }
```
В примере (8) важно обратить внимание на то, что при наличии контекста синхронизации, весь код асинхронного метода, который идет после завершения внутреннего асинхронного вызова, **выполняется через этот контекст** (вызов `current.Post(...)`). Этот факт и **является причиной** возникновения взаимоблокировок. Например, если речь идет о WinForms-приложении, то контекст синхронизации в нем связан с UI-потоком. Если UI-поток заблокирован, в примере (7) это происходит через вызов `.GetResult()`, то оставшаяся часть кода асинхронного метода выполниться не может, а значит, асинхронный метод не может завершиться, и не может освободить UI-поток, что и есть deadlock.
В примере (7) вызов `FooAsync` был сконфигурирован через `ConfigureAwait(false)`, но это не помогло. Дело в том, что конфигурировать надо именно тот объект ожидания, который будет передан в `AwaitUnsafeOnCompleted`, в нашем примере это объект ожидания от вызова `Delay`. Другими словами, в данном случае, вызов `ConfigureAwait(false)` в клиентском коде не имеет смысла. Решить проблему можно если разработчик метода `FooAsync` изменит его следующим образом:
```
[9]
async Task FooAsync()
{
await Task.Delay(5000).ConfigureAwait(false);
//Остальную часть кода метода объединим в метод
RestPartOfMethodCode();
}
private void button1_Click(object sender, EventArgs e)
{
FooAsync().GetAwaiter().GetResult();
button1.Text = "new text";
}
```
Выше мы рассмотрели риски возникающие с кодом первой группы — код с блокировкой (примеры 1-4). Теперь о второй группе (примеры 5 и 6) — код без блокировок. В этом случае возникает вопрос, когда вызов `ConfigureAwait(false)` оправдан? При разборе примера (7), мы уже выяснили, что конфигурировать надо тот объект ожидания, на основе которого будет построено продолжение выполнения. Т.е. конфигурация требуется (если вы приняли такое решение) только для **внутренних** асинхронных вызовов.
Кто виноват?
------------
Как всегда, правильным ответом будет "все". Начнем с программистов из MS. С одной стороны, разработчики Microsoft приняли решение, что, при наличии контекста синхронизации, работа должна вестись через него. И это логично, иначе зачем он еще нужен. И, как я полагаю, они ожидали, что разработчики "клиентского" кода **не** будут блокировать основной поток, тем более в том случае, когда контекст синхронизации на него завязан. С другой стороны, они дали очень простой инструмент чтобы "выстрелить себе в ногу" — слишком просто и удобно получать результат через блокирующие `.Result/.GetResult`, или блокировать поток, в ожидании завершения вызова, через `.Wait`. Т.е. разработчики MS сделали так, что "неправильное" (или опасное) использование их библиотек не вызывает каких-либо затруднений.
Но есть вина и на разработчиках "клиентского" кода. Она состоит в том, что, зачастую, разработчики не пытаются разобраться в своем инструменте и пренебрегают предупреждениями. А это прямой путь к ошибкам.
Что делать?
-----------
Ниже я привожу мои рекомендации.
### Для разработчиков клиентского кода
1. Всеми силами избегайте блокировок. Другими словами, не смешивайте синхронный и асинхронный код без особой необходимости.
2. Если приходится делать блокировку, то определите, в каком окружении выполняется код:
* Есть ли контекст синхронизации? Если да, то какой? Какие особенности в работе он создает?
* Если контекста синхронизации "нет", то: Какова будет нагрузка? Какова вероятность что ваша блокировка приведет к "утечки" потоков из пула? Хватит ли того числа потоков, что создается на старте, по умолчанию, или надо выделить больше?
3. Если код асинхронный, то нужен ли вам конфигурировать асинхронный вызов через `ConfigureAwait`?
Принимайте решение на основе всей полученной информации. Возможно, вам надо пересмотреть подход к реализации. Возможно, вам поможет `ConfigureAwait`, а может он вам не нужен.
### Для разработчиков библиотек
1. Если вы полагаете, что ваш код может быть вызван из "синхронного", то обязательно реализуйте синхронный API. Он должен быть по-настоящему синхронным, т.е. вы должны пользоваться синхронным API сторонних библиотек.
2. `ConfigureAwait(true / false)`.
Тут, с моей точки зрения, необходим более тонкий подход чем обычно рекомендуют. Во многих статьях говорится, что в библиотечном коде, все асинхронные вызовы надо конфигурировать через `ConfigureAwait(false)`. Я не могу с этим согласиться. Возможно, с точки зрения авторов, коллеги из Microsoft приняли неверное решение при выборе поведения "по умолчанию" в отношении работы с контекстом синхронизации. Но они (MS), все же, оставили возможность разработчикам "клиентского" кода изменить это поведение. Стратегия, когда библиотечный код полностью покрывается `ConfigureAwait(false)`, изменяет поведение по умолчанию, и, что более важно, такой подход лишает разработчиков "клиентского" кода выбора.
Мой вариант заключается в том, чтобы, при реализации асинхронного API, в каждый метод API добавлять два дополнительных входных параметра: `CancellationToken token` и `bool continueOnCapturedContext`. И реализовывать код в следующем виде:
```
public async Task FooAsync(
/\*другие аргументы функции\*/,
CancellationToken token,
bool continueOnCapturedContext)
{
// ...
await Task.Delay(30, token).ConfigureAwait(continueOnCapturedContext);
// ...
return result;
}
```
Первый параметр, `token` — служит, как известно, для возможности скоординированной отмены (разработчики библиотек этой возможностью, иногда, пренебрегают). Второй, `continueOnCapturedContext` — позволяет настроить взаимодействие с контекстом синхронизации внутренних асинхронных вызовов.
При этом, если асинхронный метод API будет сам частью другого асинхронного метода, то "клиентский" код сможет определить, как он должен взаимодействовать с контекстом синхронизации:
```
// Пример вызова в асинхронном коде:
async Task ClientFoo()
{
// "Внутренний" код ClientFoo учитывает контекст синхронизации, в то время как
// внутренний код FooAsync игнорирует контекст синхронизации.
await FooAsync(
/*другие аргументы функции*/,
ancellationToken.None,
false);
// Код всех уровней игнорирует контекст.
await FooAsync(
/*другие аргументы функции*/,
ancellationToken.None,
false).ConfigureAwait(false);
//...
}
//В синхронном, с блокировкой.
private void button1_Click(object sender, EventArgs e)
{
FooAsync(
/*другие аргументы функции*/,
_source.Token,
false).GetAwaiter().GetResult();
button1.Text = "new text";
}
```
В качестве заключения
---------------------
Главный вывод из всего вышеизложенного заключается в следующих трех мыслях:
1. Блокировки, чаще всего, корень всех зол. Именно наличие блокировок может привести, в лучшем случае, к деградации производительности и неэффективному использованию ресурсов, в худшем — к deadlock-у. Прежде чем использовать блокировки подумайте, нужно ли это? Возможно, есть другой, приемлемый в вашем случае, способ синхронизации;
2. Изучайте инструмент, с которым работаете;
3. Если проектируете библиотеки, то старайтесь сделать так, чтобы их правильное использование было легким, почти интуитивным, а неправильное было сопряжено со сложностями.
Я постарался максимально просто объяснить риски связанные с async/await, и причины их возникновения. А также, представил мое видение решения этих проблем. Надеюсь, что это мне удалось, и материал будет полезен читателю. Для того чтобы лучше понять, как все работает на самом деле, надо, конечно, обратиться к исходникам. Это можно сделать через репозитории MS на [GitHub](https://github.com/microsoft/referencesource/tree/master/mscorlib/system/threading/Tasks) или, что даже удобнее, через сайт самого [MS](https://referencesource.microsoft.com/#mscorlib/system/threading/Tasks/).
*P.S.* Буду благодарен за конструктивную критику.
[](https://habr.com/ru/company/clrium/blog/465081/) | https://habr.com/ru/post/463587/ | null | ru | null |
# Как очищать данные при помощи SQL
За время работы автору довелось использовать многие инструменты анализа, включая Excel, R и Python. Попробовав PostgreSQL и TimescaleDB, автор поняла, насколько простыми могут быть задачи очистки. Делимся подробностями сравнения PostgreSQL и Python из блога TimescaleDB, пока у нас начинается [курс по аналитике данных](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_101221&utm_term=lead).
Процесс анализа вкратце
-----------------------
Раньше столбцы и значения данных приходилось редактировать вручную. Приходилось извлекать «сырые» данные из CSV-файла или базы данных, а затем изменять их в Python-скрипте.
Приходилось ждать, пока машина настроит и очистит данные. А чтобы поделиться очищенными данными, нужно было запускать скрипт или передавать его другим людям. Но теперь благодаря PostgreSQL я один раз пишу запрос очистки на SQL прямо в базе данных и сохраняю результаты в таблице.
О наборе данных
---------------
Бо́льшую часть работы по очистке я проводила после анализа. Но иногда полезно очистить данные, оценить их и снова очистить. Именно с таким случаем мы и будем работать. В одном из [наборов](https://www.kaggle.com/jaganadhg/house-hold-energy-data) данных Kaggle содержатся показания потребления энергии одной из квартир в Сан-Хосе, штат Калифорния. Данные обновляются каждые 15 минут и следуют приблизительно такой схеме:
Вот что приходит в голову первым в смысле очистки:
* Тариф — текстовый тип, а это вызовет проблемы.
* Столбцы времени и даты разделены, что может вызвать проблемы при создании графиков или моделей на основе показателей времени.
* Может понадобиться отфильтровать данные по временным параметрам, например по дню недели или конкретным праздникам (оба параметра влияют на потребление энергии).
К процессу очистки в PostgreSQL можно подойти по-разному: можно создать таблицу, а затем изменить её при очистке, создать несколько таблиц при добавлении или изменении данных или работать с представлениями. В зависимости от размера данных эти подходы *могут* иметь смысл, но вычисления будут выполнятся по-разному.
Учитывая состояние данных в `energy_usage_staging`, я решила поместить их в *промежуточную таблицу*, очистить с помощью представлений, а затем вставить в таблицу поудобнее. Всё это можно сделать до оценки данных.
Часто при работе с большим объёмом данных изменение таблицы в PostgreSQL может оказаться дорогим. Я покажу, как с помощью представлений и дополнительных таблиц создать чистые данные.
Проблемы структуры
------------------
Разделённые столбцы даты и времени надо преобразовать в метку времени, а столбец тарифов— в тип float4. Подробности ниже.
#### Гипертаблицы TimescaleDB, и почему важна метка времени
В основе эффективности запроса данных временного ряда и управления этими данными лежат [гипертаблицы TimescaleDB](https://docs.timescale.com/timescaledb/latest/overview/core-concepts/hypertables-and-chunks/). Они разделяются по столбцу времени, который вы укажете при создании таблицы.
Данные разделяются по метке времени на «куски», так что каждая строка таблицы принадлежит какому-то *куску* исходя из диапазона. Позже эти куски используются в запросах строк, чтобы запросы и манипулирование данными по времени были эффективнее. Ниже вы видите разницу между обычной таблицей и гипертаблицей:
### Изменение структуры даты и времени
Чтобы по максимуму использовать функциональность TimescaleDB, например непрерывное агрегирование и ускоренные временные запросы, надо поменять структуру столбцов даты и времени в таблице `energy_usage_staging`.
Для разделения гипертаблицы можно использовать столбец даты, но тогда будет ограничен контроль над данными по времени. Один столбец с меткой времени даёт больше гибкости и экономит пространство эффективнее, чем отдельные столбцы с датой и временем.
Структура таблицы должна быть такой, чтобы из столбцов date и start\_time можно было получать полезное значение метки времени: end\_time не даёт столько информации. Иными словами, надо объединить эти два столбца в один с метками времени.
В PostgreSQL можно создать столбец, не вставляя его в базу данных. Поэтому, чтобы создать из этой промежуточной таблицы новую таблицу, добавлять дополнительные столбцы или таблицы пока не нужно. Сначала сравним исходные столбцы с вновь сгенерированным. Для этого просто *добавим* один столбец к другому. Ключевое слово AS позволяет переименовать столбцы в `time`.
```
--добавляем дату в столбец start_time
SELECT date, start_time, (date + start_time) AS time
FROM energy_usage_staging eus;
```
Результаты:
В Python с этой же целью проще всего добавить новый столбец во фрейм данных. Нужно конкатенировать два столбца вместе с определённым пространством, а затем преобразовать этот столбец в `datetime`.
```
energy_stage_df['time'] = pd.to_datetime(energy_stage_df['date'] + ' ' + energy_stage_df['start_time'])
print(energy_stage_df[['date', 'start_time', 'time']])
```
### Изменение типов данных столбцов
Благодаря функции [TO\_NUMBER()](https://www.postgresql.org/docs/14/functions-formatting.html) в PostgreSQL это просто.
Формат функции такой: `TO_NUMBER('text', 'format')`; `format` — это специальная строка PostgreSQL, которая создаётся в зависимости от типа текста. Мы имеем дело с символом `$` и числовым набором `0,00`. Строка формата будет такой: '`L99D99`'. L сообщает PostgreSQL, что в начале текста есть символ денег, 9-ки — что есть числовые значения, а D отделяет целую часть от десятичной.
Преобразование ограничим значениями не больше 99,99, поскольку в столбце тарифов нет значений больше 0,65. А что если надо преобразовать столбец с большими числовыми значениями? Тогда добавляем G для запятых.
К примеру, есть столбец тарифов с текстовыми значениями 1,672,278.23. Тогда отформатируем строку так: `L9G999G999D99`.
```
--создаём новый столбец cost_new с функцией to_number()
SELECT cost, TO_NUMBER("cost", 'L9G999D99') AS cost_new
FROM energy_usage_staging eus
ORDER BY cost_new DESC
```
Результаты:
Код на Python:
```
energy_stage_df['cost_new'] = pd.to_numeric(energy_stage_df.cost.apply(lambda x: x.replace('$','')))
print(energy_stage_df[['cost', 'cost_new']])
```
В случае Python используем лямбда-функцию, которая заменяет все знаки `$` пустыми строками. И это снова может быть неэффективно.
```
energy_stage_df['cost_new'] = pd.to_numeric(energy_stage_df.cost.apply(lambda x: x.replace('$','')))
print(energy_stage_df[['cost', 'cost_new']])
```
Представления PostgreSQL
------------------------
Представление — это объект PostgreSQL, который позволяет определять запрос и вызывать его по имени представления, как если бы это была таблица БД. Сгенерируем данные и создадим представление:
```
--запрашиваем нужные данные
SELECT type,
(date + start_time) AS time,
"usage",
units,
TO_NUMBER("cost", 'L9G999D99') AS cost,
notes
FROM energy_usage_staging
```
Результаты:
Назовём наше представление `energy_view`, а при последующей очистке просто укажем его имя в операторе `FROM`.
```
--из запроса выше создаём представление
CREATE VIEW energy_view AS
SELECT type,
(date + start_time) AS time,
"usage",
units,
TO_NUMBER("cost", 'L9G999D99') AS cost,
notes
FROM energy_usage_staging
```
Код Python:
```
energy_df = energy_stage_df[['type','time','usage','units','cost_new','notes']]
energy_df.rename(columns={'cost_new':'cost'}, inplace = True)
print(energy_df.head(20))
```
Важно: данные внутри представлений PostgreSQL должны пересчитываться при каждом запросе. Вот почему надо вставлять данные представления в гипертаблицу, как только они подготовлены.
Cоздание или генерирование необходимых данных
---------------------------------------------
Столбец примечаний (`notes`) в этом наборе пуст. Чтобы проверить это, просто включаем оператор `WHERE` и указываем, где `notes` не равны пустой строке.
```
SELECT *
FROM energy_view ew
-- когда notes — не пустые строки
WHERE notes!='';
```
И код на Python:
```
print(energy_df[energy_df['notes'].notnull()])
```
Столбец примечаний пуст, поэтому заменим его различными наборами дополнительной информации, чтобы использовать эту информацию при моделировании.
Добавим столбец дня недели при помощи `EXTRACT()` — [функции](https://www.postgresql.org/docs/14/functions-datetime.html) даты/времени PostgreSQL, которая позволяет извлекать из даты и времени различные элементы. У наших колонок в PostgreSQL есть обозначение дня недели DOW (day-of-week): 0 — это воскресенье, а 6 — суббота.
```
-- извлекаем day-of-week from date и приводим вывод к int
SELECT *,
EXTRACT(DOW FROM time)::int AS day_of_week
FROM energy_view
```
Результаты:
Код Python:
```
energy_df['day_of_week'] = energy_df['time'].dt.dayofweek
```
Можно добавить столбец, где указывается, приходится ли день на выходные или будни. Для этого воспользуемся оператором CASE:
```
SELECT type, time, usage, units, cost,
EXTRACT(DOW FROM time)::int AS day_of_week,
-- --используйте оператор case, чтобы сделать столбец истинным, если записи выпадают на выходные дни и 6
CASE WHEN (EXTRACT(DOW FROM time)::int) IN (0,6) then true
ELSE false
END AS is_weekend
FROM energy_view ew
```
Результаты:
Интересный факт: тот же запрос можно выполнить без `CASE`, но только для столбцов с двоичными данными.
```
--другой метод создания столбца с двоичными данными
SELECT type, time, usage, units, cost,
EXTRACT(DOW FROM time)::int AS day_of_week,
EXTRACT(DOW FROM time)::int IN (0,6) AS is_weekend
FROM energy_view ew
```
Код Python:
```
energy_df['is_weekend'] = np.where(energy_df['day_of_week'].isin([5,6]), 1, 0)
print(energy_df.head(20))
```
> Обратите внимание: в Python выходные представлены числами 5 и 6, а в PostgreSQL — числами 0 и 6.
>
>
А что, если добавить другие параметры? Например, праздники. Люди в праздники чаще всего не работают и проводят время дома, а значит, в эти дни потребление энергии может быть другим. Поэтому включим в анализ определение праздников. Для этого создадим ещё один столбец логических значений, который определяет наступление национального праздника. Для этого используем функцию TimescaleDB `time_bucket()`.
Эта [функция](https://docs.timescale.com/api/latest/hyperfunctions/time_bucket/) нужна, чтобы гарантировать, что учитываются все значения времени за день. Создав таблицу праздников, используем данные из неё в запросе без оператора `CASE`, но можно написать запрос и с ним.
```
--создаём таблицу для праздников
CREATE TABLE holidays (
date date)
--вставляем праздники в таблицу
INSERT INTO holidays
VALUES ('2016-11-11'),
('2016-11-24'),
('2016-12-24'),
('2016-12-25'),
('2016-12-26'),
('2017-01-01'),
('2017-01-02'),
('2017-01-16'),
('2017-02-20'),
('2017-05-29'),
('2017-07-04'),
('2017-09-04'),
('2017-10-9'),
('2017-11-10'),
('2017-11-23'),
('2017-11-24'),
('2017-12-24'),
('2017-12-25'),
('2018-01-01'),
('2018-01-15'),
('2018-02-19'),
('2018-05-28'),
('2018-07-4'),
('2018-09-03'),
('2018-10-8')
SELECT type, time, usage, units, cost,
EXTRACT(DOW FROM time)::int AS day_of_week,
EXTRACT(DOW FROM time)::int IN (0,6) AS is_weekend,
-- Затем я могу выбрать данные из таблицы прямо внутри IN
time_bucket('1 day', time) IN (SELECT date FROM holidays) AS is_holiday
FROM energy_view ew
```
Результаты:
Код Python:
```
holidays = ['2016-11-11', '2016-11-24', '2016-12-24', '2016-12-25', '2016-12-26', '2017-01-01', '2017-01-02', '2017-01-16', '2017-02-20', '2017-05-29', '2017-07-04', '2017-09-04', '2017-10-9', '2017-11-10', '2017-11-23', '2017-11-24', '2017-12-24', '2017-12-25', '2018-01-01', '2018-01-15', '2018-02-19', '2018-05-28', '2018-07-4', '2018-09-03', '2018-10-8']
energy_df['is_holiday'] = np.where(energy_df['day_of_week'].isin(holidays), 1, 0)
print(energy_df.head(20))
```
Пока сохраним эту расширенную таблицу в другом представлении, чтобы воспользоваться представлением позже.
```
--создаём другое представление с данными из первой очистки
CREATE VIEW energy_view_exp AS
SELECT type, time, usage, units, cost,
EXTRACT(DOW FROM time)::int AS day_of_week,
EXTRACT(DOW FROM time)::int IN (0,6) AS is_weekend,
time_bucket('1 day', time) IN (select date from holidays) AS is_holiday
FROM energy_view ew
```
Вы спросите: «Зачем создавать столбцы логических значений?». Для фильтрации. В PostgreSQL благодаря логическим столбцам очень легко фильтровать данные. Например, если нужно показать данные только за выходные и праздничные дни, добавим `WHERE` вместе с указанными столбцами.
```
--если используете столбцы с двоичными данными, то фильтровать их можно простым WHERE
SELECT *
FROM energy_view_exp
WHERE is_weekend AND is_holiday
```
Результаты:
Код Python:
```
print(energy_df[(energy_df['is_weekend']==1) & (energy_df['is_holiday']==1)].head(10))
```
Добавление данных в гипертаблицу
--------------------------------
Подготовив новые столбцы и организовав таблицу, создадим новую гипертаблицу и вставим очищенные данные.
```
CREATE TABLE energy_usage (
type text,
time timestamptz,
usage float4,
units text,
cost float4,
day_of_week int,
is_weekend bool,
is_holiday bool,
)
--команда создания гипертаблицы
SELECT create_hypertable('energy_usage', 'time')
INSERT INTO energy_usage
SELECT *
FROM energy_view_exp
```
> В случае работы с постоянно поступающими данными можно создать скрипт, который при импорте данных автоматически вносит эти изменения.
>
>
Переименование значений
-----------------------
Ещё один ценный метод очистки данных — переименование элементов или повторное отображение категориальных значений.
Его важность подчёркивается популярностью [вопроса](https://stackoverflow.com/questions/40427943/how-do-i-change-a-single-index-value-in-pandas-dataframe) об анализе данных Python на StackOverflow: «Как во фрейме Pandas поменять одно значение индекса». PostgreSQL и TimescaleDB используют структуры реляционных таблиц, поэтому переименовывать уникальные значения просто.
Определённые значения индекса в таблице переименовываются «на лету» через `CASE` внутри `SELECT`. Например, поменяем `0` воскресенья в столбце `day_of_week` на `7` :
```
SELECT type, time, usage, cost, is_weekend,
-- чтобы переписать значения, можно воспользоваться CASE
CASE WHEN day_of_week = 0 THEN 7
ELSE day_of_week
END
FROM energy_usage
```
Внимание: код ниже сделает понедельник равным 7, потому что в функции DOW (day-of-week) Python значение понедельника 0, а воскресенья — 6. Но так и обновляется одно значение в столбце. При этом обновлять значения, скорее всего, не придётся, а эквивалент на Python показан просто для справки.
```
energy_df.day_of_week[energy_df['day_of_week']==0] = 7
print(energy_df.head(250))
```
А если вместо числовых значений использовать названия дней недели? Убираем `CASE` и создаём таблицу сопоставления. При изменении различных значений будет эффективнее создать её, а затем объединиться с ней командой `JOIN`.
```
--создаём таблицу
CREATE TABLE day_of_week_mapping (
day_of_week_int int,
day_of_week_name text
)
--затем добавляем в неё данные
INSERT INTO day_of_week_mapping
VALUES (0, 'Sunday'),
(1, 'Monday'),
(2, 'Tuesday'),
(3, 'Wednesday'),
(4, 'Thursday'),
(5, 'Friday'),
(6, 'Saturday')
--объединяем её с таблицей очистки для повторного отображения дней недели
SElECT type, time, usage, units, cost, dowm.day_of_week_name, is_weekend
FROM energy_usage eu
LEFT JOIN day_of_week_mapping dowm ON dowm.day_of_week_int = eu.day_of_week
```
Результаты:
 Аналогичные функции отображения есть в Python.
```
energy_df['day_of_week_name'] = energy_df['day_of_week'].map({0 : 'Sunday', 1 : 'Monday', 2: 'Tuesday', 3: 'Wednesday', 4: 'Thursday', 5: 'Friday', 6: 'Saturday'})
print(energy_df.head(20))
```
Кроме того, помните: поменять название столбца в таблице можно при помощи оператора `SELECT`.
```
SELECT type AS usage_type,
time as time_stamp,
usage,
units,
cost AS dollar_amount
FROM energy_view_exp
LIMIT 20;
```
Результаты:
SQL здесь быстрее и элегантнее. На Python переименование столбцов может стать большой проблемой.
```
energy_df.rename(columns={'type':'usage_type', 'time':'time_stamp', 'cost':'dollar_amount'}, inplace=True)
print(energy_df[['usage_type','time_stamp','usage','units','dollar_amount']].head(20))
```
Заполнение недостающих данных
-----------------------------
Другая проблема в процессе очистки данных — это их отсутствие. В нашем наборе нет явно отсутствующих точек данных, но наверняка найдутся недостающие данные по часам, возникающие из-за отключения электроэнергии или других обстоятельств. Здесь и пригодятся функции заполнения TimescaleDB.
Недостающие данные часто оказывают большое и негативное влияние на точность или надёжность модели. Иногда проблема решается заполнением недостающих данных данными, которые получены обоснованными оценками. Чтобы получить такие данные, TimescaleDB предоставляет встроенные функции.
Например, при моделировании потребления энергии в отдельные дни недели по некоторым дням из-за отключения электроснабжения или проблем с датчиком данных нет. Данные можно удалить или заполнить недостающие значения обоснованными оценками.
Для примера я создала данные и назвала таблицу `energy_data`. В ней нет показаний времени и энергии между 7:45 и 11:30 утра.
Чтобы добавить эти недостающие значения, используем [гиперфункции](https://docs.timescale.com/api/latest/hyperfunctions/gapfilling-interpolation/) TimescaleDB; `interpolate()` — ещё одна гиперфункция TimescaleDB. Она создаёт точки данных, которые следуют линейной аппроксимации с учётом точек данных до и после отсутствующего диапазона.
Есть альтернативная гиперфункция `locf()`, которая переносит последнее записанное значение вперёд, чтобы заполнить пробел (locf так и расшифровывается: last-one-carried-forward, т. е. «последнее переносимое вперёд»). Обе гиперфункции должны использоваться вместе с `time_bucket_gapfill()`.
```
SELECT
--новые данные должны появляться каждые 15 минут
time_bucket_gapfill('15 min', time) AS timestamp,
interpolate(avg(energy)),
locf(avg(energy))
FROM energy_data
--чтобы использовать gapfill, придётся удалять любые данные времени, связанные со значениями null. Сделать это можно с помощью оператора IS NOT NULL
WHERE energy IS NOT NULL AND time > '2021-01-01 07:00:00.000' AND time < '2021-01-01 13:00:00.000'
GROUP BY timestamp
ORDER BY timestamp;
```
Результаты:
Код Python:
```
energy_test_df['time'] = pd.to_datetime(energy_test_df['time'])
energy_test_df_locf = energy_test_df.set_index('time').resample('15 min').fillna(method='ffill').reset_index()
energy_test_df = energy_test_df.set_index('time').resample('15 min').interpolate().reset_index()
energy_test_df['locf'] = energy_test_df_locf['energy']
print(energy_test_df)
```
Следующий вопрос: как игнорировать отсутствующие данные. Я покажу, как легко исключить данные с `NULL`.
```
SELECT *
FROM energy_data
WHERE energy IS NOT NULL
```
Можно также использовать оператор `WHERE`, чтобы указать игнорируемое время.
```
SELECT *
FROM energy_data
WHERE time <= '2021-01-01 07:45:00.000' OR time >= '2021-01-01 11:30:00.000'
```
Продолжить изучение SQL и Python вы сможете на наших курсах:
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_101221&utm_term=conc)
* [Профессия Data Analyst (10 месяцев)](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_101221&utm_term=conc)
Узнайте подробности [здесь](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_101221&utm_term=conc).
Другие профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_101221&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_101221&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_101221&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_101221&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_101221&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_101221&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_101221&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_101221&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_101221&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_101221&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_101221&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_101221&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_101221&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_101221&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_101221&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_101221&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_101221&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_101221&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_101221&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_101221&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_101221&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_101221&utm_term=conc) | https://habr.com/ru/post/594753/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.