text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# F# меня испортил, или почему я больше не хочу писать на C#
Раньше я очень любил `C#`
-------------------------
Это был мой основной язык программирования, и каждый раз, когда я сравнивал его с другими, я радовался тому, что в свое время случайно выбрал именно его. Python и Javascript сразу проигрывают динамической типизацией (если к джаваскрипту понятие типизации вообще имеет смысл применять), Java уступает дженериками, отстутствием ивентов, value-типов, вытекающей из этого карусели с разделением примитивов и объектов на два лагеря и зеркальными классами-обертками вроде `Integer`, отсутствием пропертей и так далее. Одним словом — C# клевый.
Отдельно отмечу, что я сейчас говорю о самом языке и удобстве написания кода на нем.
Тулинг, обилие библиотек и размер сообщества я сейчас в расчет не беру, потому что у каждого
из этих языков они развиты достаточно, чтобы промышленная разработка была комфортной в большинстве случаев.
А потом я из любопытства попробовал F#.
И что в нем такого?
-------------------
Буду краток, в порядке значимости для меня:
* Иммутабельные типы
* Функциональная парадигма оказалась гораздо более строгой и стройной, чем то, что мы сегодня называем ООП.
* Типы-суммы, они же `Discriminated Unions` или размеченные объединения.
* Лаконичность синтаксиса
* Computation Expressions
* SRTP (Статически разрешаемые параметры-типы)
* По умолчанию даже ссылочным типам нельзя присвоить `null`, и компилятор требует инициализацию при объявлении.
* Выведение типов или type inference
С `null` все понятно, ничто так не засоряет код проекта, как бесконечные проверки возвращаемых значений вроде `Task>`. Так что сначала давайте обсудим иммутабельность и одновременно лаконичность.
Допустим, имеем следующий POCO класс:
```
public class Employee
{
public Guid Id { get; set; }
public string Name { get; set; }
public string Email { get; set; }
public string Phone { get; set; }
public bool HasAccessToSomething { get; set; }
public bool HasAccessToSomethinElse { get; set; }
}
```
Просто, емко, ничего лишнего. Казалось бы, куда лаконичней?
Соответствующий код на F# выглядит так:
```
type Employee =
{ Id: Guid
Name: string
Email: string
Phone: string
HasAccessToSomething: bool
HasAccessToSomethingElse: bool }
```
Вот теперь *действительно* нет ничего лишнего. Полезная информация содержится в ключевом слове декларации типа данных, имени этого типа, именах полей и их типах данных. В примере из C# в каждой строчке есть ненужные `public` и `{ get; set; }`. Помимо этого, в F# мы получили иммутабельность и защиту от `null`.
Ну, положим, иммутабельность мы можем и в C# организовать, а `public` с автодополнением написать недолго:
```
public class Employee
{
public Guid Id { get; }
public string Name { get; }
public string Email { get; }
public string Phone { get; }
public bool HasAccessToSomething { get; }
public bool HasAccessToSomethinElse { get; }
public Employee(Guid id, string name, string email, string phone, bool hasAccessToSmth, bool hasAccessToSmthElse)
{
Id = id;
Name = name;
Email = email;
Phone = phone;
HasAccessToSomething = hasAccessToSmth;
HasAccessToSomethinElse = hasAccessToSmthElse;
}
}
```
Готово! Правда, количество кода увеличилось в 3 раза: все поля мы продублировали дважды.
Мало того, когда добавится новое поле, мы можем забыть добавить его в параметры конструктора и/или забыть присвоить значение внутри конструктора, и *компилятор нам ничего не скажет*.
В F# при добавлении поля вам нужно добавить новое поле. Все.
Инициализация же выглядит вот так:
```
let employee =
{ Id = Guid.NewGuid()
Name = "Peter"
Email = "peter@gmail.com"
Phone = "8(800)555-35-35"
HasAccessToSomething = true
HasAccessToSomethinElse = false}
```
И если вы забудете одно поле, то код не скомпилируется. Поскольку тип неизменяемый, единственный способ внести изменение — создать новый экземпляр. Но что делать, если мы хотим изменить только одно поле? Все просто:
```
let employee2 = { employee with Name = "Valera" }
```
Как это сделать в C#? Ну, вы и без меня знаете.
Добавьте вложенные ссылочные поля, и теперь ваш `{ get; }` ничего не гарантирует — вы можете изменить поля этого поля. Стоит ли упоминать коллекции?
Но так ли нам нужна эта иммутабельность?
Я не случайно добавил два булевых поля про доступ куда-то. В реальных проектах за доступ отвечает какой-нибудь сервис, и часто он принимает на вход модель и мутирует ее, проставляя где надо `true`. И вот я в очередном месте программы получаю такую модель, в которой эти булевы свойства выставлены в `false`. Что это значит? Юзер не имеет доступ или просто модель не прогнали еще через аксес сервис? А может прогнали, но там забыли проинициализировать какие-то поля? Я не знаю, я должен проверить и прочитать кучу кода.
Когда же структура неизменяема — я знаю, что там стоят актуальные значения, потому что **компилятор обязывает меня полностью инициализировать объект декларации**.
В противном случае при добавлении нового поля я должен:
* Проверить **все** места, где этот объект создается — возможно, там тоже нужно заполнить это поле
* Проверить соответствующие сервисы, мутирующие этот объект
* Написать/обновить юнит-тесты, затрагивающе это поле
* Актуализировать маппинги
Кроме того, можно не боятся, что мой объект мутирует внутри чужого кода или в другом потоке.
Но в C# настолько трудно добиться настоящей иммутабельности, что писать такой код просто нерентабельно, иммутабельность такой ценой никак не сэкономит время разработки.
Ну, хватит об иммутабельности. Что еще имеем? В F# мы так же бесплатно получили:
* Structural Equality
* Structural Comparison
Теперь мы можем использовать такие конструкции:
```
if employee1 = employee2 then
//...
```
И это действительно будет проверять *равенство* объектов. `Equals` который проверяет равенство по ссылке ***никому даром не нужен***, у нас уже есть `Object.ReferenceEquals`, спасибо.
Кто-то может сказать, что это никому не нужно, потому что мы не сравниваем объекты в реальных проектах, поэтому `Equals` & `GetHashCode` нам нужны *так* редко, что можно и ручками переопределить. Но я думаю, что причинно-следственная связь тут работает в братную сторону — мы не сравниваем объекты, потому что переопределять руками это все и *поддерживать* слишком дорого. Но когда это достается *бесплатно*, применение находится мгновенно: вы можете использовать прямиком ваши модели как ключи в словарях, складывать модели в `HashSet<>` & `SortedSet<>`, сравнивать объекты не по айдишнику (хотя эта опция, разумеется, доступна), а просто сравнивать.
Discriminated Unions
--------------------
Думаю, большинство из нас впитали с молоком первого тимлида правило о том, что строить логику на эксепшнах плохо. Например, вместо `try { i = Convert.ToInt32("4"); } catch()...` правильней использовать `int.TryParse`.
Но помимо этого примитивного и до тошноты затертого примера, мы постоянно нарушаем это правило. Юзер ввел невалидные данные? `ValidationException`. Вышли за границы массива? `IndexOutOfRangeException`!
В умных книжках пишут, что исключения нужны для исключительных ситуаций, непредсказуемых, когда что-то пошло совсем не так и нет смысла пытаться продолжать работу. Хороший пример — `OutOfMemoryException`, `StackOverflowException`, `AccessViolationException` и т.д. Но вылезти за границы массива — это непредсказуемо? Серьезно? Индексатор на вход принимает `Int32`, множество допустимых значений которого составляет 2 в 32 степени. В большинстве случаев мы работаем с массивами, длина которых не превышает 10000. В редких случаях миллион. То есть значений `Int32`, которые вызовут исключение ***сильно*** больше, чем те, которые отработают корректно, то есть при случайно выбранном инте статистически более вероятно попасть в "исключительную" ситуацию!
То же самое с валидацией — юзер ввел кривые данные. **Вот это сюрприз**.
Причина, по которой мы активно злоупотребляем исключениями, проста: нам не хватает мощности системы типов, чтобы адекватно описать сценарий "если все нормально, отдай результат, если нет, верни ошибку". Строгая типизация обязывает нас возвращать один и тот же тип во всех ветках исполнения метода (к счастью), но не хватало еще только в каждый тип добавлять `string ErrorMessage` & `bool IsSuccess`. Поэтому в реалиях C# исключения — пожалуй, меньшее из зол в данной ситуации.
Опять-таки, можно написать класс
```
public class Result
{
public bool IsOk { get; set; }
public TResult Result { get; set; }
public TError Error { get; set; }
}
```
Но тут нам опять придется написать кучу кода, если мы хотим, например, сделать невалидное состояние невозможным. В примитивной реализации можно присвоить и результат, и ошибку, и забыть проинициализировать `IsOk`, так что проблем от этого будет больше, чем пользы.
В F# подобные вещи определяются проще:
```
type Result<'TResult, 'TError> =
| Ok of 'TResult
| Error of 'TError
type ValidationResult<'TInput> =
| Valid of 'TInput
| Invalid of string list
let validateAndExecute input =
match validate input with // проверяем результат функции валидации
| Valid input -> Ok (execute input) // если валидно - возвращаем "Ок" с результатом
| Invalid of messages -> Error messages // если нет, возвращаем ошибку со списком сообщений
```
Никаких исключений, все лаконично, и главное, что код самодокументирован. Вам не нужно писать в xml doc, что метод кидает какое-то исключение, вам не нужно судорожно оборачивать вызов чужого метода в `try/catch` просто на всякий случай. В такой системе типов исключение — действительно непредсказуемая, неправильная ситуация.
Когда вы кидаете исключения направо и налево, вам нужна нетривиальная обработка ошибок. Вот у вас появляется класс `BusinessException` или `ApiException`, теперь вам нужно наплодить исключений, отнаследованных от них, следить, чтобы везде использовались именно они, а если вы что-то перепутаете, то вместо, например, `404` или `403` клиент получит `500`. Вас же ждет нудный разбор логов, чтение стек трейсов и так далее.
F# компилятор кидает ворнинг, если мы в `match` перебрали не все возможные варианты. Что очень удобно, когда вы добавляете новый кейс в DU. В DU мы определяем воркфлоу, например:
```
type UserCreationResult =
| UserCreated of id:Guid
| InvalidChars of errorMessage:string
| AgreeToTermsRequired
| EmailRequired
| AlreadyExists
```
Тут мы сразу видим все возможные сценарии для данной операции, что гораздо наглядней общего списка исключений. А когда мы добавили новый кейс `AgreeToTermsRequired` в соответствии с новыми требованиями, компилятор кинул ворнинг там, где мы этот результат обрабатываем.
Я ни разу не видел, чтобы в проектах использовали такое наглядное и описательное множество исключений (по понятным причинам). В итоге сценарии описаны в текстовых сообщениях этих исключений. В такой реализации появляются дубликаты, и, наоборот, разработчики ленятся добавлять новые сообщения, вместо этого делая существующие более общими.
Индексация же по массиву теперь тоже очень лаконична, никаких `if/else` и проверки длины:
```
let doSmth myArray index =
match Array.tryItem index myArray with
| Some elem -> Console.WriteLine(elem)
| None -> ()
```
Здесь используется тип стандартной библиотеки Option:
```
type Option<'T> =
| Some of 'T
| None
```
Каждый раз, когда вы его используете, код сам вам говорит, что отсутствие значения здесь возможно *согласно логике*, а не из-за ошибки программиста. И компилятор кинет ворнинг, если вы забудете обработать все возможные варианты.
Строгость парадигмы
-------------------
Чистые функции и expression-based дизайн языка дают нам возможность писать очень стабильный код.
Чистая функция соответствует следующим критериям:
* Единственный результат ее работы — вычисление значения. Она не изменяет ничего во внешнем мире.
* Функция всегда возвращает одно и то же значение для одного и того же аргумента.
Добавьте к этому тотальность (функция может корректно вычислить значение для любого возможного входящего параметра) и вы получите потокобезопасный код, который работает всегда правильно и который легко тестировать.
Expression-based design говорит нам, что все является выражением, у всего есть результат выполнения. Например:
```
let a = if someCondition then 1 else 2
```
Компилятор заставит нас учесть *все* возможные комбинации, мы не можем остановиться просто на `if`, забыв про `else`.
В C# это обычно выглядит так:
```
int a = 0;
if(someCondition)
{
a = 1;
}
else
{
a = 2;
}
```
Здесь легко можно потерять одну ветку в будущем, и `a` останется с дефолтным значением, то есть еще одно место, где может сыграть человеческий фактор.
Конечно же, на одних чистых функциях далеко не уедешь — нам нужно I/O, как минимум. Но эти нечистые эффекты можно сильно ограничить до пользовательского ввода и работы с хранилищами данных. Бизнес-логика может быть реализована на чистых функциях, и в этом случае она будет стабильней швейцарских часов.
Уход от привычного ООП
----------------------
Стандартный кейс: у вас есть сервис, который зависит от парочки других сервисов и репозитория. Те сервисы, в свою очередь, могут зависеть от других сервисов и от своих репозиториев. Все это скручивается могучим DI фреймворком в тугую колбасу функционала, отдается веб-апи контроллеру при реквесте.
Каждая зависимость нашего сервиса, которых в среднем, допустим, от 2 до 5, как и сам наш сервис, обычно имеет 3-5 методов, разумеется, большая часть которых совершенно не нужна в каждом конкретном сценарии. Из всего этого раскидистого дерева методов нам нужно в каждом отдельном сценарии обычно 1-2 метода от каждой (?) зависимости, но мы связываем воедино весь блок функционала и создаем кучу объектов. И моки, конечно же. Куда ж без них — нам нужно же как-то протестировать всю эту красоту. И вот я хочу покрыть тестом метод, но для того, чтобы вызвать этот метод, мне нужен объект этого сервиса. Чтобы его создать, я должен пропихнуть в него моки. Загвоздка в том, чтобы понять, какие именно моки — какие-то в моем методе вообще не вызываются, они мне не нужны. Какие-то вызываются, но только пара методов из них. Поэтому в каждом тесте я делаю нудный сетап этих моков с возвращаемыми значениями и прочей требухой. Потом я хочу протестировать второй сценарий в *том же методе*. Меня ждет новый сетап. Иной раз в тестах на метод кода больше, чем в самом методе. И да, ***для каждого метода*** я должен лезть в его кишки и смотреть, какие же зависимости мне *действительно* нужны в этот раз.
Проявляется это не только в тестах: когда я хочу использовать какой-то 1 метод сервиса, я должен удовлетворить все зависимости, чтобы создать сам сервис, даже если в моем методе половина из них не используется. Да, это на себя берет DI фреймворк, но все равно все эти зависимости необходимо зарегистрировать в нем. Нередко это может быть проблемой, например, если часть зависимостей лежит в другой сборке, и теперь нам нужно на нее добавить ссылку. В отдельных случаях это может сильно портить архитектуру, и тогда приходится извращаться с наследованием или выделять общий блок в отдельный сервис, тем самым увеличивая число компонентов в системе. Проблемы, безусловно, решаемые, но неприятные.
В функциональной парадигме это работает немного по-другому. Самый крутой пацан здесь — чистая функция, а не объект. И преимущественно, как вы уже поняли, тут используют иммутабельные значения, а не мутабельные переменные. Кроме того, функции прекрасно композируются, поэтому, в большинстве случаев, нам не нужны *объекты* сервисов вообще. Репозиторий достает из базы то, что тебе нужно? Ну так достань и передай в сервис само значение, а не репозиторий!
Простой сценарий выглядит примерно так:
```
let getReport queryData =
use connection = getConnection()
queryData
|> DataRepository.get connection // зависимость от коннекшна мы внедряем в функцию, а не в конструктор
// и вот нам уже не нужно следить за lifestyle'ом зависимостей в огромном дереве
|> Report.build
```
Для тех, кто не знаком с оператором `|>` и каррированием, это равносильно следующему коду:
```
let gerReport queryData =
use connection = getConnection()
Report.build(DataRepository.get connection queryData)
```
На C#:
```
public ReportModel GetReport(QueryData queryData)
{
using(var connection = GetConnection())
{
// Report здесь -- статический класс. В него компилируются F# модули
return Report.Build(DataRepository.Get(connection, queryData));
}
}
```
А поскольку функции прекрасно композируются, можно написать вообще вот так:
```
let getReport qyertData =
use connection = getConnection()
queryData
|> (DataRepository.get connection >> Report.build)
```
Заметьте, тестировать `Report.build` теперь проще некуда. Вам моки не нужны вообще. Более того, есть фреймворк `FsCheck`, который генерирует сотни входных параметров и запускает с ними ваш метод, и показывает данные, на которых метод сломался. Пользы от таких тестов несравнимо больше, они действительно проверяют на прочность вашу систему, юнит-тесты ее скорее неуверенно щекочут.
Все, что вам нужно сделать для запуска таких тестов — 1 раз написать генератор для вашего типа. Чем это лучше написания моков? Генератор универсален, он подходит для **всех** будущих тестов, и вам не нужно знать имплементацию чего бы то ни было, для того, чтобы его написать.
Кстати, зависимость от сборки с репозиториями или с их интерфейсами теперь не нужна. Все сборки оперируют общими типами и зависят только от нее, а не от друг друга. Если же вдруг вы решите сменить, например, EntityFramework на Dapper, сборку с бизнес логикой **это не затронет вообще никак**.
Statically Resolved Type Parameters (SRTP)
------------------------------------------
Тут лучше показать, чем рассказать.
```
let inline square
(x: ^a when ^a: (static member (*): ^a -> ^a -> ^a)) = x * x
```
Эта функция будет работать для *любого* типа, у которого определен оператор умножения с соответствующей сигнатурой. Разумеется, это работает и с обычными статическими методами, не только с операторами. И не только со статическими!
```
let inline GetBodyAsync x = (^a: (member GetBodyAsync: unit -> ^b) x)
open System.Threading.Tasks
type A() =
member this.GetBodyAsync() = Task.FromResult 1
type B() =
member this.GetBodyAsync() = async { return 2 }
A() |> GetBodyAsync |> fun x -> x.Result // 1
B() |> GetBodyAsync |> Async.RunSynchronously // 2
```
Нам не нужно определять интерфейс, писать обёртки для чужих классов, имплементить интерфейс, единственное условие — чтобы у типа был метод с подходящей сигнатурой! Я не знаю способа сделать так в C#.
Computation Expressions
-----------------------
Мы рассматривали пример с типом `Result`. Допустим, мы хотим выполнить каскад операций, каждая из которых нам возвращает этот самый `Result`. И если хоть одно звено в этой цепи вернет ошибку, мы хотим прекратить выполнение и вернуть ошибку сразу.
Вместо того, чтобы писать бесконечные
```
let res arg =
match doJob arg with
| Error e -> Error e
| Ok r ->
match doJob2 r with
| Error e -> Error e
| Ok r -> ...
```
Мы можем один раз написать
```
type ResultBuilder() =
member __.Bind(x, f) =
match x with
| Error e -> Error e
| Ok x -> f x
member __.Return x = Ok x
member __.ReturnFrom x = x
let result = ResultBuilder()
```
И использовать это так:
```
let res arg =
result {
let! r = doJob arg
let! r2 = doJob2 r
let! r3 = doJob3 r2
return r3
}
```
Теперь на каждой строчке с `let!` в случае `Error e` мы вернем ошибку. Если же все все будет хорошо, в конце вернем `Ok r3`.
И вы можете делать такие штуки *для чего угодно*, включая даже использование кастомных операций с кастомными названиями. Богатый простор для построения DSL.
Кстати, есть такая штука и для асинхронного программирования, даже две — `task` & `async`. Первый для работы с привычными нам тасками, второй — для работы с `Async`. Эта штука из F#, от тасок главным образом отличается тем, что у нее cold start, она также имеет интеграцию с Tasks API. Вы можете строить сложные воркфлоу с каскадным и параллельным исполнением, а запускать их лишь когда они готовы. Выглядит это так:
```
let myTask =
task {
let! result = doSmthAsync() // суть как у await Task
let! result2 = doSmthElseAsync(result)
return result2
}
let myAsync =
async {
let! result = doAsync()
let! result2 = do2Async(result)
do! do3Async(result2)
return result2
}
let result2 = myAsync |> Async.RunSynchronously
let result2Task = myAsync |> Async.StartAsTask
let result2FromTask = myTask |> Async.AwaitTask
```
Структура файлов в проекте
--------------------------
Поскольку рекорды (DTO, модели и тд) объявляются лаконично и не содержат никакой логики, в проекте существенно уменьшается количество файлов. Доменные типы могут быть описаны в 1 файле, типы, специфичные для какого-то узкого блока или слоя могут быть определены в другом файле тоже вместе.
Кстати, в F# важен порядок строк кода и файлов — **по умолчанию** в текущей строчке вы можете использовать только то, что уже описали выше. Это by design, и это очень круто, потому что предохраняет вас от циклических зависимостей. Это так же помогает при ревью — порядок файлов в проекте выдает ошибки проектирования: если в самом верху определен высокоуровневый компонент, значит кто-то накосячил с зависимостями. И это видно с первого взгляда, а теперь представьте, сколько времени вам потребуется для того, чтобы в C# при ревью такое обнаружить.
Для сравнения, вся логика и доменные типы игры Змейка у меня описана в 7 файлах, все кроме одного меньше 130 строк кода.
[**Пруф**](https://github.com/kagetoki/SnakeGame/tree/master/Snake)
Итог
----
Получив все эти мощные инструменты и привыкнув к ним, начинаешь решать задачи быстрее и изящней. Большая часть кода, 1 раз написанная и 1 раз протестированная работает **всегда**. Писать же снова на C# для меня значит отказаться от них и потерять в продуктивности. Я словно возвращаюсь в прошлый век — вот я бегал в удобных кроссовках, а теперь в лаптях. Лучше, чем ничего, но хуже, чем что-то. Да, в него потихоньку добавляют разные фичи — и pattern matching, и рекорды завезут, и даже nullable reference types.
Но все это, во-первых, сильно позже, чем в F#, во-вторых, беднее. Pattern matching без Discriminated unions & Record destruction — ну, лучше, чем ничего. Nullable reference types — неплохо, но `Option` лучше.
Я бы сказал, что главная проблема F# — это то, что тяжело его "продать" сишарпистам.
Но если вы все же решитесь изучить F# — втянуться будет легко.
И тесты будет писать приятно, и от них **действительно** будет много пользы. Property-based тесты (те, что я описывал в примере с FsCheck) мне несколько раз показали ошибки *проектирования*, которые силами QA искались бы *очень* долго. Юнит-тесты же в основном показывали мне, что я забыл что-то обновить в конфигурации тестов. И да, время от времени, показывали, что я что-то где-то упустил в коде. В F# с этим справляется компилятор. Бесплатно. | https://habr.com/ru/post/428930/ | null | ru | null |
# Выгружаем данные из метеорологической стации Oregon Scientific WMR500
Однажды мы решили, что нам на сайте нужна своя актуальная погода за окном. А значит нужна какая-то метеорологическая станция с подключением в Интернет. Недорого. Ибо брать что-то типа Davis Vantage Pro2 Plus за овер 100 тысяч рублей, да еще и держать отдельный компьютер для подключения к ней (как это сделали в [mail.ru](https://habr.com/ru/company/mailru/blog/135189/)) не хотелось как с точки зрения бюджета, так и с точки зрения сложности.
Выбор пал на недорогую, достаточно свежую метео-станцию Oregon Scientific WMR500. Обзор её я делать не буду, можете самостоятельно поискать в Интернете. Достаточно того, что она умеет измерять температуру, влажность, давление, скорость и направление ветра. В теории она умеет еще качество воздуха и уровень УФ-излучения, но мы не нашли в продаже соответствующих дополнительных датчиков. Ценой за бюджетность была схема её работы. Данные она сама отдает в облако по Wi-Fi. Доступ к данным есть в мобильном приложении, а так же с web, но несколько странный. Об этом, собственно, и пойдет речь.
Для получения доступа к web-части необходим аккаунт, который создается в мобильном приложении. Собственно и настройка станции в части того, какой Wi-Fi ей использовать для подключения происходит только в приложении при первичном подключении к временной точке доступа самой станции. Тут все делается по инструкции и ничего сложного нет. В итоге, в приложении мы получаем добавленное устройство, id которого нам понадобится далее.
Web-интерфейс находится по адресу <http://web-wmr500.idtlive.com/>
Зайдя в него, можно смотреть графики средней красивости по кнопке «Show», а так же экспортировать данные в формате XLS за выбранный период (кнопка «Export»). Сразу скажу, что показ влажности на график работает, а вот экспорт нет, потому что данные влажности экспортируются вместе с данными температуры. Такая вот странная ситуация. Посматривая в запросы можно увидеть, что для графиков есть некий api, отдающий данные в json, что уже хорошо. Можно грабить корованы!
Для примера «грабим» набор данных по темпрературе за сутки. Запрос пойдет на [web-wmr500.idtlive.com/index/api.show/index.html](http://web-wmr500.idtlive.com/index/api.show/index.html), с параметрами (тут PHP массив параметров для примера):
```
$request = [
'type' => 'temperature',
'unit' => '°C',
'id' => 'id-вашего-устройства',
'channel' => 'номер-канала-блока-датчиков',
'start' => "'2020-07-20T00:00:00Z'",
'end' => "'2020-07-21T00:00:00Z'",
];
```
Даты обязательно в одинарных кавычках и в формате ISO 8601 без TimeZone. Номер канала (channel) – 1, 2 или 3, в зависимости от того, на каком канале подключен блок датчиков. Данные запроса по типам отличаются собственно типом запрашиваемых данных (type) и единицами измерения (unit).
Все доступные типы и единицы измерения:
```
temperature – °C или °F
humidity – %
rain – mm/h или inch/h
wind – m/s, knots, kph, mph
pressure – mbar,hPa,mmHg,inHg
```
Одно плохо, через api.show можно получить данные только указанных параметров, к примеру нельзя узнать направление ветра, или точку росы, да там много всего статистического. А хотелось бы. И тут нам поможет EXPORT.
Делаем первый запрос на адрес [web-wmr500.idtlive.com/index/api.export/index.html](http://web-wmr500.idtlive.com/index/api.export/index.html) с теми же параметрами. В ответ сервер где-то в дебрях генерирует статический XLS файл и отдает ссылку на него. Скачать его можно после этого в любой момент (я видел на сервере чужие файлы за 2018 год, папка открыта для индексирования). В файлах уже существенно больше информации, вернее она там вся доступная.
Но тут тоже есть свои плюсы и свои минусы. Плюс – вы можете получить данные за нужный период. Минус — в web-часть эти данные попадают с 15-ти минутным интервалом. Для хранения погоды у себя в БД это даже хорошо, можно загрузить сразу все данные с момента запуска станции и все такое. А вот если вы хотите чаще, или быстрее получать актуальную информацию, то придется провести более продвинутые изыскания.
Я «психанул» и решил перехватить трафик приложения, оно получает данные практически мгновенно. Вернее оно получает данные «напрямую» от станции, которая отдает последние данные, полученные от блока датчиков. А блок датчиков она опрашивает раз в 15 секунд.
Оказалось, что приложение по протоколу MQTT идет куда-то в инстанс амазона (адрес 35.161.38.128 получен путем перехвата трафика, кхе-кхе), подписывается на топик со случайным topic-id, шлет в топик станции (она сама по wi-fi и подкючена только по MQTT только туда, web-часть судя по всему тоже периодически из брокера MQTT эти же даные и получает) с её id команду типа «родная, дай-ка мне свой статус, ответь в topic-id». И если для получения данных с web-части я использовал php + curl (вы можете использовать то, что вам больше по душе), то тут нужна асинхронщина в рамках одного соединения. Быстро и «на коленке» я придумал только использовать node.js. Понадобится модуль mqtt.
В моем случае это просто консольный скрипт, который через exec я «дергаю» в php.
```
#!/usr/bin/node
var mqtt = require('mqtt');
var md5 = require('md5');
String.prototype.insert = function (index, string) {
if (index > 0)
return this.substring(0, index) + string + this.substring(index, this.length);
else
return string + this;
};
var host = 'mqtt.idtlive.com';
var your_mail = 'your_account_mail@somehost.com'; // see in app, registered account
var clientId = 'Android_' + your_mail;
var deviceId = 'your-device-id'; // see in app connected device section, something like F9987D92-E180-64DE-A202-D43AAD0D5784
var channelId = 1; // channel beetwen station & external sensors block
var timeInMs = Date.now();
var uniqTopic = md5(timeInMs).toUpperCase().insert(8,'-').insert(13,'-').insert(18,'-').insert(23,'-');
var client = mqtt.connect( {
host : host,
port : 1883,
cliendId : clientId
});
client.on('connect', function() {
client.subscribe('enno/out/json/'+uniqTopic,
function(err) {
if (!err) {
client.publish('enno/out/json/'+deviceId, '{"command":"getChannel'+channelId+'Status","id":"'+uniqTopic+'"}');
} else {
console.log('connect error');
}
})
});
client.on('message', function(topic, message) {
console.log(message.toString())
client.end()
});
```
Как парсить данные из web-части (JSON), экспорта (Excel) или из MQTT (JSON) я рассказывать не буду, тут уж как хотите, так и обрабатывайте.
Вот собственно и все. Если кому-то вдруг поможет, то буду только рад.
P.S> Update, код скрипта причесан, добавлена генерация случайного топика MQTT, для имитации работы как из приложения, а так же выложен [сюда](https://github.com/NickyX3/OS_WMR500_Fetcher) | https://habr.com/ru/post/511850/ | null | ru | null |
# AngularJS против Backbone.js против Ember.js
#### 1 Введение
В статье мы сравним три популярных MV\* фреймворка для веб-разработки: AngularJS, Backbone и Ember. Выбор подходящего фреймворка для проекта кардинально влияет на вашу возможность выполнять задачи вовремя и поддерживать ваш код в будущем. Вам нужен надёжный, проверенный фреймворк, но вы не хотите, чтобы он вас ограничивал. Веб быстро развивается, и старые методики уходят в прошлое. Займёмся же подробным их сравнением.
#### 2 Познакомьтесь с фреймворками
У всех рассматриваемых фреймворков есть общие черты: их код открыт, выпущен под лицензией MIT, и они решают задачу создания одностраничного приложения через шаблон проектирования MV\*. У всех есть концепции видов, событий, моделей данных и путей.
AngularJS родился в 2009 как часть большего коммерческого продукта GetAngular. Вскоре после этого Миско Хевери, один из инженеров-основателей GetAngular, сумел воссоздать при помощи этого продукта веб-приложение, состоявшее из 17 тысяч строк кода и делавшееся в течение 6 месяцев, всего за 3 недели, и уложиться при этом в тысячу строк кода. В Google впечатлились таким фактом и стали спонсировать проект с открытым кодом AngularJS. Среди его возможностей – двустороннее связывание данных, инъекции зависимостей, простой для тестирования код и расширение возможностей HTML при помощи директив.
Backbone.js – легковесный MVC-фреймворк, родившийся в 2010. Популярность набрал в качестве альтернативы тяжёлым фреймворкам вроде ExtJS.
Ember родом из 2007 года. Он начинался как SproutCore MVC фреймворк, и сначала его разрабатывали SproutIt, затем – Apple. В 2011 году его форкнул Иехуда Кац, один из главных программистов в проектах jQuery и Ruby on Rails.
#### 3 Сообщества
Сообщество – один из важных факторов для выбора фреймворка. Больше сообщества – больше ответов на вопросы, сторонних модулей, тьюториалов на YouTube… Я составил табличку, актуальную на апрель 2014 года. Angular явно выигрывает – это 6-й популярный проект на GitHub и вопросов по нему на StackOverflow больше, чем в сумме у Ember и Backbone:
Кроме текущих показателей можно при помощи Google Trends посмотреть на скорость роста популярности фреймворков:
#### 4 Размеры фреймворка
Время загрузки страниц – вещь для успеха сайта критичная. Пользователи [не отличаются терпением](https://www.fastcompany.com/1825005/how-one-second-could-cost-amazon-16-billion-sales), поэтому необходимо стараться ускорять загрузку как можно сильнее. На это влияют два фактора – размер фреймворка и время, которое требуется ему на запуск.
Мы будем сравнивать минифицированные версии в архиве gzip. Но недостаточно сравнить размеры самих фреймворков. Например, Backbone.js, несмотря на малый размер, требует ещё Underscore.js (5kb) и jQuery (32kb) или Zepto (9.1kb).
#### 5 Шаблоны
Angular и Ember включают движок шаблонов. А Backbone оставляет его на усмотрение разработчика. Лучший способ протестировать шаблоны – это взять пример кода. Мы возьмём пример форматирования списка в HTML.
##### 5.1 AngularJS
У Angular шаблоны – это HTML со связывающими выражениями. Выражения окружены двойными фигурными скобками:
```
* {{framework.name}}
```
##### 5.2 Backbone.js
Хотя Backbone можно интегрировать с несколькими движками шаблонов, по умолчанию используется [Underscore](https://underscorejs.org/#template). Но обработка шаблонов с его помощью довольно примитивна, и приходится добавлять код на JS:
```
<% \_.each(frameworks, function(framework) { %>
* <%- framework.name %>
<% }); %>
```
##### 5.3 Ember.js
Ember на сегодняшний день использует Handlebars – это расширение популярного движка Mustache. Сейчас разрабатывается новый вариант Handlebars по имени HTMLBars. Handlebars не понимает DOM – он просто работает со строками. HTMLBars будет понимать DOM.
```
{{#each frameworks}}
* {{name}}
{{/each}}
```
#### 6 AngularJS
##### 6.1 Преимущества
Angular привнёс много новых концепций. Двустороннее связывание данных позволяет минимизировать код. Возьмём такой пример на jQuery:
```
$('#greet-form input.user-name').on('value', function() {
$('#greet-form div.user-name').text('Hello ' + this.val() + '!');
});
```
Благодаря двустороннему связыванию, такой код писать не придётся. Вы просто объявляете связку в шаблоне:
```
Салют, {{user.name}}!
```
Обещания играют важную роль в angular. JS – язык однопоточный и событийный, поэтому много чего происходит в асинхронном режиме. Асинхронный код на JS быстро разрастается и превращается в спагетти из вложенных обратных вызовов. Его часто обзывают «Пирамидальный код» или «Ад с обратными вызовами».
У Angular не только самое большое сообщество, его поддерживает и рекламирует Google. Открытый код позволяет всем принимать участие в разработке фреймворка. [Вот здесь находятся документы](https://drive.google.com/drive/#folders/0B7Ovm8bUYiUDR29iSkEyMk5pVUk) по дизайну Angular 2.0, и все могут знакомиться и комментировать их.
Angular разбивает приложение на блоки нескольких типов: контроллеры, директивы, фабрики, фильтры, сервисы и виды. Они, в свою очередь, разбиваются на модули. У всех блоков – своя роль. Виды занимаются UI, контроллеры – логикой интерфейса, сервисы общаются с бэкендом, директивы позволяют создавать компоненты и расширяют HTML.
«Angular написан с учётом тестируемости» – эта цитата из [руководства по юнит-тестам](https://drive.google.com/drive/#folders/0B7Ovm8bUYiUDR29iSkEyMk5pVUk) говорит о многом. Действительно, Angular сильно заботится о разделении сущностей, изолировании юнитов и предоставляет мощные средства для работы со встроенными сервисами вроде $http и $timeout.
##### 6.2 Недостатки
Angular часто критикуют за сложность API директив. Особенно запутывает разработчиков концепция трансклюзии, а кроме того есть такие вещи, как компиляция функций, пред- и пост- линкуемые функции, разные виды областей видимости и настройки директив.
Иерархия областей видимости использует прототипное наследование, которое сложно даётся для людей с опытом в Java и C#.
Angular Expressions широко используются в Видах. Этот язык довольно мощный, иногда даже чересчур. Он позволяет создавать сложную логику и проводить операции присваивания и различные подсчёты внутри шаблонов. Размещение логики в шаблонах усложняет тестирование. Рассмотрим следующий пример перегруженного вычислениями шаблона:
```
Жмите
```
Во многих случаях легко ошибиться в имени директивы или функции, и тяжело найти эту ошибку.
Digest Cycle, обеспечивающий магию «грязных проверок» также часто удивляет разработчиков. Легко забыть вызвать $digest(), работая в контексте, отличном от Angular. Нужно заботиться о том, чтобы случайно не сделать бесконечные digest-циклы. На страницах с обилием интерактива Angular начинает тормозить. Не стоит использовать более 2000 связок на одной странице.
#### 7 Backbone.js
##### 7.1 Преимущества
Backbone – легковесный и не занимает много памяти. Кривая обучения линейная, и у него есть очень мало концепций для понимания (модели/коллекции, виды, пути). Отличная документация, а код простой. Вы даже можете пройтись по всему коду фреймворка, который хорошо документирован, и ознакомиться с ним в течение часа.
На его основе можно строить свои фреймворки. Примеры готовых: Backbone UI, Chaplin, Geppetto, Marionette, LayoutManager, Thorax, Vertebrae. В случае Angular и Ember вам приходится жить с тем, что для вас приготовили разработчики. В Angular 2.0 обещают это исправить, но до этого ещё надо дожить.
##### 7.2 Недостатки
Backbone не предоставляет структуры. Это всего лишь набор простых инструментов для создания структуры, и вам нужно заполнить много пустых мест. Конечно, многие из этих мест заполняются сторонними плагинами – но это значит, что вам нужно принять много решений при их выборе. К примеру, вложенные модели можно сделать при помощи Backbone.DocumentModel, BackBone.NestedTypes, Backbone.Schema, Backbone-Nested, backbone-nestify и так далее. Выбор лучшего решения занимает время – а суть фреймворка в экономии вашего времени.
Нет поддержки двусторонней связанности данных, то есть вам придётся писать много вспомогательного кода для обновления вида при изменениях модели, и для обновления модели при изменениях вида.
Виды в Backbone напрямую манипулируют DOM, поэтому их сложно тестировать и сложнее повторно использовать.
#### 8 Ember.js
##### 8.1 Преимущества
Ember.js работает по принципу «соглашения вместо настроек». Ember не требует написания вспомогательного кода, он может сам догадаться до многих вещей, например автоматического определения имени пути и контроллера при определении ресурса. Он даже умеет автоматически создавать контроллер для ресурса, если вы его не определите.
Он включает хороший обработчик путей и опциональный слой для работы с данными под названием ember data. В отличие от двух других фреймворков, у Ember сразу есть модуль для работы с данными, который хорошо интегрируется с бэкендом Ruby-on-Rails или любым API с RESTful JSON.
При разработке Ember внимание уделялось быстродействию. Ваше приложение скорее всего будет грузиться и работать быстрее.
##### 8.2 Недостатки
API бурно развивался, поэтому содержит устаревший контент и примеры, которые уже не работают. Взгляните на Ember Data Changelog, и вы поймёте, что я имею в виду. Многие ответы на вопросы на StackOverflow уже неактуальны.
Handlebars загрязняют DOM множеством тегов `, что не только усложняет HTML, но и может поломать CSS или интеграцию с другими фреймворками вроде jQuery UI Sortable.
#### 9 Итоги
Мы рассмотрели преимущества и недостатки фреймворков. Целостный подход Ember к реализации MVC понравится тем разработчикам, которые исповедовали его в Ruby, Python, Java, C# и других ООП-языках. Он также подходит для создания быстро работающих приложений и избавляет вас от написания лишнего кода.
Backbone выступает за минимализм. Он мелкий, быстрый и простой в обучении, и обеспечивает вам минимум необходимых инструментов для работы.
Angular инновационно подходит к расширению возможностей HTML, он понравится веб-разработчикам. У него большое сообщество и поддержка со стороны Google, он будет расти и развиваться, и он хорошо подходит как для быстрого прототипирования, так и для объёмных проектов.` | https://habr.com/ru/post/259311/ | null | ru | null |
# Создание заставок (splash screen) в .net 3.5 SP1
Если вы сталкивались с программированием в .net, то наверняка замечали, что при запуске программы, написанной с использованием WPF, долгое время ничего не происходит. Так продолжается секунд 10, а потом уже открывается главное окно приложения. Даже запуск пустого шаблона WPF приложения занимает около двух секунд.
Эта пауза вносит неопределенность в восприятие программы пользователем: запустилась программа или нет?
Решить эту проблему можно показав заставку сразу после запуска. Это даст физический отклик сразу после запуска приложения и создаст иллюзию более быстрой загрузки.
О том, как это сделать написано под катом.
Почему приложение так долго загружается
=======================================
Это происходит из-за того, что при запуске Windows библиотеки .net, которые занимают порядка 20 мегабайт, не загружаются в память. .net Framework динамически подгружает необходимые библиотеки при запуске программы. Если мы посмотрим Output в студии при запуске программы, то сможем это увидеть:
> 'SplashDemo.vshost.exe' (Managed): Loaded 'C:\Windows\assembly\GAC\_32\mscorlib\2.0.0.0\_\_b77a5c561934e089\mscorlib.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
>
> 'SplashDemo.vshost.exe' (Managed): Loaded 'C:\Windows\assembly\GAC\_MSIL\Microsoft.VisualStudio.HostingProcess.Utilities\9.0.0.0\_\_b03f5f7f11d50a3a\Microsoft.VisualStudio.HostingProcess.Utilities.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
>
> 'SplashDemo.vshost.exe' (Managed): Loaded 'C:\Windows\assembly\GAC\_MSIL\PresentationFramework\3.0.0.0\_\_31bf3856ad364e35\PresentationFramework.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
>
> …
>
> …
>
> …
>
> 'SplashDemo.vshost.exe' (Managed): Loaded 'D:\work\Visual Studio 2008\Projects\SplashDemo\bin\Debug\SplashDemo.exe', Symbols loaded.
>
> Step into: Stepping over non-user code 'System.Windows.SplashScreen.SplashScreen'
>
> Step into: Stepping over non-user code 'SplashDemo.App.App'
>
> 'SplashDemo.vshost.exe' (Managed): Loaded 'C:\Windows\assembly\GAC\_MSIL\System.Configuration\2.0.0.0\_\_b03f5f7f11d50a3a\System.Configuration.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
>
> Step into: Stepping over non-user code 'SplashDemo.App.InitializeComponent'
>
> 'SplashDemo.vshost.exe' (Managed): Loaded 'C:\Windows\assembly\GAC\_MSIL\PresentationFramework.Aero\3.0.0.0\_\_31bf3856ad364e35\PresentationFramework.Aero.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
Как это решалось раньше
=======================
Нужно было плясать с бубном и запускать native код до начала запуска приложения. А потом его как-то останавливать. Коммерческий компонент [Quicksplash](http://www.quicksplash.net/) предлагает удалять файл из заданной папки после загрузки вашего приложения. Вариант несколько неудобный. Остальные и того хуже.
Как это решается теперь
=======================
С появлением .net 3.5 sp1 все делается буквально двумя щелчками мыши. Поддерживаются только изображения следующих форматов: BMP, GIF, JPEG, PNG и TIFF. В PNG есть поддержка альфа-канала.
Вариант №1
----------
Самый простой вариант. Он достаточен в 99% случаев. Для создания заставки необходимо добавить изображение в проект:
И в окне *Properties* добавленного файла установить параметру *Build Action* значение *SplashScreen*.
Это все, что необходимо.
Во время сборки в файл *App.g.cs* добавятся следующие строки:
> `SplashScreen splashScreen = new SplashScreen("splash.png");
>
> splashScreen.Show(true);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Их мы разберем чуть позже.
Вариант №2а
-----------
Второй вариант мало чем отличается от первого: просто мы все сделаем своими руками. Для этого добавляем картинку к проекту. Открываем *App.xaml* (не *App.xaml.cs*) и добавляем новый обработчик для события StartUp:
Переходим в файл *App.xaml.cs*, ищем только что созданный метод и дополняем его следующими строчками:
> `private void AppStartUp(object sender, StartupEventArgs e)
>
> {
>
> var splash = new SplashScreen("splash.png");
>
> splash.Show(true);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Давайте их разберем. В первой строке происходит создание нового экземпляра класса SplashScreen. Конструктор имеет единственный параметр — имя файла:
> `var splash = new SplashScreen("splash.png");
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Во второй строке мы вызываем метод *Show(bool autoClose)*. Если значение аргумента истинно, то заставка закроется автоматически после загрузки приложениея. В противном случае необходимо вызвать метод *Close*.
> `splash.Show(true);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вариант №2б
-----------
Практика показала, что бывают ситуации, когда необходимо показывать заставку не только при загрузке, но и, например, сразу после окна авторизации:
> `public Window1()
>
> {
>
> ShowAuthorizationDialog();
>
>
>
> InitializeComponent();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Из-за того, что *InitializeComponent()* вызывается после авторизации, происходит дополнительная загрузка библиотек, которые используются в коде основного приложения, но не используются в окне авторизации. Это приводит к задержке перед появлением основного окна. Для того, чтобы избежать этого эффекта можно поступить следующим образом:
> `public Window1()
>
> {
>
> ShowAuthorizationDialog();
>
>
>
> var splash = new SplashScreen("spalsh.png");
>
> splash.Show(false);
>
>
>
> InitializeComponent();
>
>
>
> splash.Close(TimeSpan.FromMinutes(0.5));
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь единственная новая строчка:
> `splash.Close(TimeSpan.FromMinutes(0.5));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Метод *Close()* закрывает заставку с эффектом затухания. В качестве параметра метод принимает интервал времени, в течение которого будет «гаснуть» заставка.
Известные баги
--------------
В процессе использование пару раз проскакивал черный фон вместо прозрачности. Причин пока не выявил.
Возникает *Win32Exeption* при переключении на другое приложение в тот момент, когда заставка гаснет. Можно поймать окружив метод *Close()* блоком *try...catch*.
### Заключение
Использование заставки в вашей программе делает ее более уютной и человечной по отношению к пользователю. Позволяет избежать лишней ментальной агрессии по отношению к разработчику. :-)
UPD: Это относится только к WPF приложениям.
UPD2: Переместил в блог [.NET](http://habrahabr.ru/blogs/net/). Спасибо. | https://habr.com/ru/post/45459/ | null | ru | null |
# Простые тесты на ruby для web
Для изучения ruby был выбран учебный проект в котором простая задача, написания тестов для web. Ввиду отсутствия знаний и опыта было решено использовать упрощенный фреймворк [sinatra](http://sinatraruby.ru/). В результате, в моем решении этой задачи всего два файла. Первый это mutaAlim.json, в котором у нас база данных в json формате.
##### Рассмотрим структуру этого файла на примере нескольких вопросов:
```
[
{
"id" : 1,
"question" : "Ассаламу Алейкум!",
"answers" : ["Ваалейкум Ассалам", "Привет", "Здорово", "Хай"]
},
{
"id" : 2,
"question" : "Как дела?",
"answers" : ["альхамдуЛилягь", "Плохо", "хорошо", "шикарно"]
}, …..(другие вопросы в таком же порядке)
]
```
У нас таким образом в json массив из хеш элементов.
Ответы в массиве по ключу answers, в котором первый вариант ответа является правильным.
##### Второй файл mutaAlim.rb в котором код приложения.
Рассмотрим его поближе. Первые строчки подключают гемы sinatra и json:
```
require 'sinatra'
require 'json'
```
Для перехода на страницу приветствия следующий код
```
get '/' do
erb :index
end
```
При переходе по [адресу](http://localhost:4567/) у нас откроется страничка, которая описана в том же файле:
```
@@index
Главная
Ассаламу гIалайкум ва раhматуЛлаhи ва баракатуhу!
==================================================
Мира вам, Милости и Благославления Всевышнего!
===============================================
Сайт для тестирования базовых знаний
=====================================
Описание
--------
Этот сайт предназначен для тех кто хочет проверить свои знания.
```
Простая страничка с кнопкой для перехода на страничку тестов. Далее в коде у нас переменные необходимые для работы приложения:
```
#хеш с тестами
@@test_hash
#количество тестов
@@kol_testov = 13
#массив из случайно выбранных неповторяющихся вопросов
@@mas_test_number = Array.new(@@kol_testov)
#массив с ответами, -1 если не ответили на вопрос иначе номер ответа
@@mas_test_answer
#считываем файл с тестами
test_file = File.open('mutaAlim.json',"rb")
@@test_hash = JSON.parse(test_file.read)
test_file.close
#для таблицы результатов
@@not_answer = "Вы не дали ответ"
#количество ответов
@@answers
#количество правильных ответов
@@ball
#процент правильных ответов
@@procent_tru_answers
#массив в котором хранится
```
Как вы заметили пришлось все переменные объявить в классе, иначе на вывод в erb были ошибки, которые я не смог понять и исправить. Далее основной элемент приложения это код странички тестов:
```
# страничка тестов
get '/test' do
if params[:var] == nil
@@mas_test_answer = Array.new(@@kol_testov) { |i| -1}
# заносим случайные вопросы в массив @@mas_test_number
@@mas_test_number[0] = Random.rand(@@test_hash.length)
@@mas_test_number.each_index do |i|
begin
flag = true
buf = Random.rand(@@test_hash.length)
0..i.times do |j|
if @@mas_test_number[j]==buf
flag = false
end
end
if flag
@@mas_test_number[i] = buf
end
end until flag==true
end
@@test_number = 0;
# заносим случайные варианты ответов в массив @@mas_random_variants
@@mas_random_variants = Array.new(@@kol_testov)
@@mas_random_variants.each_index do |i|
@@mas_random_variants[i] = Array.new(@@test_hash[@@mas_test_number[i]]["answers"].size)
end
@@mas_random_variants.each_index do |i|
@@mas_random_variants[i][0] = Random.rand(@@test_hash[@@mas_test_number[i]]["answers"].size)
@@mas_random_variants[i].each_index do |j|
begin
flag = true
buf = Random.rand(@@test_hash[@@mas_test_number[i]]["answers"].size)
0..j.times do |k|
if @@mas_random_variants[i][k]==buf
flag = false
end
end
if flag
@@mas_random_variants[i][j] = buf
end
end until flag==true
end
end
else
#сохраняем выбранный вариант ответа в массив @@mas_test_answer
@@mas_test_answer[@@test_number] = params[:var].to_i
#если возможно выдаем след вопрос
if @@test_number != @@kol_testov - 1
@@test_number += 1
end
end
erb :test
end
```
По условию `params[:var] == nil` мы определяем что пользователь впервые на страничке и «готовим» все необходимое(случайно выбираем тесты из базы, случайно «перемешиваем» варианты ответов и создаем массив для хранения ответов), иначе записываем выбранный пользователем ответ в массив. Весь функционал приложения построен на get запросах, а много путаницы в следствии того, что писалось оно в режиме «лишь бы работало». К примеру если пользователь переходит по ссылке <http://localhost:4567/test?var=0> то в массиве ответов на текущий вопрос будет установлено значение 0.
##### Рассмотрим код странички тестов
```
@@test
Тесты
Вопрос №<%= @@test\_number +1 %>
<%= @@test\_hash[@@mas\_test\_number[@@test\_number]]["question"] %>
----------------------------------------------------------------------------------------------------------
<% @@test\_hash[@@mas\_test\_number[@@test\_number]]["answers"].each\_index do |i| %>
<%= @@test\_hash[@@mas\_test\_number[@@test\_number]]["answers"][@@mas\_random\_variants[@@test\_number][i]] %>
<% end %>
<% @@mas\_test\_number.each\_index do |i| %>
[№ <%= i + 1 %>](/test/question/<%= i + 1 %>)
<% end %>
```
Как вы заметили вставка кода на страничку проиcходит при помощи erb следующим образом `<%= #код с выводом данных %>` и `<% код без вывода данных %>` . На самой страничке вопрос, варианты ответов(radiobutton), ссылки на все вопросы. кнопки навигации по тестам и кнопка завершения тестирования, которая направляет пользователя на страничку результатов теста.
##### Работа кнопок навигации и ссылок на вопросы:
```
# ссылки на каждый вопрос
get '/test/question/:id' do
@@test_number = params[:id].to_i - 1
erb :test
end
# следующий вопрос
get '/test/next' do
if @@test_number != @@kol_testov - 1
@@test_number += 1
end
erb :test
end
# предыдущий вопрос
get '/test/pred' do
if @@test_number != 0
@@test_number -= 1
end
erb :test
end
```
##### Осталось разобрать код странички результатов теста которая подсчитывает итоги
```
# страничка результатов
get '/test/result' do
@@ball = 0
@@answers = 0
#подсчет правильных ответов
@@mas_test_answer.each do |i|
if i == 0
@@ball += 1
end
if i != -1
@@answers += 1
end
end
@@procent_tru_answers = (100/@@kol_testov) * @@ball
erb :result
end
```
##### И код на html + erb
```
@@result
Результат
Результаты вашего теста
========================
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| № | Вопрос | Ваш ответ | Правильный ответ ||
<% @@mas\_test\_answer.each\_index do |i| %>
| <%= i+1 %> | <%= @@test\_hash[@@mas\_test\_number[i]]["question"] %> | <%= if (@@mas\_test\_answer[i] == -1)
@@not\_answer
else @@test\_hash[@@mas\_test\_number[i]]["answers"][@@mas\_test\_answer[i]] end %> | <%= @@test\_hash[@@mas\_test\_number[i]]["answers"][0] %> ||
<% end %>
### Количество тестов = <%= @@kol\_testov %>
### Количество ответов = <%= @@answers %>
### Количество правильных ответов = <%= @@ball %>
### Процент правильных ответов = <%= @@procent\_tru\_answers %> %
Этот сайт предназначен для тех кто хочет проверить свои знания.
```
Я понимаю что данное приложение легче написать с нуля и правильно, нежели понять или сопровождать это. Язык ruby я начал изучать на этом приложении ровно как движок sinatra, язык разметки erb и формат json, поэтому прошу строго не судить за то, что и как использовал.
В дальнейшем планируется переход от sinatra к ror, от json к полноценной базе данных, от erb к haml, от однотипных вопросов(radiobutton) к вопросам 5-6 типов, от тестов к игре и плюс дизайн с версткой.
Приложение в рабочем виде можно увидеть на [сайте](http://daavat-ru.herokuapp.com/).
Репозиторий на [гитхабе](https://github.com/asker1327/mutaAlim). | https://habr.com/ru/post/226869/ | null | ru | null |
# Адаптивная фоновая подсветка для телевизора на Raspberry Pi – аналог Ambilight
Это телевизор с диагональю 50” и 37 RGB точками адаптивной фоновой подсветки по верхней и боковым сторонам экрана. Как сделать аналогичную адаптивную фоновую подсветку для любого экрана или ТВ — тема избитая, но вполне актуальная по ряду причин.
Во-первых, все меняется. Пару лет назад еще не было проекта, работающего без программных или аппаратных костылей. Во всяком случае мне не встречались такие публикации. Те, что описаны на просторах рунета – либо потеряли актуальность в связи с устареванием программных или аппаратных платформ, либо реализуют данную технологию только применительно к мониторам, подключенным к ПК.
Во-вторых, на рынке нет и не будет самсунгов, сони, элджи и прочих ТВ с поддержкой данной технологии, так как она запатентована на многие годы вперед компанией Philips. И наконец — все решения «из коробки», доступные на али и иже с ним – имеют ряд ограничений в гибкости настроек и адаптации к размеру кадра видеоконтента, корректировок цветовой гаммы и т. д, являясь при этом всего лишь аппаратным костылем, анализирующим внешний сигнал и работающий только на формирование подсветки.
#### «Аппаратный» вариант захвата кадров
Если не рассуждать о теоретических вариантах доработки-модернизации самого телевизионного приемника, нужно согласиться с тем фактом, что в любом случае придется обрабатывать HDMI сигнал – т.е. он будет использован для анализа кадров и формирования подсветки. Здесь напрашиваются всего два варианта реализации – с обработкой сигнала от любого источника, (как лайтпаки с али) и с реализацией самого источника в виде медиа-приставки к ТВ с функцией адаптивной подсветки.
В первом случае мы получаем некую универсальность – к устройству можно подключать игровую приставку или какой-то плеер. Во втором – собираем этот самый «какой-то плеер» со встроенной функцией подсветки. Экспериментируя, я реализовал оба варианта, но здесь остановлюсь только на втором, и вот почему:
На приведенной блок-схеме первого варианта HDMI сигнал от любого источника приходит на сплиттер, где разделяется на два выхода. С первого контент воспроизводится на любом ТВ приемнике или мониторе. Со второго — сигнал синхронно поступает в аппаратный скейлер, где конвертируется в аналоговый сигнал с кадрами небольшого разрешения – 320х480. Аналоговый сигнал поступает в аппаратный USB граббер, который делает «скриншоты» каждого кадра и передает их через USB порт на вход одноплатного мини ПК – Raspberry Pi 3 B+. Программное обеспечение на малине анализирует кадры при помощи программы Hyperion и через один из выходов GPIO выдает управляющие последовательности на вход адресной ленты типа WS2812B или APA102. Все это отлично заработало, но имеет пару недостатков в виде кучи железа с соединениями и небольшой задержки в выдаче сигнала на подсветку. Задержка была заметна только на тестовых видеороликах при резкой смене цветов в бОльшей части кадра. В остальном без нареканий, кроме стоимости всего железа в этой реализации:
Raspberry Pi 3 B+ — около $55.
Корпус-радиатор — $14.
Активный HDMI 1080P сплиттер на 2 выхода — $15.
HDMI 1080P To AV скейлер — $15.
EasyCap USB граббер — $18.
Блок питания – около $10.
MicroSD карта 32GB — $10.
Соединительные кабели и прочая мелочевка – около $10.
Итого, не считая адресной ленты – почти $150.
Не то, чтобы такой вариант сразу в топку – он вполне может пригодиться для организации фоновой подсветки на каких-то больших сборных экранах в рекламе или презентациях, и цена не самая страшная за полученный результат — но для домашнего использования я остановился на втором варианте – в бОльшей степени «программном». Он вышел проще, дешевле, компактней и шустрее. Для коммерческого использования он так же вполне может сгодиться – Raspberry Pi с плеером можно успешно использовать в проектах, где нужно автоматически с момента включения циклично и бесшовно воспроизводить какой-то контент, отключая плеер, опять же автоматически — по расписанию в конце дня. Написав небольшой скрипт, мы получим рекламный девайс с функцией адаптивной подсветки любых экранов, хоть десятиметровых. Но вернемся к домашнему применению…
#### «Программный» вариант захвата кадров
Функции медиа-центра и управления подсветкой останутся за этой же Raspberry Pi 3 B+, а все соединения теперь будут сводиться к подключению нескольких разъемов – питания, интернета, выхода на подсветку и HDMI к ТВ. Не больше, чем у любой другой ТВ-приставки:
Забегая вперед, хочу отметить, что на Raspberry Pi 3 B+ получилась вполне универсальная ТВ приставка-медиацентр со всеми необходимыми возможностями подобного устройства, плюс гибко настраиваемая адаптивная подсветка любого современного (и не очень) телевизора, имеющего HDMI вход.
Основой программной части является открытая ОС Libreelec, специально заточенная под плеер Kodi. [Сайт проекта](https://www.ixbt.com/live/redirect/aHR0cHM6Ly9saWJyZWVsZWMudHYv) содержит всю необходимую информацию.
Про возможности одной из самых мощных и гибких платформ для воспроизведения видео-аудио контента, IPTV и т.д. можно почитать, забив в любой поисковик «kodi описание возможностей». Информации на русском по этой теме очень много. Я использую, пожалуй, 1/10 от всех возможностей платформы и мне этого хватает. Платформа активно поддерживается, имеет отзывчивое сообщество. Следовательно, читаем, изучаем – на вики этих проектов и на форумах есть практически вся необходимая информация и ответы на вопросы. Дистрибутив и инструкции по установке и настройке платформы берем на сайте проекта Libreelec. Так как ОС является кроссплатформенной, не забываем, что наш проект строится на Raspberry.
Нарушая странную, но устоявшуюся традицию начинать подобные публикации с описания видов адресных лент и способов их корявой поклейки на задние стенки домашних ТВ — начну с установки и настройки ПО одноплатника. К сожалению, пошаговую инструкцию по настройке сделать практически нереально – она заняла бы пол сотни страниц текста без скриншотов. Ко всему, платформа плеера активно развивается, версии ОС и Kodi меняются, актуальная на текущий момент информация — вскоре перестает быть таковой. Поэтому здесь — только основные моменты плюс ссылки на источники полезной информации.
Для настройки программной части подсветки, управления ИК пультом и самого плеера нужно иметь начальные представления о том, как устроены каталоги Libreelec, как работает локальная сеть, консоль, что делать с командной строкой и т. д., так как в процессе некоторые вещи будем делать вручную. Посредством установщиков на microSD карту встанут только ОС Libreelec и надстройка для подсветки — Hyperion.
Поскольку Raspberry Pi не имеет встроенных часов реального времени, БИОСа и резервного питания, все, что необходимо для работы — находится на microSD карте. Для установки ОС на карту необходимо скачать либо пакет [NOOBS](https://www.ixbt.com/live/redirect/aHR0cHM6Ly93d3cucmFzcGJlcnJ5cGkub3JnL2Rvd25sb2Fkcy9ub29icy8=) с сайта проекта Raspberry (на момент установки я использовал версию сборки 3.2.1), либо специальный инструмент — [«LibreELEC USB-SD Creator»](https://www.ixbt.com/live/redirect/aHR0cHM6Ly9saWJyZWVsZWMudHYvZG93bmxvYWRzX25ldy8=).
Карта памяти должна иметь хорошие показатели скоростей чтения и записи – т. е. быть не ниже 10 класса. По объему ОС Libreelec занимает немного места, для работы вполне хватит карты 16GB, если не возникнет желание приобрести объем побольше. Его можно будет использовать для хранения любого контента.
В случае с NOOBS содержимое zip архива распаковывается в корень отформатированной в FAT32 microSD карты, карта вставляется в слот обесточенной малины, включается питание и далее, выбрав в установщике нужную ОС и следуя инструкциям, разворачиваем Libreelec. Однако разработчики платформы рекомендуют установку при помощи LibreELEC USB-SD Creator, который сам загружает и записывает дистрибутив на карту, затем карта так же вставляется в слот малины, где установщик после включения питания разворачивает ОС. При этом разделы карты переформатируются, после чего из-под Windows вы не увидите весь реальный объем носителя. Если по какой-либо причине возникнет необходимость вернуть разделы в начальное состояние, вам придется сначала очистить карту штатной утилитой Windows – DiskPart, затем в разделе «Управление дисками» создать на свободном пространстве носителя новый раздел и отформатировать его.
Для упрощения установки и настройки ОС я временно подключал к малине отдельный монитор и клавиатуру с мышкой.
Так же для конфигурирования и настройки ПО малины понадобится ее связь с ПК и доступ в интернет, желательно проводной. Софт, устанавливаемый на ПК для соединения по SSH — PuTTY и WinSCP, а также виртуальная машина Java (jre-8u231-windows-x64) и конфигуратор демона Hyperion – HyperCon (HyperCon.jar). Можно использовать другой удобный файловый менеджер c панелями, например — Total Commander. Где скачать и настроить – много информации на профильных сайтах, достаточно поискать информацию поисковым запросом «работа с PUttY и WinSCP». У проекта [Hyperion](https://www.ixbt.com/live/redirect/aHR0cHM6Ly9oeXBlcmlvbi1wcm9qZWN0Lm9yZy8=) так же есть свой форум и вики.
На этом скриншоте три способа соединения малины с ПК под win через SSH – через консоль Putty, файловый менеджер WinSCP и Total Commander:
Админская учетка Libreelec по умолчанию имеет логин и пароль root@libreelec, которые лучше изменить в целях безопасности. После успешной установки в настройках системы производим несложные действия – включение SSH, SMB, назначение статического IP, отключение обновлений:
Предполагается, что малина подключена к вашей домашней сети, и вы можете узнать IP адрес подключенных к ней устройств на вашем домашнем ПК. Обновления я отключил для того, чтобы однажды настроенная система адаптивной подсветки не слетела, если разработчик изменит какие-либо связанные с ней компоненты в Libreelec.
В настройках системы в службах нужно включить SSH и включить авторизацию по паролю, так же поставить минимальную версию протокола SMB2, максимальную – SMB3. SMB понадобится для того, чтобы видеть каталоги Raspberry Pi и подключенные к ней флеш-накопители с ПК:
Под Windows 10 на ПК в настройках придется найти и включить поддержку SMB, так как она по умолчанию в ней отключена:
Так же в настройках ищем и добавляем русскую раскладку клавиатуры. С физической клавиатурой ничего не произойдет — будет только ввод на английском, зато в виртуальной экранной клавиатуре появится возможность ввода текста на русском. Для удобного доступа к каталогам на карте microSD и подключенным к малине флешкам можно в Тотал Коммандер создать и вынести на панель инструментов ярлык с адресом удаленного каталога:
Файлы в локальной сети будут передаваться со скоростью, ограниченной пропускной способностью вашего домашнего роутера, и значительно быстрее, чем в доступе через SSH. Во всяком случае скопировать фильм или музыку таким образом будет удобнее, чем таскать флешку от приставки к ПК. Вы будете видеть внутреннюю структуру каталогов в /storage на карточке малины и подключенные к USB портам накопители. У меня при проводном соединении 100 Мбит/сек. через роутер максимальная скорость загрузки файлов с ПК на USB накопитель в малине составила около 12 Мбайт/сек, что примерно соответствует пропускной способности моего проводного соединения.
При необходимости в дальнейшем вы можете развернуть на ПК любой домашний медиа-сервер (UPnP, DLNA) для потокового воспроизведения контента прямо с ПК.
После установки и настройки доступа к малине с ПК через SSH при помощи программ PUttY и WinSCP можно приступать к установке и настройке демона Hyperion. На ПК должна присутствовать виртуальная машина Java.
Работать все будет примерно так – при старте Raspberry вместе с Kodi будет запускаться в фоновом режиме специальная программа – Hyperion. Она будет анализировать все видеокадры, и в зависимости от настроек, записанных в файле конфигурации — управлять адресной лентой через один из выходов GPIO малины. Т. е. после настроек все будет работать автономно, никакой связи или взаимодействия с ПК не потребуется. Но для быстрого создания файла конфигурации и установки Hyperion на малину есть удобный конфигуратор, запускаемый на ПК. Эта программа поможет быстро создать файл конфигурации для работы демона, загрузить и установить его в Raspberry и проверить работоспособность системы, используя удобный графический интерфейс.
#### HyperCon
Конфигуратор называется HyperCon, установки не требует, просто запускаем исполняемый файл HyperCon.jar на ПК и видим такое окно:
В правой части изображен виртуальный экран, для которого будет настраиваться подсветка – зоны захвата цвета, их нумерация (начинается с 0), направление, расположение, отступы, перекрытие и глубина. В левой части – пять вкладок с настройками.
**Вкратце по вкладкам конфигуратора:**
**Hardware (железо)**
* device -> Configuration Name – любое удобное имя текущей конфигурации
* device -> Type — тип чипа адресной ленты, модуля или чего другого
* device -> Amount LEDs – количество адресуемых пикселей (сколько светодиодов в ленте)
* device -> RGB Byte order – следование цветов в используемом протоколе
**Construction (расположение источников света)**
* чекбоксы –> (led top left итд) — наличие источника света в углах конструкции
* LEDs horizontal -> Количество пикселей по верхнему краю конструкции
* LEDs Left-> Количество пикселей по левому краю конструкции
* LEDs Right -> Количество пикселей по правому краю конструкции
* Bottom gap -> Количество пропущенных зон по нижней части конструкции (для обхода ножки ТВ или всей нижней зоны)
* 1-st LED offset -> Поправка на смещение пикселей для установки первого в удобном углу.
**Image process (обработка зон)**
* Image process -> Horizontal depth – глубина зон по горизонтали, %
* Image process -> Vertical depth – глубина зон по вертикали, %
* Image process -> Horizontal gap – отступ зон от края по горизонтали, %
* Image process -> Vertical gap – отступ зон от края по вертикали, %
* Image process -> Overlap – перекрытие соседних зон, %
Blackborder detection (обнаружение черных краев экрана) — Чувствительность и режим обработки. Работает по идее так – демон анализирует края экрана по указанному уровню и вычисляет ширину темных краев для исключения из обрабатываемых зон. Это для случаев, когда воспроизводится широкоформатная картинка.
**Process (обработка кадров)**
* Smoothing -> Enabled (чекбокс включения сглаживания)
* Smoothing -> Type (тип сглаживания)
* Smoothing -> Time (время переходов)
* Smoothing -> Update freq (частота обновления)
* Smoothing -> Update delay (задержка перед обновлением кадра)
* Color calibration (настройка передачи цветов) – интуитивно понятные пункты, позволяющие отдельно для каждого из 3-х основных цветов задать минимальный и максимальный уровень свечения, насыщенность, температуру, уровень свечения фона без сигнала и т.д.
Отмеченный чекбокс Send Continuous позволяет видеть изменения в процессе настройки уже на собранной конструкции.
**Grabber (Граббер – захватчик кадров, самая интересная вкладка)**
* Internal Frame grabber (Программный граббер)
* Internal Frame grabber-> Enabled (чекбокс включения внутреннего граббера)
* Internal Frame grabber-> Width (ширина зоны)
* Internal Frame grabber-> Heigth (высота зоны)
* Internal Frame grabber-> Interval (интервал захвата граббера)
* Internal Frame grabber-> Priority Channel (приоритет этого канала)
Здесь нужны некоторые пояснения. Фишка в том, что мы на базе Raspberry Pi делаем медиаплеер, который сам будет крутить контент с локальной сети, флешки, или IP TV на платформе LibreElec. Поскольку контент и так крутится плеером малины, захват будет происходить программно, без внешнего EasyCap граббера, и демон сам разберется с кадрами, так как в этом случае источником сигнала будет HDMI выход самой Raspberry Pi. Есть возможность использовать так же внешний граббер для другого источника, не отключая внутренний – для этого предусмотрены приоритеты каналов, это последний пункт настройки программного граббера. Чем больше число – тем ниже приоритет канала.
Именно так, здесь нет ошибки.
* Grabber V4L2 (Настройки драйвера аппаратного граббера))
* Grabber V4L -> Device ( USB устройство, с которого делается захват — /dev/video0 по умолчанию)
* Grabber V4L -> Input ( Используемый вход — 0 по умолчанию)
* Grabber V4L -> Width (ширина зоны — -1 по умолчанию)
* Grabber V4L -> Heigth (высота зоны — -1 по умолчанию)
* Grabber V4L -> Frame decimation (сжатие кадра)
* Grabber V4L -> Size decimation (коэффициент сжатия)
* Grabber V4L -> Priority Channel (приоритет этого канала)
* Grabber V4L -> 3D mode (выбор режима 2D/3D)
* Grabber V4L -> Crop Left (обрезка кадра слева)
* Grabber V4L -> Crop Right (обрезка кадра справа)
* Grabber V4L -> Crop Top (обрезка кадра сверху)
* Grabber V4L -> Crop Bottom (обрезка кадра снизу)
* Grabber V4L -> три последних пункта (порог включения каналов по цветам)
**External (Внешние настройки)**
* External -> Kodi Checker (Настройки для плеера Kodi, в случае если он используется как плеер. Отмеченные чекбоксы будут отключать работу подсветки при выполнении указанных функций плеера. Можно настроить так, что подсветка будет работать только при воспроизведении контента, и отключаться во всех остальных случаях)
* External -> Json/Proto/Boblight Server (Настройки портов серверов, оставить как на скрине)
* External -> Booteffect / Static color (Настройки демо-эффектов при старте демона)
* External -> Json/Proto Forvard (Настройки портов вывода, оставить как на скрине)
**SSH (Настройки соединения ПК с Raspberry Pi)**
* SSH – Connection -> System (Выбор ОС, установленной на Raspberry Pi)
* SSH – Connection -> Target IP (IP адрес Raspberry Pi)
* SSH – Connection -> Port (как на скрине — (22))
* SSH – Connection -> Username/password (имя – пароль, заданные на Raspberry Pi)
* SSH – Connection -> Connect/Disconnect (кнопка соединения-разъединения с Raspberry Pi)
* SSH – Connection -> Show Traffic (Кнопка вызова консоли с выводом информации)
* SSH – Manage Hyperion from HyperCon -> Inst/Upd. Hyperion (Кнопка установки демона на Raspberry Pi или обновление демона через сеть. Никаких sudo get-install, соединяемся с Raspberry Pi, тыркаем и ждем вывода в консоль HyperCon-а)
* SSH – Manage Hyperion from HyperCon -> Remove Hyperion (Кнопка деинсталляции демона)
* SSH – Manage Hyperion from HyperCon -> Start/Stop (Кнопки остановки-запуска демона)
* SSH – Manage Hyperion from HyperCon -> Get Log (Вывод в консоль логов демона, удобно для
* поиска не стыковок и чтения кодов ошибок)
* SSH – Send Hyperion Configuration -> Local Config Path (Отправка файла конфигурации в указанное локальное место на ПК)
* SSH – Send Hyperion Configuration -> Send Config (Отправка файла конфигурации через SSH на Raspberry Pi)
* SSH – Colorpicker (интуитивно понятный тестер палитры – можно проверить вывод всех цветов.
* Кнопки под вкладками сохраняют-загружают настройки HyperCon-а (не сам файл конфигурации демона!!)
* HELP – понятно, а Create Hyperion Configuration позволяет локально сохранить сам файл конфига демона для Raspberry Pi — hyperion.config.json
Как видно из приведенного списка – возможностей по настройке достаточно много, и это делает инструмент очень гибким для любых хотелок и задач.
**Как пример, моя конфигурация по вкладкам:**
В первой вкладке располагаем зоны так, как будут физически расположены пиксели подсветки на задней стенке ТВ. Можно выполнить заполнение всего периметра или его части, задать направление, начало и т д. Тип ленты, который я использовал – WS2812B, поэтому на скриншоте соответствующее поле выбрано как WS281x. Количество пикселей у меня определила плотность светодиодов на имеющейся в распоряжении ленты и диагональ экрана. Остальные вкладки согласно описанию выше, а в самой последней выбираем нашу ОС на Raspberry Pi, настраиваем связь через SSH и устанавливаем демон Hyperion на одноплатник. Затем сохраняем конфиг HyperCon, создаем новый файл конфигурации Hyperion, отправляем созданный конфиг на Raspberry Pi, стартуем и пробуем в ColorPicker проверить соответствие цветов палитре. Если все совпадает, любой воспроизводимый плеером Kodi контент будет управлять фоновой подсветкой. Сигнальный вывод GPIO – 18 (физический пин гребенки – 12).
Подробно про все соединения будет рассказано ниже, после описания всех программных настроек.
Автозапуск я никак не настраивал, демон запускается одновременно с началом работы плеера. Однако было так, что подсветка все равно не включалась. Тогда пробуем проверить, прописался ли автозапуск демона в «/storage/.config/ autostart.sh» и пробуем переустановить демон, чтобы снова отправить на Raspberry Pi его конфиг. Сам конфиг программа отправляет в директорию
Raspberry Pi –
«/storage/.config/ hyperion.config.json».
Проверить работу демона можно так же, отправляя цвет на вкладке SSH HyperCon, поставив галочку «Autoupdate» и нажав кнопки стоп-старт для его перезапуска.
Если демон не стартует после перезагрузки Raspberry Pi, пробуем изменить автостарт в файле
```
/storage/.config/autostart.sh
//---------------------------------------------------------------------------------------------------------------
#!/bin/sh
sleep 5
/storage/hyperion/bin/hyperiond.sh /storage/.config/hyperion.config.json > /storage/logfiles/hyperion.log 2>&1
//---------------------------------------------------------------------------------------------------------------
```
тем самым дав задержку перед выполнением запуска демона.
#### Дистанционное управление любым ИК пультом
Так как кроме подсветки приставка будет полноценным медиацентром – к ней необходимо прикрутить и настроить пульт ДУ. Если ваш ТВ поддерживает технологию CEC (Consumer Electronics Control, т.е протокол управления через HDMI, в Kodi можно настроить и использовать уже имеющийся с ТВ пульт ДУ для управления медиа-приставкой. Так как все производители называют этот протокол в своих ТВ по-разному, (например, LG — SimpLink, Samsung -Anynet, Sony — BRAVIA Sync), поищите в настройках своего ТВ поддержку этой функции. У меня не очень удачный пульт ДУ на ТВ, поэтому я пошел другим путем — взял тот, что был со старой TV-приставкой на андроиде (пока с Китая идут другие заказанные пульты для этого проекта):
На гребенке Raspberry понадобятся пины +5V, земля и сигнальный на GPIO23 (физический пин – 16), поскольку GPIO18 (физический пин – 12), который настроен для IR девайсов по умолчанию – уже занят выводом пакетов на подсветку.
**Процесс:**
Для подключения драйвера ИК-приемника редактируем файл /flash/config.txt, в самый конец которого пишем строку (здесь и далее без кавычек):
«dtoverlay=gpio-ir,gpio\_pin=23»
Подключив ИК-приемник к малине, необходимо получить скан-коды нужных нам кнопок пульта ДУ и привязать к ним команды. После определения в консоли командой «ir-keytable» типа протокола, привязываем скан-коды к командам, полученным в консоли с помощью
«irrecord -l | grep ^KEY», вручную делаем сопоставления и создаем таблицу такого вида:
table ireltex, type: NEC
```
0x8f64d KEY_0
0x8f642 KEY_1
0x8f641 KEY_2
0x8f640 KEY_3
0x8f646 KEY_4
```
И так — все нужные нам кнопки и команды. У меня вышло 34 строки соответствий. Первой строкой –название таблицы и протокол ДУ. Следующие строки — слева скан-код кнопки. Справа, через пробел – выполняемая Kodi команда управления. И так далее, по порядку.
Таблицу необходимо сохранить. Для этого создается файл, (я его обозвал ireltex), из которого будут читаться эти привязки. Файл нужно разместить в папке «/storage/.config/rc\_keymaps/ireltex», затем создаем файл
«/storage/.config/rc\_maps.cfg», в нем записываем строку:
«\* \* ireltex» (есс-но все без кавычек).
Через консоль Putty загружаем полученную таблицу в драйвер:
«ir-keytable -c -w /storage/.config/rc\_keymaps/ireltex», перезагружаем Raspberry Pi и изменяем последнюю строчку в файле
«/flash/config.txt»
Теперь она выглядит так:
«dtoverlay=gpio-ir,gpio\_pin=23,rc-map-name=ireltex»
В файл
«/storage/.config/autostart.sh» нужно добавить автозагрузку протокола пульта, так чтобы запись выглядела так (для моего пульта ДУ и его протокола):
```
#!/bin/sh
(
sleep 5
ir-keytable -p nec
)&
sleep 5
/storage/hyperion/bin/hyperiond.sh /storage/.config/hyperion.config.json > /storage/logfiles/hyperion.log 2>&1 &
```
Снова перезагружаю Raspberry Pi и теперь Kodi откликается на команды с пульта.
Более подробно весь процесс настройки с примерами в оригинале расписан [здесь](https://libreelec.wiki/infrared_remotes).
Можно так же набрать в поисковике запрос «LibreElec + ИК Пульт» и получить по данной теме несколько статей на русском.
Если повесить выход ИК приемника кроме GPIO 23 так же на вход GPIO3 – Raspberry Pi будет включаться по команде с пульта. Минус такого метода управления в том, что сигнал на включение будет приниматься любой и с любого ИК пульта, но других способов дистанционно включать малину я не нашел. Значит нужно сделать дополнительный детектор, принимающий одну команду и передающий только этот сигнал на вход GPIO3 Raspberry Pi.
Чтобы не было чудес с самопроизвольным хаотичным мерцанием пикселей, земля ленты кроме пина GND GPIO должна соединяться непосредственно с минусовой клеммой внешнего источника питания проводом соответствующего току сечения, а сигнальный провод D-IN иметь минимальную длину.
Необходимо помнить, что различные ИК приемники могут имеют разное напряжение питания (3,3 или 5V) и назначение выводов. Чтобы не вывести из строя приемник или порты Raspberry Pi, подключение нужно делать в соответствии с документацией на используемый приемник!
**В итоге пока все соединения на выводах GPIO Raspberry Pi выглядят так:**
#### Правильное включение Raspberry Pi с ИК пульта ДУ
Теперь нужно сделать именно «правильное» включение Raspberry Pi от назначенной кнопки на ИК пульте ДУ. Сейчас устройство загружается при поступлении любого сигнала на пин GPIO3 (пятый физический пин), а так как приемнику нет разницы, что принимать в этом ИК диапазоне, загрузка происходит от сигнала с любого пульта, иногда даже при включении освещения в комнате, что не есть удобно. Для решения этой проблемы между GPIO3 и сигнальным пином ИК приемника нужен посредник, который будет декодировать сигнал, и только при совпадении команды с заранее назначенной — включать Raspberry Pi. Кроме того, нужно иметь возможность использовать разные пульты или же кнопки одного пульта. Конечно, можно написать прошивку для какого-либо ATiny стоимостью пол доллара рублей и все будет прекрасно работать, но раз уж речь идет о повторяемом и простом конструкторе — гораздо проще использовать относительно недорогой и компактный контроллер — Arduino Nano. Плата будет постоянно работать в дежурном режиме, контролируя все входящие сигналы от любых ИК источников. И только при декодировании одного из определенных заранее сигналов — давать команду на включение Raspberry Pi. Контроллер так же обеспечит простую перепрошивку при необходимости смены пульта для Raspberry Pi.
Запитываться Arduino Nano будет не совсем стандартно — от пина +5V GPIO RPi – на пин +5V Arduino. Ничего страшного в таком включении нет – со стороны USB в плате Arduino будет вход внутреннего стабилизатора, со стороны пина Vin – катод диода Шоттки. Никакой нагрузки, кроме ИК приемника к выводам Arduino nano подключаться не будет.
Таблица соединений Arduino-Raspberry будет такой — Физический вывод Raspberri Pi 3 B+ / Физический вывод Arduino Nano
4 (+5v) / +5V
6 (GND) / GND
5 (GPIO3) / D8
Кроме того, ИК приемник подключится к пинам питания на плате Arduino — (GND, +5V или 3.3V), а вывод выходного сигнала — через резисторы номиналом 100R – к пину D7 Arduino и через 510R к пину 16(GPIO23) Raspberry Pi. Таким образом ИК приемник будет напрямую передавать все команды на вход GPIO23, а на GPIO3 будут появляться один или два коротких импульса только при получении заранее прописанных в скетче команд.
**Схема подключения IR приемника, Arduino nano и адресной ленты к Raspberry Pi:**
Верхний по схеме джампер «5V External» позволяет питаться Arduino и Raspberry от внешнего источника питания вместе с подсветкой от разъема XS1 «Power», если, например количество пикселей небольшое и не создает большой нагрузки. Нижним по схеме джампером можно выбрать напряжение питания ИК приемника – 3.3 или 5V. Устройство будет оформлено в виде внешнего, подключаемого к разъему GPIO шилда, в который подключена плата Arduino nano, ИК приемник и все разъемы.
Для проверки достаточно предварительно считать и внести в скетч коды любых кнопок, например “OK” или “ENTER”, от любых пультов. Так же можно сделать массив команд, чтобы запускать приставку нажатием любой из определенной группы кнопок или какой либо последовательности нажатий. В скетче использована библиотека iarduino\_IR-master, архив которой можно легко найти в интернет. В архиве библиотеки есть скетчи-примеры, используя один из них, например — receiver\_GetProtokolAll, можно получить коды команд любых кнопок используемого пульта. В последующем эти коды нужно записать в заливаемый на Arduino Nano скетч:
```
//*******************************************************************************
#include // Подключаем библиотеку для работы с ИК-приёмником
iarduino\_IR\_RX IR(7); // Объявляем объект IR, с указанием вывода к которому подключён ИК-приёмник
const int Out\_GPOI\_3 = 8; // Объявляем пин выхода на GPIO RPi
uint32\_t Code\_001 = 0xFF708F; // RX code опрошенных ранее кнопок
uint32\_t Code\_002 = 0x106FA857;
void setup()
{
pinMode(Out\_GPOI\_3, OUTPUT);
// Инициируем передачу данных в монитор на скорости 9600 бит/сек
Serial.begin(9600);
IR.begin(); // Инициируем работу с ИК-приёмником
}
void loop()
{
if(IR.check()) // Если была принята команда от какого либо ДУ
{
// Проверяем совпадение кодов на включение, дергаем вывод
if(IR.data == Code\_001 or IR.data == Code\_002)
{
digitalWrite(Out\_GPOI\_3, HIGH); // Передаем команду на RPi
delay(5);
digitalWrite(Out\_GPOI\_3, LOW); // Возвращаем выход в исходное состояние
delay(5);
digitalWrite(Out\_GPOI\_3, HIGH); // Передаем команду на RPi
delay(5);
digitalWrite(Out\_GPOI\_3, LOW); // Возвращаем выход в исходное состояние
delay(5);
}
}
}
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
```
Поскольку библиотека iarduino\_IR-master использует тот же таймер, что и некоторые стандартные «wiring» функции среды Arduino — в этом скетче нельзя использовать micros(), millis(), tone() и возможно некоторые другие, иначе попытка компиляции приведет к невнятной ошибке. Несмотря на такой подход авторов к написанию кода — свои функции библиотека исправно выполняет и четко определяет ИК посылки, их тайминги, структуру и используемые протоколы, а возможность быстро считать коды команд любого пульта сводят его настройку к простой замене переменных в скетче.
Вся надстройка была оформлена в виде шилда, для которого были нарисованы и заказаны в Китае такие заводские доски:
В этот шилд подключается плата ардуино nano, разъем одного общего блока питания 5В, разъем на подсветку телевизора, а сам шилд включается в гребенку GPIO Raspberry Pi. После монтажа всех комплектующих выглядит это так:
Планировал оформить угловую акриловую полупрозрачную крышку на предусмотренных для крепления стоек отверстиях – но руки как-то не дошли, да и под ТВ приставку все равно не видно…
Про выбор и поклейку адресной ленты везде написано очень много, однако по этой теме и монтажу у меня так же есть несколько комментариев.
Сначала про мифы.
*«WS2812 не годится для адаптивной подсветки, надо использовать SK9822 или вовсе APA102»*
Обосновывают это тем, что частота передачи данных у аналогов APA102 значительно выше ввиду наличия тактовой линии, да и сами светодиоды имеют более широкую цветовую гамму и более надежны.
Все это верно, но, если мы поделим рабочую частоту WS2812B на количество пикселей и на 32 бита информации для каждого из них – получим частоту обновления почти 300Гц для моих 91 светодиода. Это в разы превышает необходимый порог. А все «мерцания» и «неработающие» случаи – 146% следствие кривой разводки земли и сигнального провода.
По цветовой гамме аналогично — Hyperion формирует 8-ми битные посылки для каждого цвета в каждом пикселе. Это в любом случае только 256 градаций яркости каждого из трех цветов на любой ленте. Разница в цветах будет заметна только в калькуляторе на экране хорошего монитора, но разницу в реальном свечении на ± одну или даже несколько градаций наши глаза в любом случае не увидят – это анатомия нашего зрения и ничего с ней не поделать. Ко всему, в конфигураторе есть средства для корректировки цветовой гаммы — при желании можно добиться практически идеального белого цвета при близкой к максимальной яркости. Но даже этих телодвижений скорее всего не потребуется – фоновая подсветка всего лишь создает фон на стене за ТВ, а не картинку на экране… При анализе зон захвата — и Hyperion, и Philips берут не одну конкретную точку, а усредненный цвет всей заданной зоны, поэтому оттенки всегда будут чем то отличаться от тех, что в динамике воспроизводятся на краях экрана. Учитывая все это – стрелять из пушки по воробьям никакого смысла нет, что собственно подтверждает конструкция подсветки в оригинальных телевизорах Phillips, где на диагональ 50” выведено всего 37 точек, а ширина зон составляет 5-6 см.
Еще один миф – *«WS2812B недолговечны, через месяц начали выходить из строя пиксели».*
Естественно, начнут. Причем на любой ленте. Каждый цвет в каждом светодиоде 2812B на полной яркости потребляет 18-20 мА. К примеру, у меня 91 светодиод. 91Х3Х20=5,5А. КПД около 30-40%, а это значит, что больше трех ампер уходит в тепло. Единственный эффективный путь отвода тепла от подложек кристаллов – медные дорожки ленты, которая приклеена к какой-то поверхности. Подключенная к питанию, но несветящаяся лента так же заметно теплая – сами чипы в статике имеют какое-то потребление тока. Задняя пластиковая крышка ТВ – не самый лучший теплоотвод для длительной эксплуатации ленты, поэтому лучше и правильнее использовать специальный металлический профиль. К тому же он бывает в комплекте с рассеивателем, различной глубины, ширины и формы. Вы не будете видеть отражений в виде цветных точек на глянцевых поверхностях интерьера комнаты, что тоже иногда важно.
Когда все смонтировано, подключено и проверено — останется настроить на свой вкус и цвет плеер KODI — установить все нужные эддоны, IPTV с программами передач и расшарить контент с домашнего ПК.
Если сравнивать работу подсветки с аппаратным вариантом — реакция на обработку кадров мне показалась более четкой — нет ощущения небольшой задержки в доли секунды. Сама реализация мне кажется вполне жизнеспособной – получился простой повторяемый конструктор, собираемый по принципу plug-in. Если озаботиться сборкой коммутационного шилда и сохранить настроенную систему как образ – на запуск другой такой приставки потребуется не больше времени, чем для любого «коробочного» ТВ-бокса на андроиде. Если же сделать ИК приемник выносным – устройство можно будет прятать за ТВ с настенным вариантом крепления. При наличии настроенной ОС или ее образа – система заработает в полноценном режиме при первом же включении.
Для тех, кто смотрит ТВ каналы – придется повозиться со своими платными и качественными или халявными и нерабочими плейлистами IPTV, телепрограммами к каналам, эддонами и настройками плеера, который, к слову, имеет возможность смены скинов, коих на данный момент создано великое множество на любой вкус. Поддерживается все – вывод погоды, времени, скринсейверы, сотни различных дополнений и приложений. Например, я захотел избавиться от неубирающегося меню OSD, вызванного для перемотки или паузы. Для этого отлично пришелся эддон — Hide Video OSD. Скачиваем zip архив, кладем в удобное доступное малине место, в интерфейсе эддонов выбираем установку из архива, ставим, включаем эддон в настройках, задаем время в секундах, по истечении которого OSD автоматически уберется с экрана.
Кроме прочих фишек Kodi имеет полноценный web-интерфейс, через который можно настраивать параметры, управлять плеером и медиатекой с домашнего ПК.
Публикации про все возможности плеера, и то, как например поднять медиа-сервер на ПК для Kodi – легко находятся в рунете. По удобству, всеядности и прочим параметрам я бы поставил этот плеер в один ряд с такими проектами как WinAmp и MPC-HC.
**Небольшой демонстрационный ролик, снятый на тапок:** | https://habr.com/ru/post/486106/ | null | ru | null |
# Начало работы с Push Notifications в PhoneGap
Доброго времени суток, хабрапользователи!
*Push Notifications не включены в API PhoneGap. Если сделать небольшой поиск по документации PhoneGap, то можно найти только [Notifications](http://docs.phonegap.com/en/2.4.0/cordova_notification_notification.md.html#Notification) которые представляют собой обычные alert диалоги с вожможностью использования в них звуковых эффектов и вибрации.
Но что делать, если вам просто необходимо создать кроссплатформенное приложение с Push Notifications? Я хочу обратить Ваше внимание на тестовый пример работы с некоторыми из них при помощи Android. В результате, из разработанного проекта можно будет получить также iOS, BlackBerry и Windows Phone приложения.*
В статье будут рассмотрены две библиотеки для работы с Push Notifications в PhoneGap: Urban Airship и Poosh Woosh.
Начать стоит с поиска подходящей библиотеки, а их на самом деле великое множество. Однако, нужно, чтобы библиотека была действительно кроссплатформенной и имела единый сервис доставки.
Просмотрев имеющиеся варианты, я остановилась на 2 библиотеках: Urban Airship и Poosh Woosh. У них есть свои недостатки и преимущества, поэтому рассмотрим обе библиотеки.
По сути, Urban Airship имеет 3 версии: Enterprise Edition, версию для малого бизнеса Small Business Edition и бесплатную Developer Edition. Вы можете ознакомиться со всеми преимуществами более подробно на [официальном сайте](http://urbanairship.com/products/how-to-buy).
Push Woosh также имеет несколько версий: Free, Premium, Gold, Platinum. Ознакомиться с ними можно после регистрации на [официальном сайте](https://cp.pushwoosh.com/products).
Рассмотрим более подробно бесплатные версии: Developer Edition от Urban Airship и Free от Push Woosh. Их основное отличие в том, что в Urban Airship вы можете отправлять до 1 миллиона сообщений в месяц, а в Push Woosh вы можете подключать для отправки сообщений до 1 миллиона девайсов. Кроме того, в бесплатной версии Push Woosh у вас не будет доступа к API, геозонам и тегам, а количество приложений будет ограничено 10. Urban Airship к преимуществам своего продукта относит: гибкие интерфейсы для полной настройки, безотказность, безопасность, масштабируемость, а также высокую производительность. Итак, вы можете выбрать ту, которая является более подходящей для вашего проекта.
Далее перейдем к подключению библиотек.
#### Google?
Да, именно Google. Теперь стоит обратиться к его помощи. Нужно будет использовать Google API для своего проекта. Для этого:
1. Нужно перейти по [ссылке](https://code.google.com/apis/console) и создать его, соответственно;
2. После создания проекта в браузере будет введена ссылка, похожая на эту:
```
https://code.google.com/apis/console/#project:4815162342
```
Здесь 4815162342 — это gsmSender в файле airshipconfig.properties.
3. Во вкладке Services необходимо включить Google Cloud Messaging for Android.
4. Во вкладке API Access выбираем «Create a new Server key...» В появившемся окне ничего не нужуно вводить, просто нажимает “Create”.
5. Сгенерированный API key понадобится в созданном ранее профиле Urban Airsip.
#### Go Urban Airship
Теперь, стоит скачать саму [библиотеку](http://com.urbanairship.filereleases.s3.amazonaws.com/ua-android-lib-latest.zip), а также [тестовый пример](https://github.com/urbanairship/phonegap-ua-push) с [официального сайта](http://urbanairship.com/resources/developer-resources) Urban Airship. Подключаем проект к Eclipse и добавляем в него скачанную библиотеку.
Далее нужно сделать самое интересное — разобраться с ключами, которые находятся в файле airshipconfig.properties.
Переходим к Urban Airship [профилю](https://go.urbanairship.com/apps/new/) и создаем в нем новое приложение, при этом вводим полученный API key в строку CGM API Key.
Во вкладке Details созданного проекта: Application Key — это developmentAppKey в файле airshipconfig.properties, а Application Secret — это developmentAppSecret.
И вот настал тот момент, когда, наконец-то, можно запустить приложение. *При этом не стоит забывать включить интернет.*
Для отправки Push Notifications необходимо сделать следующие шаги:
1. Читаем лог и видим похожую строку. Копируем push ID, который понадобится для отправки Push Notification на указанный телефон.
2. В [профиле](https://go.urbanairship.com/) переходим на вкладку Push -> Test Push Notifications и выбираем Android. Здесь в строку Apid вводим скопированный push ID, в Extra key — Application Key, а в Extra value — Application Secret. Alert — это то сообщение, которое необходимо передать.
3. Проверяем — нажимаем “Send it!”. При клике на Push Notifications происходит переход на само приложение.
#### Pushwoosh
В работе с Pushwoosh всё очень похоже.
Вы можете скачать [тестовый пример](https://github.com/shaders/push-notifications-sdk/tree/master/SDK%20Sample%20Projects/Android-Phonegap) для PhoneGap.
Понадобится [регистрация](https://cp.pushwoosh.com) и создание приложения. Для примера работы с приложением введем полученный у Google, API key.
Далее в коде файла index.js заменим projectId на собственный, в поле appid введем в полученный от PushWoosh код:
Теперь можно отправлять первый Push Notification от Push Woosh (для этого не надо вводить дополнительных кодов для девайсов).
 | https://habr.com/ru/post/171087/ | null | ru | null |
# Получаем информацию по продуктам от Амазона через API
Amazon.com это не только огромный магазин, но еще и бесплатный легальный доступ к огромному количеству информации по продуктам. Некотрое время назад, Амазон перестал принимать запросы без подписи, скрипт, который я написал, подписывает запрос в соответствии с текущими требованиями API. В качестве примера, я хочу показать, как получать информацию по книгам через API Амазона зная только ISBN номер.
Для начала, необходимо пройти регистрацию на сайте [aws.amazon.com](http://aws.amazon.com). После чего вы получаете доступ к Вашей учетной записи, в которой необходимо обратить внимание на закладку «Access Identifiers». Для правильной работы скрипта, необходимо скопировать два параметра «Your Access Key ID» и «Your Secret Access Key». После чего, вставить эти идентификаторы в соответствующие строки скрипта. В результате, скрипт, будет получать информацию по книге в XML формате. Который, вы можете использовать по своему усмотрению.
Более подробно о параметрах, которые вы можете передавать API вы можете прочитать на сайте амазона [здесь](http://docs.amazonwebservices.com/AWSEcommerceService/4-0/)
> `Copy Source | Copy HTML1. php</font
> 2. $info = getBookInfo('1591409268', ваш\_access\_key, ваш\_secure\_access\_key);
> 3.
> 4. print $info;
> 5.
> 6. function getBookInfo($isbn, $access\_key, $secure\_access\_key)
> 7. {
> 8. // формируем список параметров запроса
> 9. $fields = array();
> 10. $fields['AWSAccessKeyId'] = $access\_key;
> 11. $fields['ItemId'] = $isbn;
> 12. $fields['MerchantId'] = 'All';
> 13. $fields['Operation'] = 'ItemLookup';
> 14. $fields['ResponseGroup'] = 'Request,Large';
> 15. $fields['Service'] = 'AWSECommerceService';
> 16. $fields['Version'] = '2009-01-06';
> 17. $fields['Timestamp'] = gmdate('Y-m-d\TH:i:s\Z');
> 18.
> 19. // сортируем параметры согласно спецификации Amazon API
> 20. ksort($fields);
> 21.
> 22. $query = array();
> 23. foreach ($fields as $key=>$value) {
> 24. $query[] = "$key=" . urlencode($value);
> 25. }
> 26.
> 27. // подписываем запрос секретным ключом
> 28. $string = "GET\nwebservices.amazon.com\n/onca/xml\n" . implode('&', $query);
> 29. $signed = urlencode(base64\_encode(hash\_hmac('sha256', $string, $secure\_access\_key, true)));
> 30.
> 31. // формируем строку запроса к сервису
> 32. $url = 'http://webservices.amazon.com/onca/xml?' . implode('&', $query) . '&Signature=' . $signed;
> 33.
> 34. $ch = curl\_init();
> 35. curl\_setopt($ch, CURLOPT\_URL, $url);
> 36. curl\_setopt($ch, CURLOPT\_RETURNTRANSFER, 1);
> 37. curl\_setopt($ch, CURLOPT\_FOLLOWLOCATION, 1);
> 38. $data = curl\_exec($ch);
> 39. $info = curl\_getinfo($ch);
> 40.
> 41. if ($info['http\_code'] != '200') return false;
> 42.
> 43. return $data;
> 44. }
> 45. ?>
> 46.` | https://habr.com/ru/post/67365/ | null | ru | null |
# $mol_atom: теория и практика реактивности
Здравствуйте, меня зовут Дмитрий Карловский и я… состоятельный человек. У меня есть состояние на сервере, есть состояния в локальных хранилищах, есть состояние окна браузера, есть состояние доменной модели, есть состояние интерфейса. И всё это многообразие состояний нужно поддерживать синхронизированным. Если одно состояние как-то изменяется, то остальные связанные с ним состояния должны как можно скорее обновиться. Особую пикантность ситуации придаёт то, что синхронизация с сервером может занимать секунды, а блокировать пользовательский интерфейс можно лишь на доли секунд.
Далее вы узнаете: как реактивность побеждает асинхронность, как императивная реактивность уживается с функциональной, как простые абстракции позволяют писать надёжный и быстрый код, а также как я однажды перешёл на идемпотентную сторону силы и всё заверте
Разбираемся в сортах реактивности
=================================
Прежде всего стоит определиться с понятием "реактивность" (reactivity). Это — явление, когда изменение одного состояния приводит ко каскадному изменению других состояний. Реактивное программирование (reactive programming) использует этот принцип для описания правил изменения одних состояний при изменений других. В дальнейшем единицу реактивного состояния для простоты мы будем называть "атомом".
Если вы никогда не программировали в реактивной парадигме, то могу порекомендовать прочитать [мою статью двухлетней давности](https://habrahabr.ru/post/235121/), где объясняется зачем оно вообще надо. Тем не менее она слегка устарела, так как $mol\_atom реализует уже более продвинутую логику.
```
[ State1 ]----/ Rule1-2 /---->[ State2 ]----/ Rule2-3 /---->[ State3 ]
```
Реактивные правила могут описываться в трёх парадигмах:
**Перезапуски (restarts)**. Правила хранятся отдельно от состояния и представляют собой процедуру меняющую одни состояния на основе других состояний. Когда какое-либо состояние, задействованное этой процедурой, изменяется, процедура автоматически перезапускается. Проблема этого подхода в стационарности правил синхронизации, больших накладных расходах и риске уйти в бесконечный цикл.
```
[ State ]<-------->[ Rule1-2( State ) ]
[ State ]<-------->[ Rule2-3( State ) ]
```
Примеры реализаций: [AngularJS@1](https://docs.angularjs.org/api/ng/type/$rootScope.Scope), [MeteorJS](https://docs.meteor.com/api/tracker.html).
**Проталкивание (push)**. Внутри атома хранятся правила формирования состояний других атомов. Обычно правила задаются при инициализации приложения и в дальнейшем не меняются, а если и меняются, то вручную. API реализующих этот подход библиотек очень сильно раздут — десятки и сотни методов решают его многочисленные проблемы: немедленное исполнение правил, зависимость от одного единственного атома, реагирование даже если новое значение равно старому и прочие.
```
[ State1 => Rule2( State1 ) ]-------->[ State2 => Rule3( State2 ) ]-------->[ State3 ]
```
Примеры реализаций: [BaconJS](https://baconjs.github.io/), [KefirJS](https://rpominov.github.io/kefir/), [RxJS](https://github.com/Reactive-Extensions/RxJS).
**Затягивание (pull)**. Внутри атома хранится правило формирования его состояния в виде функции от состояний других атомов. Состояние формируется лениво, в момент обращения к нему. Если от состояния атома перестаёт кто-либо зависеть, то он может "засыпать" теряя зависимость от других атомов. В "ленивости", динамической автоматической активации и деактивации правил основное преимущество данного подхода, поэтому именно о нём и пойдёт дальнейшее повествование.
```
[ State1 ]-------->[ State2 = Rule2( State1 ) ]-------->[ State3 = Rule3( State2 ) ]
```
Примеры реализаций: [KnockOutJS](http://knockoutjs.com/), [MobXJS](https://github.com/mobxjs/mobx), [CellX](https://github.com/Riim/cellx) и собственно [$mol\_atom](https://github.com/eigenmethod/mol/tree/master/atom).
Стоит отметить, что приведённое разделение принципов условно и отражает основной принцип работы соответствующих библиотек.
Нет времени объяснять
=====================
Создаём пару изменяемых атомов с вычисляемым значением по умолчанию:
```
const userName = new $mol_atom( 'userName' , next => next || 'Anonymous' )
const showName = new $mol_atom( 'showName ' , next => next || false )
```
Создаём вычисляемый атом, не допускающий прямое изменение своего значения:
```
const greeting = new $mol_atom( 'greeting' , next => {
if( !showName.value() ) return 'Hello!'
return `Hello, ${ userName.value() }!`
} )
```
Создаём презентационный атом, выводящий приветствие в консоль всякий раз, когда что-либо в данных меняется:
```
const presenting = new $mol_atom( 'presenting' , next => {
console.log( greeting.value() )
} )
```
Принудительно активируем презентационный атом:
```
presenting.value()
//Hello!
```
Меняем сразу 2 атома, но вывод будет только один:
```
showName.value( true )
userName.value( 'John' )
//Hello, John!
```
Принудительно презентуем после каждого изменения данных:
```
userName.value( 'Jin' )
presenting.value()
// Hello, Jin!
showName.value( false )
presenting.value()
// Hello!
```
Пытаемся изменить приветствие напрямую — ничего не выходит:
```
greeting.value( 'Hi!' )
```
Принудительно устанавливаем приветствие в обход правил:
```
greeting.value( 'Hi!' , $mol_atom_force )
//Hi!
```
Меняем исходные данные — ноль реакции:
```
showName.value( false )
```
Принудительно обновляем значение приветствия по правилам:
```
greeting.value( void null , $mol_atom_force )
//Hello!
```
Включаем логирование всех атомов и меняем один из них:
```
$mol_log.filter( '' )
showName.value( true )
//21:44:11 showName.value() ["push", true, false]
//21:44:11 greeting.value() ["obsolete"]
//21:44:11 $mol_atom.sync []
//21:44:11 userName.value() ["push", "Anonymous", undefined]
//21:44:11 greeting.value() ["push", "Hello, Anonymous!", "Hello!"]
//21:44:11 presenting.value() ["obsolete"]
//Hello, Anonymous!
```
Выключаем логгирование:
```
$mol_log.filter( null )
```
[Попробовать онлайн.](http://jsbin.com/cezaruzuti/1/edit?js,console) [Ещё пример.](http://jsbin.com/xuwuyilavu/1/edit?js,output)
А внутре у ней что?
===================
Казалось бы, что может быть проще: при изменении одного состояния, вызывать пересчёт зависимых состояний. Однако..
Прежде всего нужно определиться что от чего зависит.
Допустим, вы делаете блог и на странице какого-нибудь поста нужно выводить в заголовке окна название поста, а на странице постов отфильтрованных по тегу — название тега. Получается, состояние заголовка окна динамически меняет свои зависимости. То оно зависит от названия поста, то от имени тега, но в обоих случаях оно зависит от некоторого условия, определяющего от чего ему нужно зависеть.
Уже в этом простом примере видно, как важна поддержка динамических зависимостей. Поэтому нам не подходит такая абстракция как "stream", вокруг которой построены популярные "push" библиотеки.
Типичная "pull" реализация работает следующим образом:
1. Когда атом вычисляет своё состояние, он первым делом помещает себя в некоторую глобальную переменную, что позволяет другим атомам понять, какой атом сейчас вычисляется.
2. Далее он создаёт пустой список своих зависимостей, в котором будут зарегистрированы все атомы, к которым так или иначе будет произведено обращение.
3. Только теперь происходит исполнение формулы — обычной функции, возвращающей некоторый результат.
4. В процессе исполнения формулы, может быть обращение к каким угодно другим функциям, объектам и браузерным интерфейсам.
5. Если в процессе исполнения формулы произойдёт обращение к значению другого атома, то тот, взяв из глобальной переменной зависимый атом, слинкует их таким образом, что оба будут знать, что значение одного зависит от значения другого.
6. После того, как формула вычислена, полученное значение запоминается в атоме, чтобы в дальнейшем можно было возвращать его сразу, без относительно долгого вычисления формулы.
7. И наконец, происходит сравнение нового списка зависимостей и старого, чтобы "разъединить" более не зависящие друг от друга атомы.
8. Если значение атома меняется, то происходит уведомление завясящих от него атомов, что их значения устарели и им тоже требуется актуализация.
Таким образом мы имеем всегда актуальную сеть из атомов, которая динамически перестраивается, отражая реальные зависимости в данный момент времени.
Стоит отметить, что к формулам (и, как следствие, ко всем так или иначе вызываемым функциям) предъявляется требование быть идемпотентными. То есть, если ни одна зависимость не изменилось, то и результат работы функции должен остаться неизменным. Под результатом тут понимается не только возвращаемое формулой значение, но и производимые в процессе вычисления побочные действия.
Именно благодаря идемпонентности, появляется возможность кешировать результат на неопределённый срок и сбрасывать кеш лишь когда он либо больше не нужен, либо больше не актуален.
Но что если при вычислении значения возникнет исключение? Если его не перехватить, то текущий "вычисляемый атом", помещённый в глобальную переменную, так там и останется, что в дальнейшей работе приложения может привести к появлению весьма странных зависимостей, что довольно не просто отдебажить. Кроме того, каждый раз при обращении к атому, будет происходить вычисление формулы и всплытие исключения, что не только засорит консоль на больших объёмах данных, но и вызовет неслабые тормоза. И вишенкой на торте проблем будет то, что часть атомов так и останется в неактуальном состоянии.
Говоря простым языком, состояние приложение перестанет быть консистентным и начнёт работать нестабильно. Чтобы этого не допустить, каждый атом должен перехватить исключение и сохранить в себе вместо значения и позволить ему всплыть дальше. Таким образом, при следующем обращении к атому, это исключение будет брошено вновь. Если исключение было следствием некорректных данных, то как только данные станут корректными, атом пересчитает своё значение и вместо кидания исключения будет уже возвращать актуальное значение.
Но в какой момент зависимые атомы должны пересчитывать свои значения? Если делать это сразу при получении уведомления об устаревании, атом может впустую по многу раз исполнять формулу, когда последовательно меняются несколько его зависимостей. Поэтому, в хороших реализациях атом немедленно лишь помечается устарешим, а вот актуализируется он уже отложенно.
Вообще говоря, проблема лишних вычислений не так безобидна, как может показаться. Она может приводить ко следующим неприятным последствиям:
1. Снижение производительности вплоть до невозможности пользоваться приложением.
2. Возникновение исключений в неожиданных местах. Типичная ситуация — обращение к уже удалённому объекту.
3. Лишние запросы к серверу, нотификации и тому подобные не "схлопывающиеся" повторения.
Существует несколько стратегий отложенной актуализации атомов:
1. **В порядке устаревания.** В момент устаревания, атом добавляется в конец очереди на пересчёт. Самая простая стратегия. Однако, она оставляет довольно большое число лишних пересчётов.
2. **В порядке создания.** Каждому атому задаётся числовой идентификатор. Позднее созданные атомы имеют и большее значение идентификатора. Пересчитываются атомы, начиная с атома с наименьшим идентификатором. Получается, что зависимые атомы пересчитываются раньше, чем те, от которых они зависят, так как они зачастую создаются в процессе вычисления зависящих. Это всё опять же приводит к лишним вычислениям.
3. **В порядке увеличения глубины.** Атомы сортируются по максимальной глубине зависимостей. Сначала пересчитываются атомы без зависимостей, потом зависящие от атомов без зависимостей, потом от атомов, которые зависят от атомов без зависимостей и так далее. При такой схеме лишних пересчётов практически не происходит. Однако, иногда возникают казусы, когда атом имеет небольшую глубину, но его существование определяется атомом с большей глубиной. Таким образом он пересчитывает своё значение первым, а позже удаляется, так как в нём больше нет необходимости.
4. **В правильном порядке.** Зависимости актуализируются в том же порядке, в котором к ним было произведено обращение при вычислении зависимого атома.
Чтобы обеспечить правильный порядок актуализации, каждый атом может находиться в одном из 4 состояний:
1. **Устаревший** (obsolete). При следующем обращении, его значение будет вычислено по формуле. Когда атом переходит в это состояние, он уведомляет зависимые атомы, что они "возможно устарели".
2. **Возможно устаревший** (checking). При следующем обращении, он сначала убедится, что все его зависимости в актуальном состоянии. Как только одна из них изменит своё значение, то атом станет "устаревшим" со всеми вытекающими. Иначе — станет "актуальным" без перевычисления значения. Когда атом переходит в состояние "возможно устаревший", то тут же уведомляет зависимые атомы, что они тоже "возможно устарели". Таким образом этот состояние каскадно распространяется на всё зависимое поддерево. Если от этого атома никто не зависит, то он добавляет себя в очередь на отложенную актуализацию.
3. **Актуальный** (actual). При обращении, возвращает запомненное значение. Если при переходе в актуальное состояние, его значение изменилось, то он уведомляет зависимые атомы, что они "устарели".
4. **Вычисляется** (pulling). Когда атом начинает перевычисляться, то переходит в это состояние. Обращение к атому в этом состоянии приводит к возникновению исключения, так как свидетельствует о циклической зависимости. После вычисления, даже если оно закончилось ошибкой, атом запоминает результат, переходя в "актуальное" состояние.
Такая логика работы может показаться слишком сложной и избыточной, однако но она позволяет гарантировать, что:
1. Приложение не зависнет из-за циклических зависимостей.
2. Пересчёт атома будет происходить не раньше, чем его зависимости примут актуальное значение.
3. Пересчёт атома не будет произведён, если актуальные значения его зависимостей не поменялись.
4. При обращении к атому, мы гарантированно получаем актуальное значение (остальные схемы этого не гарантируют, так как не исключают возможной необходимости его повторного вычисления).
[Нужно больше мемов](https://youtu.be/t9kQLU_o5lU?t=1m2s)
=========================================================
Тут и далее примеры идут на языке TypeScript, который является ES6 с добавлением типизации после двоеточий.
Работать с атомами напрямую не очень удобно. Им нужно давать уникальные имена, чтобы в логах выводилось что-то осмысленное, а не просто абстрактные числа. Нужно их где-то хранить и не создавать лишний раз. Чтобы избавиться от этой рутины, введём понятие "свойства", как полиморфного метода, который в зависимости от числа параметров "возвращает" или "устанавливает и тут же возвращает" некоторое значение.
Обычное свойство имеет следующий интерфейс:
```
{
< Value >() : Value
< Vlaue >( nextValue : Value ) : Value
}
```
Например:
```
class App {
title( next? : string ) {
if( next !== void null ) document.title = next
return document.title
}
}
```
Его можно сделать реактивным (кешируемым с автоматической инвалидацией кеша), просто добавив декоратор `$mol_mem()`:
```
class App {
@ $mol_mem()
title( next? : string ) {
if( next !== void null ) document.title = next
return document.title
}
}
```
Оформим код приветствующего приложения в виде класса (для удобства воспользуемся $mol\_object, помогающем генерировать правильные имена, но вы можете его и не использовать, определяя метод toString объекта вручную):
```
class App extends $mol_object {
@ $mol_mem()
userName( next? : string ) { return next || 'Anonymous' }
@ $mol_mem()
showName( next? : boolean ) { return next || false }
greeting() {
if( !this.showName() ) return 'Hello!'
return `Hello, ${ this.userName() }!`
}
@ $mol_mem()
presenting() {
console.log( this.greeting() )
}
}
```
Как можно заметить свойство `greeting` не реактивное, так что этот метод будет вызываться каждый раз при обращении к нему. А вот `showName` — реактивное, так что метод будет вызываться лишь при первом чтении значения по умолчанию и при передаче ему нового значения.
Мы могли бы объявлять свойства в духе MobX, но для этого пришлось бы писать более громоздкий код с дублированием имени свойства:
```
class App {
@observable
get userName() { return 'Anonymous' }
set userName( next : string ) { return next }
@observable
get showName() { return false }
set showName( next : boolean ) { return next }
get greeting() {
if( !this.showName ) return 'Hello!'
return `Hello, ${ this.userName }!`
}
@computed
get presenting {
console.log( this.greeting )
}
}
```
Кроме того, нельзя было бы также легко и просто перегружать свойство целиком извне, как в следующем примере:
```
class My extends $mol_object {
@ $mol_mem()
static instance() {
return new this
}
name(){ return `Jin #${ Date.now() }` }
@ $mol_mem()
showName( next ) {
return ( next === void null ) ? true : next
}
@ $mol_mem()
app() {
const app = new App
app.userName = ()=> this.name()
app.showName = ( next )=> this.showName( next )
return app
}
}
My.instance().app().presenting()
//Hello, Jin #1481383086982!
```
[Попробовать онлайн.](http://jsbin.com/fifugofohu/1/edit?js,console) [Ещё пример.](http://jsbin.com/givowayepe/1/edit?js,console)
Тут мы использовали перегрузку свойств для элегантного создания одностороннего биндинга для свойства `userName` и двустороннего для свойства `showName`. Это очень мощная техника, позволяющая детально настроить поведение любого объекта, сразу после его создания, без риска его поломать.
Стоит обратить внимание на исключительно понятные логи, по которым чётко видно какие состояния как изменялись:
```
$mol_log.filter( '' )
My.instance().app().showName( false )
$mol_log.filter( null )
//11:27:58 My.instance().showName() ["push", false, true]
//11:27:58 My.instance().app().presenting() ["obsolete"]
//Hello!
```
Часто требуется работать не с одним значением, а с целым семейством значений, различаемых некоторым ключом, но по одной и той же логике. Для этих случаев используется следующий интерфейс:
```
{
< Key , Value >( key : Kay ) : Value
< Key , Vlaue >( key : Key , nextValue : Value ) : Value
}
```
Для примера, создадим простейший класс, позволяющий использовать REST ресурсы:
```
class Rest extends $mol_object {
@ $mol_mem_key()
static resource( uri : string , next? : any , force : $mol_atom_force ) {
const request = new XMLHttpRequest
const method = ( next === void null ) ? 'get' : 'put'
request.onload = ( event : Event )=> {
this.resource(
uri ,
request.responseText ,
$mol_atom_force
)
}
request.onerror = ( event : ErrorEvent )=> {
setTimeout( ()=> {
this.resource(
uri ,
event.error || new Error( 'Unknown HTTP error' ) ,
$mol_atom_force
)
} )
}
request.open( method , uri )
request.send( next )
throw new $mol_atom_wait( `${ method } ${ uri }` )
}
}
```
Для разных uri будут создаваться отдельные атомы. Но при обращении к одному и тому же uri — будет использован один и тот же атом. Как можно заметить, логика получения данных и установки значения полностью совпадает. Разница лишь в том, что при запросе данных будет использован http-метод "get", а при передаче данных — "put".
Так как атомы умеют адекватно работать с исключительными ситуациями, то тут мы использовали это их свойство для абстрагирования кода приложения от асинхронности. Так как данные ещё не загружены, то мы не можем сразу же их вернуть. Вместо этого кидается специальное исключение и вычисление зависимых от этого свойства свойств прерывается в ожидании каких-либо изменений. Когда приходит ответ от сервера, он устанавливается в качестве значения свойства и зависимые атомы "оживают", но на этот раз их вычисление не прерывается. Стоит отметить, что обработчик ошибок может быть вызван браузером синхронно, поэтому устанавливается свойству значение отложенно, чтобы гарантировать, что будет установленно именно оно, а не $mol\_atom\_wait, который кидается далее.
Давайте реализуем приложение, рисующее все эмодзи, которые поддерживает гитхаб:
```
class App extends $mol_object {
@ $mol_mem()
static presenting() {
const emojis = JSON.parse( Rest.resource( 'http://api.github.com/emojis' ) )
document.body.innerHTML = ''
for( let id in emojis ) {
const image = document.createElement( 'img' )
image.src = emojis[ id ]
document.body.appendChild( image )
}
}
}
App.presenting()
```
[Попробовать онлайн.](http://jsbin.com/vehuwuzeli/1/edit?js,output)
Как видно, нам не пришлось плясать с колбэками, обещаниями, генераторами, стримами, асинхронными функциями и прочими адскими созданиями. Вместо этого наш код остался простым и понятным.
Более сложный пример с параллельной загрузкой файлов рассмотрен в [обстоятельной статье про $mol](https://habrahabr.ru/post/311172/).
Но я ведь только внедрил..
==========================
[RxJS](https://github.com/Reactive-Extensions/RxJS/)
----------------------------------------------------
[Облегчённая версия](https://github.com/Reactive-Extensions/RxJS/blob/master/dist/rx.lite.compat.js) — всего лишь 250КБ.
Всё это только для того, чтобы вместо последовательного кода писать комбинаторы комбинаторов кучи мелких замыканий. Мейнтейнеры AngularJS@2 ведь не могут ошибаться. Спикер с \*JsConfTalksMeetUpDays убедительно размахивал об этом руками. Именно так нужно писать код в 2k16:
```
const greeting = showName
.select( showName => {
if( showName ) return userName.map( userName => `Hello, ${ userName }!` )
return Rx.Observable.from([ 'Hello!' ])
} )
.switch()
```
А за такое устаревшее поделие, нужно руки отрывать:
```
greeting() {
if( this.showName() ) return `Hello, ${ this.userName() }!`
else return 'Hello!'
}
```
[Promises](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Promise)
-------------------------------------------------------------------------------------------------
Встроенные уже почти в каждый браузер, они позволяют вам писать… цепочки из цепочек мелких замыканий. Ведь именно так выглядит код настоящего синьора:
```
let _config
const getConfig = ()=> {
if( _config ) return _config
return _config = $.get( 'config.json' ).then( JSON.parse )
}
let _profile
const getProfile = ()=> {
if( _profile ) return _profile
return _profile = $.get( 'profile.json' ).then( JSON.parse )
}
const getGreeting = ()=> getConfig()
.then( config => {
if( !config.showName ) return 'Hello!'
return getProfile()
.then( profile => `Hello, ${profile.userName}!` )
} )
```
Этот же код просто невозможно поддерживать:
```
@ $mol_mem()
config() {
return JSON.parse( Rest.resource( 'config.json' ) )
}
@ $mol_mem()
profile() {
return JSON.parse( Rest.resource( 'profile.json' ) )
}
@ $mol_mem()
greeting() {
if( !this.config().showName ) return 'Hello!'
return `Hello, ${ this.profile().userName }!`
}
```
[Async functions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function)
--------------------------------------------------------------------------------------------------------------
Вы на самом острие технологий. На столь остром, что многие браузеры, не понимают то, что вы пишете:
```
let _config
const getConfig = async ()=> {
if( _config ) return _config
return _config = JSON.parse( await $.get( 'config.json' ) )
}
let _profile
const getProfile = async ()=> {
if( _profile ) return _profile
return _profile = JSON.parse( await $.get( 'profile.json' ) )
}
const getGreeting = async ()=> {
if( !( await getConfig() ).showName ) return 'Hello!'
return `Hello, ${ ( await getProfile() ).userName }!`
}
```
Поэтому вы используете [webpack](https://webpack.js.org/) и [babel](https://babeljs.io/), которые во мгновение ока преобразуют ваш код, понимаемый лишь двумя передовыми браузерами, в код для нижнего интернета:
```
'use strict';
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
var _config = void 0;
var getConfig = function () {
var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
return regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
if (!_config) {
_context.next = 2;
break;
}
return _context.abrupt('return', _config);
case 2:
_context.t0 = JSON;
_context.next = 5;
return $.get('config.json');
case 5:
_context.t1 = _context.sent;
return _context.abrupt('return', _config = _context.t0.parse.call(_context.t0, _context.t1));
case 7:
case 'end':
return _context.stop();
}
}
}, _callee, undefined);
}));
return function getConfig() {
return _ref.apply(this, arguments);
};
}();
var _profile = void 0;
var getProfile = function () {
var _ref2 = _asyncToGenerator(regeneratorRuntime.mark(function _callee2() {
return regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
if (!_profile) {
_context2.next = 2;
break;
}
return _context2.abrupt('return', _profile);
case 2:
_context2.t0 = JSON;
_context2.next = 5;
return $.get('profile.json');
case 5:
_context2.t1 = _context2.sent;
return _context2.abrupt('return', _profile = _context2.t0.parse.call(_context2.t0, _context2.t1));
case 7:
case 'end':
return _context2.stop();
}
}
}, _callee2, undefined);
}));
return function getProfile() {
return _ref2.apply(this, arguments);
};
}();
var getGreeting = function () {
var _ref3 = _asyncToGenerator(regeneratorRuntime.mark(function _callee3() {
return regeneratorRuntime.wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
_context3.next = 2;
return getConfig();
case 2:
if (_context3.sent.showName) {
_context3.next = 4;
break;
}
return _context3.abrupt('return', 'Hello!');
case 4:
_context3.next = 6;
return getProfile();
case 6:
_context3.t0 = _context3.sent.userName;
_context3.t1 = 'Hello, ' + _context3.t0;
return _context3.abrupt('return', _context3.t1 + '!');
case 9:
case 'end':
return _context3.stop();
}
}
}, _callee3, undefined);
}));
return function getGreeting() {
return _ref3.apply(this, arguments);
};
}();
```
И нет, этот код всё-равно никуда не годится:
```
@ $mol_mem()
config() {
return JSON.parse( Rest.resource( 'config.json' ) )
}
@ $mol_mem()
profile() {
return JSON.parse( Rest.resource( 'profile.json' ) )
}
@ $mol_mem()
greeting() {
if( !this.config().showName ) return 'Hello!'
return `Hello, ${ this.profile().userName }!`
}
```
Тут ведь не понятно, асинхронный метод `config` или нет, а ведь это очень важно знать!
Но если всё же..
================
$mol\_atom является основным строительным кирпичиком [фреймворка $mol](https://github.com/eigenmethod/mol). Он обеспечивает надёжную и гибкую динамическую взаимосвязь между всеми компонентами, позволяя описывать их предельно простым синхронным кодом. Асинхронность не выпячивается наружу, а полностью (да-да, именно полностью) инкапсулируется внутри асинхронных модулей, делая работу с ней простой и приятной. Ошибки не рушат всё приложение, а корректно обрабатываются. А дебаг на редкость удобен, благодаря человекопонятным идентификаторам, синхронному коду и быстрому доступу из консоли к любому состоянию. [Независимая сборка $mol\_atom+$mol\_mem](https://eigenmethod.github.io/mol/mem/-/web.js) весит всего 25KB и может быть использована с любым другим фреймворком. | https://habr.com/ru/post/317360/ | null | ru | null |
# (Справа налево (Зазеркалье
Кажется, с заголовком что-то не так? Это одна из проблем, с которыми сталкиваются веб-разработчики при добавлении поддержки таких языков, как арабский. В этой статье расскажем о проблемах, с которыми мы столкнулись, и решениях, которые придумали для поддержки арабского языка в десктопном клиенте Spotify и веб-плеере.
Локализация в Spotify — важное дело. Наша миссия состоит в том, чтобы «раскрыть потенциал человеческого творчества, предоставляя миллионам музыкантов возможность зарабатывать своим искусством на жизнь, а миллиардам поклонников — наслаждаться и вдохновляться им». Для достижения этой миссии важно, чтобы пользователи из разных стран могли эффективно общаться на своих языках. Недавно мы запустили Spotify в регионах Северной Африки и Западной Азии. Одним из языков в этих регионах является арабский. В отличие от английского, арабский читается справа налево. Это сказывается на веб-сайтах, которые хотят поддерживать арабский язык.
Оглавление
==========
* [Макет зеркального отображения](#1)
* [Английский язык в формате RTL](#2)
* [Арабское письмо](#3)
* [Стандарты качества](#4)
* [Полезные источники](#5)
В статье будем использовать следующие аббревиатуры:
**LTR** (Left To Right): текст, который читается слева направо, например, английский или испанский.
**RTL** (Right To Left): текст, который читается справа налево, например, арабский.
Макет зеркального отображения
=============================
На арабском языке справа налево распространяется не только текст, но и весь макет страницы. Например, следует перевернуть изображения, указывающие направление. Мы столкнулись с несколькими исключениями, которые рассмотрим ниже в разделе иконок.
### Как работает атрибут dir
Направление текста в элементе браузеру сообщает атрибут `dir`. Чтобы задать глобальное направление страницы, необходимо задать атрибут `dir` для всей страницы.
Значения атрибута:
* **ltr** — используется для письма слева направо (например, английский, шведский). Это значение по умолчанию.
* **rtl** — используется для письма справа налево (например, арабский, иврит, персидский).
* **auto** — используется для динамического содержимого. Браузер сам выбирает направление. Для обработки элементов и определения направления используется алгоритм [Unicode Bidirectional Algorithm](http://unicode.org/reports/tr9/#Introduction). Подробнее см. в разделе [«Английский язык в формате RTL»](#2).
### CSS
И CSS Flexbox, и CSS Grid смотрят на атрибут `dir`, чтобы определить направление элемента. Например, `flex-start` автоматически переключается на RTL, когда атрибут `dir` установлен в `"rtl"`.
Но атрибута `dir` с использованием flexbox или grid может быть недостаточно для отражения всего пользовательского интерфейса на RTL. Слишком много асимметричных свойств CSS, за которыми нужно следить при разработке веб-сайта, поддерживающего как LTR, так и RTL. Например `margin-left: 20px` и `text-align: right` в RTL поменяются и станут `margin-right: 20px` и `text-align: left`.
Есть много инструментов для автоматизации этой работы. Мы выбрали [PostCSS-RTL](https://github.com/vkalinichev/postcss-rtl), который на этапе сборки генерирует правила RTL с «перевёрнутыми» свойствами.
```
.foo {
margin-left: 15px;
text-align: right;
color: rebeccapurple;
}
```
*Вход CSS*
```
[dir] .foo {
color: rebeccapurple;
}
[dir="ltr"] .foo {
margin-left: 15px;
text-align: right;
}
[dir="rtl"] .foo {
margin-right: 15px;
text-align: left;
}
```
*Вывод CSS*
### Иконки
Иконки и элементы, имеющие направление или связанные с прогрессом, следует перевести в RTL. Например, кнопки навигации назад и вперёд нужно поменять местами.
*Кнопка «Назад» в LTR*
*Кнопка «Назад» в RTL (вместо арабского используется английский текст)*
Все анимации с направлением движения тоже надо перевернуть. Например, карусели должны скользить в другую сторону.
### Исключения
Изначально мы предполагали, что всё будет зеркально. Но довольно быстро увидели некоторые исключения. Например, кнопки воспроизведения мультимедиа и индикатор выполнения не требуют зеркального отображения, поскольку они относятся к направлению проигрываемой ленты. Арабоязычные пользователи ожидают, что элементы управления воспроизведением и индикатор выполнения будут выглядеть так же, как и на языке LTR.
*Индикатор воспроизведения в LTR*
Английский язык в формате RTL
=============================
Нередко на одной странице смешиваются тексты LTR и RTL. На Spotify более 40 миллионов песен музыкантов со всего мира и более 3 миллиардов плейлистов. Контент представлен на многих языках для пользователей со всего мира. Поэтому в клиентах Spotify контент LTR и RTL часто смешивается.
### (Hello (World: проблема пунктуации и скобок
Одна из первых проблем, с которой мы столкнулись, выглядела так:
*Проблема скобок*
Такое происходит, потому что браузер задаёт базовое направление текста исходя из значения атрибута `dir` нашего элемента. Знаки препинания, такие как `( ) . !` и остальные, не описываются направлением в Unicode. Они наследуют базовое направление текста.
Двунаправленный алгоритм Unicode Bidirectional Algorithm рассматривает каждый символ в строке справа налево. В качестве примера возьмём на странице строку `"Hello (World)"`.
* Алгоритм начинает разбор строки справа. Он видит ненаправленный символ `)`, поэтому смотрит на базовое направление текста и видит, что текст идёт справа налево. Алгоритм решает перенести `)` в начало строки.
```
“Hello (World)” -> “(Hello (World”
```
* Алгоритм видит `d` с направлением LTR. Его не нужно перемещать. То же самое касается других английских символов вплоть до `(`.
* Алгоритм видит `(` без направления. Он помнит преобладающее базовое направление (заданное предыдущим символом `W`) слева направо. Алгоритм решает не перемещать `(`. То же самое касается пробела и всех символов в `"Hello”`
Подробнее о том, как работает Unicode Bidirectional Algorithm, см. [здесь](https://www.w3.org/International/articles/inline-bidi-markup/uba-basics).
В итоге мы получаем строку `"(Hello (World"`. Мы решили эту проблему, указав значение `auto` для атрибута `dir` во всём динамическом контенте, например, в именах исполнителей, названиях альбомов и песен. Это изолирует содержимое и задаёт базовое направление в соответствии с первым строго типизированным символом направления. В этом случае ненаправленные символы всегда будут наследовать направление от окружающих символов, а не страницы. Поэтому получится строка `"Hello (World)"`. Для соблюдения корректного выравнивания используйте атрибут только для встроенных элементов inline, иначе придётся добавлять в элементы свойство `text-align`.
### ...ello World: проблема с усечением
Смешанный контент также представляет проблему, если вы хотите добавить усечение, которое не подходит элементу.
*LTR UI: арабский текст, усечённый с неправильной стороны*
*RTL UI: английский текст, усечённый с неправильной стороны*
Усечение происходит с неправильной стороны, потому что браузер задаёт направление текста из атрибута `dir`. Проблему решает установка атрибута `"auto"` для элемента с усечённым текстом.
*LTR UI: арабский текст, усечённый с правильной стороны*
*RTL UI: английский текст, усечённый с правильной стороны*
Арабское письмо
===============
При разработке мультиязычного UI важно убедиться, что интерфейс правильно работает для всех алфавитов. Вот, вкратце, что нужно проверить при добавлении арабского языка.
#### Межсимвольный интервал
Арабское письмо — это вязь. Большинство, если не все символы в слове связаны друг с другом. По этой причине в арабском не следует использовать межсимвольный интервал. Он разрывает символы, нарушая естественную вязь.
#### Размер шрифта
Как правило, у арабских символов более сложные глифы, чем у английских. Там больше линий и нюансов, которые должны вписаться в такое же пространство. Из-за этого арабское письмо с тем же размером шрифта менее разборчивое, чем английский язык. Символы слишком маленькие. Мы решили увеличить минимальный размер шрифта на арабском языке с 11 до 12px. Мы также убедились, что шрифт не усложняет арабские глифы. Хорошим выбором будет [Google Noto](https://www.google.com/get/noto/), который более разборчив, чем Arial — резервный шрифт по умолчанию для арабского языка в браузере.
#### Вертикальная обрезка
Некоторые арабские буквы выше английских. Это может привести к обрезке символов по вертикали. Возможно, для арабского потребуется увеличить межстрочный интервал (line-height).
*Вертикальная обрезка*
#### Заглавные буквы
В арабском нет заглавных букв, поэтому нет смысла что-то выделять прописными буквами на странице.
#### Арабские запятые
Во многих языках в качестве запятой используется `,`. В арабском языке другой разделитель: `،`.
У нас в коде часто встречалась команда `array.join(‘, ‘)`. Для поддержки разных разделителей в зависимости от языковых настроек пользователя мы добавили метод `getSeparator()`.
#### Цифры на арабском
На арабском языке две системы цифр
* Западные арабские цифры: 0 1 2 3 4 5 6 7 8 9
* Восточные арабские цифры: ٩ ٣ ٤ ٥ ٦ ٧ ٨ ١ ٢ ٠
Выберите одну систему и используйте её последовательно во всём приложении. Мы выбрали западные арабские цифры.
#### Прозрачный цвет текста
Глифы на арабском могут перекрываться. Прозрачный цвет текста не работает, поскольку перекрывающиеся части не получают ожидаемой прозрачности. Решение проблемы — полностью непрозрачный цвет и непрозрачность для текстового элемента.
*Проблема прозрачности*
Стандарты качества
==================
Вот некоторые вещи, которые мы сделали, чтобы качественно внедрить арабский язык:
* Тестовые сессии в команде
* Бета-тест с арабоязычными сотрудниками
* Тест UI и переводов внешними агентствами.
Чтобы обеспечить качество арабского UI, понадобились некоторые инструменты.
Мы решили создать бота GitHub. Он публикует комментарии на пул-реквесты, которые соответствуют потенциальным проблемам. Комментарий ничего не навязывает: это просто напоминание проверить, как изменение повлияет на арабский язык, со ссылкой на инструкции по тестированию. Бот комментирует изменённые строки, соответствующие заполнению, межсимвольному интервалу, преобразованиям и т. д. Код CSS конвертируется PostCSS-RTL, поэтому обычно достаточно взглянуть на изменение на арабском языке и убедиться, что оно выглядит хорошо. Свойства CSS можно устанавливать через JS, а PostCSS-RTL не преобразует JS. Бот же проверяет JS-файлы и комментирует их тоже, если там встречаются соответствующие свойства.
*Комментарий tob-bot*
Полезные источники
==================
1. [Material Design – двунаправленность](https://material.io/design/usability/bidirectionality.html#)
2. [Методы интернационализации: авторинг HTML & CSS](https://www.w3.org/International/techniques/authoring-html)
3. [Авторинг HTML: письменность справа налево](https://www.w3.org/TR/i18n-html-tech-bidi/)
4. [Сравнительный анализ арабского и персидского языков](https://w3c.github.io/alreq/gap-analysis/)
5. [ECMAScript Internationalization API](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl) | https://habr.com/ru/post/450000/ | null | ru | null |
# Работаем с банковскими (рабочими) днями
Полгода назад при разработке системы финансового учета поднялся вопрос о идентификации банковский дней. Произошло это в следующем контексте — при выставлении счета отводится некий промежуток времени (в банковских днях) по истечению которого надо трубить тревогу, если счет еще не оплачен.
Вооружившись трудовым кодексом решил выяснить какие дни можно считать операционными для банка. Статья 112-я гласит:
> **Нерабочие праздничные дни**
>
>
>
> Нерабочими праздничными днями в Российской Федерации являются:
>
> 1, 2, 3, 4 и 5 января — Новогодние каникулы;
>
> 7 января — Рождество Христово;
>
> 23 февраля — День защитника Отечества;
>
> 8 марта — Международный женский день;
>
> 1 мая — Праздник Весны и Труда;
>
> 9 мая — День Победы;
>
> 12 июня — День России;
>
> 4 ноября — День народного единства.
>
>
>
> При совпадении выходного и нерабочего праздничного дней выходной день переносится на следующий после праздничного рабочий день.
>
>
На основен этой информации был написан простой класс на PHP который позволяет:1. подсчитывать кол-во банковских (рабочих) дней за определенный промежуток времени
2. высчитывать дату +N банковских дней
3. ну и, естейственно, определять каким днем является определенное число.
**Примеры использования:**
`echo BankDay::getEndDate('2008-10-14', 10, 'd.m.Y');
//28.10.2008
echo BankDay::getEndDate('now', 10);
//1229008080
echo BankDay::getNumDays('2008-02-25', '2008-03-15');
//13
echo BankDay::getNumDays('now', '10 days');
//7
echo BankDay::isWorkDay('2009-01-06');
//false
\* This source code was highlighted with Source Code Highlighter.
##### Скачать исходник
*Дабы избежать недопониманий — в данном контексте «банковский» = «операционный» = «рабочий» день*` | https://habr.com/ru/post/67092/ | null | ru | null |
# SAST для самых маленьких. Обзор open-source инструментов поиска уязвимостей для C/C++
Привет, Хабр!
Навыки статического анализа кода в арсенале исследователя безопасности приложений фактически являются must-have скиллом. Искать ручками уязвимости в коде, не прибегая к автоматизации, для небольших проектов вполне быть может и приемлемый сценарий. Но для больших задач с миллионами строк кода — это непозволительная роскошь с точки зрения временных затрат. Решения по автоматизации всего этого процесса не заставили себя долго ждать. Именно по этой причине мы имеем такой широкий выбор инструментов статического анализа, в разнообразии которого можно утонуть. Рассказать же подробно о всех не хватит и книги.
По этой причине главными героями сегодняшней статьи стали несколько известных и развивающихся инструментов статического анализа кода, которые могут пригодиться исследователям безопасности в процессе поиска уязвимостей. Мы постарались отобрать инструменты так, чтобы они обязательно имели открытый исходный код, возможность работы с языками C/C++ (так как они являются наиболее сложными в аспекте безопасного программирования) и без каких-либо ограничений для этого (например, как в SonarQube), а также имели возможность создавать собственные запросы/правила для кастомизации анализа под конкретный проект/тип уязвимости с минимальными усилиями.
Присутствие не самых известных инструментов в обзоре может немного удивить. Тем не менее они являются интересными образцами и достойны рассмотреня. Если вы хотите рассказать о своем фаворите, будем рады почитать о вашем опыте в комментариях!
Прежде чем начать обзор, сперва обратимся к истокам. Напомним, что такое SAST и за что его так все ~~не~~ любят.
### Что такое SAST?
SAST (Static Application Security Testing) – это процесс тестирования, при котором применяется техники статического анализа для поиска ошибок и потенциальных проблем безопасности. Как уже отмечалось, на данный момент существует огромное количество SAST-инструментов для различных языков программирования. Пожалуй, наиболее полный перечень всевозможных инструментов расположен в [github-репозитории](https://github.com/analysis-tools-dev/static-analysis) Analysis Tools. Внушительный по объему список также был представлен OWASP Foundation – [Source Code Analysis Tools](https://owasp.org/www-community/Source_Code_Analysis_Tools).
К сожалению, о SAST далеко не все отзываются лестно. Так уж вышло, что общее отношение к SAST у ряда специалистов скорее скептично-негативное ввиду большого количества ложных срабатываний. Это отбивает желание пользоваться подобными инструментами, тратя на них свое драгоценное время.
Задача этой статьи вовсе не переубедить, а показать, что эти инструменты — не панацея, а лишь вспомогательный элемент в процессе поиска уязвимостей. Зная контекст исследуемого приложения/системы, можно создавать довольно эффективные правила, которые позволят найти отправные точки к возможным багам, ну и вообще облегчат поиск в огромной груде кода.
### Наши подопытные
С учетом уже упомянутых критериев для обзора были выбраны следующие SAST-инструменты:
* [Semgrep](#semgrep)
* [CodeQL](#codeql)
* [Weggli](#weggli)
* [Joern](#joern)
* [MATE](#mate)
Чтобы оценить их, нам понадобится проект с исходным кодом, содержащий уязвимости. Было бы очень здорово охватить все слабости, перечисленные в [Weaknesses in Software Written in C](https://cwe.mitre.org/data/definitions/658.html) и [Weaknesses in Software Written in C++](https://cwe.mitre.org/data/definitions/659.html), но мы решили взять одну из них и сделать акцент на различных способах ее реализации, чтобы проверить возможности исследуемых инструментов. И это… **double-free**, она же [CWE-415](https://cwe.mitre.org/data/definitions/415.html)! Данная уязвимость, несмотря на свою простоту и почтенный возраст, до сих пор обнаруживается в ряде известных проектов. Правила для анализа будем создавать под этот тип ошибки.
Помимо уязвимых сниппетов кода, наш проект будет содержать несколько простых ловушек для SAST-инструментов. Для людей эти "ловушки" могут показаться смешными, но для инструментов это целое испытание. Подобным образом можно будет выявить проблемные места инструментов, например, некоторые из них могут не уметь работать с Control Flow, не обладать межпроцедурным анализом и т.д. Так что постараемся внимательно изучать документацию, быть в курсе существующих примеров правил/запросов, и конечно же, подходить творчески и экспериментировать.
Игрушечный проект расположился в github-репозитории ["double-free-samples"](https://github.com/Nalen98/double-free-samples).
Оформим для себя небольшой чек-лист по багам в коде игрушечного проекта, чтобы оценивать работу инструментов в будущем. В табличку запишем информацию об уязвимых участках кода и о "ловушках" для SAST-инструментов, т.е. ситуациях, при которых уязвимость не может существовать. Если они будут обнаружены в результатах, это будут ложноположительные кейсы.
**Checklist**
| № | Тип | Место в коде | Метод | Описание |
| --- | --- | --- | --- | --- |
| 1 | **уязвим** | `funcs.cpp:14` | `double_free()` | Тривиальный double-free |
| 2 | не уязвим | `funcs.cpp:24` | `no_double_free()` | Переназначение указателя, нет ошибки |
| 3 | **уязвим** | `funcs.cpp:41` | `df_by_pointer()` | Тривиальный double-free, вызывается через указатель на функцию |
| 4 | **уязвим** | `funcs.cpp:57` | `df_with_wrappers()` | double-free с методом-оберткой `wrapper(char *ptr)` над вызовом `free` |
| 5 | **уязвим** | `funcs.cpp:69` | `conditional_dfree()` | double-free в случае первого освобождения в if-блоке |
| 6 | **уязвим** | `funcs.cpp:70` | `conditional_dfree()` | double-free без захода в if-block + trio free 0\_o |
| 7 | не уязвим | `funcs.cpp:80` | `free_null()` | Переназначение указателя, нет ошибки |
| 8 | **уязвим** | `funcs.cpp:89` | `double_delete()` | Тривиальный double-delete |
| 9 | не уязвим | `funcs.cpp:105` | `intrnl_reassignment()` | Переназначение указателя во внутреннем вызове `reassignment(char *ptr)`, нет ошибки |
| 10 | **уязвим** | `funcs.cpp:117` | `bad_goto()` | double-free после goto-перехода |
| 11 | не уязвим | `funcs.cpp:133` | `good_goto()` | Недостижимый вызов `free`, нет ошибки |
Также стоит отметить, что код проекта полностью готов к сборке, если это будет необходимо инструменту статического анализа. Несомненно, на деле у исследователей безопасности не всегда имеется такая возможность. Однако это не повод не рассматривать те инструменты, которые нуждаются в кодовой базе. Как правило, в контексте их работы это является неплохим преимуществом, ведь кодовая база содержит много полезной информации для анализа, что влияет на качество результатов.
Начнем же наш обзор!
### Semgrep
[Semgrep](https://github.com/returntocorp/semgrep) — легковесный инструмент статического анализа для поиска ошибок в коде. Был разработан командой [r2c](https://r2c.dev/#semgrep), написан в большинстве своем на OCaml. Первый релиз состоялся в начале 2020 года. Пожалуй, это один из немногих инструментов, в котором трансформация "From Zero To Hero" для пользователя является самой скоростной. Всё это благодаря тому, что язык запросов, или в данном случае паттернов, максимально похож на язык программирования исследуемого проекта.
Когда Semgrep выполняет анализ кода, он создает абстрактное синтаксическое дерево (AST), которое затем транслируется в промежуточный язык, с которым уже и проводится анализ. Это крайне удобно и позволяет за короткое время научиться создавать эффективные правила. На этот счет инструмент имеет отличную [документацию](https://semgrep.dev/docs/), а также большое количество хвалебных отзывов от AppSec-комьюнити, в том числе в виде отдельных статей. Мы тоже не обойдем стороной его **достоинства** — вот они:
* Не требует сборки проекта, а значит можно предоставлять несобираемые исходники, результат декомпиляции
* Поддерживаемые языки: C#, Go, Java, JavaScript, JSX, JSON, PHP, Python, Ruby, Scala, TypeScript, TSX. C/C++ имеют статус экспериментальных языков, как и [многие другие](https://semgrep.dev/docs/supported-languages/)
* Синтаксис паттернов совпадает с синтаксисом языка проекта
* Быстрая обработка запросов благодаря многопоточности
* Имеет крутую [playground-площадку](https://semgrep.dev/playground/new) для обучения синтаксису
* В [реестре](https://semgrep.dev/r) semgrep-правил можно подсмотреть security rules для множества языков, создавать свои и делиться ими
* Есть собственный [TrophyСase](https://semgrep.dev/docs/trophy-case/) — найденные CVE с помощью Semgrep
И несколько **недоработок**:
* Не знает про межпроцедурное взаимодействие, анализирует все методы подряд без разбора что, где и когда вызывается
* Не так много публичных правил для C/C++
Как уже отмечалось, поддержка C/C++ пока что является экспериментальной, и публичных правил для этих языков не много. В сравнении с языками зрелой поддержки Java, Python, Go, Ruby, C#, имеющими впечатляющий ruleset.
Эту проблему поднимал исследователь Marco Ivaldi в статьe ["Semgrep ruleset for C/C++ vulnerability research"](https://security.humanativaspa.it/semgrep-ruleset-for-c-c-vulnerability-research/). Он написал несколько десятков собственных правил для поиска уязвимостей в C/C++, их можно найти в его [github-репозитории](https://github.com/0xdea/semgrep-rules). Официальный репозиторий [semgrep-rules](https://github.com/returntocorp/semgrep-rules), к сожалению, не содержит правил для C++. Если вы опытный специалист и хотели бы внести вклад в развитие "сишного" комьюнити Semgrep, вы нужны, как никогда!
* Не поддерживает межфайловое взаимодействие, разрешение внешних ссылок, Global taint
Под внешней ссылкой в данном контексте понимаются файлы к включению, указанные в директиве `#include <>` или `#include ""`. Semgrep не умеет работать с внешними ссылками и абсолютно не знает, что там может находиться внутри. Таковы особенности инструмента. Теперь пару слов о taint-анализе.
Анализ DataFlow как более обширное понятие используется для вычисления возможных значений, которые переменная может содержать в различных точках программы, определяя, как эти значения распространяются и где используются. Tainting tracking как более узкое понятие подразумевает контроль потока недоверенных данных (пользовательский ввод) по всему коду проекта с целью выявить их влияние на выполнение программы. Taint-анализ подразделяется на виды:
1) Local taint анализирует поток данных внутри одной функции. В данном случае рассматриваются только ребра между узлами графа, принадлежащие одной и той же функции.
2) Global taint исследует поток "порчи" между разными функциями по всей программе.
Стандартные правила Semgrep выполняются только в отношении одного файла, а новомодный ["Taint mode"](https://semgrep.dev/docs/writing-rules/data-flow/taint-mode/) выполняется только в рамках одной функции, что для больших проектов и более сложных ошибок скорее бестолково, чем полезно. На этот счет r2c выпустила новый проприетарный инструмент под названием [DeepSemgrep](https://r2c.dev/blog/2022/introducing-deepSemgrep/), который должен был добавить функционал global taint. Чтобы им воспользоваться, необходимо к запуску стандартной утилиты `semgrep` в командной строке добавить дополнительный аргумент, вот так:
```
semgrep --deep
```
а в правиле указать дополнительные поля `pattern-sources` и `pattern-sinks`. К сожалению, поддерживаемыми языками на данный момент являются только Java и Ruby. На этом обсуждение достоинств и недостатков Semgrep заканчиваем и переходим к созданию правила.
Локальные правила в Semgrep бывают двух типов — эфемерные (единоразовые) и YAML-правила.
Эфемерный тип может быть полезен, если знаете, как кратко сформулировать ваше правило "вместо тысячи слов". Например, хотим примитивный double-free:
```
semgrep -e 'free($VAR); ... free($VAR);' --lang=c path/to/src
```
Такой запрос получит достаточно много ложноположительных результатов, так как мы совсем не уточнили, что высвобожденный чанк, на который указывает наш поинтер, не должен быть переназначен перед вторым освобождением. Для реализации более подробных и сложных правил необходимо создать YAML-файл и в нём описать все необходимые условия.
Для написания правила воспользуемся следующими конструкциями Semgrep:
* `id` — строковый идентификатор правила
* `metadata` — данные о правиле, указывается по желанию, как здесь, `references` содержит информацию о CWE
* `message` — поле сообщения, которое будет выводиться после каждого успешного поиска
* `severity` — серьезность ошибки, известные вариации: INFO, WARNING, ERROR
* `languages` — язык, для которого определяется данное правило
* `patterns` — оператор, объединяющий шаблоны с использованием логического "AND"
* `pattern-either` — как `patterns`, только с логическим "OR"
* `pattern` — шаблон, представляющий собой выражение, которое необходимо найти в коде проекта
* `pattern-not` — выражение, которое нужно игнорировать при поиске
* `pattern-inside` — ограничивает поиск требуемого паттерна внутри указанного выражения
* `pattern-not-inside` — не включает в результат, если требуемый паттерн содержится в данном выражении
Semgrep богат на различные конструкции. С ними можно дополнительно ознакомиться в [документации](https://semgrep.dev/docs/writing-rules/rule-syntax). Очень полезными являются, например, `pattern-regex`, позволяющий искать в коде по заданной PCRE-регулярке, `metavariable-pattern` и `metavariable-regex`, позволяющие гибко настроить метапеременные по заданным шаблонам/PCRE-регуляркам соответственно.
Итоговое правило будет выглядеть так:
**config.yaml**
```
rules:
- id: detect-double-free
metadata:
references:
- https://cwe.mitre.org/data/definitions/415.html
message: >-
Some vulnerable (and not) double-free cases. If malloc() returns
the same value twice and the program later gives the attacker control
over the data that is written into this doubly-allocated memory,
the program becomes vulnerable to a buffer overflow attack.
severity: ERROR
languages:
- cpp
pattern-either:
- patterns:
- pattern: |
free($PTR);
...
free($PTR);
- pattern-not: |
free($PTR);
...
$PTR = $EXPR;
...
free($PTR);
- pattern-not-inside: |
$FTYPE $FUNC(..., $TYPE $ARG, ...){
...
$ARG = $EXPR;
...
}
...
$FUNC($PTR);
...
- pattern-not-inside: |
if ($CONF){
...
goto $LAB;
}
...
free($PTR);
...
$LAB:
...
free(ptr);
- patterns:
- pattern: |
if ($COND){
...
free($PTR);
...
}
...
free($PTR);
- pattern-not: |
if ($COND){
...
free($PTR);
...
$PTR = $EXPR;
...
}
...
free($PTR);
- pattern-not: |
if ($COND){
...
free($PTR);
...
}
...
$PTR = $EXPR;
...
free($PTR);
- patterns:
- pattern-inside: |
$FTYPE $FUNC(..., $TYPE $ARG, ...){
...
free($ARG);
...
}
...
- pattern-not-inside: |
$FTYPE $FUNC(..., $TYPE $ARG, ...){
...
free($ARG);
...
$ARG = $EXPR;
...
}
...
- pattern: |
$FUNC(..., $PTR, ...);
...
$FUNC(..., $PTR, ...);
- pattern-not: |
$FUNC(..., $PTR, ...);
...
$PTR = $EXPR;
...
$FUNC(..., $PTR, ...);
- patterns:
- pattern: |
delete [] $PTR;
...
delete [] $PTR;
- pattern-not: |
delete [] $PTR;
...
$PTR = $EXPR;
...
delete [] $PTR;
- patterns:
- pattern: |
delete $PTR;
...
delete $PTR;
- pattern-not: |
delete $PTR;
...
$PTR = $EXPR;
...
delete $PTR;
```
Запускаем:
```
semgrep --config config.yaml [PATH/TO/SRC]
```
**Результаты**
```
Findings:
13┆ free(buf1);
14┆ free(buf1);
⋮┆----------------------------------------
38┆ free(buf2);
39┆
40┆ buf3 = (char *) malloc(SIZE);
41┆ free(buf2);
⋮┆----------------------------------------
56┆ wrapper(buf1);
57┆ wrapper(buf1);
⋮┆----------------------------------------
66┆ if (condition){
67┆ free(ptr);
68┆ }
69┆ free(ptr);
⋮┆----------------------------------------
66┆ if (condition){
67┆ free(ptr);
68┆ }
69┆ free(ptr);
70┆ free(ptr);
⋮┆----------------------------------------
69┆ free(ptr);
70┆ free(ptr);
⋮┆----------------------------------------
88┆ delete [] x;
89┆ delete [] x;
⋮┆----------------------------------------
113┆ free(ptr);
114┆ goto free_me;
115┆
116┆ free_me:
117┆ free(ptr);
Ran 1 rule on 3 file: 8 findings.
```
Что ж, в этом и есть сила Semgrep! Были найдены все кейсы двойного освобождения, ложноположительные результаты отсутствуют. Всё это потому, что мы создали соответствующие паттерны для тех ситуаций в коде проекта, где ошибка двойного освобождения могла бы существовать, и отфильтровали те случаи, когда ошибки нет. Это правило хорошо работает для игрушечного проекта и является достаточным. Запустите это правило на другом, более сложном проекте — результат вас не обрадует, поскольку правило охватывает далеко не все паттерны ситуаций, при которых в принципе может существовать ошибка double-free, а таких кейсов огромное количество. Пробуйте, дополняйте свои правила разнообразными паттернами, и их объемы будут соразмерно расти с качеством результатов.
Semgrep, несмотря на свои недостатки, оставляет о себе положительное впечатление. Инструмент продолжает развиваться благодаря отличной команде разработчиков и широкому заинтересованному AppSec комьюнити. Продолжим наш обзор и перейдем к рассмотрению следующего инструмента — CodeQL.
### CodeQL
[CodeQL](https://github.com/github/codeql) впервые был представлен компанией [Semmle](https://en.wikipedia.org/wiki/Semmle) в 2018 году. Бывалые ресечеры могут помнить его как [SemmleQL](https://msrc-blog.microsoft.com/2018/08/16/vulnerability-hunting-with-semmle-ql-part-1/). Он довольно быстро был выкуплен GitHub и с 2020 года принадлежит Microsoft. Одним из основных преимуществ CodeQL является, пожалуй, лучшая реализация DataFlow-анализа/Taint tracking в рамках кодовой базы по сравнению с другими инструментами. Последняя является иерархическим представлением кода, она включает в себя абстрактное синтаксическое дерево (AST) всего проекта, CFG (Control Flow Graph) и DataFlow данные, которые требуются для taint-анализа.
О CodeQL уже бывали выступления на международных площадках (например, ZeroNights 2021 — ["Company wide SAST"](https://www.youtube.com/watch?v=JK8uUKjo_ag&ab_channel=ZeroNights)), о нем не раз писали отличные статьи, в том числе и на Хабре (например, [CodeQL: SAST своими руками (и головой)](https://habr.com/ru/company/swordfish_security/blog/541554/), [Сканирование кода C++ с помощью GitHub Actions](https://habr.com/ru/company/microsoft/blog/566716/)), так что не будем повторяться и кратко обозначим некоторые особенности инструмента.
**Преимущества:**
* [Поддерживаемые языки](https://codeql.github.com/docs/codeql-overview/supported-languages-and-frameworks/): C/C++, C#, Go, Java, JavaScript, Python, Ruby, TypeScript
* Удобная интеграция в Visual Studio Code — [CodeQL extension](https://marketplace.visualstudio.com/items?itemName=GitHub.vscode-codeql)
* Неплохая [документация](https://codeql.github.com/docs/), а также полезные [лекции](https://help.semmle.com/QL/ql-training/cpp/global-data-flow-cpp.html#1) от Semmle
* Качественный анализ DataFlow/TaintTracking
* Возможность реализации объектно-ориентированных запросов (object-oriented queries)
* В наличии воркшопы и полезные интро как от [самих создателей](https://securitylab.github.com/ctf/uboot/), так и от [комьюнити](https://jorgectf.github.io/blog/post/practical-codeql-introduction/)
* В онлайн-консоли [LGTM](https://lgtm.com/help/lgtm/about-lgtm) (Looks Good To Me) можно создавать и тестировать СodeQL-запросы к доступным базам opensource-проектов или к собственным GitHub-репозиториям. Однако недавно появилась новость, что LGTM заявляет о своем [закрытии](https://github.blog/2022-08-15-the-next-step-for-lgtm-com-github-code-scanning/) к концу 2022 года и рекомендует использовать GitHub Code Scanning
* Список уязвимостей безопасности, [найденных с помощью CodeQL](https://medium.com/csg-govtech/hunting-bugs-in-accel-ppp-with-codeql-8370e297e18f), заметно пополняется
**Недостатки:**
* Необходимость создания кодовой базы
Это значит, что, если проект написан на компилируемом языке, он должен быть готов к сборке. Если проект по каким-либо причинам не может быть собран, CodeQL использовать не получится.
* Специфика языка запросов
К сожалению, как в случае с Semgrep, где можно с лету начинать писать собственные паттерны, с CodeQL придется потратить время на изучения языка запросов.
* Время исполнения запросов к базе
Это больше относится к taint-анализу. Если кодовая база велика, то некоторые запросы могут исполняться крайне долго, что, пожалуй, не удивительно. С базой в 4 миллиона строк кода запрос мог исполняться до полутора часов. Иногда taint-анализ окончательно замораживался и не возвращался из состояния поиска путей.
* Лицензионные ограничения
Учитывая формальную сторону, Github не разрешает использовать CodeQL для создания и анализа кодовых баз в ряде случаев. Более подробная информация располагается в [GitHub CodeQL Terms and Conditions](https://securitylab.github.com/tools/codeql/license).
* Мистика результатов DataFlow анализа
Ошибки случаются, даже у taint-движка CodeQL. Порой в результатах встречаются некоторые ноды taint-путей, которые не внушают доверия, и часто такие пути вовсе не существуют. Например:
Теперь вернемся к нашему проекту. Для начала создадим СodeQL базу данных из директории с кодом, вот так:
```
codeql database create my_db --language=cpp
```
Прикрепляем ее в VSCode в качестве основной базы и приступаем к поиску баг. В официальном репозитории CodeQL есть ряд [готовых запросов](https://github.com/github/codeql/tree/main/cpp/ql/src) для поиска некоторых типов уязвимостей. Попробуем воспользоваться одним из [таких](https://github.com/github/codeql/blob/bbd7e623418e41775c90cfbbe44ad25b3bf9c5e3/cpp/ql/src/experimental/Security/CWE/CWE-415/DoubleFree.ql) как раз для поиска ошибок типа double-free. Вот, что мы получим:
Как можно заметить, этот запрос не обнаружил double-delete, а также двойное освобождение через метод-обертку `wrapper`. Для новичков в CodeQL этот запрос может оказаться сложным и запутанным, поэтому попробуем создать наш собственный, поменьше и попроще, который будет обнаруживать конкретно double-delete в проекте.
Общий макет CodeQL-запросов обычно следующий:
```
import
import
from /\* ... variable declarations ... \*/
where /\* ... logical formulas ... \*/
select /\* ... expressions ... \*/
```
Дополним его объектами [FunctionCall](https://codeql.github.com/codeql-standard-libraries/cpp/semmle/code/cpp/exprs/Call.qll/type.Call%24FunctionCall.html) и предикатами:
* `getTarget()` — получает функцию этого вызова как отельный объект;
* `getAPredecessor()` — получает прямого предка данной ноды потока управления.
Теперь сформируем наш запрос:
```
import cpp
from FunctionCall fc, FunctionCall fc2
where
fc.getTarget().hasName("operator delete[]")
and fc2.getTarget().hasName("operator delete[]") and
fc != fc2 and fc.getAPredecessor*() = fc2
select fc, "Double-delete $@ and $@", fc2, "here", fc, "and here"
```
Результат нас обрадует — CodeQL найдет примитивный double-delete, как мы и хотели:
Отлично, а теперь попробуем применить taint tracking и найти столько double-free, сколько сможем. Воспользуемся `semmle.code.cpp.dataflow.TaintTracking` для создания собственной taint-конфигурации, а также `DataFlow::PathGraph` для корректного отображения найденных путей.
**taint.ql**
```
/**
* @name Double free
* @kind path-problem
* @id double-free
*/
import cpp
import semmle.code.cpp.dataflow.TaintTracking
import DataFlow::PathGraph
class Config extends TaintTracking::Configuration {
Config() {this = "Double free"}
override predicate isSource(DataFlow::Node source) {
exists(FunctionCall call |
source.asDefiningArgument() = call.getArgument(0)
and
call.getTarget().hasGlobalOrStdName("free")
)
}
override predicate isSink(DataFlow::Node sink) {
exists(FunctionCall call |
call.getTarget().hasGlobalOrStdName("free")
and
sink.asExpr() = call.getArgument(0)
)
}
}
from Config config, DataFlow::PathNode source, DataFlow::PathNode sink
where config.hasFlowPath(source, sink)
select sink, source, sink, "Memory is $@ and $@, causing a potential vulnerability.", source, "freed here", sink, "here"
```
Почти хорошо. Запрос успешно нашел вызов `free` в методе-обертке и обозначил путь требуемых данных (указателя на чанк) от источника к приемнику.
Однако CodeQL выдал один false-positive результат в кейсе с внутренним вызовом функции `reassignment(char *ptr)`, где поинтер снова будет содержать адрес того самого чанка, который распределитель кучи достанет из корзины. К сожалению, переопределение предиката `isSanitizer` taint-конфигурации никак не смогло на это повлиять, так как taint path не включил в себя вызов этой функции, а значит и фильтрация будет безуспешной.
Таким образом, CodeQL — неплохой инструмент статического анализа, где результат сильно зависит от качества запросов, которые мы создаем к базе. CodeQL оставляет довольно противоречивое впечатление, так как несмотря на свой потенциал (особенно для объектно-ориентированных языков программирования) он имеет множество недостатков. В статье исследователя Valtteri Rahkonen ["SAST Tool Comparison Using Secure C Coding Standard Examples"](https://blog.fraktal.fi/sast-tool-comparison-95df4a9647f2), где сравнивались ряд open-source и коммерческих SAST-инструментов, CodeQL показал один из самых слабых результатов. Однако не будем останавливаться на плохой ноте. CodeQL может открыть большие возможности для исследования кода, что доказывает растущее число CVE, найденных с его помощью.
### Weggli
[Weggli](https://github.com/googleprojectzero/weggli) — инструмент семантического поиска в кодовых базах на C/C++. Разработан исследователем Felix Wilhelm из Google Project Zero и опубликован осенью 2021 года с целью помочь ресечерам находить интересные места в больших кодовых базах. "Killer feature" данного инструмента — возможность исследовать C/C++ проекты без необходимости их сборки, в чем он очень похож на Semgrep.
На данный момент о Weggli не так много информации. Одна из немногих статей о Weggli от парочки бывалых пользователей CodeQL, ["Playing with Weggli"](https://dustri.org/b/playing-with-weggli.html), рассказывает о попытках исследователей разобраться в синтаксисе запросов Weggli и получить желаемые результаты. В следующем [github-репозитории](https://github.com/p4zuu/weggli-examples/tree/master/linux-kernel/double-free) содержится пример занятного Weggli-запроса для поиска double-free в ядре Linux. Мы тоже попробуем разобраться и создать свой запрос для поиска этой ошибки в нашем проекте. Но сперва отметим несколько особенностей инструмента.
**Преимущества:**
* Не требует сборки проекта
* Первоклассная поддержка C и C++
* Высокая скорость поиска
**Недостатки:**
* Отсутствие выделенной документации
* Мало примеров, статей от комьюнити и иных ресурсов, которые могли бы быть полезными для тех, кто пытается разобраться в работе инструмента
* Отсутствие межфайловой/межпроцедурной семантики
* Не умеет в Control Flow
Опишем конструкции Weggli, которыми воспользуемся для написания правила:
* `$func` — переменная, в данном случае содержащая имя функции
* `$ptr` — переменная, обозначающая указатель, который хотим проследить в рамках double-free
* `NOT` — отрицательный подзапрос, фильтрующий результаты по заданному условию
* `_` — любая AST-нода
Правило для поиска double-free в нашем проекте сделаем таким:
```
weggli --cpp -R '$func=free' '{ $func($ptr); NOT: $ptr = _; NOT: return; $func($ptr); }' ~/project
```
**Результат**
```
funcs.cpp:9
void double_free()
{
char *buf1;
buf1 = (char *) malloc(SIZE);
**free(buf1);**
**free(buf1);**
}
funcs.cpp:29
void df_by_pointer()
{
..
char *buf3;
buf1 = (char *) malloc(SIZE);
buf2 = (char *) malloc(SIZE);
free(buf1);
**free(buf2);**
buf3 = (char *) malloc(SIZE);
**free(buf2);**
free(buf3);
}
funcs.cpp:61
void conditional_dfree()
{
int condition = 1;
char *ptr;
ptr = (char *) malloc(SIZE);
if (condition)
**free(ptr);**
**free(ptr);**
free(ptr);
}
funcs.cpp:61
void conditional_dfree()
{
int condition = 1;
char *ptr;
ptr = (char *) malloc(SIZE);
if (condition)
free(ptr);
**free(ptr);**
**free(ptr);**
}
funcs.cpp:61
void conditional_dfree()
{
..
char *ptr;
ptr = (char *) malloc(SIZE);
if (condition)
**free(ptr);**
free(ptr);
**free(ptr);** // Это прям нечто!
}
funcs.cpp:99
void intrnl_reassignment()
{
char *ptr;
ptr = (char *) malloc(SIZE);
**free(ptr);**
reassignment(ptr);
**free(ptr);**
}
funcs.cpp:109
void bad_goto()
{
char *ptr;
ptr = (char *) malloc(SIZE);
**free(ptr);**
goto free_me;
free_me:
**free(ptr);**
return;
}
```
Weggli, как и ожидалось, не смог обработать внутренние вызовы, и поэтому пропустил double-free через вызов `wrapper`, выдал false-positive с переопределением указателя во внутреннем вызове `reassignment` и улыбнул на находке:
```
if (condition)
**free(ptr);** // first free
free(ptr);
**free(ptr);** // second free, это прям нечто!
```
Составим аналогичный запрос для поиска double-delete — и Weggli хорошо справится с ним, успешно найдет этот простой кейс:
```
weggli --cpp 'delete $a; NOT: $a = _; delete $a' ~/project
```
Weggli — молодой инструмент и пока его функциональность не столь широка, как у Semgrep или CodeQL, но это отличное начинание. Ждем от Феликса новых идей и улучшений!
### Joern
[Joern](https://github.com/joernio/joern) — инструмент командной строки для статического анализа исходного кода и байт-кода от [ShiftLeft](https://www.shiftleft.io/). Реализован на языке Scala, а анализ кода выполняется с использованием языка запросов CPGQL, предметно-ориентированного языка (также основан на Scala), разработанного специально для работы с CPG (code property graph). CPG как понятие в контексте Joern является основообразующим, это описано в научной работе самих разработчиков — ["Modeling and Discovering Vulnerabilities with Code Property Graphs"](https://www.sec.cs.tu-bs.de/pubs/2014-ieeesp.pdf). CPG представляет собой промежуточное представление кода, включает в себя AST проекта, Control Flow граф, информационные потоки и иные необходимые данные для дальнейшего анализа. Реализацию CPG можно найти в [github-репозитории ShiftLeft](https://github.com/ShiftLeftSecurity/codepropertygraph).
Одноименный [предок Joern](https://github.com/fabsx00/joern-old) со схожей концепцией анализа кода на основе CPG появился еще в далеком 2012 году и был представлен в рамках международной конференции ACSAC'12 (Annual Computer Security Applications Conference) исследователем [Fabian Yamaguchi](https://fabianyamaguchi.com/) и командой компьютерной безопасности Геттингенского университета. CPG прежней реализации хранился в графовой СУБД [Neo4J](https://neo4j.com/) (в новом Joern заменен на [OverflowDB](https://github.com/ShiftLeftSecurity/overflowdb)), а в качестве языка запросов выступал [Gremlin](https://tinkerpop.apache.org/gremlin.html). На своем веку Joern-old успел обжиться собственной [TrophyCase](http://web.archive.org/web/20180319074427/http://mlsec.org/joern/wallofbugs.shtml) из нескольких десятков CVE. Однако ряд концептуальных недостатков с каждым годом становился все более явным, поэтому разработчики решили переосмыслить текущую реализацию и создать тот Joern, который есть сейчас.
Одной из главных особенностей Joern является возможность осуществления taint-анализа без необходимости сборки проекта. Эта мысль также поднимается в [цикле статей](https://jaiverma.github.io/blog/joern-uboot) о Joern, где исследователь сравнивает его работу с CodeQL на примере уже упомянутого [CodeQL U-Boot challenge](https://securitylab.github.com/ctf/uboot/). Joern во многом не уступал в этом "версусе", и порой его запросы выглядели гораздо более компактными и эффективными. Посмотрим, насколько Joern хорош на деле. Но сперва отметим и другие **положительные стороны** Joern:
* Отличная [документация](https://docs.joern.io/home) как по работе с самим инструментом, так и к [языку запросов CPGQL](https://docs.joern.io/cpgql/reference-card)
* Не требует сборки проекта
* Имеет собственный [Discord-чат](https://discord.com/invite/vv4MH284Hc) для быстрой поддержки и обмена опытом
* [Поддерживаемые языки](https://docs.joern.io/home#supported-languages): C/C++, Javascript, Kotlin, Python, Ghidra(x86/x64), JVM bytecode, LLVM bitcode
* Поддержка taint-анализа
* В наличии примеры [запросов](https://queries.joern.io/) на CPGQL для разных языков, пусть и не в большом количестве
* На его основе сделан инструмент [Joern Scan](https://docs.joern.io/scan) для сканирования кода и поиска некоторых категорий уязвимостей
* Расширяемость функционала плагинами, [подробнее](https://docs.joern.io/extensions)
**Недостатки:**
* Требуется знания не только CPGQL, но и основ Scala, чтобы создавать более-менее эффективные запросы
* Ruleset, к сожалению, совсем не велик
* Не для крупных проектов, т.к. создание CPG может быть крайне долгим или завершиться ошибкой в таких случаях
* Ошибки межпроцедурного анализа, приводящие к ложным срабатываниям. К ним мы еще вернемся.
Теперь попробуем создать собственные запросы для поиска double-free и double-delete. Первой командой, которую запустим в интерактивной оболочке, является `importCode`, которая создаст новый каталог проекта и сохранит в нем двоичное представление CPG:
```
██╗ ██████╗ ███████╗██████╗ ███╗ ██╗
██║██╔═══██╗██╔════╝██╔══██╗████╗ ██║
██║██║ ██║█████╗ ██████╔╝██╔██╗ ██║
██ ██║██║ ██║██╔══╝ ██╔══██╗██║╚██╗██║
╚█████╔╝╚██████╔╝███████╗██║ ██║██║ ╚████║
╚════╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═══╝
Version: 1.1.1140
Type `help` or `browse(help)` to begin
joern> importCode(inputPath="путь_к_исходникам", projectName="имя_проекта")
res1: Cpg = Cpg (Graph [67082 nodes])
```
Объект `cpg` является корневым всего языка запросов, так что чаще всего обращаться придется именно к нему и его предикатам. Например, хотим получить все вызовы `free` в проекте:
```
cpg.call("free").l.map(
call => (
call.id,
call.method.name,
call.code,
call.location.lineNumber match {
case Some(n) => n.toString
case None => "n/a"
}
)
)
```
**Результат**
```
res3: List[(Long, String, String, String)] = List(
(24797L, "double_free", "free(buf1)", "13"),
(24799L, "double_free", "free(buf1)", "14"),
(24812L, "no_double_free", "free(ptr)", "22"),
(24820L, "no_double_free", "free(ptr)", "24"),
(24844L, "df_by_pointer", "free(buf1)", "37"),
(24846L, "df_by_pointer", "free(buf2)", "38"),
(24854L, "df_by_pointer", "free(buf2)", "41"),
(24856L, "df_by_pointer", "free(buf3)", "42"),
(24863L, "wrapper", "free(ptr)", "47"),
(24901L, "conditional_dfree", "free(ptr)", "67"),
(24903L, "conditional_dfree", "free(ptr)", "69"),
(24905L, "conditional_dfree", "free(ptr)", "70"),
(24918L, "free_null", "free(ptr)", "78"),
(24923L, "free_null", "free(ptr)", "80"),
(24966L, "intrnl_reassignment", "free(ptr)", "103"),
(24970L, "intrnl_reassignment", "free(ptr)", "105"),
(24983L, "bad_goto", "free(ptr)", "113"),
(24987L, "bad_goto", "free(ptr)", "117"),
(25005L, "good_goto", "free(ptr)", "127"),
(25011L, "good_goto", "free(ptr)", "131")
)
```
Обратите внимание на первый атрибут `id` — значение типа `Long`, которое точно идентифицирует каждый узел графа потока управления (`cfgNode` в синтаксисе CPGQL). Опробуем же taint-анализ для поиска double-free!
Для этого создадим следующий запрос:
```
joern> run.ossdataflow // начиная с Joern v1.1.299 не обязателен к объявлению
joern> def source = cpg.call("free").argument
joern> def sink = cpg.call("free").argument
joern> sink.reachableByFlows(source).filter(f => f.elements.size > 1).p
```
Здесь мы объявили две переменные — `source` и `sink`, которые содержат единственный аргумент `free` — указатель, который мы хотим проследить по пути "порчи". Этим займется вызов `reachableByFlows`, который возвращает пути для потоков данных от источника к приемнику. `filter` (filter step) позволит продолжить обход для всех узлов графа, которые соответствуют его условию. В данном случае условие уберет так называемые "петли" (поток от вызова `free` к самому себе). Таковы особенности Joern.
Выхлоп будет следующий:
**Спрятан под спойлер**
```
res10: List[String] = List(
"""____________________________________________________
| tracked | lineNumber| method | file |
|========================================================|
| free(ptr) | 113 | bad_goto | ~/sources/funcs.cpp |
| free(ptr) | 117 | bad_goto | ~/sources/funcs.cpp |
""",
"""_____________________________________________________________
| tracked | lineNumber| method | file |
|=================================================================|
| free(ptr) | 67 | conditional_dfree | ~/sources/funcs.cpp |
| free(ptr) | 69 | conditional_dfree | ~/sources/funcs.cpp |
| free(ptr) | 70 | conditional_dfree | ~/sources/funcs.cpp |
""",
"""_____________________________________________________________
| tracked | lineNumber| method | file |
|=================================================================|
| free(ptr) | 69 | conditional_dfree | ~/sources/funcs.cpp |
| free(ptr) | 70 | conditional_dfree | ~/sources/funcs.cpp |
""",
"""__________________________________________________________
| tracked | lineNumber| method | file |
|==============================================================|
| free(buf2) | 38 | df_by_pointer | ~/sources/funcs.cpp |
| free(buf2) | 41 | df_by_pointer | ~/sources/funcs.cpp |
""",
"""_____________________________________________________________________________
| tracked | lineNumber| method | file |
|=================================================================================|
| free(ptr) | 103 | intrnl_reassignment | ~/sources/funcs.cpp |
| reassignment(ptr) | 104 | intrnl_reassignment | ~/sources/funcs.cpp |
| reassignment(char *ptr) | 92 | reassignment | ~/sources/funcs.cpp |
| void | 92 | reassignment | ~/sources/funcs.cpp |
| reassignment(ptr) | 104 | intrnl_reassignment | ~/sources/funcs.cpp |
| free(ptr) | 105 | intrnl_reassignment | ~/sources/funcs.cpp |
""",
"""________________________________________________________
| tracked | lineNumber| method | file |
|============================================================|
| free(buf1) | 13 | double_free | ~/sources/funcs.cpp |
| free(buf1) | 14 | double_free | ~/sources/funcs.cpp |
""",
"""_____________________________________________________________
| tracked | lineNumber| method | file |
|=================================================================|
| free(ptr) | 67 | conditional_dfree | ~/sources/funcs.cpp |
| free(ptr) | 69 | conditional_dfree | ~/sources/funcs.cpp |
"""
)
```
К сожалению, результат taint-анализа содержит ряд ошибок. Несомненно, он смог обнаружить примитивные кейсы двойного освобождения, кейсы с if-блоком и goto, но не нашел случай с оберткой над `free` (вызовы `wrapper`), выдал ложноположительный результат с внутренним переназначением указателя (вызов `reassignment`). Исследуя, почему произошли такие ошибки, мы выяснили:
1) У Joern нет какой-либо кастомизации taint-конфигурации, кроме назначения непосредственного источника/приемника данных. В секции "Data-Flow Steps" документации не обнаружилось каких-либо примитивов, которыми можно было бы воспользоваться и, к примеру, ограничить пути с учетом собственных требований. Да, это прямой намек на CodeQL и его предикаты `isSanitizer` и `isBarrier`, которые позволяют настраивать анализ с заданными условиями. Это могло бы помочь отфильтровать часть ложноположительных путей, не связанных с уязвимостью.
2) Ложноотрицательный результат:
Joern не выдал результат с вызовом `free` в обертке, и было принято решение сделать еще один маленький taint-анализ от аргумента первого вызова `wrapper(buf1)` (funcs.cpp:56) к аргументу `free`:
```
joern> def source = cpg.call.id(28247).argument
joern> def sink = cpg.call("free").argument
joern> sink.reachableByFlows(source).p
```
Результат оказался странным:
```
"""_______________________________________________________________________
| tracked | lineNumber| method | file |
|=========================================================================|
| wrapper(buf1) | 56 | df_with_wrappers | ~/sources/funcs.cpp |
| wrapper(buf1) | 57 | df_with_wrappers | ~/sources/funcs.cpp |
| wrapper(char *ptr) | 45 | wrapper | ~/sources/funcs.cpp |
| free(ptr) | 47 | wrapper | ~/sources/funcs.cpp |
"""
```
То есть, Joern видит в контексте этой ситуации только один вызов `free`, а значит double-free здесь тоже не может существовать, что неверно.
3) Ложноположительный результат:
Внутреннее переназначение указателя (вызов `reassignment`) на пути между двумя вызовами `free` защищает от ошибки, но Joern так не посчитал. Исследуя проблему, оказалось, что мы не единственные, кто столкнулся с ней. Было обнаружено открытое [issue "Dataflow inconsistency related to reassignment and subcalls"](https://github.com/joernio/joern/issues/1009) в github-репозитории Joern, где рассматривается крайне схожая ситуация с внутренними вызовами и переназначениями. Будем надеяться, что эта ошибка будет исправлена разработчиками и улучшит качество taint-анализа.
Ложноположительные результаты также могут появляться по той причине, что Joern не имеет представления о том, по какой ветке пойдет поток исполнения, и знать исход условных выражений он не способен. Именно поэтому инструмент предложил все варианты двойных освобождений в вызове `conditional_dfree()`. Если бы мы имели такой кейс, как:
```
bool res = 1;
free(ptr);
if (res){
goto goodbye;
}
free(ptr); // недостижим
```
Joern бы отметил, что в одном случае уязвимость существует, а в другом нет, хотя по факту ответ однозначен. Уловка бы сработала, и такой пример оказался бы в результатах.
Несомненно, taint-анализ для поиска ошибок двойного освобождения является наиболее удобным и эффективным выбором, если таковой имеется. Но поскольку в данном случае он не отработал так, как хотелось бы, попробуем углубиться в CPGQL и создать более сложный запрос, не прибегая к taint-конструкциям Joern. В конце концов, у нас в руках сам CPG! Вручную опишем необходимые условия, в которых видим (или не видим) ошибку double-free в рамках нашего проекта. Чем больше ситуаций будет охватывать наше правило, тем качественнее будут результаты. Получилось оно следующим:
**Правило**
```
import scala.collection.mutable.Map
import scala.collection.mutable.ListBuffer
import scala.util.control.Breaks._
var result = new ListBuffer[Call]()
var preparedCalls = Map[String, Int]()
def do_job(call:Call, argIndex:Int, otherCalls:Map[Call, Int]): Unit = {
val localArgDeclCall = call.argument.argumentIndex(argIndex).isIdentifier.refsTo.id.head
val sameArgDeclCalls = otherCalls.filter(x =>
x._1.argument.argumentIndex(x._2).isIdentifier.refsTo.id.head == localArgDeclCall).toSet
if (sameArgDeclCalls.isEmpty){
return
}
for (suspectCall <- sameArgDeclCalls){
val assignList = suspectCall._1.postDominatedBy.assignment
.filter(_.id < call.id)
.filter(_.argument.isIdentifier.name.head.equals(call.argument(argIndex).code))
if (suspectCall._1.id < call.id && assignList.isEmpty){
val innerCalls = suspectCall._1.postDominatedBy.isCall.filter(_.id <= call.id).toSetMutable
if (innerCalls.contains(call)){
innerCalls -= call
if (innerCalls.isEmpty) {
result += call
return
}
else {
var argUsage = false
for (innerCall <- innerCalls) {
breakable {
var arg_idx = 0
for (arg <- innerCall.argument.isIdentifier) {
if (arg.refsTo.id.head.equals(localArgDeclCall)) {
arg_idx = arg.argumentIndex
}
}
if (arg_idx == 0){
break
}
val ptr_name = cpg.method(innerCall.name).parameter.index(arg_idx).name
val innerAssignments = cpg.method(innerCall.name).postDominatedBy.assignment.argument.isIdentifier.name.toList
if (innerAssignments.contains(ptr_name.head)){
argUsage = true
return
}
}
}
if (!argUsage) {
result += call
return
}
}
}
}
}
}
preparedCalls += ("free" -> 1)
for (call <- cpg.call("free")){
val arg_name = call.argument(1).code
val localAssignments = call.method.postDominatedBy.assignment
.filter(x => arg_name.contains(x.argument.isIdentifier.code))
if (localAssignments.isEmpty){
for (arg <- call.method.parameter.toList){
if (arg_name.contains(arg.name)){
preparedCalls += (call.method.name -> arg.index)
}
}
}
}
for ((methodName, argIndex) <- preparedCalls){
for (call <- cpg.call(methodName)){
val otherCalls = Map[Call, Int]()
for ((name, index) <- preparedCalls){
for (chosenOne <- cpg.call(name).filter(_.id != call.id).toList){
otherCalls += (chosenOne -> index)
}
}
do_job(call, argIndex, otherCalls)
}
}
result.l.map(
call => (
call.method.name,
call.code,
call.location.lineNumber match {
case Some(n) => n.toString
case None => "n/a"
}
)
)
```
В сравнении с предыдущими объем этого правила впечатляет. Оно не идеально, поскольку не обрабатывает многие другие кейсы, в которых ошибка двойного освобождения допустима, однако для нашего проекта является достаточным. Правило собирает все возможные вызовы `free` и чистые обертки над ними, которые удовлетворяют условию, что не содержат переназначений аргумента-указателя на всем протяжении исполнения. Далее для каждого подобного вызова делается ряд проверок. Исследуются, есть ли такие вызовы, которые имеют один и тот же аргумент (в соответствии с его объявлением) в методе. Затем проверяется, есть ли между этими вызовами переназначения указателя, в том числе и во внутренних вызовах между ними. Само переназначение, кстати, в CPG выступает как вызов `.assignment`:
```
res20: List[operatorextension.OpNodes.Assignment] = List(
Call(
id -> 28159L,
argumentIndex -> -1,
argumentName -> None,
code -> "buf1 = (char *) malloc(SIZE)",
columnNumber -> Some(value = 2),
dispatchType -> "STATIC_DISPATCH",
dynamicTypeHintFullName -> ArraySeq(),
lineNumber -> Some(value = 12),
methodFullName -> ".assignment",
name -> ".assignment",
order -> 2,
signature -> "",
typeFullName -> ""
)
)
```
Удовлетворяющие всем условиям вызовы собираются в лист и выводятся. Результат для нашего проекта будет таким:
```
res102: List[(String, String, String)] = List(
("df_with_wrappers", "wrapper(buf1)", "57"),
("double_free", "free(buf1)", "14"),
("df_by_pointer", "free(buf2)", "41"),
("conditional_dfree", "free(ptr)", "69"),
("conditional_dfree", "free(ptr)", "70"),
("bad_goto", "free(ptr)", "117")
)
```
Очень неплохо! Найдены все ошибки, ложноположительных кейсов нет. Ручная работа с CPG оказалась не напрасной и дала свои плоды.
Для поиска примитивного double-delete можно также воспользоваться `reachableByFlows`, но в качестве названия метода указать `.delete`. Данный кейс успешно найдется:
```
"""______________________________________________________________
| tracked | lineNumber| method | file |
|===============================================================|
| delete [] x | 88 | double_delete | ~/sources/funcs.cpp |
| delete [] x | 89 | double_delete | ~/sources/funcs.cpp |
"""
```
Вот такие результаты! Можно сказать, что Joern — хороший инструмент статического анализа для небольших/средних по объему проектов, с интересным бэкграундом, задумкой, не без изъянов, но с крепкой научной основой. Joern позволил реализовать правила, в которых, ручками исследуя CPG/CFG, можно было учесть очень важные детали, без которых точность поиска была бы значительно ниже. Для инструмента, не требующего сборки проекта, получить подобные результаты — это очень здорово.
### MATE
[MATE](https://github.com/GaloisInc/MATE) представляет собой целый набор инструментов статического анализа кода для C/C++ проектов. В этом обзоре данный toolset является темной лошадкой, разработан командой [Galois](https://galois.com/) совместно с DARPA. Релиз состоялся совсем недавно, в конце лета этого года, и инструментарий еще не успел обрасти многочисленными примерами использования, набором правил, воркшопами и каким-либо фидбеком. Однако потенциал MATE достаточно велик, таким широким кругом возможностей может похвастаться не каждый инструмент. Стоит отметить, что на данный момент MATE является программным обеспечением исследовательского уровня, разработчики проводят большую работу, чтобы сделать его более надежным.
Как и Joern, MATE в своем анализе формирует граф свойств кода (CPG). Для создания запросов к CPG MATE предоставляет предметно-ориентированный язык на основе Python и [SQLAlchemy](https://www.sqlalchemy.org/). Согласно [документации MATE](https://galoisinc.github.io/MATE/quickstart.html), CPG-проекта формируется из следующих позиций:
* абстрактное синтаксическое дерево (AST)
* граф вызовов (CG)
* граф потока управления (CFG)
* межпроцедурный граф потока управления (ICFG)
* межпроцедурный граф потока данных (DFG)
* граф зависимости управления (CDG)
* points-to graph (PTG)
* сопоставления исходного кода с LLVM
* memory layout
* отладочная информация DWARF
Также в документации можно ознакомиться с [таблицей сравнения](https://galoisinc.github.io/MATE/overview.html#comparison-to-related-tools) MATE с другими SAST-инструментами, большинство из которых уже побывали в обзоре, с [ограничениями MATE](https://galoisinc.github.io/MATE/overview.html#limitations), которые важно учитывать при анализе. Самым важным из них, пожалуй, является обязательное требование предоставлять собираемые исходники, поскольку MATE анализирует LLVM-байткод, и для этого требуется компиляция с clang.
Теперь уделим внимание некоторым составным компонентам MATE:
* [mate-cli](https://galoisinc.github.io/MATE/cli-overview.html)
Утилита командной строки для взаимодействия с [MATE REST API](https://galoisinc.github.io/MATE/using-rest-api.html). Точка старта при анализе проекта. Например, компиляция из исходников и создание проекта в среде MATE происходит следующим образом:
```
mate-cli oneshot -p ~/sources/
```
Далее заходим в веб-интерфейс (<http://localhost:3000/builds>) и видим наш проект:
* [Детекторы POIs](https://galoisinc.github.io/MATE/pois.html) (Points of Interest)
Проводят автоматический анализ проекта. Детекторы нацелены на поиск конкретных типов уязвимостей, таких как command injection, path traversal, использование неинициализированной памяти, раскрытие указателей и других. В рамках поиска уязвимостей в нашем игрушечном проекте каких-либо ценных точек интереса детекторы MATE не обнаружили, что видно на скриншоте.
* [Flowfinder](https://galoisinc.github.io/MATE/tutorial-flowfinder.html)
Инструмент Flowfinder визуализирует CPG проекта и позволяет взаимодействовать с ним. Играет вспомогательную функцию как при анализе результатов POI, так и во время создания запросов. Предназначен для обеспечения межпроцедурного анализа потоков данных программы на высоком уровне абстракции.
* [Manticore с недостаточными ограничениями](https://galoisinc.github.io/MATE/under-constrained-manticore.html)
Предоставляет из себя веб-интерфейс для изучения приложений с помощью механизма символьного исполнения [Manticore](https://github.com/trailofbits/manticore) в режиме с недостаточными ограничениями, что означает, что символьному исполнению могут подвергаться отдельные функции. Это очень крутой функционал, поскольку он позволяет оценить поведение функций с заданными аргументами обособленно от всего приложения/системы. В нашем случае встроенный Manticore будет не очень полезен по той причине, что все исследуемые методы в проекте не зависят от подаваемых в аргументы значений. В остальных случаях этот функционал может очень пригодиться. В разделе ["Specifying additional symbolic constraints"](https://galoisinc.github.io/MATE/under-constrained-manticore.html#specifying-additional-symbolic-constraints) подробно описаны некоторые конструкции для создания собственных ограничений.
* [UsageFinder](https://galoisinc.github.io/MATE/usagefinder.html)
UsageFinder — автономное приложение в составе Jupyter Notebook для поиска уязвимостей, возникающих в результате неправильного использования внутренних или внешних API. Результатом его работы является ряд визуализаций тех методов, которые были выбраны для подробного анализа. Например, UsageFinder построит следующую таблицу вызовов для метода `df_by_pointer()`, в которой видны два вызова `free` с одним и тем же аргументом (зеленая ячейка):
Также инструмент способен создавать граф условий между вышеперечисленными в таблице вызовами. Например, таким он будет для метода `conditional_dfree()`:
* [Jupyter Notebook](https://galoisinc.github.io/MATE/using-notebooks.html?highlight=jupyter%20notebook)
Интерактивный блокнот, интегрированный в среду MATE, позволяет создавать кастомные запросы к CPG проекта на уже упомянутом предметно-ориентированном языке.
Здесь мы и остановимся. С учетом [документации по API](https://galoisinc.github.io/MATE/architecture.html#query-desc) создадим свой запрос для поиска примитивного кейса с double-delete. Исполним в блокноте такой код:
```
delete_calls = session.query(cpg.Function).filter_by(name="_ZdaPv").one()
for call in delete_calls.callsites:
filtered_calls = delete_calls.callsites.copy()
filtered_calls.remove(call)
path = (
db.PathBuilder(cfl.ForwardCFGPath)
.starting_at(lambda Node: Node.uuid == call.uuid)
.stopping_at(lambda Node: Node.uuid.in_([c.uuid for c in filtered_calls]))
.limited_to(2000)
.build(cpg)
)
flow = (
session.query(path)
.join(cpg.Instruction, cpg.Instruction.uuid == path.target)
.with_entities(cpg.Instruction)
)
visualize_ctxt(cpg, flow, "double-delete")
```
Результат:
```
funcs.cpp:89:5:double_delete()
==============================
88: delete [] x;
double-delete --> 89: delete [] x;
90: }
```
В запросе мы использовали конструктор `PathBuilder`, который используется для задания необходимых условий для поиска желаемого пути в CPG-графе. Например, при помощи оператора `starting_at` можно задать условие, где должен начинаться путь. Аналогичный оператор `stopping_at` служит для указания, на каких узлах должны заканчиваться пути графа. Возможно странным может показаться название функции `_ZdaPv` — оно вовсе не похоже на `operator delete[]`. На этот счет вспоминаем, что MATE работает с LLVM IR, заглядываем в FlowFinder и убеждаемся, что вызов оператора действительно соответствует `:llvm-link:@\_ZdaPv`.
Попробуем усложнить наш запрос, добавив ряд проверок и дополнений, чтобы найти все ошибки double-free в нашем мини-проекте. Для этого напишем код на python, следуя схожей логике, что и при создания правила в Joern. То есть, сперва соберем обертки над `free` без внутренних переназначений указателя. Оценить это нам помогут узлы `STORE/LOAD` графа. Далее для каждого вызова `free` или обертки над ним отфильтруем такие, которые имеют один и тот же аргумент, убедимся, что между ними не было переназначений, в том числе и во внутренних вызовах. Правило получилось также объемным, поэтому было решено скрыть его под спойлером.
**Правило для MATE**
```
class extCall:
def __init__(self, call, arg_idx):
self.call = call
self.arg_idx = arg_idx
def collectWrappers():
for call in frees.callsites:
operations = call.argument0.operand0.used_by
operations.pop(0)
for op in operations:
if op.opcode.name == "STORE":
break;
index = 0
for arg in call.parent_block.parent_function.arguments:
if call.argument0.operand0.variable == arg:
for parent in call.parent_block.parent_function.callsites:
funcName = call.parent_block.parent_function.name
if funcName not in callNames:
callNames.append(funcName)
if extCall(parent, index) not in allCalls:
allCalls.append(extCall(parent, index))
index+= 1
session.rollback()
with session.no_autoflush:
allCalls = []
callNames = []
callNames.append("free")
frees = session.query(cpg.Function).filter_by(name="free").one()
for callsite in frees.callsites:
allCalls.append(extCall(callsite, 0))
collectWrappers()
for extObject in allCalls:
call = extObject.call
arg_idx = extObject.arg_idx
argumentObj = getattr(call, "argument" + str(arg_idx))
call_list = [c.call for c in allCalls]
call_list.remove(call)
filtered_list = [c for c in call_list
if getattr(c, "argument" + str(arg_idx)).operand0.variable == argumentObj.operand0.variable]
if len(filtered_list) == 0:
continue;
for otherCall in filtered_list:
for operation in argumentObj.operand0.used_by:
opUuid = int(operation.uuid)
if opUuid > int(call.uuid) and opUuid < int(otherCall.uuid):
if operation.opcode.name == "STORE":
filtered_list.remove(otherCall)
break;
if operation.opcode.name == "LOAD" \
and operation.used_by[0].callee_operand.name not in callNames:
call_uid = int(operation.used_by[0].uuid)
load_uid = int(operation.uuid)
arg_num = len(operation.used_by[0].callee_operand.arguments)
idx = arg_num - (call_uid - load_uid)
arg = operation.used_by[0].callee_operand.arguments[idx]
internal_use = arg.used_by[0].operand1.used_by
internal_use.pop(0)
for op in internal_use:
if op.opcode.name == "STORE":
filtered_list.remove(otherCall)
break; break; continue;
session.rollback()
path = (
db.PathBuilder(cfl.ForwardCFGPath)
.starting_at(lambda Node: Node.uuid == call.uuid)
.stopping_at(lambda Node: Node.uuid.in_([cs.uuid for cs in filtered_list]))
.limited_to(2000)
.build(cpg)
)
flow = (
session.query(path)
.join(cpg.Instruction, cpg.Instruction.uuid == path.target)
.with_entities(cpg.Instruction)
)
visualize_ctxt(cpg, flow, "double-free here")
```
**А вот какой результат оно выдаст**
```
funcs.cpp:14:2:double_free()
============================
13: free(buf1);
double-free here --> 14: free(buf1);
15: }
funcs.cpp:41:2:df_by_pointer()
==============================
40: buf3 = (char *) malloc(SIZE);
double-free here --> 41: free(buf2);
42: free(buf3);
funcs.cpp:69:2:conditional_dfree()
==================================
68: }
double-free here --> 69: free(ptr);
70: free(ptr);
funcs.cpp:70:2:conditional_dfree()
==================================
69: free(ptr);
double-free here --> 70: free(ptr);
71: }
funcs.cpp:70:2:conditional_dfree()
==================================
69: free(ptr);
double-free here --> 70: free(ptr);
71: }
funcs.cpp:117:5:bad_goto()
==========================
116: free_me:
double-free here --> 117: free(ptr);
118: return;
funcs.cpp:57:2:df_with_wrappers()
=================================
56: wrapper(buf1);
double-free here --> 57: wrapper(buf1);
58: }
```
MATE справился со всеми задачами, не выдав ни одного ложноположительного кейса. Отличный результат! В очередной раз убеждаемся, что работать ручками напрямую с CPG очень интересно, и, получается, довольно результативно. MATE предоставил нам много возможностей для качественного анализа и однозначно заслуживает популяризации.
### Итоги
В статье мы подробно описали ряд open-source инструментов статического анализа кода, оценив их работу путем создания собственных правил для поиска уязвимостей двойного освобождения. Результаты оказались довольно неплохими, а потенциал каждого из инструментов позволяет расширять и улучшать эти правила, чтобы они охватывали все больше проблемных участков в коде.
Мы не будем отдавать преференций конкретному участнику обзора, так как инструменты имеют ряд своих особенностей, преимуществ и ограничений, которые в совокупности для одних специалистов будут более, чем приемлемы, а для других могут показаться недостаточными/неподходящими. Надеемся, что этот обзор оказался полезным, и со временем к SAST будет все меньше скепсиса.
И напоследок **опрос мнений!** У нас в Digital Security SAST является неотъемлемой частью [гибридного подхода в услугах по поиску уязвимостей](https://dsec.ru/security-audit/issledovanie-programmnogo-obespecheniya/audit-ishodnogo-koda-po/). | https://habr.com/ru/post/702652/ | null | ru | null |
# Погружаемся в 3D с помощью Marmalade SDK
Приветствую, братья по цеху, а также просто интересующиеся мобильными платформами и 3D-графикой читатели. В [предыдущем посте](http://habrahabr.ru/blogs/development/120684/) (а также в майском номере журнала «Хакер») я уже писал о том как начать работать с AirplaySDK ([с некоторых пор](http://habrahabr.ru/blogs/mobiledev/122009/) он теперь называется Marmalade) — инструментарием, позволяющим создавать мобильное приложение на C++ один раз и впоследствии компилировать его на множество платформ: iOS, Android, Windows Mobile, Bada, Symbian и т. д. HelloWorld-приложение — это уже что-то, но останавливаться на достигнутом мы с вами не любим, а потому в этой статье речь пойдёт уже о создании небольшого 3D-приложения. Описываемый SDK имеет добрую документацию, а потому я ограничусь лишь небольшим примером создания 3D-модели, её загрузки в наше мобильное приложение и смены ракурса камеры для просмотра сцены. Ну что же, приступим?
#### Подготовка к работе
Итак, для начала создадим в Maya обычную коробку и закрасим её в синий цвет.
С вашего позволения я не буду перегружать статью мануалом по созданию коробок в Maya, так как это не основная тема нашего сегодняшнего разговора, да и я далеко не специалист по работе в Maya.
Итак, коробка создана. Теперь нам следует установить плагин для экспорта модели в специальный формат для Marmalade SDK. Для этого нужно выполнить следующие операции копирования файлов:
/Tools/Exporters/Maya/ASMaya212Exporter.mll -> /bin/plug-ins
/Tools/Exporters/Maya/ASExpUI.dll -> /bin/plug-ins
/Tools/Exporters/Maya/exporter.txt -> /bin/plug-ins
/Tools/Exporters/Maya/metabase.txt -> /bin/plug-ins
/s3e/bin/libeay32.dll -> /bin
где — путь к папке с установленным SDK, — папка установки Maya 2012. Прошу заметить что для разных версий Maya процесс установки разный. Подробнее об этом читайте в [документации](http://www.madewithmarmalade.com/devnet/docs#/tools/arttoolsinstallation/installationmaya.html) (а так же обратите внимания на наличие инструкции по установке не только для Maya, но и для 3dsMax).
Теперь открываем Maya и в меню *Windows > Settings/Preferences > Plug-in Manager* устанавливаем галочки *loaded* и *auto load* напротив *ASMaya212Exporter.mll*.
Плагин установлен. Открываем наш проект с созданной коробкой и в консоли MEL вводим команду *ASMayaExporter*.
#### Экспорт модели
По команде *ASMayaExporter* у Вас появится окно экспорта модели.
Для начала натравите параметр *Project Data Directory* на директорию *data* Вашего проекта. В [прошлом посте](http://habrahabr.ru/blogs/development/120684/) мы разбирали что это за директория и с чем её едят. В неё будет сохраняться наша 3D-модель. Так же обязательным является поле *Asset name*, где вы должны указать имя своей модели. Давайте назовём её *FirstBox*, так будет удобнее.
Теперь о необязательных, но не менее важный параметрах. Слова *geometry*, *skeleton*, *animation* говорят сами за себя, а вот параметр *oneGeo* я уже опробовал на своей шкуре. Если Ваша модель будет состоять из нескольких составных частей — обязательно отметьте это поле, чтобы получить единый GEO-файл для Вашей модели, а не десятки для каждого из примитивов модели.
Теперь нажимаем кнопку *Export* и наша модель появляется в директории *data*.
#### Пишем код
Опять же, в своей прошлой статье я писал о том как создать проект для работы с SDK. Поэтому описывать весь процесс по-новой не буду.
Для начала приведу исходник единственного файла с главной функцией *main()*:
```
#include "IwGx.h"
#include "IwGraphics.h"
#include "IwResManager.h"
int main()
{
IwGxInit();
IwGraphicsInit();
IwGetResManager()->LoadGroup("FirstBox.group");
CIwModel* pModel = (CIwModel*)IwGetResManager()->GetResNamed("FirstBox", "CIwModel");
IwGxSetLightType(1, IW_GX_LIGHT_DIFFUSE);
CIwSVec3 dd(0xFF, 0xFF, 0xFF);
IwGxSetLightDirn(1, ⅆ);
IwGxSetPerspMul(0xAF);
while( !s3eDeviceCheckQuitRequest() )
{
IwGxClear( IW_GX_COLOUR_BUFFER_F | IW_GX_DEPTH_BUFFER_F );
IwGxLightingOn();
CIwMat view = CIwMat::g_Identity;
view.t.z = -80;
view.t.y = 80;
view.t.x = -60;
view.LookAt(view.GetTrans(), CIwVec3(0, 0, 0), -CIwVec3::g_AxisY);
IwGxSetViewMatrix(&view);
CIwMat modelMatrix = CIwMat::g_Identity;
IwGxSetModelMatrix(&modelMatrix);
pModel->Render();
IwGxFlush();
IwGxSwapBuffers();
s3eDeviceYield(0);
}
IwGraphicsTerminate();
IwGxTerminate();
return 0;
}
```
Код весьма прост даже для неискушённого программиста. Но некоторые моменты я поясню.
После экспорта модели в папке *data* появится файл *FirstBox.group*. Как раз его мы и загружаем в строке:
```
IwGetResManager()->LoadGroup("FirstBox.group");
```
После загрузки файла ресурсов загружаем непосредственно модель, созданную в Maya:
```
CIwModel* pModel = (CIwModel*)IwGetResManager()->GetResNamed("FirstBox", "CIwModel");
```
Так же следует обратить особое внимание на функцию *IwGxSetPerspMul(...)*. Это своего рода установка степени эффекта «рыбьего глаза». Если оставить этот параметр по умолчанию, то ваши сцены по краям экрана будут создавать впечатление просмотра через ~~дырку унитаза~~ донышко от бутылки.
Объект *view* представляет собой взгляд на сцену. Его поле *t* с параметрами *x*, *y* и *z* задаёт положение камеры в пространстве. Метод LookAt определяет направление взгляда: первый параметр — установленное в предыдущих трёх строках положение (from), второй — точка в пространстве, на которую нужно направить взгляд (to), и третий параметр — это направление вверх (т.е. если бы мы, например, установили *CIwVec3::g\_AxisY* вместо *-CIwVec3::g\_AxisY*, то смотрели бы на сцены «вверх ногами»).
*modelMatrix* задаёт матрицу преобразования модели. Выкинув из головы столь занудный термин я объясню проще: с помощью этого объекта мы задаём такие параметры, как поворот модели и положение в пространстве.
Ну и, конечно же, стоит выложить скриншот полученной сцены:
#### Заключение
Конечно, я не ставил целью в рамках данной статьи рассказать Вам обо всех возможностях работы с 3D в Marmalade SDK. Сцена весьма примитивна, но всё остальное Вы сможете почерпнуть либо из документации к инструментарию, либо, если читатели проявят интерес к теме, я буду писать на эту тему побольше статей. Так что надеюсь на ваши отзывы и на то что появятся причины написать продолжение к моим статьям.
**UPD.** С некоторых пор Airplay SDK переименован в Marmalade SDK. | https://habr.com/ru/post/122891/ | null | ru | null |
# [Перевод] Построение документов Latex с помощью Waf
Это исправленный и дополненный [перевод статьи](http://jnwhiteh.net/posts/2010/09/building-latex-documents-with-waf.html) о многофункциональной системе сборки Waf.
С самого начала использования сервиса [Dropbox](https://www.dropbox.com/) для хранения моих научных исследований и проектов я стал искать решение, которое позволит мне строить документы LaTeX без засорения каталога с документом. В обычных условиях я просто игнорирую такие файлы, но под Dropbox, каждый раз после построения документа файлы начинают синхронизироваться с сервером. Так как в Dropbox нет возможности указать файлы для игнорирования (если кто-то из компании читает это сообщение, пожалуйста, сделайте файл .dropboxignore), то я начал искать другое решение.
#### Темные времена: Makefile
В начале я использовал Makefile с последовательностью команд, которая делала копию каталога с проектом, переходила во временный каталог, а после чего выполняла требуемые команды.
> `PROJECTNAME := thesisIntro
>
>
> TMPDIR := /tmp/latexBuild.$(PROJECTNAME)/
>
>
>
>
>
> view: pdf
>
>
> -cd $(TMPDIR) && open -a Preview introduction.pdf
>
>
>
>
>
> pdf: setup
>
>
> -cd $(TMPDIR) && pdflatex introduction
>
>
>
>
>
> setup:
>
>
> -rm -fr $(TMPDIR)
>
>
> -mkdir $(TMPDIR)
>
>
> -cp -R \* $(TMPDIR)
>
>
>
>
>
> clean:
>
>
> -rm -fr $(TMPDIR)`
Хотя такое решение и работало, но оно не позволяло делать что-нибудь нетривиальное. Я мог вместо перемещения проекта во временный каталог использовать один из больших Makefile для Latex, выполняющих более сложные задачи, такие как автоматическое определение зависимостей и т.п. Однако совмещение временного каталога для сборки с нетривиальным make-фалом является весьма непростой задачей.
#### Новая альтернатива: Waf
Несколько месяцев назад я увидел [сообщение в блоге](http://alan.lamielle.net/2009/09/29/using-waf-to-build-latex-documents) Alan LaMielle, в котором он рассказывал об опыте использования системы сборки [waf](http://code.google.com/p/waf/). Waf написан на Python и позицируется как билдовая система с поддержкой настоящего языка программирования и являющаяся мощным инструментом, что на мой взгляд полностью соответствует действительности. Waf распространяется как одиночный python-скрипт, который при первом запуске распаковывает библиотеку в скрытый каталог и начинает работу. Он поставляется с поддержкой нескольких языков программирования, включая Go, Python, LaTeX и даже старого доброго C. Скрипты описанные далее должны без проблем работать с waf, начиная с версии 1.6, который включает все требуемые возможности.
Настройка *waf* заключается в написании python-скрипта с именем *wscript*, который и помещается в каталог с вашим проектом. Файл содержит детали, касающиеся сборки вашего проекта. Для документа LaTeX, который я сейчас пишу, я использую *wscript* со следующим содержимым:
> `#! /usr/bin/env python
>
>
>
>
>
> top = '.'
>
>
> out = '/tmp/wafbuild-dphilconf'
>
>
>
>
>
> def configure(conf):
>
>
> conf.check\_tool('tex')
>
>
> conf.find\_program('dot', var="DOT")
>
>
> if not conf.env.PDFLATEX:
>
>
> conf.fatal('could not find the program pdflatex')
>
>
>
>
>
> def view_pdf(bld):
>
>
> bld.exec\_command("open -a Preview \"{0}/dphilconf2010.pdf\"".format(out))
>
>
>
>
>
> def build(bld):
>
>
> # Создаем правило, которое преобразует любой .dot-файл в pdf
>
>
> for x in bld.path.ant\_glob('\*.dot'):
>
>
> tg = bld(rule='${DOT} -Tpdf -o${TGT[0].get\_bld().abspath()} ${SRC[0].abspath()}', source=x, target=x.change\_ext('.pdf'))
>
>
>
>
>
> bld.add\_group()
>
>
>
>
>
> obj = bld(
>
>
> features = 'tex',
>
>
> type = 'pdflatex',
>
>
> source = 'dphilconf2010.tex',
>
>
> )
>
>
>
>
>
> if bld.options.view:
>
>
> bld.add\_post\_fun(view_pdf)
>
>
>
>
>
> def options(opt):
>
>
> opt.tool\_options('tex')
>
>
>
>
>
> # Добавляем опцию командной строки
>
>
> opt.add\_option('--view', action='store\_true', default=False, help='View the document')`
#### Описание: waf configure
Перед тем как начать строить документ в первый раз, я запускаю
> ````
>
> python waf configure
>
> ````
чтобы установить каталог для сборки. Если мне захочется посмотреть результирующий PDF, то я просто добавляю опцию *--view*.
Типичный файл *wscript* содержит функцию конфигурации *configure*, которая вызывается когда пользователь выполняет *waf configure*. В нашем функции мы убеждаемся, что присутствуют инструменты для работы с tex (за это отвечает строчка *conf.check\_tool('tex')*) и утилита pdflatex. Кроме того, для сборки нам требуется утилита командной строки dot, существование которой мы также проверяем. Вот пример типичного вывода операции *waf configure*:
> ````
>
> Setting top to : /Users/jnwhiteh/Dropbox/Academic/DPhilConf2010
> Setting out to : /tmp/wafbuild-dphilconf
> Checking for program tex : /usr/texbin/tex
> Checking for program latex : /usr/texbin/latex
> Checking for program pdflatex : /usr/texbin/pdflatex
> Checking for program bibtex : /usr/texbin/bibtex
> Checking for program dvips : /usr/texbin/dvips
> Checking for program dvipdf : not found
> Checking for program ps2pdf : not found
> Checking for program makeindex : /usr/texbin/makeindex
> Checking for program pdf2ps : not found
> Checking for program dot : /usr/local/bin/dot
> 'configure' finished successfully (0.088s)
>
> ````
Как вы видите скрипт конфигурации нашел все необходимые программы и произвел настройку системы сборки.
#### Описание: waf build
Функция сборки достаточно прямолинейна и понятна: сначала мы итерируемся по всем .dot-файлам в каталоге, добавляя правило сборки для каждого из них. Данное правило создает маппинг из .dot-файла в .pdf-файл и везде, где эти .pdf-файлы включаются в оригинальный LaTeX-документ билдовая система добавляет зависимость. В результате, при изменении исходного .dot-файла автоматически будут перестроены .pdf-файлы для этого изображения и главного документа.
Вызов *bld.add\_group()* говорит о том, что элементы первой группы должны быть построены до элементов второй. Вторая группа содержит правила сборки, использующие программы из пакета Latex. Определяется инструмент для сборки (pdflatex) и имя исходного документа.
Последний штрих процесса построения — проверка опции view. Если данная опция присутствует, то мы указываем системе, что после сборки необходимо вызвать пользовательскую функцию *view\_pdf*. Данная функция просто запускает системную команду и открывает результирующий PDF-файл.
Опция view определяется внутри функции опций (*options*) и задается пользователем с помощью аргумента коммандной строки *--view*.
#### Собираем все вместе
Если вы захотите использовать приведенный выше *wscript*, то вам необходимо поменять в нем имя исходного документа. Далее вы должны выполнить *waf configure*, а после *waf build*, чтобы построить документ. Ваш документ, возможно, будет проще, поэтому вы можете ознакомится с примером соответствующего [wscript для LaTeX](http://code.google.com/p/waf/source/browse/trunk/demos/tex/wscript) из репозитория waf.
Преимущество построения документа с помощью Waf в том, что автоматически отслеживаются зависимости оригинального документа (система проводит сканирование исходных tex-файлов), поэтому любые изменения в файлах от которых зависит документ (включая файлы с графикой) вызовут перестройку финального pdf.
Ссылки:
* [Домашняя страница проекта Waf](http://code.google.com/p/waf/)
* [Ultimate LaTeX buildfile](http://www.acoustics.hut.fi/u/mairas/UltimateLatexMakefile/)
* [LaTeX makefile](http://code.google.com/p/latex-makefile/) | https://habr.com/ru/post/111623/ | null | ru | null |
# Выполнение SQL запросов в DB Oracle в Sublime Text 2
Надеюсь всем хорошо знаком популярный редактор Sublime Text 2. Хочу поделиться опытом, как я смог облегчить себе жизнь, написав плагин для быстрого вызова запросов в BD Oracle прямо из редактора, просто выделив запрос и нажав комбинацию.
Любимый нами за быстроту, легкость и кросс-платформенность Sublime Text богат огромным количеством расширений, т. н. пакетов и плагинов на любой вкус и цвет. Но плагина для вызова SQL запросов я не нашел (если я не прав, то буду рад если поделитесь). Ну чтож, нету — не беда, напишем свой.
Почитав [документацию](http://www.sublimetext.com/docs/2/api_reference.html) и посмотрев пару [примеров](http://www.sublimetext.com/docs/plugin-examples) приступим.
Плагин будет работать очень просто: выделил запрос, нажал комбинацию и в новом окне появится результат.
Первым делом создаем новый плагин Tools -> New plugin
```
import sublime, sublime_plugin
class ExampleCommand(sublime_plugin.TextCommand):
def run(self, edit):
self.view.insert(edit, 0, "Hello, World!")
```
Сразу сохраняем его под именем под именем Oquery.py, но Sublime предлжит нам его сохранить в папке User, но мы сохраним его на уровень выше в папку Packages в собственной для него папке Oquery.
Для общения с базой нам нужен класс [cx\_Oracle](http://cx-oracle.sourceforge.net/). Скачиваем и возвращаемся в нашу папку OQuery и создаем в ней папку lib, в которой мы будем хранить необходимые библиотеки. В ней мы сохраним скачаный архив в папке cx\_Oracle.
Я хочу чтобы ответ запроса был предоставлен в виде симпатичных таблиц, и для этого уже есть подходящий для нас [плагин](https://code.google.com/p/prettytable/). Проделываем все то же самое: скачиваем, распаковываем и переименовываем папку в prettytable.
Для хранения настроек базы нам необходим конфигурационный файл Oquery.sublime-settigs. Создаем его и сохраняем в корневой папке нашего плагина с содержанием (пример):
```
{
"host" : "localhost",
"port" : 1521,
"dbname" : "demoDB",
"username" : "user1",
"password" : "pass"
}
```
Теперь у нас все есть приступаем к написанию самого плагина.
В верху файла объявляем кодировку и импортируем нужные нам модули, в том числе и сам коннектор к базе и библиотеку вывода табличек
```
# coding=utf-8
import sys
import os
sys.path.append(os.path.dirname(sys.executable))
sys.path.append(os.path.join(os.path.dirname(__file__), "lib","cx_Oracle"))
sys.path.append(os.path.join(os.path.dirname(__file__), "lib","prettytable"))
import sublime
import sublime_plugin
import cx_Oracle
import unicodedata
import prettytable
```
Строки
```
sys.path.append(os.path.join(os.path.dirname(__file__), "lib","cx_Oracle"))
sys.path.append(os.path.join(os.path.dirname(__file__), "lib","prettytable"))
```
Говорит сублайму где искать наши библиотеки. При подключении prettytable Sublime у меня ругался на отсутствие модуля unicodedata, и простое импортирование его от ошибки не избавляло, так как в Sublime есть баг, благодаря которому сублайм не знает где расположен тот самый модуль unicodedata. Не много погуглив я нашел решение добавив строчку
```
sys.path.append(os.path.dirname(sys.executable))
```
И проблема решается.
Приступаем к самой команде
```
class OqueryCommand(sublime_plugin.TextCommand):
def run(self, edit):
# получаем объект view
view = self.view
# получаем массив координат выделенной области
region = view.sel()[0]
if not region.empty():
# если не пустой, вырезаем сам текст запроса
selection = view.substr(region)
try:
# В этом классе находятся все наши настройки из файла Oquery.sublime-settings
settings = sublime.load_settings('Oquery.sublime-settings')
# подключаемся к базе
db = cx_Oracle.connect(str(settings.get('username')), str(settings.get('password')), settings.get('host')+':'+str(settings.get('port'))+'/'+settings.get('dbname'))
except cx_Oracle.DatabaseError, e:
sublime.message_dialog(str(e))
else:
# создаем курсор
cursor = db.cursor()
try:
# и выполняем запрос
cursor.execute(selection)
except cx_Oracle.DatabaseError, e:
sublime.message_dialog(str(e))
else:
# обявляем класс нашей таблицы и кормим ей наш курсор
pt = prettytable.from_db_cursor(cursor)
# переводим все в строку
tableStr = pt.get_string()
# создаем новое окно
output = view.window().new_file();
# и отдаем ему весь результат
output.insert(edit, 0, tableStr)
else:
sublime.message_dialog('Select a proper SQL query')
```
Вот и все. но еще нам нужно объявить комбинацию для вызова нашей команды. Делается это очень просто Preferences -> Key Bindings User. И добавляем в него одну строчку
```
[
{ "keys": ["ctrl+o", "ctrl+r"], "command": "oquery" }
]
```
Наш плагин будет работать по комбинации (ctrl+o)+r. Вы можете выбрать и другую.
Вот и все теперь мы выделяем любой запрос и легким нажатием клавиш, мы получаем ответ в новом окне. Не правда ли замечательно?
При желании вы можете переделать все на любую другую базу данных.
Кому лень, прилагаю [архив](https://drive.google.com/file/d/0B7MyU4-LTezXX1VmRjFHR2pWaXc/edit?usp=sharing) | https://habr.com/ru/post/203742/ | null | ru | null |
# Unity3d. Уроки от Unity 3D Student (B04-B08)
Добрый день.
Предыдущие уроки вы можете найти в [соответствующем топике.](http://habrahabr.ru/post/141362/)
Теперь в каждом посте в скобках (в конце) будут указываться номера уроков. Буква в начале номера обозначает раздел (B-Beginner, I — Intermediate).
PS: Если вы не проходили предыдущие уроки, очень рекомендую их пройти, т.к. последующие изредка на них ссылаются.
#### Базовый Урок 04 — Уничтожение объектов
---
*В уроке рассказывается как удалять объекты со сцены, использую команду Destroy (уничтожить).*
Создайте пустую сцену и добавьте в нее сферу (**GameObject->Create Other->Sphere**) и куб (**GameObject->Create Other->Cube**). Куб назовем **“Box”**. Расположите объекты как показано на рисунке ниже.
Добавьте **C#-Скрипт** (**Project View->Create->C# Script**) и назовите его **Destroyer**. Как уже говорилось, при создании C#-скрипта Unity создает некий каркас, состоящий из подключенных библиотек и основного класса (используемого скриптом) с методами **Start()** и **Update()**. В [Базовом Уроке 02 (основы ввода)](http://habrahabr.ru/post/141362/#b02) использовался метод **Update()**, который вызывается каждый кадр. В данном случае мы воспользуемся методом **Start()**, который выполняется сразу после загрузки сцены. Добавим в тело метода **Start()** функцию **Destroy()** и передадим в нее **gameObject**, указав таким образом, что скрипт должен уничтожить объект, компонентом которого он является:
```
// метод Start() выполняется единожды, сразу после окончания загрузки сцены
Start() {
// уничтожить объект к которому прикреплен данный скрипт
Destroy(gameObject);
}
```
Добавим скрипт к сфере. Сделать это можно несколькими путями. Перетащив скрипт из **Project View** на сферу в **Scene View**.
Или на имя объекта в **Hierarchy**.
Так же можно выбрать сферу и добавить скрипт через меню компонентов (**Component->Scripts->Destroyer**) или просто перетащив скрипт в **Inspector View** выбранного объекта.
Снова выберите сферу и убедитесь, что среди компонентов присутствует ваш скрипт.
Нажмите на **Play** и вы увидите, что сразу после загрузки сцены сфера исчезает.
Давайте теперь попробуем уничтожить другой объект. Для этого нам понадобится статический метод [**Find**](http://unity3d.com/support/documentation/ScriptReference/GameObject.Find.html) класса **GameObject**. Заменим код в методе **Start()** следующим:
```
// ищем объект с именем Box и если таковой есть – уничтожаем его
Destroy(GameObject.Find(“Box”));
```
Примечание от автора перевода: Обратите внимание, что во втором случае мы передаем значение, вызывая статическую функцию, поэтому пишем имя класса (GameObject — с большой буквы), в то время как в первом мы передаем объект этого класса (gameObject — с маленькой буквы). В противном случае компилятор выдаст ошибку:
`error CS0176: Static member `UnityEngine.GameObject.Find(string)' cannot be accessed with an instance reference, qualify it with a type name instead`
что переводится как:
“статический член UnityEngine.GameObject.Find(string) не может быть доступен по ссылки экземпляра (класса), вместо этого определите (вызовите) его с именем типа.”
Сохраним изменения в коде скрипта. Скрипт не требуется убирать со сферы и добавлять к нашему кубу, т.к. назависимо от того, к какому объекту он теперь прикреплен, скрипт будет искать любой объект (на сцене) с именем **Box**. Нажмем **Play** и увидим как теперь сфера остается в сцене, а куб пропадает.
Что делать, если нам требуется уничтожить объект не сразу, а спустя какое-то время? Это можно сделать передав значение во 2ой параметр функции **Destroy**:
```
// Теперь уничтожаем Box спустя 3и секудны после загрузки сцены
Destroy(GameObject.Find(“Box”), 3);
```
Нажмите **Play** и убедитесь, что куб изчезает через 3и секунды после того, как сцена целиком загрузится.
[Ссылка на оригинальный урок](http://www.unity3dstudent.com/2010/07/beginner-b04-destroying-objects/)
###### Дополнительные материалы:
[Справка по функции Destroy() из официального справочника о скриптах Unity3d](http://unity3d.com/support/documentation/ScriptReference/Object.Destroy.html)
#### Базовый Урок 05 — Реализация создание объектов
---
*В уроке рассказывается как создавать объекты в сцене в реальном времени (runtime), используя префабы и команду Instantiate (инстанциирование)*
Если вы хотите добавлять объекты на сцену, когда сцена уже загружена, то вам требуется использовать скрипты, а точнее команду **Instantiate()**.
Загрузите сцену из [Базового урока 03 (Префабы)](http://habrahabr.ru/post/141362/#b03) или создайте такую же новую. В нашей сцене присутствует префаб **BouncyBox**.
Нажмите **Play** и убедитесь, что куб по-прежнему падает и отталкивается от поверхностей.
Теперь удалите со сцены экземпляр **BouncyBox**.
После этого добавьте пустой объект (напоминаю, **GameObject->Create Empty** или **Ctrl + Shift + N** в Windows, **Cmd + Shift + N** в MacOS). Расположите его примерно в том месте, где раньше был экземпляр **BouncyBox**.
Создадим **C#-Скрипт** и назовем его **Creater**. Начнем редактирование скрипта. Заведем открытую (**public**) переменную типа **GameObject** и назовем ее **thePrefab**. Модификатор **public** требуется указывать, если, например, вы хотите передавать значение переменной через **Inspector View**. После чего в теле функции **Start()** создадим еще один **GameObject** (с именем **instance**) и проинициализируем его значением с помощью статической функции **Instantiate()**.
```
public GameObject thePrefab;
void Start () {
GameObject instance = new GameObject();
instance = Instantiate(thePrefab,
transform.position,
transform.rotation) as GameObject;
}
```
Рассмотрим метод **Instantiate()** подробнее.
```
Instantiate(GameObject original, Vector3 position, Quaternion rotation)
```
Метод клонирует объект **original** с заданными вектором положения (**position**) и кватернионом поворота (**rotation**).
Тип [Vector3](http://unity3d.com/support/documentation/ScriptReference/Vector3) является обычным 3х компонентым вектором (аналогично вектору из **R**3).
Тип [Quaternion](http://unity3d.com/support/documentation/ScriptReference/Quaternion) — [кватернион](http://wat.gamedev.ru/articles/quaternions), задающий поворот объекта.
Добавьте скрипт к пустому объекту (c именем **GameObject**).Напоминаю, поскольку **thePrefab** объявлен с модификатором **public**, вы можете задавать его начальное значение прямо в **Inspector View** (у соответствующего компонента, то есть в нашем случае это **Creator** у **GameObject'а**). Перетащите наш префаб в место указания значения (или выберете его из списка, кликнув на кружок справа).
Нажмем **Play** и увидим, что на сцене появился наш прыгающий кубик.
Но наш кубик прыгает просто вверх и вниз, потому что не имеет начального угла поворота. Выберите **GameObject** и поверните его под небольшим углом.
Теперь, нажав **Play**, вы увидите, что кубик падает и отталкивается под различными углами.
[Cсылка на оригинальный урок](http://www.unity3dstudent.com/2010/07/beginner-b05-instantiate-to-create-objects/)
###### Дополнительные материалы:
[Описание функции instantiate() из официального справочника о скриптах Unity3d](http://unity3d.com/support/documentation/ScriptReference/Object.Instantiate.html)
[Описание класса Transform из официального справочника о скриптах Unity3d](http://unity3d.com/support/documentation/ScriptReference/Transform.html)
#### Базовый Урок 06 — Простой таймер
---
*В данном уроке рассказывается как в Unit при помощи скриптов
создавать простой таймер, используя Time.deltaTime и переменную типа float.*
Воспользуемся сценой из предыдущего урока (с пустым игровым объектом,
генерирующим экземпляры префаба, т.е. **BouncyBox**).
Создадим **С#-скрипт** и назовем его **Timer**. Добавим переменную **myTimer**, и напишем следующий код.
```
public float myTimer = 5.0f;
void Update() {
//Time.delaTime - время (сек), которое требовалось для отрисовки последнего кадра (read only)
myTimer -= Time.deltaTime;
if (myTimer <= 0.0f) {
Debug.Log("GAME OVER");
}
}
```
Сохраняем скрипт и переключаемся назад в Unity. Добавим скрипт к объекту **GameObject**.
Напомню, т.к. **myTimer** объявлена открытой (**public**), то в **Inspector View** вы можете менять ее начальное значение.
Жмем **Play**. Как только значение **myTimer** упадет до нуля, в статус баре вы увидите строку **GAME OVER**. Значение переменной **myTimer** будет продолжать опускаться (это можно увидеть в **Inspector View**).
Для того, чтобы переменная **myTimer** не опускалась ниже нуля, добавим еще одно ветвление в функцию **Update()**, в итоге мы получаем следующий код:
```
void Update () {
if(myTimer > 0){
myTimer -= Time.deltaTime;
}else if(myTimer <= 0){
Debug.Log("GAME OVER");
}
}
```
Нажмем **Play** и проследим за поведением переменной **myTimer**. Когда ее значение будет достаточно близким к нулю, то оно перестанет изменяться.
[Ссылка на оригинальный урок](http://www.unity3dstudent.com/2010/07/beginner-b06-simple-timer/)
###### Дополнительные материалы:
[Информация о Time.deltaTime из официального руководства о скриптах Unity3d](http://unity3d.com/support/documentation/ScriptReference/Time-deltaTime.html)
#### Базовый Урок 07 — Основы движения
---
*В уроке рассказывается, как двигать объекты c помощью функции transform.Translate.*
Создадим сцену с кубом, камерой и источником света.
Создадим новый **C#-скрипт** и назовем его **Move**.
Поскольку движение должно быть непрерывно во времени, то основной код будет располагаться в методе **Update()**. Вызовем функцию **Translate**, объекта **transform** и передадим ей в качестве параметра **Vector3(0, 0, 1)**. Получим следующий код:
```
void Update () {
transform.Translate(new Vector3(0.0f, 0.0f, 1.0f)); // задаем движение объекту вдоль оси Oz
}
```
Разберемся подробнее в коде. Тут **transform** — это объект класса [Transform](http://Transform(http://unity3d.com/support/documentation/ScriptReference/Transform.html), привязанный к нашему объекту. Метод **Translate()** двигает объект вдоль вектора на расстояние равное его длине (параллельный перенос).
Сохраним наш скрипт и добавим его к нашему кубу. Нажмите **Play** и увидите как куб стремительно улетает вдоль оси **Oz**.
Давайте уменьшим скорость движения, например, умножив наш вектор на **Time.deltaTime**, то есть:
```
transform.Translate(new Vector3(0.0f, 0.0f, 1.0f) * Time.deltaTime);
```
Нажмите **Play** и убедитесь, что куб начинает двигаться заметно медленнее.
Можно сделать наш скрипт более удобным в использовании, если скорость задать не фиксированным вектором, а через переменную. Заведем **public** переменную типа **float** и назовем ее **speed**. С помощью этой переменной можно будет задавать начальную скорость через **Inspector View** (по умолчанию она будет равна **5.0f**):
```
public float speed = 5.0f;
void Update () {
transform.Translate(new Vector3(0.0f, 0.0f, speed) * Time.deltaTime);
}
```
Сохраним скрипт и убедимся, что в **Inspector View** у компонента **Move** появилась переменная **Speed**.
Посмотрите, как будет меняться скорость движения нашего объекта в соответствии с заданным начальным значением этой переменной. Например, при **Speed = 3** скорость объекта не очень быстрая, но и не медленная.
Примечение: Для выражения **Vector3(0.0f, 0.0f, 1.0f)** существует короткая (но видимо чуть более медленная, если не прав, прошу поправить) запись **Vector3.forward**.
Кусок кода из обертки:
```
public static Vector3 forward
{
get
{
return new Vector3(0.0f, 0.0f, 1.0f);
}
}
```
[Ссылка на оригинальный урок](http://www.unity3dstudent.com/2010/07/beginner-b07-basic-translate-movement/)
###### Дополнительные материалы:
[Информация о методе transform.Translate из официального справочника о скриптах Unity3d](http://unity3d.com/support/documentation/ScriptReference/Transform.Translate.html)
[Информация Time.deltaTime из официального справочника о скриптах Unity3d](http://unity3d.com/support/documentation/ScriptReference/Time-deltaTime.html)
#### Базовый Урок 08 — Основы движения с помощью силы.
---
*В уроке рассказывается как c помощью приложения силы двигать физическое тело (Rigidbody).*
Если у вас на сцене есть объект с компонентом **Rigidbody**, то нужно задавать ему движение с помощью приложения силы (передав таким образом все расчеты движения [физическому движку игры](http://www.nvidia.ru/object/physx_new_ru.html)). В противном случае вы можете начать конфликтовать с физикой объекта. Мы по-прежнему используем сцену из [Базового урока 03](http://habrahabr.ru/post/141362/#b03).
Создадим **C#-скрипт** и назовем его **Force**. В методе **Start()** вызовем метод **AddForce()** компонента **rigidbody** (cвязанного с нашим объектом) и передадим ему вектор приложенной силы **Vector3(0.0f, 0.0f, power)**. В классе заведем переменную типа **float** с именем power и значением, по умолчанию равным **500.0f**:
```
public float power = 500.0f;
void Start () {
rigidbody.AddForce(new Vector3(0.0f, 0.0f, power));
}
```
Сохраним скрипт и добавим его к нашему объекту (или префабу). Теперь, если нажать **Play**, вы увидите как куб падает не вниз а под углом, из-за воздействия силы приложенной вдоль оси **Oz**.
[Ссылка на оригинальный урок](http://www.unity3dstudent.com/2010/07/beginner-b08-basic-force-movement/)
###### Дополнительные материалы:
[Информация о классе Rigidbody из официального справочника по скриптам Unity3d](http://unity3d.com/support/documentation/ScriptReference/Rigidbody.html)
[Информация о методе AddForce из официального справочника по скриптам Unity3d](http://unity3d.com/support/documentation/ScriptReference/Rigidbody.AddForce.html)
PS: Всем хороших и плодотворных выходных | https://habr.com/ru/post/142845/ | null | ru | null |
# Настройка домашней среды для разработки (docker + gitlab + DNS)
Intro
=====
Не смог придумать подходящее название для поста, поэтому кратко опишу, о чем будет идти речь.
У большинства из нас есть какие-нибудь мелкие личные поделки, которые не выходят за рамки наших домов. Кто-то хостит их на рабочем компьютере, кто-то — на Heroku, кто-то — на VPS, а у кого-то есть домашний сервер. На реддите даже есть сообщество [r/homelab](https://www.reddit.com/r/homelab/), в котором люди обсуждают разные железки и софт для т.н. *домашней лаборатории*.
Я не настолько увлечен этим вопросом, но у меня дома стоит Intel NUC, который проигрывает музыку с NAS с помощью [MPD](https://www.musicpd.org). Помимо MPD на нем крутятся мои мелкие поделки, которые помогают мне с ним работать: ныне мертвый бот для телеграма, HTTP API на синатре и корявенький фронтенд для него.
В посте я без особых подробностей (многих из которых сам не понимаю) опишу процесс установки DNS-сервера для работы с доменными именами для сервисов, схему одновременной работы нескольких сервисов с помощью Docker и установку Gitlab с CI. Ничего нового вы не узнаете, но вдруг кому-нибудь пригодится этот "гайд". К тому же я бы хотел услышать предложения по поводу того, как можно было бы сделать это проще/элегантнее/правильнее.
Изначально код моих сервисов лежал на битбакете/гитхабе и после создания докер-образов мне нужно было зайти под SSH и запустить пару скриптов, которые создавали/обновляли контейнеры с сервисами. Поймал себя на мысли, что вижу мелкий раздражающий баг в приложении, который я не исправляю только потому, что мне лень производить всю эту процедуру. Очевидно, что пора было автоматизировать все. Тут-то и пришла мысль установки Gitlab + CI.
Локальные домены с помощью DNS
==============================
Все контейнеры создавались с флагом `--network=host` для простоты — достаточно было использовать разные порты в приложениях. Однако с ростом количества сервисов запоминать, какое приложение какой порт использует. Да и вводить каждый раз IP-адрес с портом в браузере не очень красиво, поэтому прежде чем устанавливать гитлаб я решил разобраться с хостингом нескольких приложений на одном сервере.
Идея простая: настраиваем DNS, скармливаем его роутеру, устанавливаем Nginx и с помощью его конфигурации перенаправляем запросы на разные порты в зависимости от домена. Это же позволит не заморачиваться с портами при разработке, т.к. контейнеры начнут использовать `--publish` вместо `--network=host`.
При установке использовался [этот гайд](https://www.itzgeek.com/how-tos/linux/debian/configure-dns-server-on-debian-9-ubuntu-16-04.html). В нем настройка производится для Ubuntu 16.04, у меня же Debian.
Дальнейшие действия производятся от пользователя `root`.
Первым делом устанавливаем `bind9` и утилиты:
```
apt-get install -y bind9 bind9utils bind9-doc dnsutils
```
Далее нам нужно настроить доменную зону. Для этого добавляем в файл `/etc/bind/named.conf.local` следующее:
```
zone "nondv.home" IN { // Желаемое доменное имя
type master;
file "/etc/bind/fwd.nondv.home.db"; // Forward lookup file
allow-update { none; }; // Since this is the primary DNS, it should be none.
};
```
Также в гайде добавляется конфигурация для reverse lookup, но, честно говоря, я не особо понимаю, для чего это нужно, поэтому не стал этого делать.
Теперь создаем файл `/etc/bind/fwd.nondv.home.db`:
```
$TTL 604800
@ IN SOA ns1.mydomain.home. root.mydomain.home. (
20 ; Serial
604800 ; Refresh
86400 ; Retry
2419200 ; Expire
604800 ) ; Negative Cache TTL
;Name Server Information
IN NS ns1.nondv.home.
;IP address of Name Server
ns1 IN A 192.168.0.3
;A - Record HostName To Ip Address
nuc IN A 192.168.0.3
gitlab IN A 192.168.0.3
mpd IN A 192.168.0.3
@ IN A 192.168.0.3
```
Далее перезапускаем bind9 и устанавливаем автозапуск:
```
systemctl restart bind9
systemctl enable bind9
```
Обратите внимание, что я использовал `.home` вместо `.local`. Это было сделано потому, что домен `nondv.local` не резолвился без поддоменов. Ну, точнее `dig` распознавал его нормально, но браузеры и `curl` — нет. Как мне объяснил коллега, это скорее всего связано с разным софтом вроде Bonjour (мой рабочий ноутбук с яблоком на крышке). В общем, с доменом `.home` подобных проблем быть не должно.
Собственно, это все. Я после этого добавил DNS как первичный в роутер и переподключился к нему (чтобы автоматически обновился файл `/etc/resolve.conf`).
Nginx
=====
Как я уже сказал, чтобы иметь возможность обращаться по HTTP на 80 порт ко всем сервисам одновременно, нам нужно настроить Nginx так, чтобы он проксировал запросы на разные порты в зависимости от домена.
Документация по образу nginx доступна на сайте [Docker Hub](https://hub.docker.com/_/nginx/).
Подготовим основной файл конфигурации `/srv/nginx/nginx.conf`:
```
user nginx;
worker_processes 1;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
access_log /var/log/nginx/access.log main;
sendfile on;
keepalive_timeout 65;
server {
listen 80;
server_name nondv.home;
rewrite ^/$ http://mpd.nondv.home redirect; # основной домен, на который будут пеправляться ненастроенные запросы
}
include /etc/nginx/conf.d/*.conf;
}
```
Далее настроим домены. Я покажу только один:
```
# /srv/nginx/conf.d/gitlab.conf
server {
listen 80;
server_name gitlab.nondv.home;
location / {
proxy_pass http://127.0.0.1:3080;
}
}
```
Запуск контейнера производится командой:
```
docker run --detach \
--network host \
--name nginx \
--restart always \
--volume /srv/nginx/nginx.conf:/etc/nginx/nginx.conf:ro \
--volume /srv/nginx/conf.d:/etc/nginx/conf.d:ro \
nginx:alpine
```
Вот и все, теперь HTTP запросы на 80 порт будут отлавливаться с помощью nginx и перенаправляться на нужный порт.
Gitlab
======
Здесь все просто по [официальному руководству](https://docs.gitlab.com/omnibus/docker/):
```
docker run --detach \
--hostname gitlab.nondv.home \
--publish 3080:80 --publish 3022:22 \
--name gitlab \
--restart always \
--volume /srv/gitlab/config:/etc/gitlab:Z \
--volume /srv/gitlab/logs:/var/log/gitlab:Z \
--volume /srv/gitlab/data:/var/opt/gitlab:Z \
gitlab/gitlab-ce:latest
```
Ждем, когда все настроится (поглядываем в `docker logs -f gitlab`) и после входим в контейнер (`docker exec -it gitlab bash`) для доп. настройки:
```
nano /etc/gitlab/gitlab.rb # or vim
# /etc/gitlab/gitlab.rb
external_url 'http://gitlab.nondv.home'
gitlab_rails['gitlab_shell_ssh_port'] = 3022
# /etc/gitlab/gitlab.rb
gitlab-ctl reconfigure
```
Для надежности можно перезапустить контейнер (`docker container restart gitlab`).
CI
--
Gitlab CI уже интегрирован, но ему нужен Gitlab Runner ([документация](https://docs.gitlab.com/runner/install/docker.html#general-gitlab-runner-docker-image-usage)).
Для этого я написал небольшой скрипт:
```
NAME="gitlab-runner$1"
echo $NAME
docker run -d --name $NAME --restart always \
--network=host \
-v /srv/gitlab-runner/config:/etc/gitlab-runner \
-v /var/run/docker.sock:/var/run/docker.sock \
gitlab/gitlab-runner:alpine
```
После создания раннера, нам нужно его зарегистирировать. Для этого заходим в гитлаб (через браузер), идем в Admin area → Overview → Runners. Там описана установка раннеров. Вкратце, вы просто выполняете:
```
docker exec -it gitlab-runner register
```
и отвечаете на вопросы.
Ваши собственные HTTP-сервисы
=============================
Они запускаются по аналогии с гитлабом. Публикуете их на каком-нибудь порте и добавляете конфиг в nginx.
Заключение
==========
Теперь вы можете хостить ваши проекты на домашнем сервере и использовать мощь Gitlab CI для автоматизации сборки и публикации ваших проектов. Удобно ведь делать `git push` и не беспокоиться о запуске, верно?
Еще я бы рекомендовал настроить почту для гитлаба. Лично я использовал почтовый ящик на Яндексе. [Документация](https://docs.gitlab.com/omnibus/settings/smtp.html). | https://habr.com/ru/post/417179/ | null | ru | null |
# Улучшение параметров безопасности SSL-соединения в Zimbra Collaboration Suite Open-Source Edition
Надежность шифрования является одним из наиболее важных показателей при использовании информационных систем для бизнеса, ведь ежедневно они участвуют в передаче огромного количества конфиденциальной информации. Общепринятым средством оценки качества SSL-соединения является независимый тест от Qualys SSL Labs. Поскольку данный тест может запустить кто угодно, для SaaS-провайдеров особенно важно, чтобы оценка в этом тесте была максимальной. О качестве SSL-соединения заботятся не только SaaS-провайдеры, но и обычные предприятия. Для них данный тест является отличной возможностью выявить потенциально уязвимые места и заблаговременно закрыть все лазейки для киберпреступников.
В Zimbra OSE допустимо использовать два вида SSL-сертификатов. Первый — это самоподписанный сертификат, который автоматически добавляется при установке. Этот сертификат бесплатен и не ограничен по времени использования, а значит идеально подойдет для тестирования Zimbra OSE или ее использования исключительно в рамках внутренней сети. Однако при входе в веб-клиент пользователи будут видеть предупреждение от браузера, что данный сертификат ненадежен, и тест от Qualys SSL Labs ваш сервер однозначно провалит.
Второй — это коммерческий SSL-сертификат, подписанный удостоверяющим центром. Такие сертификаты без проблем воспринимается браузерами и обычно используются при коммерческой эксплуатации Zimbra OSE. Сразу после корректной установки коммерческого сертификата Zimbra OSE 8.8.15 показывает оценку A в тесте от Qualys SSL Labs. Это отличный результат, но наша цель достигнуть результата A+.
Для того, чтобы достичь максимальной оценки в тесте от Qualys SSL Labs при использовании Zimbra Collaboration Suite Open-Source Edition необходимо выполнить ряд шагов:
**1. Увеличение параметров протокола Диффи-Хеллмана**
По умолчанию во всех компонентах Zimbra OSE 8.8.15, которые используют OpenSSL, значение параметров протокола Диффи-Хеллмана составляет 2048 бит. В принципе, этого более чем достаточно для получения оценки А+ в тесте от Qualys SSL Labs. Однако, в том случае, если вы обновляетесь с более старых версий, значение параметров может оказаться ниже. Поэтому рекомендуется после завершения обновления выполнить команду zmdhparam set -new 2048, которая повысит параметры протокола Диффи-Хеллмана до приемлемых 2048 бит, а при желании при помощи этой же команды можно повысить значение параметров до 3072 или 4096 бит, что с одной стороны приведет к увеличению времени генерации, однако с другой стороны положительно скажется на уровне безопасности почтового сервера.
**2. Включение TLS 1.3**
В актуальных версиях Zimbra 8.8.15 с патчем не ниже 20 и Zimbra 9 с патчем не ниже 8 появилась поддержка протокола TLS 1.3, однако по умолчанию его использование отключено. Для того, чтобы активировать TLS 1.3 в Zimbra Proxy, необходимо ввести команду **zmprov mcf +zimbraReverseProxySSLProtocols TLSv1.3**. Чтобы проверить активировался ли TLS 1.3, введите команду **zmprov gcf zimbraReverseProxySSLProtocols**. Также рекомендуется отключить на прокси-сервере поддержку TLS 1 и TLS 1.1 с помощью команд **zmprov mcf -zimbraReverseProxySSLProtocols TLSv1** и **zmprov mcf -zimbraReverseProxySSLProtocols TLSv1.1**
Также необходимо добавить TLS\_AES\_256\_GCM\_SHA384 — шифры, используемые в TLS 1.3 в список используемых Zimbra Proxy. Для этого сперва получите список используемых шифров **zmprov gcf zimbraReverseProxySSLCiphers**, а затем введите дополненный список шифров командой вида zmprov mcf zimbraReverseProxySSLCiphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128:AES256:TLS\_AES\_256\_GCM\_SHA384:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4' После этого необходимо перезагрузить сервер прокси **zmproxyctl restart**
Поддержку TLS 1.3 также нужно включать для почтового хранилища и узла MTA. Для этого воспользуйтесь командами соответственно:
`zmlocalconfig -e mailboxd_java_options='-server -Dhttps.protocols=TLSv1.2,TLSv1.3 -Djdk.tls.client.protocols=TLSv1.2,TLSv1.3 -Djava.awt.headless=true -Dsun.net.inetaddr.ttl=${networkaddress_cache_ttl} -Dorg.apache.jasper.compiler.disablejsr199=true -XX:+UseG1GC -XX:SoftRefLRUPolicyMSPerMB=1 -XX:+UnlockExperimentalVMOptions -XX:G1NewSizePercent=15 -XX:G1MaxNewSizePercent=45 -XX:-OmitStackTraceInFastThrow -verbose:gc -Xlog:gc*=info,safepoint=info:file=/opt/zimbra/log/gc.log:time:filecount=20,filesize=10m -Djava.net.preferIPv4Stack=true'`
`zmlocalconfig -e zmmtaconfig='-server -Dhttps.protocols=TLSv1.2,TLSv1.3 -Djdk.tls.client.protocols=TLSv1.2,TLSv1.3 -Djava.awt.headless=true -Dsun.net.inetaddr.ttl=${networkaddress_cache_ttl} -Dorg.apache.jasper.compiler.disablejsr199=true -XX:+UseG1GC -XX:SoftRefLRUPolicyMSPerMB=1 -XX:+UnlockExperimentalVMOptions -XX:G1NewSizePercent=15 -XX:G1MaxNewSizePercent=45 -XX:-OmitStackTraceInFastThrow -verbose:gc -Xlog:gc*=info,safepoint=info:file=/opt/zimbra/log/gc.log:time:filecount=20,filesize=10m -Djava.net.preferIPv4Stack=true'`
После внесения изменений в настройки, перезагрузите MTA и почтовые хранилища.
**3. Включение рекомендованного списка используемых шифров**
По умолчанию Zimbra Collaborataion Suite Open-Source Edition поддерживает широкий спектр сильных и слабых шифров, при помощи которых шифруются данные проходящие по защищенному соединению. Однако использование слабых шифров является серьезным минусом при проверке безопасности SSL-соединения. Для того, чтобы этого избежать, необходимо настроить список используемых шифров.
Для этого следует воспользоваться командой `zmprov mcf zimbraReverseProxySSLCiphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128:AES256:TLS_AES_256_GCM_SHA384:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4'`
В эту команду сразу включен набор рекомендованных шифров и благодаря ей команде можно сразу включить в список надежные шифры и исключить ненадежные. Теперь остается только перезагрузить узлы с обратными прокси с помощью команды zmproxyctl restart. После перезагрузки внесенные изменения вступят в силу.
В том случае, если этот список вас по тем или иным причинам не устраивает, можно удалить из него ряд слабых шифров с помощью команды `zmprov mcf +zimbraSSLExcludeCipherSuites`. Так, например, команда `zmprov mcf +zimbraSSLExcludeCipherSuites TLS_RSA_WITH_RC4_128_MD5 +zimbraSSLExcludeCipherSuites TLS_RSA_WITH_RC4_128_SHA +zimbraSSLExcludeCipherSuites SSL_RSA_WITH_RC4_128_MD5 +zimbraSSLExcludeCipherSuites SSL_RSA_WITH_RC4_128_SHA +zimbraSSLExcludeCipherSuites TLS_ECDHE_RSA_WITH_RC4_128_SHA`, которая полностью исключит использование шифров RC4. Так же можно поступить и с шифрами AES и 3DES.
**4. Включение HSTS**
Включенные механизмы принудительного включения шифрования соединения и восстановления сеанса TLS также являются обязательными условиями для получения высшего балла в тесте от Qualys SSL Labs. Для их включения необходимо ввести команду `zmprov mcf +zimbraResponseHeader "Strict-Transport-Security: max-age=31536000"`. Данная команда добавит необходимый заголовок в конфигурацию, а для вступления новых настроек в силу придется перезагрузить Zimbra OSE с помощью команды **zmcontrol restart**.
Уже на этом этапе тест от Qualys SSL Labs будет демонстрировать оценку A+, однако если вы захотите дополнительно улучшить безопасность вашего сервера, можно предпринять еще ряд мер.
Например, можно включить принудительное шифрование межпроцессных соединений, а также включить принудительное шифрование при подключении к службам Zimbra OSE. Для проверки межпроцессных соединений следует ввести следующие команды:
```
zmlocalconfig -e ldap_starttls_supported=1
zmlocalconfig -e zimbra_require_interprocess_security=1
zmlocalconfig -e ldap_starttls_required=true
```
Для включения принудительного шифрования нужно ввести:
```
zmprov gs `zmhostname` zimbraReverseProxyMailMode
zmprov ms `zmhostname` zimbraReverseProxyMailMode https
zmprov gs `zmhostname` zimbraMailMode
zmprov ms `zmhostname` zimbraMailMode https
zmprov gs `zmhostname` zimbraReverseProxySSLToUpstreamEnabled
zmprov ms `zmhostname` zimbraReverseProxySSLToUpstreamEnabled TRUE
```
Благодаря этим командам будут шифроваться все соединения с прокси-серверами и почтовыми серверами, а также будет осуществляться проксирование всех этих соединений.
Таким образом, следуя нашим рекомендациям можно не только добиться высочайшей оценки в тесте на безопасность SSL-соединения, но и значительно повысить безопасность работы всей инфраструктуры Zimbra OSE.
По всем вопросам, связанными c Zextras Suite вы можете обратиться к Представителю компании «Zextras» Екатерине Триандафилиди по электронной почте ekaterina.triandafilidi@zextras.com | https://habr.com/ru/post/508372/ | null | ru | null |
# TinyML. Сжимаем нейросеть
Сейчас перед программистами стоит сложная задача - как внедрить такую громоздкую структуру, как нейронная сеть - в, допустим, браслет? Как оптимизировать энергопотребление модели? Какова цена таких оптимизации, а также насколько обосновано внедрение моделей в небольшие устройства, и почему без этого нельзя обойтись.
А в чем польза?
---------------
Представим дорогой промышленный сенсор - 1000 измерений в секунду, температурный датчик, измерение вибраций, передача данных на 10 км, мощный процессор - 20 млн операций в секунду! Его работа это посылать на сервер данные о температуре, вибрации, а также значения других параметров для предупреждения поломокоборудования. Но вот незадача - 99% посылаемых им данных бесполезна, от неё - чистый убыток за электричество. А таких датчиков на производстве могут быть десятки и сотни.
В действительности нас интересуют не сами данные с этого устройства, а инсайды из них - всё ли работает в штатном режиме? Нет ли аварийных ситуаций? Быть может, вскоре потребуется ремонт? Так почему бы не задеплоить нейронку на сам датчик, и вместо бесконечного потока данных лишь иногда посылать сигналы "Всё в порядке" или "Аномалии в показателях!" Вот именно этим вопросом и занимается TinyML.
Видите в середине очень странный пик? Даже следящему за показаниями приборов человеку тяжело его заметить, а вот МЛ модель справится с этим легко, и "не проморгает" моментВсё крутится вокруг того, как бы нам максимально ужать модель, чтобы она влезла в небольшое устройство. В качестве "устройства" сойдет всё: чайник, промышленный сенсор, утюг, телефон, браслет и т.д.
В отличие от облачного, embedded ("встроенный") AI работает на самом устройствеПреимущества подхода
--------------------
Во-первых - экономия ресурсов. Так как постоянной связи с сервером не требуется, это весомо экономит электроэнергию, ведь можно обойтись без постоянного подключения к WiFi, Bluetooth и так далее.
Во-вторых - быстрая скорость работы. Перекачивать данные на сервер - слишком долго, когда нужен результат "здесь и немедленно".
В-третьих - это экономия на облачных вычислениях. В облачном подходе данные требуется отослать на сервер не только для обучения модели, но и для предикта. Представьте, что для приложения замены лица на вашем телефоне будет постоянно требоваться связь с интернетом, как в случае с навигатором... Весьма неудобно и затратно. Собственно, поэтому такие технологии уже встроены в наш телефон (а это - работа TinyML).
В-четвертых - безопасность. Посылать данные куда-то всегда связано с риском, гораздо безопаснее получать результат уже на устройстве, а с устройства посылать только предикт.
В-пятых - скорость работы самих нейронных сетей становится быстрее, ибо работа с int внутри нейронки идёт быстрее, чем с float - об этом расскажу ниже.
Quantization
------------
А помочь засунуть жирную нейронку в худенький датчик поможет такой трюк, как Квантизация. Суть метода проста - а давайте сократим место, занимаемое числами в памяти. Обычные нейронки используют такой тип данных, как толстый 32 битный флоат. Что будет, если мы заменим их на худые 8 битные инты? Места занимать они станут меньше, но и качество упадёт.
Недостижимая мечта - использовать 1 бит. Тогда мы получим гигантский выигрыш в размере. Жаль, что это невозможно.
Или возможно? Бинаризированные свёрточные нейронные сети к вашим услугам. Почитать о них подробнее можно [здесь](https://arxiv.org/abs/1602.02830).
Перемножение матриц в этом случае выглядит "немного" по другомуОт теории к практике
--------------------
А теперь, дабы было задорнее, немного кода. Сделаем простейшую модель, предсказывающую синус числа.
```
# Генерируем данные для нашей нейронки
x_values = np.random.uniform(
low=0, high=2*math.pi, size=1000).astype(np.float32)
# Перемешиваем
np.random.shuffle(x_values)
y_values = np.sin(x_values).astype(np.float32)
# Добавляем шум, чтобы было "как в реальной жизни"
y_values += 0.1 * np.random.randn(*y_values.shape)
plt.plot(x_values, y_values, 'b.')
plt.show()
```
Данные готовы. Теперь делим их на тренировочную, тестовую и валидационную выборку (эту и некоторые другие части кода я пропущу для экономии вашего времени, полный ноутбук с кодом вот [тут](https://colab.research.google.com/github/tensorflow/tensorflow/blob/master/tensorflow/lite/micro/examples/hello_world/train/train_hello_world_model.ipynb#scrollTo=l4-WhtGpvb-E)).
Время строить нашу нейронку!
```
# Создаём нейронную сеть
model = tf.keras.Sequential()
model.add(keras.layers.Dense(16, activation='relu', input_shape=(1,)))
model.add(keras.layers.Dense(16, activation='relu'))
model.add(keras.layers.Dense(1))
model.compile(optimizer='adam', loss="mse", metrics=["mae"])
# Тренируем модельку
history = model.fit(x_train, y_train, epochs=500, batch_size=64,
validation_data=(x_validate, y_validate))
# Сохраняем
model.save(MODEL_TF)
```
Теперь давайте посмотрим, что получилось:
Полученное качество для наших экспериментов вполне сойдетИтак, основная модель готова. Настало время "посжимать" её самыми разными способами. А поможет в этом нам TFLiteConverter, созданный специально для облегчения ваших нейронок.
```
# Конвертируем нашу нейронку в формат TensorFlow Lite БЕЗ квантизации
converter = tf.lite.TFLiteConverter.from_saved_model(MODEL_TF)
model_no_quant_tflite = converter.convert()
# Сохраняем
open(MODEL_NO_QUANT_TFLITE, "wb").write(model_no_quant_tflite)
# Конвертируем нашу нейронку в формат TensorFlow Lite ИСПОЛЬЗУЯ квантизацию
def representative_dataset():
for i in range(500):
yield([x_train[i].reshape(1, 1)])
converter.optimizations = [tf.lite.Optimize.DEFAULT]
# Задаем параметры, по котором в нейронке всё будет конвертировано в int
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8
# Задаем репрезентативный набор данных, чтобы обеспечить правильность квантизации
converter.representative_dataset = representative_dataset
model_tflite = converter.convert()
open(MODEL_TFLITE, "wb").write(model_tflite)
```
Итого имеем три нейронные сети: обычную, конвертированную TensorFlow Lite без квантизации, конвертированную TensorFlow Lite с квантизацей. Самое время сравнить, сколько же места они занимают.
```
pd.DataFrame.from_records(
[["TensorFlow", f"{size_tf} bytes", ""],
["TensorFlow Lite", f"{size_no_quant_tflite} bytes ", f"(reduced by {size_tf - size_no_quant_tflite} bytes)"],
["TensorFlow Lite Quantized", f"{size_tflite} bytes", f"(reduced by {size_no_quant_tflite - size_tflite} bytes)"]],
columns = ["Model", "Size", ""], index="Model")
```
Итак, по сравнению с первоначальной нейронкой, конвертация с помощью TensorFlow Lite даёт 32% выигрыша в размере, а квантизация целых 40% ! Весьма впечатляющий результат, однако, какой ценой мы его достигли?
Потеря качества почти не существенна, на уровне погрешности. Но стоит иметь ввиду, что мы используем весьма простую модельку для теста, на более крупных моделях результат может быть не настолько оптимистичным!
Конвертация в С код
-------------------
Все предыдущие действия мы делали на Python в ноутбуке, но ведь нас интересует, как задеплоить модель в микроконтроллер, правильно? А для этого требуется сконвертировать полученную модель в код, с которым эти сами микроконтроллеры привыкли работать. ВАЖНО! Приведенный ниже код я запускал на Ubuntu, если хотите подобное сделать на Windows - придётся искать обходные пути.
```
# Ставим xxd
!apt-get update && apt-get -qq install xxd
# А теперь конвертируем
!xxd -i {MODEL_TFLITE} > {MODEL_TFLITE_MICRO}
# Меняем имя переменных
REPLACE_TEXT = MODEL_TFLITE.replace('/', '_').replace('.', '_')
!sed -i 's/'{REPLACE_TEXT}'/g_model/g' {MODEL_TFLITE_MICRO}
# Давайте глянем, что из себя представляет сконвертированная в C код модель
!cat {MODEL_TFLITE_MICRO}
```
Я вставил лишь первые несколько строк сконвертированной модели, однако вообще их около 400.
Код на микроконтроллере
-----------------------
Модель у нас есть, а теперь посмотрим, как будет выглядеть наш С код на, собственно, микроконтроллере. Перед деплоем на микроконтроллер код можно (и нужно) сперва запустить на компьютере. Сразу скажу, что я выцепил только самые интересные куски кода, однако если вы хотите запустить его на своем компе - то [вот](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/micro/examples/hello_world/hello_world_test.cc).
```
// Определяем входное значение, а также ожидаемое выходное
float x = 0.0f;
float y_true = sin(x);
// Логирование
tflite::MicroErrorReporter micro_error_reporter;
// Подтягиваем ранее сохранённую модельку
const tflite::Model* model = ::tflite::GetModel(g_model);
```
Далее выделяем место на нашем устройстве. Сколько его взять? На самом деле, вопрос решается в лоб: берем некое рандомное, разумное число. Если модель вмещается и всё работает- хорошо, пробуем сократить место. Продолжать сей процесс, пока система не перестанет работать.
Ну и наконец, вот так выглядит предсказание синуса на микроконтроллере:
```
x = 5.f;
y_true = sin(x);
input->data.int8[0] = x / input_scale + input_zero_point;
interpreter.Invoke();
y_pred = (output->data.int8[0] - output_zero_point) * output_scale;
TF_LITE_MICRO_EXPECT_NEAR(y_true, y_pred, epsilon);
```
Edge Impulse
------------
Отдельно стоит упомянуть платформу Edge [Impulse](https://www.edgeimpulse.com/) от ребят, плотно занимающихся TinyML.
Она берет на себя много работы по деплою моделей непосредственно на микроконтроллеры, достаточно всего лишь подключить какую нибудь ардуинку к компьютеру, и в пару кликов накатить на неё модельку. Сам не пользовался, и не думаю, что что нибудь очень серьезное на её базе сделать получится, однако желающим немного поиграться - точно сюда.
Ну и вместо заключения - тема с TinyML набирает обороты. В некоторых сферах (браслеты отслеживания состояния людей с больным сердцем, обнаружение рака языка встроенной нейронной сетью через фотографию и т.д.) у неё просто нет альтернатив. Рост количества подобных устройств [прогнозируется](https://www.prnewswire.com/news-releases/edge-computing-market-is-projected-to-grow-from-2-485-36-million-in-2018-to-usd-8-854-78-million-by-2025--with-a-cagr-of-19-90--valuates-reports-301015459.html) на уровне 20% в год, а значит, об этой технологии мы будем слышать всё чаще и чаще.
Если хотите знать больше по теме, то присоединяйтесь к нашему NoML Community - <https://t.me/noml_community>.
Список источников
-----------------
* Ноутбук для создания модели <https://colab.research.google.com/github/tensorflow/tensorflow/blob/master/tensorflow/lite/micro/examples/hello_world/train/train_hello_world_model.ipynb#scrollTo=l4-WhtGpvb-E>
* Код на С для деплоя модели <https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/micro/examples/hello_world/hello_world_test.cc>
* Бинаризированные свёрточные нейронные сети <https://arxiv.org/abs/1602.02830>
* Сайт комьюнити TinyML <https://www.tinyml.org/>
* Специализированный ютуб канал (здесь и обзорные видео, и применение технологии в промышленности) <https://www.youtube.com/channel/UC9iWqvsWjhowkHWVJquHwkg>
* Платформа для разработки Edge Impulse <https://www.edgeimpulse.com/>
* Книга, полностью посвященная TinyML <https://www.amazon.com/_/dp/1492052043?tag=oreilly20-20> | https://habr.com/ru/post/559400/ | null | ru | null |
# Разделённые запросы в EF Core
ORM Entity Framework Core с каждой версией становится все более и более богатой на фичи. Команда разработчиков тратит много времени на перфоманс и вероятно простое обновление Nuget-пакета уже приведет к некоторому бусту, который почувствуют пользователи. Но сегодня я хочу рассказать о совершенно конкретной фиче: это новый режим запросов — "разделённые запросы" или "split queries" в оригинале.
Предыстория
===========
На моем текущем проекте в качестве хранилища используется Postgres, доступ к которой осуществляется через драйвер `Npgsql` и EF Core. Одной из центральных сущностей всего бизнес-процесса является "методика выполнения ПЦР-исследования", которая по сути представляет рецепт как выполнить исследование и включает в себя довольно много информации:
* список используемых реагентов с указанием "рецепта смешивания"
* список результатов, которые будут определены
* список оборудования на котором возможно выполнение исследования
* и так далее, всего 8 вложенных коллекций
Сам объект методики тоже имеет около дюжины полей, в основном небольших — название, описание, версия, и т.д.
Большинство коллекций являются связями много-ко-многим с другими справочными записями, которые сами содержат не так много информации, ну может до полудюжины скалярных полей.
В самом начале мы не парили себе голову и стали использовать lazy-loading, что хорошо работало в сценариях "частичного применения": когда извлекалась методика только со списком реагентов, или методика только со списком результатов.
Но в определенных сценариях требовалось получить методику "целиком", что привело к классической проблеме N+1, когда для извлечения сущности и связанных коллекций требуется 1 запрос на извлечение сущности и еще по одному для каждого элемента коллекции.
Такое отношение к данным сильно просаживало производительность и следующим витком было включить коллекции в родительский объект с использованием `LINQ`-конструкций `.Include().ThenInclude()`.
Всё работало более менее хорошо до появления **царь-методики**. Это комплексный и сложный тест, в который включено много реагентов, много результатов, он использует много каналов детекции. К ней производится много форм комплектации наборов реагентов.
Так или иначе, мы получили развесистую структуру, в которой каждая вложенная коллекция имела не как обычно 3-5 записей, а по 20-30. Вот тут наш софт и сказал *"кря"*.
Если раньше на извлечение полной сущности уходило от нескольких десятков миллисекунд до сотен, то у **царь-методики** это занимало до **полутора десятков секунд**, что иногда приводило к краху запроса в БД. Это было уже недопустимо и требовало каких-то решений.
Пересказ документации
=====================
Как пишут Майкрософт в [своей статье про разделённые запросы](https://docs.microsoft.com/ru-ru/ef/core/querying/single-split-queries) обычно каждый LINQ-запрос преобразуется в один SQL запрос с использованием JOIN для извлечения связанных коллекций.
Я позволю себе немного перевернуть пример из документации и извлекать не блоги и посты, а посты и комменты. Пусть модель данных выглядит следующим образом:
```
public class Post
{
public int ID { get; set; }
public string Content { get; set; }
public List Comments { get; set; }
}
public class Comment
{
public int ID { get; set; }
public Post ParentPost { get; set; }
public int ParentPostID { get; set; }
public string CommentText { get; set; }
}
```
И попытаемся извлечь хайповый пост с 1000 комментариями из бд следующим запросом:
```
var veryPopularPost = Posts
.Include(x => x.Comments)
.First(x => x.ID == 42);
```
Что будет транслировано примерно в такой SQL-запрос усреднённый, потому что вариаций масса:
```
SELECT p.id, p.content, c.id, c.parentpostid, c.commenttext
FROM posts AS p
LEFT JOIN comments AS c ON (p.id = c.parentpostid)
WHERE p.id = 42
LIMIT 1;
```
А что если статья большая? Например автор был в ударе и выдал 100 КБ текста (это около 50 печатных листов). Комментаторы читали, наслаждались и комментировали, так что оставили 1000 комментариев. Сколько примерно будет весить результирующий набор, который надо вычитать ORM?
На вскидку — `p.content` = 100 КБ, повторим 1000 раз и на выходе ~ 100 МБ текста, дублирующегося 1000 раз. И это без учета размера `int` и текста комментариев.
Lazy-load в этом случае будет побыстрее, хотя бомбить базу **1000 и одним запросом** — тоже сомнительное развлечение. Можно ли что-то с этим сделать не прибегая вручную к оптимизации запросов?
AsSplitQuery()
--------------
Да, и вот каким образом. В EF Core 5.0 появилась новая директива `.AsSplitQuery()`, которая заставит query provider транслировать загрузку связанной коллекции отдельным запросом.
```
var veryPopularPost = Posts
.Include(x => x.Comments)
.AsSplitQuery()
.First(x => x.ID == 42);
```
Транслируется в следующие SQL-запросы:
```
SELECT p.id, p.content
FROM posts AS p
WHERE p.id = 42
LIMIT 1;
SELECT c.id, c.parentpostid, c.commenttext, p.id
FROM posts AS p
INNER JOIN comments AS c ON (p.id = c.parentpostid)
WHERE p.id = 42
LIMIT 1;
```
Что уже приведет к тому, что текст записи не будет читаться 1000 раз, а только 1.
Для нескольких коллекций поведение будет аналогичное, что избавит от комбинаторного взрыва.
Бенчмарки
=========
На скорую руку я сваял бенчмарк. Пусть есть коллекция записей типа `MainEntity`, в которой нет ничего, кроме вложенных коллекций. 5 "маленьких" записей и 1 большая.
```
public class MainEntity
{
public int ID { get; set; }
public List Ref1 { get; set; }
public List Ref2 { get; set; }
public List Ref3 { get; set; }
public List Ref4 { get; set; }
public List Ref5 { get; set; }
public List BigRef { get; set; }
}
public abstract class RefEntity
{
public int ID { get; set; }
public string Payload { get; set; } = string.Empty;
public MainEntity MainEntity { get; set; }
public int? MainEntityID { get; set; }
}
public class RefEntity1 : RefEntity { }
public class RefEntity2 : RefEntity { }
public class RefEntity3 : RefEntity { }
public class RefEntity4 : RefEntity { }
public class RefEntity5 : RefEntity { }
public class BigRefEntity : RefEntity { }
```
Записи заполняются при инициализации БД строчками случайной длины по 10 символов для "маленькой" записи и по 1000 для "большой".
В каждую вложенную коллекцию добавляется по `ItemsInCollection` записей. Тестовый метод извлекает по 2 записи `MainEntity`, присоединяя к ней от 0 до 6 коллекций (параметр `LoadRefs`) в двух режимах — одним запросом и разделёнными запросами (параметр `SplitQueries`).
```
[Benchmark]
public List QueryLoad()
{
IQueryable query = LoadRefs switch
{
0 => dbContext.MainEntities,
1 => dbContext.MainEntities
.Include(x => x.Ref1),
2 => dbContext.MainEntities
.Include(x => x.Ref1)
.Include(x => x.Ref2),
3 => dbContext.MainEntities
.Include(x => x.Ref1)
.Include(x => x.Ref2)
.Include(x => x.Ref3),
4 => dbContext.MainEntities
.Include(x => x.Ref1)
.Include(x => x.Ref2)
.Include(x => x.Ref3)
.Include(x => x.Ref4),
5 => dbContext.MainEntities
.Include(x => x.Ref1)
.Include(x => x.Ref2)
.Include(x => x.Ref3)
.Include(x => x.Ref4)
.Include(x => x.Ref5),
6 => dbContext.MainEntities
.Include(x => x.Ref1)
.Include(x => x.Ref2)
.Include(x => x.Ref3)
.Include(x => x.Ref4)
.Include(x => x.Ref5)
.Include(x => x.BigRef),
\_ => throw new ArgumentOutOfRangeException()
};
var splitQuery = SplitQueries ? query.AsSplitQuery() : query;
return splitQuery.Take(2).ToList();
}
```
Полный код бенчмарка доступен на [гитхабе](https://github.com/zetroot/CartesianExplosion).
Я запускал бенчмарк на домашней машине, СУБД в дефолтной конфигурации, подключение локальное через localhost.
```
BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19042
AMD Ryzen 5 2400G with Radeon Vega Graphics, 1 CPU, 8 logical and 4 physical cores
.NET Core SDK=5.0.201
[Host] : .NET Core 5.0.4 (CoreCLR 5.0.421.11614, CoreFX 5.0.421.11614), X64 RyuJIT [AttachedDebugger]
Job-HMJXLI : .NET Core 5.0.4 (CoreCLR 5.0.421.11614, CoreFX 5.0.421.11614), X64 RyuJIT
InvocationCount=1 UnrollFactor=1
```
| ItemsInCollection | SplitQueries | LoadRefs | Mean | Error | StdDev | Median |
| --- | --- | --- | --- | --- | --- | --- |
| 2 | False | 0 | 694.6 μs | 18.42 μs | 52.57 μs | 686.9 μs |
| 2 | False | 1 | 1,004.3 μs | 25.43 μs | 69.60 μs | 983.4 μs |
| 2 | False | 2 | 1,255.3 μs | 32.02 μs | 89.25 μs | 1,237.0 μs |
| 2 | False | 3 | 1,578.9 μs | 45.46 μs | 126.73 μs | 1,545.1 μs |
| 2 | False | 4 | 2,013.3 μs | 56.55 μs | 162.26 μs | 1,976.8 μs |
| 2 | False | 5 | 2,685.2 μs | 69.00 μs | 196.85 μs | 2,651.1 μs |
| 2 | False | 6 | 4,646.8 μs | 134.52 μs | 392.41 μs | 4,515.2 μs |
| 2 | True | 0 | 726.5 μs | 17.60 μs | 48.76 μs | 725.0 μs |
| 2 | True | 1 | 1,403.1 μs | 34.46 μs | 96.06 μs | 1,394.3 μs |
| 2 | True | 2 | 1,928.7 μs | 57.68 μs | 165.51 μs | 1,923.3 μs |
| 2 | True | 3 | 2,639.6 μs | 96.20 μs | 277.56 μs | 2,584.5 μs |
| 2 | True | 4 | 3,128.8 μs | 117.46 μs | 340.77 μs | 3,180.4 μs |
| 2 | True | 5 | 3,725.9 μs | 121.37 μs | 357.87 μs | 3,713.8 μs |
| 2 | True | 6 | 4,299.9 μs | 166.28 μs | 485.04 μs | 4,233.4 μs |
| 5 | False | 0 | 706.6 μs | 18.03 μs | 50.25 μs | 698.9 μs |
| 5 | False | 1 | 1,071.6 μs | 20.91 μs | 51.69 μs | 1,068.6 μs |
| 5 | False | 2 | 1,512.7 μs | 30.13 μs | 54.33 μs | 1,513.6 μs |
| 5 | False | 3 | 2,809.9 μs | 148.44 μs | 435.35 μs | 2,619.9 μs |
| 5 | False | 4 | 7,803.3 μs | 435.35 μs | 1,242.08 μs | 7,243.8 μs |
| 5 | False | 5 | 37,752.4 μs | 439.33 μs | 366.86 μs | 37,791.4 μs |
| 5 | False | 6 | 321,948.5 μs | 3,336.86 μs | 2,605.20 μs | 321,361.0 μs |
| 5 | True | 0 | 714.0 μs | 12.87 μs | 11.41 μs | 715.7 μs |
| 5 | True | 1 | 1,436.5 μs | 33.54 μs | 92.37 μs | 1,418.8 μs |
| 5 | True | 2 | 2,233.7 μs | 79.47 μs | 230.55 μs | 2,232.8 μs |
| 5 | True | 3 | 3,056.3 μs | 166.89 μs | 476.15 μs | 3,051.3 μs |
| 5 | True | 4 | 3,339.3 μs | 105.32 μs | 303.88 μs | 3,340.5 μs |
| 5 | True | 5 | 3,962.7 μs | 179.15 μs | 508.21 μs | 3,862.4 μs |
| 5 | True | 6 | 4,496.6 μs | 133.87 μs | 394.71 μs | 4,484.2 μs |
| 10 | False | 0 | 747.7 μs | 30.51 μs | 88.51 μs | 719.0 μs |
| 10 | False | 1 | 1,211.5 μs | 49.81 μs | 142.92 μs | 1,162.0 μs |
| 10 | False | 2 | 2,161.1 μs | 88.84 μs | 259.14 μs | 2,123.4 μs |
| 10 | False | 3 | 9,423.3 μs | 702.14 μs | 2,014.57 μs | 9,313.8 μs |
| 10 | False | 4 | 90,392.5 μs | 821.13 μs | 727.91 μs | 90,467.2 μs |
| 10 | False | 5 | **1,202,652.5 μs** | 23,336.09 μs | 24,969.36 μs | 1,205,782.6 μs |
| 10 | False | 6 | **34,625,732.4 μs** | 691,082.68 μs | 1,055,356.24 μs | 34,718,363.9 μs |
| 10 | True | 0 | 747.0 μs | 24.88 μs | 68.93 μs | 738.7 μs |
| 10 | True | 1 | 1,712.9 μs | 53.74 μs | 154.20 μs | 1,697.2 μs |
| 10 | True | 2 | 2,519.9 μs | 107.27 μs | 316.28 μs | 2,491.5 μs |
| 10 | True | 3 | 3,349.0 μs | 149.58 μs | 436.33 μs | 3,295.7 μs |
| 10 | True | 4 | 4,268.4 μs | 165.83 μs | 483.72 μs | 4,274.0 μs |
| 10 | True | 5 | **4,882.6 μs** | 188.59 μs | 547.13 μs | 4,832.2 μs |
| 10 | True | 6 | **5,560.8 μs** | 249.02 μs | 726.40 μs | 5,478.1 μs |
Обратите внимание на выделенные значения. Добавление одной дополнительной коллекции всего с 10 записями (пусть и с относительно большими данными) приводит к деградации в почти 30 раз.
А при использовании разделенных запросов разница уже не так драматична. Да и сами цифры значительно меньше в абсолютных величинах (5,5 мс против 34625 мс).
Всем спасибо и следите за комбинаторными взрывами!
### Ссылки
* [Описание от Microsoft](https://docs.microsoft.com/ru-ru/ef/core/querying/single-split-queries)
* [Остальные фичи EF Core 5.0](https://docs.microsoft.com/ru-ru/ef/core/what-is-new/ef-core-5.0/whatsnew)
* [Репозиторий с бенчмарком](https://github.com/zetroot/CartesianExplosion) | https://habr.com/ru/post/549736/ | null | ru | null |
# Готовим скриншоты для документации в GIMP (часть 1)
Как известно, неотъемлемой частью профессионального программного продукта является качественная документация. А документация, в свою очередь, немыслима без иллюстраций. В большинстве случаев иллюстрации представляют собой скриншоты, которые должны быть не только красивыми и информативными, но и единообразно оформленными. Последнее важно, если над разными разделами документации работают разные специалисты (технические писатели). В этой статье мы рассмотрим, как редактор растровой графики [GIMP](http://gimp.org/) и его встроенный язык сценариев Script-Fu могут пригодиться для подготовки иллюстраций. В качестве примеров использованы скриншоты нашего продукта [eXpressApp Framework](http://devexpress.com/Products/NET/Application_Framework/).
Язык сценариев Script-Fu основан на [Scheme](http://ru.wikipedia.org/wiki/Scheme) (диалекте Lisp), и доступен в GIMP «из коробки» на любой платформе, поэтому мы выбрали именно его. В качестве первого простейшего примера рассмотрим скрипт, который применяет эффект тени с предустановленными параметрами. Почему не воспользоваться стандартным Drop Shadow? Да потому что он задает много лишних вопросов о параметрах тени. А мы хотим, чтобы тень была всегда одинаковая (черного цвета, с определёнными смещением, радиусом размытия и прозрачностью), и чтобы не приходилось заново задавать эти параметры. Итак, открываем любимый текстовый редактор и пишем скрипт:
```
(define (script-fu-quick-shadow image drawable)
(gimp-context-push)
(gimp-image-set-active-layer image drawable)
(gimp-image-undo-group-start image)
; Вызов стандартной процедуры script-fu-drop-shadow
(script-fu-drop-shadow image drawable 3 4 10 '(0 0 0) 40 TRUE)
(gimp-image-undo-group-end image)
(gimp-displays-flush)
(gimp-context-pop)
)
(script-fu-register "script-fu-quick-shadow"
"Быстрая тень"
"Отбросить тень со стандартными параметрами:
смещение по X = 3, по Y = 4, радиус размытия = 10,
цвет черный, прозрачность 40%."
"Василий Пупкин "
"ООО Рога и Копыта"
"2010/10/6"
"RGB\*"
SF-IMAGE "Image" 0
SF-DRAWABLE "Drawable" 0
)
(script-fu-menu-register "script-fu-quick-shadow"
"/Filters/Мои скрипты"
)
```
Типичный скрипт состоит из определения основной процедуры, которая делает всю работу (**script-fu-quick-shadow**), и вызовов встроенных процедур **script-fu-register** и **script-fu-menu-register**, которые регистрируют скрипт, определяют какие параметры он будет запрашивать у пользователя и создают соответствующий пункт в меню. Cкрипт «Быстрая тень» требует только наличия открытого RGB изображения, и запрашивать ничего не должен. В своей основной процедуре он обращается к встроенной процедуре **script-fu-drop-shadow**. Если хотите разобраться, что за параметры переданы этой процедуре, найдите её описание в «просмотре процедур Script-Fu» (Фильтры -> Script-Fu -> Консоль -> Просмотреть...). Вызовы процедур до и после вызова **script-fu-drop-shadow** типичны для большинства скриптов и требуютcя для передачи текущего контекста плагину, корректного взаимодействия с буфером Undo/Redo и обновления UI после отработки скрипта. Кстати, большинство встроенных фильтров GIMP реализованы на Script-Fu, и под Windows их исходники доступны в папке *%ProgramFiles%\GIMP-2.0\share\gimp\2.0\scripts*, а под Linux – в */usr/local/share/gimp/2.0/scripts*. Вы можете использовать их как отправную точку при разработке собственных скриптов.
Сохраним наш первый скрипт с расширением scm, и поместим его в папку пользовательских скриптов. В Windows, пользовательские скрипты лежат в папке *%USERPROFILE%\.gimp-2.6\scripts*, в Linux – в папке *~/.gimp-2.6/scripts*. Теперь надо перезапустить GIMP, или выполнить команду Фильтры -> Script-Fu -> Обновить Сценарии. Если в коде нет ошибок, наш скрипт будет виден в «просмотре процедур Script-Fu»:
Обратите внимание, здесь видны сведения об авторе, которые мы передали в **script-fu-register**. Можете воспользоваться этой возможностью, чтобы пользователи знали кому говорить спасибо, или передать пустые строки и сохранить инкогнито.
Выполнить скрипт можно через меню “Фильтры -> Мои скрипты”:
Для удобства вызова можно назначить подходящую клавиатурную команду. Стоит отметить, что GIMP поддерживает динамические шоткаты – достаточно нажать желаемый «аккорд» когда указатель находится над требуемым пунктом меню, и настройка будет сохранена. По умолчанию эта полезная функция отключена, ее можно включить в настройках в разделе «Интерфейс».
Скрипт «Быстрая тень» предполагает, что он вызывается для скриншота окна, обрезанного по рамке. Такое изображение можно получить, нажав Alt+PrtScr, или используя специализированный софт для захвата скриншотов, например [SnagIt](http://www.techsmith.com/screen-capture.asp). Ниже приведен скриншот окна, обработанный «быстрой тенью»:
Всё бы хорошо, но скруглённые уголки окна, под которыми остался непрозрачный фон, портят картину. К сожалению, нам не попадалось утилит для захвата скриншотов, которые умеют оставлять прозрачность под уголками (может быть, читатель что-то посоветует). Поэтому в качестве обходного манёвра используем следующий скрипт:
```
(define (script-fu-cut-corners image
drawable
radius
only-top)
(gimp-context-push)
(gimp-image-set-active-layer image drawable)
(gimp-image-undo-group-start image)
; Добавляем альфа-канал (прозрачность)
(gimp-layer-add-alpha drawable)
; Выделяем все изображение, cкругляем уголки выделения
(gimp-round-rect-select image 0 0 (car (gimp-image-width image))
(car (gimp-image-height image))
radius radius CHANNEL-OP-REPLACE TRUE FALSE 0 0)
; Инвертируем выделение
(gimp-selection-invert image)
; Если требуется подрезать только верхние уголки...
(if (= only-top TRUE)
; ...то вычитаем из выделения область изображения
; охватывающую оба нижних уголка
(gimp-rect-select image
0
(- (car (gimp-image-height image)) radius)
(car (gimp-image-width image))
radius
CHANNEL-OP-SUBTRACT
FALSE
0))
; Удаляем выделенные области
(gimp-edit-clear drawable)
; Снимаем выделение
(gimp-selection-none image)
(gimp-image-undo-group-end image)
(gimp-displays-flush)
(gimp-context-pop)
)
(script-fu-register "script-fu-cut-corners"
"Подрезать уголки"
"Подрезать скругленные уголки скриншота окна."
"Василий Пупкин "
"ООО Рога и Копыта"
"2010/10/6"
"RGB\*"
SF-IMAGE "Image" 0
SF-DRAWABLE "Drawable" 0
SF-ADJUSTMENT "Радиус (0 - 20 пикселей)" '(8 0 20 1 10 0 0)
SF-TOGGLE "Только верхние" FALSE
)
(script-fu-menu-register "script-fu-cut-corners"
"/Filters/Мои скрипты")
```
Этот скрипт запрашивает параметры у пользователя. Во-первых, нужно указать радиус скругления уголков. Для дефолтной темы Windows 7 подходит значение 8 точек, в Vista радиус поменьше. Во-вторых, для некоторых тем может пригодиться опция – подрезать только верхние уголки.
Ниже приведён результат последовательного запуска скриптов “Подрезать уголки” и “Быстрая тень”:
Уже выглядит лучше, можно вставлять в документацию или на сайт.
В нашей следующей статье по GIMP мы рассмотрим, как красиво оформить скриншот фрагмента окна. Например, вот так:
Продолжение — [здесь](http://habrahabr.ru/company/devexpress/blog/107026/). | https://habr.com/ru/post/106611/ | null | ru | null |
# О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать
> Рекурсия: см. рекурсия.
Все программисты делятся на 112 категорий: кто не понимает рекурсию, кто уже понял, и кто научился ею пользоваться. В общем, гурилка из меня исключительно картонный, так что постигать Дао Рекурсии тебе, читатель, всё равно придётся самостоятельно, я лишь постараюсь выдать несколько волшебных пенделей в нужном направлении.
Прикладное программирование всегда занимается решением прикладных задач путем прикладывания усилий программиста для достижения результата в неидеальных условиях. Именно исходя из неидеальности этого мира и ограниченности ресурсов и складывается потребность в программистах: кому-то ведь надо помогать теоретикам упихать их стройную и красивую теорию в практику.
> — Как она сложена?
>
> — Превосходно! Только рука немного торчит из чемодана.
Именно пытаясь разместить стройную теорию алгоритма в жесткий рюкзак реальных ресурсов и приходится постоянно кроить по живому, перепаковывать, и вместо красивых и стройных определений Фибоначчи:
```
def fib(n):
if n<0: raise Exception("fib(n) defined for n>=0")
if n>1: return fib(n-1) + fib(n-2)
return n
```
приходится городить всевозможные грязные хаки, начиная от:
```
@memoized
def fib(n):
if n<0: raise Exception("fib(n) defined for n>=0")
if n>1: return fib(n-1) + fib(n-2)
return n
```
И заканчивая вообще:
```
def fib(n):
if n<0: raise Exception("fib(n) defined for n>=0")
n0 = 0
n1 = 1
for k in range(n):
n0, n1 = n1, n0+n1
return n0
```
### Так что же такое рекурсия?
Рекурсия, по сути, это доказательство по индукции. Мы рассказываем, как получить результат для некоего состояния, предполагая что у нас есть результат для другого набора состояний, так же рассказываем, как получить результат в тех состояниях, к которым всё скатывается так или иначе.
> Если вы ждете гостей и вдруг заметили на своем костюме пятно, не огорчайтесь. Это поправимо.
>
> Например, пятна от растительного масла легко выводятся бензином. Пятна от бензина легко снимаются раствором щелочи.
>
> Пятна от щелочи исчезают от уксусной эссенции. Следы от уксусной эссенции надо потереть подсолнечным маслом.
>
> Ну, а как выводить пятна от подсолнечного масла, вы уже знаете...
Теперь давайте рассмотрим классический пример: обход дерева в глубину. Впрочем нет, давайте рассмотрим другой пример: нам надо распечатать дерево выражений в форме обратной польской записи. То есть для дерева 1 мы хотим напечатать «2 2 +» а для дерева 2 «2 2 + 2 2 + \*».
**tex**
```
\begin{tikzpicture}
\node (is-root) {+}
child { node {2} }
child { node {2} };
\path (is-root) +(0,+0.5\tikzleveldistance)
node {\textit{Tree 1}};
\end{tikzpicture}
\begin{tikzpicture}
\node (is-root) {*}
child { node {+} [sibling distance=1cm] child {node{2}} child {node{2}} }
child { node {+} [sibling distance=1cm] child {node{2}} child {node{2}} };
\path (is-root) +(0,+0.5\tikzleveldistance)
node {\textit{Tree 2}};
\end{tikzpicture}
```
Как легко видеть, задача превращается в простой «обход дерева в глубину»: для каждого узла выводим содержимое всех его дочерних элементов, после чего выводим сам узел. То есть код будет:
```
class TreeNode(object):
def __init__(self, value=None, children=[]):
self.value = value
self.children = children
def printTree(node):
for child in node.children:
printTree(child)
print node.value,
def main():
tree1 = TreeNode("+", [ TreeNode(2), TreeNode(2) ])
tree2 = TreeNode("*", [ TreeNode("+", [ TreeNode(2), TreeNode(2) ]), TreeNode("+", [ TreeNode(2), TreeNode(2) ]) ])
print "Tree1:",
printTree(tree1)
print
print "Tree2:",
printTree(tree2)
print
if __name__ == "__main__":
main()
```
Казалось бы, всё отлично! Код прекрасно работает до тех пор, пока дерево соответствует требованиям: любой узел имеет массив детей (возможно пустой) и какое-либо значение. Кто скажет какое еще требование к этому дереву?
Не буду томить. Требование: не сильно большая глубина дерева. Как так? А вот как:
```
def buildTree(depth):
root = TreeNode("1")
node = root
for k in range(depth):
node = TreeNode("--", [ node ])
return node
def depthTest(depth):
tree = buildTree(depth)
print "Tree of depth", depth, ":",
printTree(tree)
def main():
for d in range(10000):
depthTest(d)
```
Запускаем, и ууупс! «Tree of depth 997: RuntimeError: maximum recursion depth exceeded». Лезем в документацию, и обнаруживаем функцию [sys.getrecursionlimit](https://docs.python.org/2/library/sys.html#sys.getrecursionlimit). А теперь давайте отойдём от мира интерпретируемых языков, и перейдём в мир языков, которые запускаются прямо на процессоре. Например, на C++.
Мысленно перепишем 1-в-1 этот код на С++ (оставлю эту задачу читателю в качестве разминки), и попробуем найти предел, когда приложение упрется в ограничение…
**для ленивых**
```
#include
#include
#include
using namespace std;
class TreeNode {
public:
string value\_;
vector children\_;
TreeNode(const string& value, const vector& children):
value\_(value), children\_(children) {}
virtual ~TreeNode() {}
};
void printTree(const TreeNode\* node) {
for(auto i : node->children\_)
printTree(i);
cout << node->value\_ << " ";
}
TreeNode\* buildTree(const int depth) {
auto root = new TreeNode("1", {});
auto node = root;
for(int i = 0; i children;
children.push\_back(node);
node = new TreeNode("--", children);
}
return node;
}
void depthTest(const int depth) {
auto tree = buildTree(depth);
cout << "Tree of depth " << depth << ": ";
printTree(tree);
cout << endl;
}
int main() {
for(int d=60000;; d+=16384) {
depthTest(d);
}
}
```
Запускаем… «Bus error (core dumped)». Судя по gdb, в момент падения стек глубиной 104790 фреймов. А что произойдёт, если мы захотим печатать не просто подряд через пробелы, а выводить еще "{" и "}" вокруг выражений? Ну то есть для дерева 1 чтобы результатом было {2 2 +} а для дерева 2 — {{2 2 +}{2 2 +}\*}? Перепишем…
```
def printTree(node):
opened = False
for child in node.children:
if not opened:
print "{",
opened = True
printTree(child)
print node.value,
if opened:
print "}",
```
Ничего не изменилось, по прежнему падает при попытке распечатать дерево глубиной 997. А теперь то же самое, но на плюсах… Опа. Глубина стека при падении — 87327. Стоп. Мы всего-то добавили одну локальную переменную, никак не влияющую на алгоритм и суть происходящего, а предельный размер дерева сократился на 17%! А теперь самое весёлое — всё это сильно зависит от опций компилятора, от того, на какой платформе выполняется, в какой ОС и с какими настройками.
Но не это самое смешное. Давайте представим, что эту функцию использует другая функция. Всё хорошо, если она одна такая — мы можем подсчитать, на сколько же фактических шагов меньше максимальная глубина. А если эта функция используется из другой рекурсивной? Тогда возможности этой функции будут зависеть от глубины другой функции.
Вот таким образом наш прекрасный простой алгоритм перестаёт внезапно влезать в наш несовершенный чемодан. Предоставлю читателю самому представить как хорошо иметь подобные ограничения в сервисе, который запущен в продакшене и предоставляет некий сервис ничего не подозревающим хакерам, которые только и делают, что тычут в этот сервис своими грязными fuzzy тестерами.
### Так в чем же проблема?
**Использование рекурсивного алгоритма подразумевает использование практически не контролируемого ресурса: стека вызовов**.
Во-1х, мы не можем точно знать сколько уже его использовано. Во-2х, мы не можем точно знать, сколько его еще осталось. В-3их мы не можем гарантировать доступность определённого размера этого ресурса к каждому вызову. В 4-ых, мы не можем фиксировать расход данного ресурса. Таким образом, мы попадаем в зависимость от ресурса, контролировать и распределять который чертовски сложно. В результате, мы не можем гарантировать каких либо характеристик данной функции/сервиса. Хорошо, если наш сервис работает в managed контексте: java, python, .net итп. Плохо, если сервис работает в неконтролируемой среде: [javascript](http://stackoverflow.com/questions/7826992/browser-javascript-stack-size-limit) (с которым вообще [всё плохо](https://www.safaribooksonline.com/library/view/high-performance-javascript/9781449382308/ch04s03.html)). Еще хуже, если сервис работает на C++, и [глубина](http://www.rapid7.com/db/vulnerabilities/http-openssl-cve-2014-0221) [рекурсии](http://www.openwall.com/lists/oss-security/2014/08/27/1) [зависит](https://bugs.mageia.org/show_bug.cgi?id=12842) от данных, переданных пользователем.
### Что же делать?
Если мы работаем не на микроконтроллере, о объёме стека можно не задумываться: для обычной цепочки вызовов его должно хватать. При условии, разумеется, что мы заботимся гигиене локальных переменных: большие объекты и массивы выделяются используя память (new/malloc). Однако использование рекурсии подразумевает, что вместо ограниченного количества вызовов, у нас их будет просто счетное.
Итак, чтобы избавиться от проблем, созданных рекурсией, можно сделать следующее (от простого к сложному):
— Жестко ограничить максимальный размер/формат/числа во входящих данных. Привет, [zip бомбам](https://ru.wikipedia.org/wiki/Zip-%D0%B1%D0%BE%D0%BC%D0%B1%D0%B0) и иже с ними — порой даже маленький входящий пакет может устроить большой переполох.
— Жестко ограничить максимальную глубину вызовов некоторым числом. Важно помнить, что это число должно быть ОЧЕНЬ небольшим. То есть порядка сотен. И обязательно добавить тесты, которые проверяют, что программа с этим максимальным числом не ломается. Причем с максимальным числом на всех возможных ветках исполнения (привет выделению локальных переменных по требованию). И не забывать проверять этот тест на разных опциях компилияции и после каждого билда.
— Жестко ограничить объём используемый стека. Используя сложные обходные маневры и знания о практической реализации исполнения в железе можно получить размер стека, который использован сейчас (типа взятия адреса локальной volatile переменной). В некоторых случаях (например, через libunwind в linux'е) можно получить так же доступный объём стека текущему потоку, и взять между ними разницу. При использовании подобного метода важно иметь тесты, проверяющие, что отсечение работает гарантированно и при всех вариантах входных данных — например, может получиться весело, если проверка идёт в одном методе, который рекурсивен через 3-4 других. И оно может упасть в промежуточном… Но только в режиме релиза, после inline'а некоторых функций, например. Впрочем, тут еще важны тесты на максимальную допустимую сложность, чтобы невзначай не отсечь часть корректных входных запросов, которыми клиенты реально пользуются.
— Лучший способ: **избавиться от рекурсии**.
> И не лги, что ты волен и свят — Ты пленен и неволен.
>
> Я раскрыл пред тобой небосвод!
>
> Времена изменяют свой ход — Посмотри на ладони…
>
>
>
> Беспредельная сладость свободы
>
> Отринуть свободу
>
> [Сергей Калугин](http://www.lib.ru/KSP/kalugin.txt#3)
Да-да. После постижения Дао рекурсии постигаешь так же Дао отказа от рекурсии. Практически все рекурсивные алгоритмы имеют нерекурсивные аналоги. Начиная от более эффективных (см. выше Фибоначчи), и заканчивая эквивалентными, использующими очередь в памяти вместо стека вызовов.
Каноническая нерекурсивная реализацию обхода дерева в глубину:
```
def printTree(node):
stack = [ (node, False, False) ]
while len(stack)>0:
i = len(stack)-1
node, visited, opened = stack[i]
if not visited:
for child in reversed(node.children):
if not opened:
print "{",
opened = True
stack.append( (child, False, False) )
visited = True
stack[i] = (node, visited, opened)
else:
print node.value,
if opened:
print "}",
del stack[i]
```
Как легко видеть, алгоритм не изменился, но вместо использования стека вызовов используется массив stack, размещенный в памяти, и хранящий как контекст обработки (в нашем случае — флаг opened) так и контекст обработки (в нашем случае — до или после обработки детей). В случаях, когда нужно что-то делать между каждым из рекурсивных вызовов, либо добавляются фазы обработки. Обратите внимание: это уже оптимизированный алгоритм, складывающий всех детей в стек сразу, и именно поэтому складывающий в обратном порядке. Это гарантирует сохранение того же порядка, что и у исходного нерекурсивного алгоритма.
Вот этот же код, только написанный «в лоб», сохраняя контекст (заодно, выводящий запятые между элементами):
```
def printTree(node):
stack = [ (node, 0) ]
while len(stack)>0:
i = len(stack)-1
node, phase = stack[i]
if phase < len(node.children):
child = node.children[phase]
if phase == 0:
print "{",
if phase > 0:
print ",",
stack.append( (child, 0) )
stack[i] = (node, phase+1)
else:
print node.value,
if phase>0:
print "}",
del stack[i]
```
Да, переход на безрекурсивные технологии не совсем бесплатен: мы платим периодически более дорогим — динамическим выделением памяти для организации стека. Впрочем, это окупается: в «ручной стек» сохраняются не вообще все локальные переменные, а только минимально необходимый контекст, размер которого уже можно контролировать. Вторая статья расходов: читабельность кода. Код, записанный в нерекурсивном виде несколько сложнее для восприятия за счет ветвлений от текущего состояния. Решение этой проблемы лежит уже в области организации кода: вынесение шагов в отдельные функции и грамотное их наименование.
### Злоключение
Несмотря на наличие некоего «налога на обезрекурсивание», я лично считаю его обязательным к уплате в любом месте, где идёт обработка данных, так или иначе поступивших от пользователя.
**А как не используете рекурсию вы?** | https://habr.com/ru/post/256351/ | null | ru | null |
# Эволюция игрового фреймворка. Сервер на Python. Часть 1. Слои инфраструктуры
Допустим, у нас большие планы, и мы хотим реализовать серверную часть для всех основных игровых жанров. Однако, прежде, чем приступить к этому, нужно хорошенько подготовиться. Нужно создать такую основу, которая бы подходила для каждой игры, чтобы потом не нужно было ничего переделывать на пол-пути. В том числе и все сделанные на тот момент игры.
Главная наша задача — совместить несовместимое, выработать такое решение, которое бы позволяло создавать игровые приложения любой сложности **качественно** и максимально **быстро**! Сочетание этих несовместимых, казалось бы, условий обеспечит нам фреймворк, эволюцию которого мы и намерены здесь проследить. В первой статье будет описано создание инфраструктурного фреймворка, а во второй — разработка логики на его основе. Всего — две статьи на описание методологии разработки всей серверной части.
В качестве языка программирования выберем Python за его простоту и элегантность. Мы начнем в сокетов (`asyncio`), а закончим HTTP-сервером. Наша задача состоит в том, чтобы код логики не зависел от типа сервера и задействованных сетевых протоколов.
1. [Исходная точка](https://habr.com/ru/post/678658/#section1)
2. [Разделение логики и инфраструктуры](https://habr.com/ru/post/678658/#section2)
3. [Разделение форматирования и передачи сообщений](https://habr.com/ru/post/678658/#section3)
4. [Разделение логики на контроллеры](https://habr.com/ru/post/678658/#section4)
5. [Состояние](https://habr.com/ru/post/678658/#section5)
6. [Репозиторий](https://habr.com/ru/post/678658/#section6)
7. [HTTP-сервер](https://habr.com/ru/post/678658/#section7)
8. [Выводы](https://habr.com/ru/post/678658/#section8)
Исходная точка
--------------
При разборе [клиента](https://habr.com/ru/post/677312/) мы проследили, как из отображения выделяется логика — сначала модель, а потом и контроллер. Потом мы все игровые действия вместо вызовов методов сделали простыми объектами-командами. Так как отображение и логика взаимодействуют исключительно такими командами, то отображению становится все равно, где находится логика — в том же приложении или в другом, запущенном на иной машине, расположенной за тысячи километров. На клиенте контроллер без логики, таким образом, превращается в простой шлюз между отображением и логикой, между клиентом и сервером.
На сервере, прежде чем команды дойдут до логики, мы должны установить соединение с клиентом и принять от него сообщения. После этого мы декодируем их в объекты команд и передаем их соответствующей функции бизнес-логики на обработку. Таким образом, вокруг логики выстраивается целый массив инфраструктуры, которую нам предстоит упорядочить. Чтобы разобраться в ней самым внимательным образом, начнем с самого простого примера сокет-сервера.
Про то, как реализованы сокеты в Python, мы писали в [другом месте](https://habr.com/ru/post/676110/). Тут мы продолжим с того, на чем закончили [там](https://habr.com/ru/post/676144/) — с TCP-сервера на [asyncio](https://docs.python.org/3/library/asyncio.html). Добавим в него кодирование и обработку сообщений, а также возможность отправлять их другим клиентам. В результате чего наша первая версия программы будет выглядеть так:
```
last_index = 0
writers = []
async def handle_connection(reader, writer):
global last_index
global writers
writers.append(writer)
last_index += 1
index = last_index
print("+Connected")
unparsed_bytes = b""
while True:
# Receive
try:
request_bytes = await reader.read(1024)
except ConnectionError:
break
if reader.at_eof():
break # Disconnected by client
request_bytes = unparsed_bytes + request_bytes
request_bytes_list = request_bytes.split(b"\x00")
unparsed_bytes = request_bytes_list.pop()
# Process
for request_bytes in request_bytes_list:
if not request_bytes:
continue
request = request_bytes.decode("utf8")
print(" >> Received: {repr(request)}")
try:
command = json.loads(request)
to_self_command, to_all_command = await handle_command(index, command)
except Exception as e:
print(f"[SERVER#{index}] Error while parsing or processing: {e}")
to_self_command, to_all_command = {"error": str(e)}, None
self_response = json.dumps(to_self_command) if to_self_command else None
all_response = json.dumps(to_all_command) if to_all_command else None
print(f" << Send: {repr(self_response)} as self_response and commands: "
f"{repr(all_response)} to all {len(writers)} connections")
if self_response:
to_self_bytes = self_response.encode("utf8") + b"\x00"
try:
writer.write(to_self_bytes)
await writer.drain()
except ConnectionError:
pass # Yet must send to others
if all_response:
to_all_bytes = all_response.encode("utf8") + b"\x00"
for w in writers:
try:
w.write(to_all_bytes)
except ConnectionError:
continue
await asyncio.gather(w.drain() for w in self.writers)
writers.remove(writer)
writer.close()
print(f"-Disconnected")
async def main(host, port):
print(f"Start server: {host}:{port}")
server = await asyncio.start_server(handle_connection, host, port)
async with server:
await server.serve_forever()
HOST, PORT = "", 5554
if __name__ == "__main__":
asyncio.run(main(HOST, PORT))
```
Это был код, отвечающий за пересылку и первичную обработку сообщений. Бизнес-логика реализована в `handle_command()`. В ней реализовано всего три команды: взять, поместить и изменить (get, set, update). Так как в логике могут присутствовать запросы к базам данным или внешним сервисам, то, чтобы не блокировать выполнение программы на это время, данная функция также сделана асинхронной (`async`):
```
storage = {}
async def handle_command(index, command):
global storage
key = command.get("key")
code = command.get("code")
if code == "get":
state = storage.get(key)
return {"success": True, **command, "state": state}, None
elif code == "set":
state = command.get("state")
storage[key] = state
return {"success": True, **command}, None
elif code == "update":
index = command.get("index")
value = command.get("value")
if not isinstance(index, int) or not isinstance(value, int):
return {"success": False, **command}, None
state = storage.get(key)
if state is None:
storage[key] = state = []
if index >= len(state):
state += [0] * (index - len(state) + 1)
state[index] = value
return None, {"success": True, **command}
return None, None
```
Пока что все соединения сохраняются в простой массив `writers`, а в обработчике команд (`handle_command()`) мы различаем только два типа адресатов для ответных команд: назад к себе (`to_self_command`), и ко всем (`to_all_command`). Это самый примитивный подход и в одном из следующих примеров мы заменим его на перечисление индивидуальных адресатов по их индексам. Обработчик команд будет возвращать массив кортежей, каждый из которых в первом элементе будет содержать список индексов соединений, а во втором список команд, которые им предназначаются: `result = [(indexes, commands), (indexes2, commands2)]`. Соответственно, все соединения должны будут сохраняться не в списке `writers`, как раньше, а в словаре `writer_by_index`. Но пока вернемся к архитектуре приложения.
Разделение логики и инфраструктуры
----------------------------------
Сейчас наше приложение цельное и неразделимое, а потому максимально "нереюзабельное". Другими словами, мы не можем использовать отдельные его части повторно, так как все они жестко связаны друг с другом. Хоть логика и вынесена в отдельную функцию `handle_command()`, но в `handle_connection()` вместо нее нельзя подставить другую. Если мы захотим написать новое приложение с другой логикой, то нам придется копировать и `handle_connection()`. Конечно, нас это не устраивает.
В качестве быстрого решения можно передавать ссылку на функцию с логикой (`handle_command()`) в параметрах `handle_connection()`. Или можно вынести обе функции в класс, а в подклассах их переопределять. Но лучше всего логику (обработку команд) и инфраструктуру (обмен командами по сети) вообще реализовать в двух разных классах.
Преимущество классов перед отдельными функциями в том, что в них можно хранить собственный контекст из переменных-членов (атрибутов), а также группировать и переопределять в подклассах методы.
Разделение приложения на инфраструктуру (Server) и логику (Logic)Разделение на два класса задает два магистральных пути развития в разработке сервера. С одной стороны мы можем подготовить разные типы и версии функционала по передаче объектов (Server), с другой — наделать кучу разных игр (Logic). И все это независимо друг от друга. Единственное условие, которое должно соблюдаться, это чтобы класс логики содержал метод с такой сигнатурой: `handle_command(self, index, command)`:
```
class SocketServer:
def __init__(self, logic, host, port):
self.logic = logic
self.host = host
self.port = port
self.writers = []
def run(self):
asyncio.run(self.main())
async def main(self):
print(f"Start server: {self.host}:{self.port}")
server = await asyncio.start_server(handle_connection, host, port)
async with server:
await server.serve_forever()
async def handle_connection(self, reader, writer):
...
# Call:
# to_self_command, to_all_command = await self.logic.handle_command(index, command)
# instead of:
# to_self_command, to_all_command = await handle_command(index, command)
class MyLogic:
# global storage -> self.storage
def __init__(self):
self.storage = {}
async def handle_command(self, index, command):
...
```
Код запуска при этом немного изменится:
```
HOST, PORT = "", 5000
if __name__ == "__main__":
server = SocketServer(MyLogic(), HOST, PORT)
server.run()
```
Таким образом, сервер получает определенный класс логики и обращается к нему согласно интерфейсу. Связь эта односторонняя, так как логика ничего не знает об инфраструктуре.
Это был только первый шаг. Следующим будет — отделение функционала по транспортировке сообщений (сокеты) от способа их кодирования (JSON, YML, XML).
Разделение форматирования и передачи сообщений
----------------------------------------------
Отделить логику приложения от инфраструктуры было хорошей идеей. В результате логика просто преобразуют одни команды в другие, попутно меняя свое состояние. При этом она не задумывается, откуда они берутся и куда деваются. За все это отвечает класс сервера (`SocketServer`). Вот сервером сейчас и займемся. Посмотрим, на какие части, в свою очередь, распадается он сам.
Заглянув внутрь него, мы увидим, что определенный способ обработки сообщений (JSON) там жестко завязан на определенный способ их передачи (TCP-сокеты). И если мы захотим использовать другой формат передачи данных, то нам заодно придется скопировать кучу кода, к формату не относящегося.
Первое решение, которое приходит на ум — реализовать данные функции в разных методах (выделить методы `parse()` и `serialize()`):
```
class SocketServer:
def __init__(self, logic, host, port) -> None:
self.logic = logic
self.host = host
self.port = port
self.last_index = 0
self.writer_by_index = {}
async def handle_connection(self, reader, writer):
self.last_index += 1
index = self.last_index
self.writer_by_index[index] = writer
print(f"[SERVER#{index}] +Connected")
unparsed_bytes = b""
while True:
# Receive
try:
request_bytes = await reader.read(1024)
except ConnectionError:
break
if reader.at_eof():
print(f"[SERVER#{index}] EOF. Connection closed")
break
request_bytes = unparsed_bytes + request_bytes
# Handle
result, unparsed_bytes = await self.handle_bytes(index, request_bytes)
# Send response
await self.send(result)
print(f"[SERVER#{index}] -Disconnected")
del self.writer_by_index[index]
writer.close()
async def handle_bytes(self, index, request_bytes):
# Decode request
request, unparsed_bytes = self.parse(request_bytes)
# Make response
try:
# Parse request
command = json.loads(request)
# Process request
result = self.logic.handle_command(index, command)
except Exception as e:
print(f"[SERVER#{index}] Error while parsing or processing: {request} {traceback.format_exc()}")
result = [([index], [{"error": str(e)}])]
return result, unparsed_bytes
async def send(self, result):
if not result:
return
# Serialize
result = [(indexes, self.serialize(commands))
for indexes, commands in result]
# Send
wait_writers = []
for indexes, response_bytes in result:
for i in indexes:
writer = self.writer_by_index.get(i)
if writer:
try:
writer.write(response_bytes)
wait_writers.append(writer)
except ConnectionError:
continue
await asyncio.gather(writer.drain() for writer in wait_writers)
def parse(self, data_bytes):
request_bytes, unparsed_bytes = request_bytes.split(b"\x00")
request = request_bytes.decode("utf8")
return request, unparsed_bytes
def serialize(self, data):
return json.dumps(commands).encode("utf8") + b"\x00"
```
Теперь, например, если мы захотим изменить JSON на YML, то нам нужно всего лишь наследоваться от SocketServer и переопределить `parse()` и `serialize()`. Но при таком подходе остается все тот же недостаток при комбинировании разных функционалов. Для каждой комбинации придется создавать отдельный класс: JSONTCPSocketServer, YMLUDPSocketServer, JSONHTTPServer и так далее. Рассмотрим данный вопрос подробнее.
Код по доставке (сокеты) и код по форматированию (JSON) остается в одном классе. Это значит, что если нужно создать классы для двух типов сокетов (TCP и UDP) и трех видов форматов (JSON, YML, XML), то в итоге мы получим 2 \* 3 = 6 классов для всех возможных комбинаций. Хотя должно быть по идее 2 + 3 = 5. Пусть 6 и 5 отличаются не сильно, но иметь в качестве закона возрастания кода умножение вместо сложения дает уже на следующем этапе избыточность в 33 % (3 \* 3 = 9, 3 + 3 = 6). И то, что код при этом не дублируется — заслуга Python'а (множественное наследование), а не наша.
Выделение парсера как отдельного инфраструктурного слояПоэтому лучше поступить по-нормальному и разнести доставку и первичную обработку сообщений по разным классам. В данном случае вынести из класса сервера парсер:
```
class SocketServer:
def __init__(self, parser, logic, host, port) -> None:
self.parser = parser
self.logic = logic
self.host = host
self.port = port
self.last_index = 0
self.writer_by_index = {}
# ...
async def handle_bytes(self, index, request_bytes):
try:
# Parse
commands, unparsed_bytes = self.parser.parse(request_bytes)
# Handle
result = await self.logic.handle_commands(index, commands)
except Exception as e:
result = [([index], [{"error": str(e)}])]
unparsed_bytes = b""
return result, unparsed_bytes
async def send(self, result):
if not result:
return
# Serialize
result = [(indexes, self.parser.serialize(commands))
for indexes, commands in result]
# Send
wait_writers = []
for indexes, response_bytes in result:
for i in indexes:
writer = self.writer_by_index.get(i)
if writer:
try:
writer.write(response_bytes)
wait_writers.append(writer)
except ConnectionError:
continue
await asyncio.gather(writer.drain() for writer in wait_writers)
class Parser:
def parse(self, data_bytes):
return data_bytes, b""
def serialize(self, data):
return data
class JSONParser(Parser):
def parse(self, data_bytes):
# Get unparsed_bytes
data_bytes, unparsed_bytes = data_bytes.rsplit(b"\x00", 1)
# bytes -> list of str
data_str = data_bytes.decode("utf8")
message_list = data_str.split("\x00")
# Parse JSON commands (suppose, a command cannot be a list)
result = []
for message in message_list:
if not message:
continue
commands = json.loads(message)
if not commands:
continue
if isinstance(commands, list):
result.extend(commands)
else:
result.append(commands)
return result, unparsed_bytes
def serialize(self, data):
if not data:
return b""
data_str = json.dumps(data)
data_bytes = data_str.encode("utf8") + b"\x00"
return data_bytes
class MyLogic:
async def handle_commands(self, index, commands):
# Custom logic
result = []
for command in commands:
key = command.get("key")
code = command.get("code")
...
return result
HOST, PORT = "", 5000
if __name__ == "__main__":
server = SocketServer(JSONParser(), MyLogic(), HOST, PORT)
server.run()
```
Остановимся на кое-каких технических деталях.
Сервер может за раз принять одно сообщение, а может принять и несколько — в зависимости от того, сколько в потоке байтов присутствует разделителей. Сколько было в буфере, столько и возвращает. Да и в каждом сообщении, в принципе, можно отправлять сразу несколько команд вместо одной. Поэтому логично в парсере возвращать сразу список команд и условиться, что всегда возвращаться будет только список. Соответственно, и `handle_command()` будет принимать и возвращать команды только списками. Потому он и переименован теперь в `handle_commands()`.
То, что мы передаем в парсер байты, а не декодированные в UTF-8 строки, позволяет нам реализовывать в них собственные кастомные бинарные протоколы. Разграничение сообщений нулевым символом (`b"\x00"`) помещено в парсер по этой же причине. Если удалось распарсить команду, она возвращается. Если нет — возвращаются байты, чтобы позже к ним добавить новые и повторить попытку.
Как вы могли заметить, мы перешли от массовой адресации сообщений к точечной, о которой уже говорили выше. То есть вместо отсылки данных всем соединениям в списке `writers`, мы можем теперь отправлять команды по конкретным индексам соединений из словаря `writer_by_index`. Для этого `handle_commands()` к каждому списку команд добавляет еще список индексов соединений, которым они предназначены.
Чтобы по-прежнему можно было делать массовую отправку, нужно сохранять все индексы в хранилище при подключении, а при отключении — удалять их из списка. Поэтому в класс логики добавляется еще пара методов: `on_connect()` и `on_disconnect()`:
```
class SocketServer:
# ...
async def handle_connection(self, reader, writer):
...
result = []
await self.logic.on_connect(index, result)
await self.send(result)
unparsed_bytes = b""
while True:
...
result = []
await self.logic.on_disconnect(index, result)
await self.send(result)
del self.writer_by_index[index]
writer.close()
class MyLogic:
def __init__(self):
self.storage = {}
async def on_connect(self, index, result):
indexes = self.storage.get("indexes")
if indexes is None:
self.storage["indexes"] = [index]
else:
indexes.append(index)
async def on_disconnect(self, index, result):
indexes = self.storage.get("indexes")
if indexes and index in indexes:
indexes.remove(index)
async def handle_commands(self, index, commands):
# Custom logic
result = []
all_indexes = self.storage.get("indexes")
for command in commands:
key = command.get("key")
code = command.get("code")
if code == "get":
state = storage.get(key)
result.append((all_indexes, [{"success": True, **command, "state": state}]))
elif code == "set":
state = command.get("state")
storage[key] = state
result.append(([index], [{"success": True, **command}]))
elif code == "update":
index = command.get("index")
value = command.get("value")
if not isinstance(index, int) or not isinstance(value, int):
result.append(([index], [{"success": False, **command}]))
continue
state = storage.get(key)
if state is None:
storage[key] = state = []
if index >= len(state):
state += [0] * (index - len(state) + 1)
state[index] = value
result.append((all_indexes, [{"success": True, **command}]))
return result
```
Разделение логики на контроллеры
--------------------------------
Допустим далее, что нам нужно сделать серверы по игре в шахматы, шашки, крестики-нолики... Для каждого создается отдельный класс логики, где переопределяется лишь один метод `handle_commands()` — и никакого дублирования кода. Передаем в конструктор `SocketServer` первым аргументом объект логики, и сервер готов к использованию:
```
class ChessLogic(MyLogic):
async def handle_commands(self, index, commands):
...
class CheckersLogic(MyLogic):
async def handle_commands(self, index, commands):
...
HOST, PORT = "", 5000
if __name__ == "__main__":
server = SocketServer(JSONParser(), CheckersLogic(), HOST, PORT)
server.run()
```
Но возможно, у вас уже возник закономерный вопрос. А что, если мы захотим создать сервер, где можно было бы по выбору играть и в шахматы, и в шашки? Вот тут уже придется изгаляться. Здесь нужен какой-то класс-диспетчер логики, который будет перенаправлять команды к соответствующему обработчику:
```
class ComboLogic:
def __init__(self) -> None:
self.chess = ChessLogic()
self.checkers = CheckersLogic()
# Use same storage for all
self.chess.storage = self.checkers.storage = self.storage = {}
async def on_connect(self, index, result):
...
async def on_disconnect(self, index, result):
...
async def handle_commands(self, index, commands):
# Custom logic
result = []
for command in commands:
key = command.get("key")
if key == "chess":
result.extend(await self.chess.handle_commands(index, commands))
elif key == "checkers":
result.extend(await self.checkers.handle_commands(index, commands))
return result
HOST, PORT = "", 5000
if __name__ == "__main__":
server = SocketServer(JSONParser(), ComboLogic(), HOST, PORT)
server.run()
```
Несложно заметить в цикле обработки команд явное дублирование кода (`handle_commands()` и `extend()`). Попробуем его устранить с помощью словаря:
```
class ComboLogic:
def __init__(self) -> None:
self.logic_by_key = {
"chess": ChessLogic(parser),
"checkers": CheckersLogic(parser),
}
self.storage = {}
# Provide common storage
for logic in self.logic_by_key.items():
logic.storage = self.storage
# ...
async def handle_commands(self, index, commands):
# Custom logic
result = []
for command in commands:
key = command.get("key")
logic = self.logic_by_key.get(key)
if logic:
result.extend(await logic.handle_commands(i, [command]))
return result
HOST, PORT = "", 5000
if __name__ == "__main__":
logic_by_key = {
"chess": ChessLogic(),
"checkers": CheckersLogic(),
}
server = SocketServer(JSONParser(), ComboLogic(logic_by_key), HOST, PORT)
server.run()
```
Сейчас класс логики выбирается по одному из свойств команды — `key`. Но впоследствии, когда будут реализованы комнаты (rooms) и перемещения игроков по ним, можно будет выбирать обработчик команды по тому, в какой комнате, в какой игре находится пользователь. Если он в покер-руме, по умолчанию берется логика покера, если за шахматным столом — логика шахмат.
Выделение из логики менеджера контроллеров (Application) как часть инфраструктурыНалицо фактическое разделение логики на два типа классов: диспетчер (`ComboLogic`) и собственно реализации логики (`ChessLogic`, `CheckersLogic`). У последних из общего только интерфейс с сигнатурой метода `handle_commands()`. А диспетчер всегда один и тот же для всех приложений и никогда не меняется. Фактически он превратился в движок приложения, поэтому его уместнее будет переименовать в `Engine`, или лучше — в `Application`. А логику отдельных игр тогда — в контроллеры:
```
class Application:
def __init__(self, default_controller, controller_by_key=None) -> None:
self.default_controller = default_controller
self.controller_by_key = controller_by_key or {}
self.storage = {} # App state
async def on_connect(self, index, result):
if self.default_controller:
self.default_controller.on_connect(storage, index, result)
async def on_disconnect(self, index, result):
if self.default_controller:
self.default_controller.on_disconnect(storage, index, result)
async def handle_commands(self, index, commands):
result = []
# Handle
for command in commands:
key = command.get("key")
controller = self.controller_by_key.get(key, self.default_controller)
if controller:
await controller.handle_command(self.storage, index, command, result)
return result
class MyController:
# To be able to send commands to all current connections
async def on_connect(self, storage, index, result):
indexes = storage.get("indexes")
if indexes is None:
storage["indexes"] = [index]
else:
indexes.append(index)
async def on_disconnect(self, storage, index, result):
indexes = storage.get("indexes")
if indexes and index in indexes:
indexes.remove(index)
async def handle_command(self, storage, index, command, result):
...
class ChessController:
async def handle_command(self, storage, index, command, result):
...
class CheckersController:
async def handle_command(self, storage, index, command, result):
...
HOST, PORT = "", 5000
if __name__ == "__main__":
controller_by_key = {
"chess": ChessLogic(),
"checkers": CheckersLogic(),
}
app = Application(MyController(), controller_by_key)
server = SocketServer(JSONParser(), app, HOST, PORT)
server.run()
```
Содержимое методов `on_connect()` и `on_disconnect()` было вынесено из приложения в контроллер по умолчанию, так как данная логика весьма специфическая и может меняться от приложения к приложению. Мы не должны для этого переопределять класс `Application`.
Отметим также, что в контроллерах теперь не `handle_commands()`, а `handle_command()`. То есть команды обрабатываются по одной. Это удобнее, так как не нужно каждый раз делать обработку в цикле. И главное — диспетчер все равно будет передавать на обработку по одной команде, так как любая команда в массиве может требовать своего собственного обработчика.
Еще, результат больше не возвращается через return, а передается в виде списков в аргументах. Это тоже упрощает реализацию обработчиков.
И последнее. Так как контроллеры — это в сущности всего лишь часть общей логики приложения, то все они должны использовать одно общее состояние (`storage`). Сами контроллеры состояния не имеют и иметь не могут. Они — логика в самом чистом виде. Поэтому при каждом вызове `handle_command()` среди прочих аргументов передается и ссылка на состояние приложения.
Состояние
---------
Скажем напоследок пару слов о состоянии и о том, как оно у нас получилось таким, каким получилось.
В ООП подходе все само собой складывается так, что для каждой логической сущности создается программный объект с свойствами и методами. В свойствах хранится текущее состояние сущности, а в методах реализуются функции, которые это состояние изменяют.
При таком подходе все состояние приложения размазано тонким слоем по десяткам и сотням таких объектов. Чтобы сохранить состояние всего приложения в файл, придется обойти все объекты, собрать все их свойства и перевести в простые JSON-объекты. А чтобы загрузить, восстановить приложение из файла, придется воссоздать по иерархии JSON-объектов иерархию наших программных объектов, определить нужный класс для каждого, учитывая параметры конструкторов, и потом восстановить значения всех его свойств (даже приватных). В общем, ясно, что это очень и очень сложно и муторно.
Тут сначала может появиться идея, что все свойства объекта можно просто хранить в словаре. И не перебирать свойства объекта, когда его нужно сохранить, а просто отдавать этот словарь. Следующей мыслью возникает вопрос. А зачем нам вообще восстанавливать все эти объекты — их иерархию и внутреннее состояние? Почему не оперировать изначально чистой JSON-структурой? Тогда и объекты никакие нужны не будут, а будут одни функции. Простой набор функций.
По счастью, Python мультипарадигменный язык программирования, и на нем можно писать и в ООП-стиле, и в процедурном, и в функциональном. Мы начали с самой простой возможной реализации сервера — процедурной. Поэтому состояние у нас было изначально в отдельном словаре, общем на все приложение.
Когда мы перешли к ООП, мы сохранили использование централизованного состояния. Мы не стали его распределять по классам, потому что в этом не было никакого смысла. Классы мы применяли лишь для группировки функций и возможности подменять реализации некоторых из них в подклассах (см. паттерн [шаблонный метод](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BC%D0%B5%D1%82%D0%BE%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))). (Если же мы сможем так организовать методы, чтобы вообще не менять в них состояние, то перейдем к математической концепции функций — к функциональному стилю.)
Повезло нам с состоянием? Не совсем. Все дело в методике разработки. Всегда нужно начинать с самого простой возможной версии, а потом добавлять в нее только то, без чего нельзя обойтись. Тогда про многие проблемы вы даже и не узнаете, что они бывают.
Репозиторий
-----------
В объектах команд помимо названия действия, которое нужно выполнить, также обычно указывается объекты, которые в этом участвуют. Например, чтобы передвинуть что-то на игровом поле, нужно явно определить, что вы будете двигать и куда. Если поле имеет декартову систему координат, то объекты можно указать через координаты. В противном случае придется использовать уникальные идентификаторы (id). Впрочем идентификаторы можно часто применять и параллельно с координатами (указывать или то, или другое).
Также возможны команды, которые будут требовать обращения к свойствам объекта. Тогда поля в команде могут иметь следующий формат: `"{id}.{property}"`. Таким же образом можно обращаться и к различным вложенным объектам, например: `"id1.inner_id2.inner_id3"`.
Сейчас состояние реализовано простым классом `dict`. Поэтому в коде мы не можем просто вызывать: `object = storage.get("id1").get("inner_id2").get("inner_id3")`, так как какого-то промежуточного элемента может и не быть, и тогда возникнет исключение. Но и делать проверки для каждого id мы не можем, так как для этого придется добавить много "глупого" кода. Мы не хотим загромождать нашу логику разными дурацкими проверками, но и не добавить их тоже не можем. Поэтому в идеале для получения объекта должна вызываться только одна функция: `object = storage.get("id1.inner_id2.inner_id3")` (все проверки и прочая логика должны выполняться в ней автоматически). А для этого придется создать новый класс для хранилища:
```
class Storage:
def __init__(self):
self.storage = {}
def get(self, path):
return resolve_path(self.storage, path)
def set(self, path, value):
...
def update(self, path, value):
...
def delete(self, path):
...
def resolve_path(target, path=None):
if not path or target is None:
return target
current = target
keys = path.split(".")
for key in keys:
if isinstance(current, dict):
current = current.get(key)
else:
return None
return current
```
Аналогично `get()` будут выполнены и остальные методы: `set()`, `update()`, `delete()`. Если промежуточный вложенный объект отсутствует, то можно либо возвращать `None`, либо создавать пустой `dict` на его месте. Также можно добавить в `get()` значение по умолчанию (`get(path, default=None)`), которое будет установлено (`set()`), если `get(path)` возвращает `None`.
Когда у нас есть собственный класс вместо стандартного, нам становится проще добавлять в него новые функции. Например, хранилище можно синхронизировать с базой данных или делать периодическое автосохранение полностью всего состояния в файл, чтобы игру можно было восстановить при случайном падении сервера.
В `Application`, таким образом, можно подставлять разные реализации хранилища, лишь бы они использовали тот же интерфейс. Тогда можно выбирать нужную стратегию работы с данными (получение и хранение) без всяких изменений со стороны контроллеров. Бизнес-логика не будет даже подозревать откуда берутся данные и сохраняются ли они в БД или нет. Это не их забота.
Выделение хранилища (Repository) как отдельного слоя инфраструктурыВ [DDD](https://en.wikipedia.org/wiki/Domain-driven_design) такой фасад для доступа к данным, который к тому же может поддерживать их целостность и актуальность, называется репозиторием (Repository). Поэтому мы вполне можем использовать и это название вместо Storage.
Сюда же можно добавить и настройки приложения. Чтобы не путать их с состоянием, добавим для них метод: `getconfig(path)`. Все настройки приложения можно хранить в специальном файле (лучше всего для этого подходит формат YML) и загружать при его запуске. Поэтому методы `setconfig()` и `updateconfig()` не нужны.
Начальные состояния объектов также можно хранить в настройках, откуда оно будет копироваться при создании объекта состояния. На этот случай можно также создать отдельный метод:
```
class Repository:
# ...
def create(self, config_path=None, initial=None):
if self.state is None:
return None
# Get initial
config = self.getconfig(config_path, {}) if config_path else {}
initial = {**config, **initial}
id = initial.get("id")
if id is None:
# Generate id
...
# Set
return self.set(id, initial)
```
Так как теперь может существовать несколько вариаций хранилища, мы должны иметь возможность задать одну из них при инициализации приложения:
```
class Application:
def __init__(self, default_controller, controller_by_key=None, storage=None) -> None:
self.default_controller = default_controller
self.controller_by_key = controller_by_key or {}
self.storage = storage if storage else Repository() # App state
HOST, PORT = "", 5000
if __name__ == "__main__":
controller_by_key = {
"chess": ChessLogic(),
"checkers": CheckersLogic(),
}
app = Application(MyController(), controller_by_key, Repository())
server = SocketServer(JSONParser(), app, HOST, PORT)
server.run()
```
HTTP-сервер
-----------
Без сокет-сервера не обойтись, если игра многопользовательская, и нужно как можно быстрее оповещать всех участников о происходящий в приложении событиях. Но если мы строим ферму или наряжаем ёлочку, то нам достаточно простого HTTP-сервера, ведь все события мы генерируем сами на клиенте. Даже если что-то происходит само на сервере, то это происходит прогнозируемым образом. А значит, в одном из сообщений сервер даст знать клиенту, в какой момент тому нужно сделать запрос, чтобы проверить, не случилось ли чего. Давайте теперь посмотрим, насколько сильно изменится наша реализация при использовании HTTP-протокола.
HTTP-сервер — это тоже сокет-сервер, но с тем отличием, что соединение разрывается сразу после отправки первого же ответного сообщения. Алгоритм его работы такой: сокет-соединение устанавливается, принимается запрос от клиента, он обрабатывается, и отсылается ответное сообщение на клиент. В конце каждой отправки соединение тут же закрывается.
Изолирование логики от инфраструктуры позволяет нам использовать логику повторно с любым типом серверов без всяких изменений в классах логики. Единственное, что будет меняться — это кое-какие слои инфраструктуры. В инфраструктуре первым делом изменяется способ транспортировки сообщений — слой Server.
HTTP — протокол стандартный и широко известный. Поэтому существует множество реализаций такого типа серверов, в том числе и на Python: Django, Twisted, Tornado. Мы выберем один из самых популярных и минималистичных — Flask. Принцип его работы можно проиллюстрировать следующим примером:
```
import json
from flask import Flask, send_file, request
app = Flask(__name__)
def handle(request):
return {}
@app.route("/storage/")
def storage(key):
response = handle(request)
return response
```
Главная задача данных фреймворков — это преобразование строковых HTTP-сообщений в объекты request и response. Чтобы преобразовать эти объекты в привычные нам команды и обратно, создадим специальный `FlaskParser`. Допустим клиент использует RESTful API (это когда назначение запроса — взять, задать, изменить — определяется методом: get, post, patch):
```
class FlaskParser(Parser):
command_by_alias = {
"GET": "get",
"POST": "save",
"PATCH": "update",
}
def parse(self, request):
# Parse
values = request.values
data_str = values.get("data")
data = json.loads(data_str) if data_str else None
if data is None:
data = {}
# Prepare command
code = data.get("code")
if not code:
code = values.get("_method") or request.method
data["code"] = self.command_by_alias.get(code, code)
data["key"] = request.view_args.get("key")
return data, b""
# No real serialization needed here
def serialize(self, command):
return command
```
Также, поскольку HTTP-сервер запускается зачастую в нескольких процессах, которые все должны разделять общее состояние, то нам придется использовать репозиторий, хранящий данные не в памяти, а в какой-нибудь БД.
Итого, изменяется всего три слоя: сервер, парсер и репозиторий. С репозиторием ничего нового — синхронизировать данные с БД часто бывает нужно и в сокет-серверах. Класс сервера можно также использовать старый, так как там нам нужен только метод `handle_bytes()`. Для унификации его можно переименовать в более абстрактный `handle_requests()` и вынести весь код, кроме `handle_connection()` в базовый класс `Server`. В конце концов действительно уникальным для HTTP-сервера классом будет только парсер:
```
import json
from flask import Flask, send_file, request
app = Flask(__name__)
controller_by_key = {
"chess": ChessLogic(),
"checkers": CheckersLogic(),
}
application = Application(MyController(), controller_by_key, DBRepository())
server = Server(FlaskParser(), application)
@app.route("/storage/")
async def storage(key):
return await server.handle\_bytes(key, request)[0]
```
Одно из испытаний на универсальность наша схема успешно выдержала.
Выводы
------
Разбиение всего приложения на несколько независимых друг от друга слоев позволяет классы каждого из них разрабатывать отдельно от классов других слоев. Все, что от них требуется — это держаться в рамках заданных для них интерфейсов. Если интерфейсы остаются неприкосновенными, то любые изменения внутри слоя никак не отразятся на остальных. В этом и заключается вся прелесть слоистой архитектуры.
Четыре слоя инфраструктуры и их отношение к логике (Controller)При разбиении цельного приложения на слои мы сначала выделили две основные логические части: инфраструктуру и бизнес-логику. Первая в последствии разделилась на Server и Parser. А из второй отделились еще два инфраструктурных слоя: Application и Repository. В результате данные в программе обрабатываются по следующей цепочке:
> Server → Parser → Application → Controller → Repository
>
>
Инфраструктура — это все то, что не относится напрямую к логике, но помогает ей выполнять свои задачи. Будучи общей для самых разных задач, ее можно вынести в основную библиотеку классов. А поскольку эти классы также задают всю структуру приложения, составляют его каркас, то его с полным правом можно назвать фреймворком.
Отделив все вспомогательные функции и вынеся их в специальный инфраструктурный фреймворк, мы получили бизнес-логику в чистом виде — в виде контроллеров. Настолько чистом, что они не зависят даже от самих себя (т.е. друг от друга). О том, как писать бизнес-логику правильно, и на какие слои разбивается она сама, можно узнать в следующей, заключительной [статье](https://habr.com/ru/post/678666/).
[Исходники](https://gitlab.com/markelov-alex/hx-py-framework-evolution/-/tree/main/f_models/server_socket/v3/)
[< Назад](https://habr.com/ru/post/677854/) | [Начало](https://habr.com/ru/post/674754/) | [Вперед >](https://habr.com/ru/post/678666/) | https://habr.com/ru/post/678658/ | null | ru | null |
# Учёные посчитали количество кубитов, чтобы взломать шифрование ECDSA для ключей Bitcoin
*Эллиптическая кривая — это график уравнения `y2 = x3 + ax + b`. В сети Bitcoin используется вариант с `a = 0` и `b = 7`*
Критики Bitcoin говорят, что система зиждется на математическом фундаменте эллиптической криптографии [ECDSA](https://en.bitcoin.it/wiki/Secp256k1), которую теоретически могут взломать после изобретения квантовых компьютеров. Например, проседание курса BTC в 2019 году [объясняли](https://habr.com/ru/post/471054/) паникой из-за новости о том, что компания Google [достигла квантового превосходства](https://www.ft.com/content/b9bb4e54-dbc1-11e9-8f9b-77216ebe1f17).
Сейчас учёные [произвели расчёт](https://avs.scitation.org/doi/10.1116/5.0073075), сколько конкретно кубитов требуется для взлома шифрования на эллиптических кривых ECDSA, которое используется для кодирования ключей в сети Bitcoin.
Протокол Bitcoin использует следующие константы:
`Уравнение эллиптической кривой: y2 = x3 + 7
Простой модуль = 2^256 – 2^32 – 2^9 – 2^8 – 2^7 – 2^6 – 2^4 – 1 = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE FFFFFC2F
Базовая точка = 04 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798 483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8
Порядок = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141`
Этот набор параметров известен как [secp256k1](https://en.bitcoin.it/wiki/Secp256k1).
Учёные из Сассекского центра квантовых технологий (Сассекский университет, Великобритания) и компании Universal Quantum подсчитали количество физических кубитов, необходимых для взлома 256-битного шифрования ключей в сети Bitcoin с помощью эллиптической кривой в течение доступного промежутка времени, в который это имеет смысл.
Как показал расчёт, для взлома шифрования в течение часа с использованием поверхностного кода потребуется 317 × 106 физических кубитов. Чтобы взломать шифр в течение дня, потребуется 13 × 106 физических кубитов.
Для сравнения, самый большой в мире квантовый компьютер IBM сейчас работает со [127 кубитами](https://www.newscientist.com/article/2297583-ibm-creates-largest-ever-superconducting-quantum-computer/).
Для достижения «квантового превосходства» Google попыталась использовать компьютер с 72 кубитами [Bristlecone.](https://ai.googleblog.com/2018/03/a-preview-of-bristlecone-googles-new.html), но потерпела неудачу, поэтому ограничилась версией с 53 кубитами Sycamore, на котором и было зафиксировано это достижение. Система была спроектирована таким образом, чтобы решить одну специфическую математическую задачу не несколько порядков быстрее суперкомпьютера на традиционной архитектуре. Заявление Google о достижении квантового превосходства [вызвало критику коллег](https://www.ibm.com/blogs/research/2019/10/on-quantum-supremacy/), но их статью [принял Nature](https://www.nature.com/articles/s41586-019-1666-5).
Расчёт количества кубитов для взлома шифрования на эллиптических кривых [опубликован](https://avs.scitation.org/doi/10.1116/5.0073075) 25 января 2022 года в журнале *AVS Quantum Science* (doi: 10.1116/5.0073075). | https://habr.com/ru/post/650761/ | null | ru | null |
# Мониторинг IPTV
Возникла необходимость проводить мониторинг мультикаст потоков. Начался поиск готовых решений. Первое что удалось нагуглить: [IPTV-Analyzer](http://www.iptv-analyzer.org/wiki/index.php/Main_Page), [NetUP IPTVProbe](http://www.netup.tv/ru-RU/iptvprobe.php). У каждого решения были свои недостатки или стоили немалых денег. Было принято решение создать свой собственный мониторинг. Основная задача уведомлять и логировать падение мультикаст потока.
**Механизм:**
С помощью ffmpeg подключаемся к потоку в течение NN времени, кадр начинает снимать с NN секунды, чтобы не было артефактов на картинке. Если в течение NN секунд не получается что-то получить, то пишем в базу с ошибкой снятия. Все довольно просто.
**Приступим к установке основных компонентов:**
`sudo apt-get install apache2 php5 mysql-server libapache2-mod-php5 libapache2-mod-auth-mysql php5-mysql ffmpeg`
**apache** – для web-интерфейса.
**mysql** — в базе будем хранить данные, необходимые для статистики, и список каналов.
**ffmpeg** – нам будет необходим для снятия скриншотов с мультикаст-потока.
Основные компоненты установлены, приступим к настройке.
В директории *(по умолчанию используемая apache2 /var/www/ )* создаем файл dbinit.php c настройками подключения к базе:
```
php
$dbhost = "localhost";
$dbname = "name";
$dbuser = "user";
$dbpass = "password";
mysql_connect($dbhost, $dbuser, $dbpass);
mysql_query("set character_set_client='utf8'");
mysql_query("set character_set_results='utf8'");
mysql_query("set collation_connection='utf8_general_ci'");
mysql_select_db($dbname);
?
```
**Структура базы:**
date – TIMESTAMP *(Дата падения или поднятия канала)*
name – TEXT *(Имя канала)*
state – TEXT *(Состояние: true-поднятие, false-падение)*
Необходимо это для дальнейшего расчета сколько времени канал был в дауне.
Создаем скрипт, который будет генерировать ну и, собственно, «мониторить» каналы.
Назовем его gen.php
```
php
include "dbinit.php";
$query = "SELECT * FROM `name`";
$result = mysql_query($query);
if (!$result)
{
print "<centerошибка:" . mysql_error() . "";
}
elseif (mysql_num_rows($result) == 0)
{
print "";
}
else
{
$rows = array();
while ($row = mysql_fetch_assoc($result))
{
$rows[]= $row;
}
foreach($rows as $row)
{
echo exec('/usr/bin/timeout 20s /usr/bin/time -f %U -o /var/www/tmp/'.$row['name'].'.txt /usr/bin/ffmpeg -i udp://@'.$row['mcast'].' -y -f image2 -sameq -t 0.001 -ss 00:00:4 -s 120*80 /var/www/screen/'.$row['mcast'].'.jpg');
echo exec('/bin/cp -f /var/www/tmp/'.$row['mcast'].'.txt /var/www/rez/');
}
?>
```
**Рассмотрим подробнее строки скрипта.**
Для выполнения скрипта ставим таймаут выполнения *(timeout 20s )*, если канал будет недоступен — он будет висеть очень долго.
Время снятия скриншота пишем в файл:
```
/usr/bin/time -f %U -o /var/www/tmp/'.$row['name'].'.txt
```
Снятие скриншота
```
/usr/bin/ffmpeg -i udp://@'.$row['name'].' -y -f image2 -sameq -t 0.001 -ss 00:00:4 -s 120*80 /var/www/screen/'.$row['name'].'.jpg
```
**Получение результатов и добавление их в базу:**
**Создадим файл rez.php**
```
php
$lines = file ('rez/'.$row['mcast'].'.txt');
if ($lines[0]=='')
{
$last_result=mysql_result(mysql_query("select state from name where name='".$row['name']."' order by date desc limit 0,1"),0);
if($last_result=='true')
{
$query = "INSERT INTO `name` (`date`, `name`, `state`) VALUES ('{$date}', '{$row['name']}', 'false');";
mysql_query($query) or die(mysql_error());
}
foreach ($A as $v)
{
echo exec('/usr/bin/perl /usr/local/scripts/jabber_alert.pl -e '.$v.'@jabber.server -n tv@jabber.server -w password -y '.translitIt ($row['name']).'-'.$row['mcast'].' << "EOF" read -d "^D" input');
}
}
else
{
$last_result=mysql_result(mysql_query("select state from name where name='".$row['name']."' order by date desc limit 0,1"),0);
echo $last_result;
if($last_result=='false')
{
$query = "INSERT INTO `name` (`date`, `name`, `state`) VALUES ('{$date}', '{$row['name']}', 'true');";
mysql_query($query) or die(mysql_error());
}
echo $row['name']." ". $lines[1]."Работает ";
}
?
```
При удачном снятии скриншота время выполнения записывается в файл, если не получилось файл будет пустой. В скрипте выполняем проверку на содержимое в файле.
Рассылаем по джаберу о упавшем канале
```
echo exec('/usr/bin/perl /usr/local/scripts/jabber_alert.pl -e '.$v.'@jabber.server -n tv@jabber.server -w password -y '.translitIt ($row['name']).'-'.$row['mcast'].' << "EOF" read -d "^D" input');
```
[jabber\_alert.pl](http://www.jabberdoc.org/tools/jabber_alert.pl)
**Создаем index.php**
```
php
foreach($rows as $row)
{
$work=mysql_result(mysql_query("select date from name where date'".$row['date']." order by date limit 0,1'"),0);
$date1 = new DateTime($work);
$date2 = new DateTime($row['date']);
$interval = $date2->diff($date1);
if($work=="") { $style="red"; } else { $style="";}
echo "| ".$row['date'];
if($work!="")
{
echo " - ".$work."";
}
echo " | ";
if($interval->format("%h") != 0)
{
echo $interval->format("%hч. ");
}
echo $interval->format("%iм. %sс.")." | ".$row['name']." |
";
}
?>
```
Выводим упавшие/поднятые каналы и раскрашиваем их.
Добавляем в крон выполнение двух скриптов.
Решение не столь изящно, но оно работает и свои задачи выполняет.
Доработав можно получить такое:
 | https://habr.com/ru/post/145151/ | null | ru | null |
# Что-то не так с IDS сигнатурой
Имена Snort и Suricata IDS знакомы каждому, кто работает в сфере сетевой безопасности. Системы WAF и IDS — это те два класса защитных систем, которые анализируют сетевой трафик, разбирают протоколы самого верхнего уровня и сигнализируют о злонамеренной или нежелательной сетевой активности. Если первая система помогает веб-серверам обнаружить и избегать атак, специфичных только для них, то вторая, IDS, способна обнаружить атаки во всем сетевом трафике.
Многие компании устанавливают IDS для контроля трафика внутри корпоративной сети. Благодаря механизму DPI они собирают транспортные потоки, заглядывают внутрь пакетов от IP до HTTP и DCERPC, а также выявляют как эксплуатацию уязвимостей, так и сетевую активность вредоносных программ.
Сердце и тех и других систем — наборы сигнатур для выявления известных атак, разрабатываются экспертами сетевой безопасности и компаниями по всему миру. Мы, команда @attackdetection, также занимаемся разработкой сигнатур для обнаружения сетевых атак и вредоносной активности. Далее в статье речь пойдет о обнаруженном нами новом подходе, который позволяет нарушить работу систем IDS Suricata и скрыть такую активность.
Как работает IDS
----------------
Перед погружением в детали этой техники обхода средств IDS и этапа, для которого применяется найденная техника, необходимо освежить представление об общем принципе работы IDS.
Первым делом входящий трафик разбивается на TCP, UDP или другие транспортные потоки, после чего парсеры маркируют их и разбивают на высокоуровневые протоколы и их поля — нормализуя, если требуется. Полученные декодированные, разжатые и нормализованные поля протоколов затем проверяются наборами сигнатур, которые выявляют, есть ли среди сетевого трафика попытки сетевых атак или пакеты, присущие вредоносной активности.
Наборы сигнатур, к слову, это продукт многих индивидуальных исследователей и компаний. Среди поставщиков вы найдете такие имена, как Cisco Talos, Emerging Threats, а в открытом наборе правил сейчас насчитывается более 20 000 активных сигнатур.
Общие способы обхода IDS
------------------------
Несовершенство IDS и ошибки в их ПО позволяют находить условия, при которых они не способны обнаружить атаку в сетевом трафике. Среди достаточно давно известных техник обхода стадии разбора стримов можно перечислить и такие:
* Нестандартная фрагментация пакетов на уровнях IP, TCP или, например, DCERPC, с которой IDS порой не способна справиться.
* Пакеты с пограничными или некорректными значениями TTL или MTU также могут обрабатываться IDS некорректно.
* Неоднозначность восприятия накладывающихся TCP-фрагментов (номеров TCP SYN) может трактоваться IDS иначе, чем на сервере или клиенте, которому этот TCP-трафик предназначался.
* Подставной пакет TCP FIN, например с неверной контрольной суммой (т. н. TCP un-sync), может быть воспринят как конец сессии вместо игнорирования.
* Разное время таймаута TCP-сессии между IDS и клиентом также может послужить инструментом для сокрытия атак.
Что касается этапа разбора протоколов и нормализации полей, многие техники обхода WAF могут быть позаимствованы и для IDS. Их число значительно больше, поэтому приведем лишь некоторые из них:
* HTTP double encoding.
* Gzip-сжатие HTTP-пакета без соответствующего заголовка Content-Encoding может так и остаться неразжатым на стадии нормализации, такой прием можно порой встретить в трафике вредоносных программ.
* Использование редких кодировок, как, например, Quoted-Printable для протоколов POP3/IMAP, также может сделать некоторые сигнатуры бессильными.
Не стоит забывать и про баги, специфичные для каждого вендора IDS или сторонних библиотек в их составе, которые можно найти на публичном багтрекере.
Одну из таких специфичных баг, позволявшую отключать проверки сигнатур при определенных условиях, нашла команда @attackdetection в Suricata IDS, и эта ошибка могла быть проэксплуатирована для сокрытия таких атак, как, например, BadTunnel.
Во время этой атаки уязвимый клиент открывает сгенерированную злоумышленником HTML-страницу и тем самым устанавливает UDP-тоннель сквозь сетевой периметр до сервера злоумышленника для портов 137 с обеих сторон. После установления тоннеля злоумышленник получает возможность спуфить имена внутри сети уязвимого клиента, посылая поддельные ответы на NBNS-запросы. Несмотря на то, что к серверу злоумышленника уходило три пакета, ему было достаточно ответить лишь на один из них для установления тоннеля.
Найденная ошибка состояла в том, что если ответом на первый UDP-пакет от клиента был ICMP-пакет, например ICMP Destination Unreachable, то из-за неточного алгоритма отныне этот стрим проверялся сигнатурами только для ICMP-протокола. Любые дальнейшие атаки, в том числе и спуфинг имен, оставались незамеченными для IDS, так как осуществлялись поверх UDP-тоннеля. Несмотря на отсутствие номера CVE для этой уязвимости, она приводила к обходу защитных функций IDS.
Названные выше техники байпаса известны давно и устранены в современных и долго развивающихся IDS, а специфичные баги и уязвимости работают лишь для непропатченных версий.
Поскольку наша команда работает над исследованием сетевой безопасности и сетевых атак и непосредственно разрабатывает и тестирует сетевые сигнатуры, мы не могли не обратить внимания на способы обхода, связанные с самими сигнатурами и их несовершенством.
Уклоняемся от сигнатур
----------------------
Постойте, как вообще сигнатуры могут быть проблемой?
Исследователи изучают появляющиеся угрозы и формируют свое понимание того, как та или иная атака может быть обнаружена на сетевом уровне за счет особенностей эксплуатации или других сетевых артефактов, а затем переводят полученное представление в одну или множество сигнатур на понятном для IDS языке. Из-за ограниченных возможностей системы или ошибки исследователя остаются непокрытые способы эксплуатации уязвимостей.
Если протокол и формат сообщений среди одного семейства вредоносных программ и их поколения остается неизменным и сигнатуры для них работают замечательно, то при эксплуатации уязвимостей чем выше сложность протокола и его вариативность, тем проще атакующей стороне изменить эксплойт без потери функциональности — и обойти сигнатуры.
Хотя для наиболее опасных и громких уязвимостей вы найдете целое множество качественных сигнатур от разных вендоров, некоторые другие сигнатуры можно обойти простыми приемами. Приведу в пример весьма распространенную ошибку сигнатур для протокола HTTP: порой достаточно лишь изменить порядок аргументов HTTP GET, чтобы обойти проверку сигнатурой.
И вы будете правы, если подумаете, что в сигнатурах встречаются проверки подстрок с фиксированным порядком аргументов, например “?action=checkPort” или “action=checkPort&port=”. Требуется лишь внимательно изучить сигнатуру и проверить, нет ли в ней такого же хардкода.
Другими и не менее сложными для проверок протоколами и форматами являются, например, DNS, HTML или DCERPC, вариативность которых чрезвычайно высока. Поэтому для покрытия сигнатурами всех вариаций атак и разработки не только качественных, но и быстрых сигнатур, разработчику необходимо обладать широким спектром умений и твердым знанием сетевых протоколов.
О несовершенстве IDS-сигнатур говорят давно, и вы можете найти мнения других авторов в их докладах: [1](https://www.google.ru/url?sa=t&rct=j&q=&esrc=s&source=web&cd=3&ved=0ahUKEwj1z6GFjPPXAhWiAJoKHWBwCMYQFgg7MAI&url=https%3A%2F%2Fwww.blackhat.com%2Fpresentations%2Fbh-usa-00%2FRon-Gula%2Fron_gula.ppt&usg=AOvVaw0atDOmktQHu-zmOZBBZZfO), [2](https://www.alertlogic.com/blog/ids/ips-signature-bypassing-(snort)/), [3](https://github.com/ahm3dhany/IDS-Evasion).
Сколько весит сигнатура
-----------------------
Как уже было сказано, скорость работы сигнатуры лежит в зоне ответственности разработчика, и естественно, что большему количеству сигнатур требуется больше вычислительных ресурсов для проверок. Правило золотой середины [советует](http://ossectools.blogspot.ru/2011/04/network-intrusion-detection-systems.html) добавлять один CPU для каждой тысячи сигнатур или каждой половины гигабита сетевого трафика в случае Suricata IDS.
Тут зависимость и от количества сигнатур, и от объема сетевого трафика. Хоть эта формула и выглядит полной, она не учитывает того факта, что сигнатуры могут быть быстрыми или медленными, а трафик — самым разнообразным. Так что же произойдет, если медленная сигнатура попадет на плохой трафик?
Suricata IDS умеет выводить данные о производительности сигнатур в журнал. Туда попадают данные о самых медленных сигнатурах, формируя топ с указанием времени их выполнения, выраженного в ticks — времени CPU и количестве их проверок.
Наверху журнала — самые медленные сигнатуры.
Выделенные сигнатуры это и есть те, которые называются медленными. Топ постоянно обновляется и на разных профилях трафика он будет наверняка состоять из других сигнатур. Это происходит потому, что сигнатуры в целом состоят из подмножества простых проверок, например поиска подстроки или регулярного выражения, выстроенных в определенном порядке. При проверке сетевого пакета или стрима сигнатура проверит все его содержимое на наличие всех допустимых комбинаций. Таким образом, дерево проверок для одной и той же сигнатуры может быть более разветвленным или менее, а следовательно, и время выполнения будет варьироваться в зависимости от анализируемого трафика. Задачей разработчика является, среди прочего, оптимизация сигнатуры для работы на любом возможном трафике.
Что бывает, если мощность IDS подобрана неправильно и она не справляется с проверкой всего сетевого трафика? Как правило, если нагрузка ядер CPU составляет в среднем больше 80%, то IDS уже начинает пропускать проверку некоторых пакетов. Чем выше нагрузка на ядра, тем больше непроверенных мест появляется в сетевом трафике и тем выше шанс, что зловредная активность останется незамеченной.
Что, если попытаться усилить этот эффект, когда сигнатура осуществляет проверку сетевых пакетов слишком долго? Такая схема эксплуатации должна вывести IDS из игры, заставив пропускать пакеты и атаки. Начнем с того, что у нас уже есть топ горячих сигнатур на живом трафике, и попытаемся усилить эффект на них.
Эксплуатируем
-------------
Одна из таких сигнатур выявляет в трафике попытку эксплуатации уязвимости CVE-2013-0156 RoR YAML Deserialization Code Execution.
Весь HTTP-трафик по направлению к корпоративным веб-серверам подвергается проверке на наличие трех строк в строгой последовательности — “ type”, “yaml” и “!ruby” — и проверке регулярным выражением.
Прежде чем мы приступим к генерации «плохого» трафика, я приведу некоторые гипотезы, которые нам в этом помогут:
* Найти совпадение подстроки легче, чем доказать, что такого совпадения нет.
* Проверка регулярным выражением для IDS Suricata медленнее, чем поиск подстроки.
Это значит, что если мы хотим от сигнатуры долгих проверок, то проверки эти должны быть безуспешными и использовать регулярные выражения.
Для того чтобы дойти до проверки регулярным выражением, три подстроки должны присутствовать в пакете друг за другом.
Пробуем соединить их в таком порядке и запустить IDS для проверки. Для конструирования файлов с HTTP-трафиком в формате Pcap из текста я использовал инструмент [Cisco Talos file2pcap](https://github.com/Cisco-Talos/file2pcap):
Еще один журнал keyword\_perf.log помогает нам увидеть, что цепочка проверок успешно дошла (content matches — 3) до регулярного выражения (PCRE) и завершилась неудачей (PCRE matches — 0). Если далее мы хотим извлечь пользу из дорогих PCRE-проверок, то нам необходимо полностью его разобрать и подобрать эффективный трафик.
Задача обратной разработки регулярного выражения хоть и легко выполняется вручную, но плохо автоматизируется из-за таких конструкций, как, например, backreferences или named capture groups: способов автоматически подобрать строку для успешного прохождения регулярного выражения любого вида я не нашел.
Минимально необходимой строкой для такого выражения оказалась следующая конструкция. Для проверки гипотезы о том, что неуспешный поиск дороже успешного, отрежем от этой строки крайний правый символ и прогоним регулярку еще раз.
Выходит, тот же принцип применим и в регулярных выражениях: безуспешная проверка заняла больше шагов, чем ее успешный аналог. В этом случае разница составила более 50%. Вы можете убедиться в этом сами.
Другой занимательный факт открылся при дальнейшем изучении этого регулярного выражения. Если мы неоднократно продублируем минимальную необходимую строку без последнего символа, то разумно ожидать увеличения числа шагов для окончания проверки, однако зависимость такого роста совершенно взрывная:
```
2 x (
```
Время проверки нескольких десятков таких строк составляет уже около секунды, и повышая их количество, мы упираемся в timeout error. Этот эффект в регулярных выражениях называется Catastrophic Backtracking и ему посвящено немало статей, в том числе и на [Хабре](https://habrahabr.ru/post/131915/). Такие ошибки можно встретить в популярных продуктах и по сей день; например, недавно такую нашли во фреймворке [Apache Struts](https://cwiki.apache.org/confluence/display/WW/S2-050).
Бежим с найденными строками обратно к Suricata IDS и проверяем их:
```
Keyword Ticks Checks Matches
-------- -------- ------- --------
content 19135 4 3
pcre 1180797 1 0
```
Однако вместо фанфар и Catastrophic Backtracking мы получаем едва ощутимую для IDS нагрузку — всего 1 миллион ticks. Это история о том, как после отладки, изучения исходного кода Suricata IDS и используемой внутри библиотеки libpcre я наткнулся на PCRE-лимиты, а именно:
### * MATCH\_LIMIT DEFAULT = 3500
* MATCH\_LIMIT\_RECURSION\_DEFAULT = 1500
Эти лимиты и ограничивают регулярные выражения от попадания в катастрофы во многих библиотеках регулярных выражений. Те же лимиты можно встретить и в WAF, где преобладают проверки регулярных выражений. Эти лимиты, конечно, могут быть изменены в конфигурации IDS, но распространяются по умолчанию и не рекомендуются к изменению.
Эксплуатация только лишь регулярного выражения не поможет нам достичь желаемого результата. Но что, если проверить при помощи IDS сетевой пакет с таким контентом?
В таком случае мы получим следующие значения в журнале:
```
Keyword Avg. Ticks Checks Matches
-------- ---------- ------- --------
content 3338 7 6
pcre 12052 3 0
```
Количество проверок было равно 4, а стало 7 лишь из-за дублирования изначальной строки. Хоть механизм и остался неясным, стоит ожидать лавинообразного увеличения числа проверок, если мы продублируем строки еще. В конце концов я смог добиться следующих значений:
```
Keyword Avg. Ticks Checks Matches
-------- ---------- ------- --------
content 1508 1507
pcre 1492 0
```
Суммарно число проверок подстрок и регулярных выражений не превышает 3000, какой бы контент ни проверялся сигнатурой. Очевидно, в самой IDS также присутствует внутренний ограничитель, который на этот раз носит название inspection-recursion-limit и равняется по умолчанию как раз 3000. При всем количестве лимитов в PCRE, IDS и ограничений на единовременный размер контента, попадающего под проверку, если видоизменить контент и использовать лавинообразные проверки регулярных выражений, то результат получится что надо:
```
Keyword Avg. Ticks Checks Matches
-------- ---------- ------- --------
content 3626 1508 1507
pcre 1587144 1492 0
```
Несмотря на то, что сложность одной проверки регулярного выражения не поменялась, число таких проверок значительно выросло и достигло полутора тысяч. Перемножив число проверок на среднее количество тактов, затраченных на каждую проверку, получим заветные 3 миллиарда тиков.
```
Num Rule Avg Ticks
-------- ------------ -----------
1 2016204 3302218139
```
И это более чем тысячекратное усиление! Для эксплуатации потребуется лишь утилита curl для составления минимального запроса HTTP POST. Выглядеть он будет примерно так:
Минимальный набор HTTP-полей и HTTP body с повторяющимся паттерном.
Такой контент не может быть бесконечно большим и заставлять IDS тратить громадное количество ресурсов на его проверку, так как несмотря на то, что внутри TCP-сегменты и соединяются в единый поток-стрим, — стрим и собранные HTTP-пакеты не проверяются целиком, какими бы большими они ни были. Вместо этого они проверяются небольшими кусочками размером около 3-4 килобайт. Этот размер сегментов для проверки, как и глубина проверок, задаются в конфиге (ровно как и все в IDS). Размер сегмента слегка «дрожит» от запуска к запуску во избежание атак на границу фрагментации таких сегментов — когда атакующий, зная размер сегментов по умолчанию, может дробить сетевые пакеты таким образом, чтобы атака разделилась на два соседних сегмента и не могла быть обнаружена сигнатурой.
Итак, в наших руках оказалось мощное оружие, загружающее IDS на более чем 3 000 000 000 тиков CPU за одно применение. Что это вообще значит?
Фактически полученная цифра это примерно 1 секунда работы среднестатистического CPU. Простая взаимосвязь состоит в том, что послав один HTTP-запрос размером 3 КБ, мы загружаем IDS работой на целую секунду. Чем больше ядер у IDS, тем больше потоков данных она способна обрабатывать одновременно.
Не стоит забывать, что IDS не стоит без дела и, как правило, занимает часть своих ресурсов проверкой фонового сетевого трафика, тем самым снижая порог для этой атаки.
Проводя измерения на рабочей IDS-конфигурации с 8/40 ядрами CPU Intel Xeon E5-2650 v3 2.30 Ghz без фонового трафика, пороговым значением, после которого все 8 CPU-ядер оказываются на 100% загруженными, стали всего лишь 250 килобит в секунду. И это для системы, предназначенной для переработки многих гигабит сетевого потока, то есть в тысячи раз больше.
Для эксплуатации именно этой сигнатуры атакующему достаточно лишь посылать около 10 HTTP-запросов в секунду на защищаемый веб-сервер для постепенного заполнения очереди сетевых пакетов у IDS. После исчерпания буфера пакеты начнут проходить мимо IDS и с этого самого момента атакующий может использовать любые инструменты или проводить произвольные атаки и оставаться незамеченным для систем обнаружения. Постоянный уровень зловредного трафика позволит отключить IDS до тех пор, пока этот трафик не перестанет бомбардировать внутреннюю сеть, а для кратковременных атак атакующий может послать короткий спайк из таких пакетов и также добиться слепоты у системы обнаружения, но на короткий период.
Эксплуатация медленных сигнатур не может быть обнаружена существующими механизмами: хоть IDS и обладает профилирующим кодом, она не умеет отличать просто медленную сигнатуру от катастрофически медленной и автоматически об этом сигнализировать. Стоит заметить, что сигнализация о срабатывании сигнатуры также не происходит — вследствие отсутствия подходящего контента.
Помните тот невыясненный рост числа проверок? Ошибка IDS действительно имела место быть и приводила к росту числа излишних проверок. Уязвимость получила наименование [CVE-2017-15377](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-15377) и в данный момент устранена в ветках Suricata IDS 3.2 и 4.0.
Описанный выше подход хорошо работает для одного конкретного экземпляра сигнатуры. Она распространяется в составе открытого набора сигнатур и, как правило, включена по умолчанию, но на вершине топа самых горячих сигнатур то и дело всплывают новые, а другие еще ждут своего трафика. Язык описания сигнатур для IDS Snort и Suricata предлагает разработчику множество удобных инструментов, таких как декодирование base64, прыжки по контенту и математические операции. Другие комбинации проверок могут также вызывать взрывообразный рост потребляемых для проверки ресурсов. Внимательное наблюдение за данными о производительности может стать отправной точкой для эксплуатации. После того, как проблема CVE-2017-15377 была устранена, мы снова запустили Suricata IDS проверять наш сетевой трафик и увидели точно такую же картину: топ самых горячих сигнатур на вершине журнала, но уже с другими номерами. Это говорит о том, что таких сигнатур, равно как и подходов к их эксплуатации, множество.
Не только IDS, но еще и антивирусы, WAF и многие другие системы основаны на сигнатурном поиске. Следовательно, подобный подход может быть применен для поиска слабых мест в их производительности. Он способен незаметно прекратить обнаружение зловредной активности системами обнаружения. Связанная с ним сетевая активность не может быть обнаружена защитными средствами и детекторами аномалий. Ради эксперимента включите профилирующую настройку в своей системе обнаружения — и понаблюдайте за вершиной журнала производительности.
**Автор**: Кирилл Шипулин из команды @attackdetection, [Twitter](http://www.twitter.com/attackdetection) | [Telegram](http://www.t.me/kirill_wow) | https://habr.com/ru/post/344642/ | null | ru | null |
# История одной задачи: Кратчайший мемоизатор на JavaScript
Дело было вечером, накануне ежегодной конференции [HolyJS](http://holyjs-piter.ru) в Санкт-Петербурге. Наша компания уже не первый год является спонсором: соответственно, имеет и свой стенд с интересностями для пытливого ума неравнодушных разработчиков. Когда основное блюдо было готово и все задания были отревьювены и законфирмены, я решил подкинуть на ночь глядя еще интеллектуальной пищи коллегам:
> Напишите мемоизатор — функцию-декоратор, сохраняющую результаты выполнения оборачиваемой функции для предотвращения повторных вычислений. У вас есть всего 50 символов.
Язык — разумеется, **JavaScript**. Сама задача — классика, но ограничение в 50 символов обернулось настоящим челенджем.
В перерывах первого дня конференции мы обсуждали варианты достижения цели, постепенно сокращая ответ. Весь ажиотаж увенчался идеей поделиться задачей со всеми участниками конференции, и на второй день мы визуализировали задачу (см. приложение) и стали раздавать бланки желающим. В итоге получили около 40 решений и в очередной раз убедились в незаурядности сообщества js-разработчиков, но рекорд **Дмитрия Катаева** (SEMrush) в **53** символа остался. Давайте разбираться!
### Привычная реализация
```
function memoize(f) {
let cache = {};
return function ret() {
let key = JSON.stringify(arguments);
if (!cache.hasOwnProperty(key)) {
cache[key] = f.apply(this, arguments);
}
return cache[key];
}
}
```
Результат: ~**190** символов
* memoize — наш мемоизатор
* f — декорируемая, оборачиваемая функция
* ret — результирующая функция
Чтобы получить ответ — размер функции — воспользуемся:
```
memoize.toString().replace(/\s+/g, ' ').length
```
При оценке размера функции обращаем внимание на ее тело и список параметров. Если функция анонимна, то объявление не учитывается.
Простые тесты для проверки работоспособности после надругательств:
```
const log = memoize(console.log);
const inc = memoize(o => o.x + 1);
```
| № | Вызов функции | Результат выполнения в консоли |
| --- | --- | --- |
| 1. | `log(false)` | > false |
| 2. | `log('2', {x:1})` | > '2', {x:1} |
| 3. | `log(false)` | Ничего, так как для этих значений функция уже выполнялась. |
| 4. | `log('2', {x:1})` | Ничего, так как для этих значений функция уже выполнялась. |
| 5. | `inc({x:1})` | 2 |
| 6. | `inc({x:2})` | 3 |
Далее результат каждой реализации будет отмечен результатом тестов.
### Чистая реализация
Первым делом хочется избавиться от *Function Declaration* в пользу стрелочной функции, так как контекст *this* нам не интересен, к *arguments* мы не обращаемся и как конструктор через *new* вызывать не намереваемся. Заодно сократим имена используемых локальных переменных:
```
const memoize = f => {
let c = {};
return function() {
let k = JSON.stringify(arguments);
if (!c.hasOwnProperty(k)) {
c[k] = f.apply(this, arguments);
}
return c[k];
}
}
```
Результат: **154**, тесты прошли
Далее можно провести аналогичную операцию с результирующей функцией, но там нам необходим *arguments*. Тут нам на помощь приходит *spread operator*, позволяющий заменить передаваемый итерируемый объект аргументов переменной-массивом *a*. Кроме того, мы больше не будем передавать декорируемой функции контекст *this*: если это необходимо, то поможет *Function.prototype.bind* или свой полифил.
```
const memoize = f => {
let c = {};
return (...a) => {
let k = JSON.stringify(a);
if (!c.hasOwnProperty(k)) {
c[k] = f(...a);
}
return c[k];
}
}
```
Результат: **127**, тесты прошли
Теперь обратимся к телу результирующей функции. Очевидно, что нахождение ключа в кэше и возврат значения — громоздки. Попробуем сократить как:
```
const memoize = f => {
let c = {};
return (...a) => {
let k = JSON.stringify(a);
return c[k] || (c[k] = f(...a));
}
}
```
Результат: **101**, упали тесты 3 и 4
Здесь мы отказываемся от метода *hasOwnProperty*. Мы можем себе это позволить, так как результат сериализации массива аргументов через *JSON.stringify* всегда будет "[...]" и маловероятно, что в прототипе кэша (*Object*) окажется такое свойство.
Далее мы используем особенность "логического" оператора ИЛИ возвращать первое выражение, если оно может быть преобразовано в *true*, или в противном случае — второе с предшествующим вычислением функции.
И тут у нас упали тесты 3 и 4. Это произошло потому что декорируемая функция *console.log* не возвращает значение: результатом будет *undefined*. Мы кладем это в кэш, а когда при повторном вызове пытаемся через особенность дизъюнктора проверить, то получаем неявно выведенный *false* в первом операнде и, соответственно, попадаем во второй, что приводит к вызову функции. Этот эффект будет иметь место для всех сводимых к *false* результатам: *0, "", null, NaN* и др.
Вместо ИЛИ и *if statement* можем использовать условный тернарный оператор:
```
const memoize = f => {
let c = {};
return (...a) => {
let k = JSON.stringify(a);
return c.hasOwnProperty(k) ?c[k] :c[k] = f(...a);
}
}
```
Результат: **118**, тесты прошли
Сократили совсем незначительно. А что если использовать вместо простого объекта — *Map* в качестве хранилища? Там же есть короткий метод *has*:
```
const memoize = f => {
let c = new Map;
return (...a) => {
let k = JSON.stringify(a);
return (c.has(k) ?c :c.set(k, f(...a))).get(k);
}
}
```
Результат: **121**, тесты прошли
Сократить совсем не удалось. Но отбрасывать *Map* сразу не стоит. Эта реализация key-value хранилища позволяет использовать в качестве ключа — объекты. А это значит, не отказаться ли нам от *JSON.stringify* вообще?
```
const memoize = f => {
let c = new Map;
return (...a) => (c.has(a) ?c :c.set(a, f(...a))).get(a);
}
```
Результат: **83**, упали тесты 3 и 4
Выглядит очень многообещающе! Однако, начали снова падать тесты 3 и 4. Это потому что сравнение ключей в объекте *Map* реализовано с помощью алгоритма *SameValueZero*. Если опустить детали с *NaN, -0* и *0*, то работает он аналогично *strict comparison operator* (*===*). А у нас — новый массив аргументов (а значит — объект) на каждый вызов обернутой функции, даже при одинаковых значениях. Сравнение же происходит по референсу объекта и поэтому метод *Map.prototype.has* никогда ничего не найдет.
Таким образом, использование *Map* не сократило нам *hasOwnProperty* или *JSON.stringify*.
На помощь приходит *in operator*, который проверяет наличие свойства в объекте или в цепочке его прототипов. Почему мы можем не бояться поиска в прототипах было объяснено выше.
```
const memoize = f => {
let c = {};
return (...a) => {
let k = JSON.stringify(a);
return k in c ?c[k] :c[k] = f(...a);
}
}
```
Результат: **105**, тесты прошли
Тело и мемоизатора, и результирующей функции состоит из двух выражений с необходимостью объявления и инициализации локальной переменной перед логикой в *return statement*. Можно ли здесь сократить тело стрелочной функции до одного выражения? Конечно, с помощью паттерна *IIFE* (*Immediately Invoked Function Expression*):
```
const memoize = f => (c => (...a) =>
(k => k in c ?c[k] : c[k] = f(...a))(JSON.stringify(a))
)({});
```
Результат: **82**, тесты прошли
Пора избавиться от лишних пробелов:
```
f=>(c=>(...a)=>(k=>k in c?c[k]:c[k]=f(...a))(JSON.stringify(a)))({});
```
Результат: **68**, тесты прошли
Очевидно, что теперь узким местом является длинный метод *JSON.stringify*, который рекурсивно сериализует объект в JSON-строку, которая используется у нас в качестве ключа. На самом деле, нам нужна не функция сериализации, а хэш-функция, с помощью которой мы могли бы проверить равенство объектов, как это работает в других языках. Но нативного решения в JavaScript, к сожалению, нет, а самописный полифил *hashCode* в прототипе *Object* явно выходит за рамки.
Хм, а зачем нам вообще заниматься сериализацией самим? При добавлении элемента в объект по ключу, произойдет его неявный вызов toString. Так как мы отказались от использования итерируемого объекта *arguments* в пользу массива через *spread operator*, то вызов *toString* будет не от *Object.prototype*, а от *Array.prototype*, в котором он переопределен и джойнит через запятую свои элементы. Таким образом, для разного набора аргументов получим разный ключ.
```
f=>(c=>(...a)=>a in c?c[a]:c[a]=f(...a))({});
```
Результат: **44**, упал тест 6
Только начинает падать тест 6. Кажется, что возвращаемое значение — это результат предыдущего вызова функции в тесте 5. Почему так происходит? Да, мы обошли вызов *toString* для объекта *arguments*, но мы не учли, что любой аргумент тоже может быть сложным объектом, вызывая *toString* у которого мы получим всеми любимый *[object Object]*. Это значит, что аргументы {x:1} и {x:2} будут использовать один и тот же ключ в хэше.
Хорошим претендентом на функцию сериализации казался *btoa*, используемый для преобразования в base64. Но и он приводит сначала к строке, поэтому без шансов. Мы думали и в сторону генерации URI, и формирования *ArrayBuffer*, любых функций для получения какого-либо хэша или сериализованного значения. Но так и остались на месте.
Кстати, и у *JSON.stringify* есть свои особенности: *Infinity, NaN, undefined, Symbol* будут приведены к *null*. То же касается функций. При возможности происходит неявный вызов *toJSON* от объекта, а *Map* и *Set* будут представлены просто перечислимыми элементам. Оно и понятно, учитывая конечный формат: JSON.
Что же дальше?
### Токсичная доработка
Все мы безусловно любим чистые функции, но в условиях задачи такого требования не стоит. А это значит, что пора бы добавить щепотку side-effect’ов.
Первое, почему бы не инициировать кэш следующим образом:
```
(f,c={})=>(...a)=>(k=>k in c?c[k]:c[k]=f(...a))(JSON.stringify(a));
```
Результат: **66**, тесты прошли
Здесь мы используем *default parameter* в стрелочной функции. Конечно, мы предоставляем клиенту возможность задать свой кэш, ну и что? Зато мы сократили 2 символа.
Как еще можно инициировать кэш для декорируемой функции? Правильный ответ: а зачем нам его инициировать? Почему бы не использовать что-то готовое в контексте оборачиваемой функции. А что если саму функцию? Все мы знаем что функции в JavaScript — это тоже объекты:
```
f=>(...a)=>(k=>k in f?f[k]:f[k]=f(...a))(JSON.stringify(a));
```
Результат: **59**, тесты прошли
Здесь *JSON.stringify* обезопасит нас от пересечения с другими свойствами и методами объекта (функции), оборачивая аргументы в "[...]".
В этот самый момент примененный ранее паттерн *IIFE* перестает себя оправдывать. Но сохранить единственное выражение для стрелочной функции остро необходимо, чтобы избежать *return statement*:
```
f=>(...a)=>(k=JSON.stringify(a),k in f?f[k]:f[k]=f(...a));
```
Результат: **57**, тесты прошли
Так как мы не используем *block statement* в стрелочной функции, то не можем объявить переменную (*var* или *let*), но можем воспользоваться глобальным контекстом — side-effect! Тут конфликт уже имеет некоторые шансы быть.
С помощью *comma operator* мы конкатенируем два выражения в одно: операнды вычисляются слева-направо, а результатом является значение последнего.
```
f=>(...a)=>(k=JSON.stringify(a))in f?f[k]:f[k]=f(...a);
```
Результат: **54**, тесты прошли
Так, с помощью перестановки одной лишь скобки, мы избавились сразу от трех символов. *Grouping operator* над вычислением ключа позволил нам объединить оба операнда выражения просто в одно выражение, а закрывающая скобка убрала пробел перед *in operator*.
И наконец:
```
f=>(...a)=>f[k=JSON.stringify(a)]=k in f?f[k]:f(...a);
```
Результат: **53**, тесты прошли
Почему бы не вычислить ключ в момент обращения к значению. А далее — все тот же тернарный оператор и присвоение. Итого: 53 символа!
Возможно ли убрать оставшиеся 3 символа?
### Осмысление
Зачем все это? Эта простая задача и последующая цепочка приведений привычного к неприличному демонстрирует немалое количество особенностей языка JavaScript. В своих рассуждениях мы затронули такие вещи как:
* Arrow function expression
* Lexical scoping & IIFE
* Array-like arguments object
* Spread, comma, or operators
* Strict comparison operator
* JSON.stringify & toString
* In operator & hasOwnProperty
* Grouping operator & block statement
* Map object
* и что-то еще
Подобные этой истории являются хорошим поводом погрузиться в изучение специфики языка, помогают лучше его понять (или наоборот). Ну и конечно just for fun!
### Приложение
*В своих приключениях Рику часто приходится калибровать свою портальную пушку. Процедура требует времени, но входные данные часто повторяются. Ученый старается запоминать уже когда-то полученные результаты чтобы не производить расчеты повторно, но алкоголизм и старческий маразм сильно сказываются на его памяти. Он попросил Морти улучшить модуль настройки пушки, дополнив функцией-мемоизатором. Эта функция должна сохранять результаты декорируемой функции, чтобы предотвратить повторные вычисления. Только Морти панически боится длинных функций. Помогите ему решить задачу **максимально** компактно. В качестве аргументов декорируемая функция может принимать целые числа, строки, булева и объекты.* | https://habr.com/ru/post/413303/ | null | ru | null |
# Consul.io Часть 2
В [первой части](https://habrahabr.ru/post/278085/) мы подробно рассмотрели какие проблемы и задачи ставит перед нами распределенная архитектура приложения. Мы определили какие инструменты мы можем использовать для решения этих проблем и отметили важность реализации discovery на начальном этапе проекта. А также, выбрали Consul основным приложением на базе которого мы будем рассматривать реализацию discovery-сервиса.
В заключительной части мы рассмотрим как Consul работает с протоколом DNS, разберем основные запросы к HTTP API, посмотрим какие виды Health Checks мы можем использовать и, конечно, разберем для чего нужен K/V storage. И что самое важное, ближе познакомимся с некоторыми особенностями на практике.
#### Интерфейс DNS
Consul может отвечать на запросы по протоколу DNS, при этом можно использовать любой DNS-клиент для запросов. DNS-интерфейс доступен для компонентов на локальном хосте на порту 8600. Помимо прямых запросов к Consul, можно прописать его как resolver в системе и прозрачно использовать его для разрешения имен, проксируя все внешние запросы к вышестоящему “полноценному” DNS-серверу и разрешая запросы в приватной зоне .consul самостоятельно.
Для реализации примитивной DNS-балансировки в случае присутствия в каталоге нескольких сервисов с одинаковым именем и разными IP-адресами Consul случайно перемешивает IP-адреса в ответе.
Помимо прямого запроса на разрешение доменного имени в рамках кластера можно выполнять поиск (lookup). Поиск может быть выполнен как для сервиса (service lookup), так и для узла кластера (node lookup).
Формат доменного имени при DNS-запросе в рамках consul-кластера жестко определен и не подлежит изменению.
#### Узел кластера
Это обычный DNS-запрос, который вернет IP-адрес узла кластера по его имени (имя узла задается при старте агента при помощи параметра — node). Рассмотрим формат имени узла для DNS-запроса:
`[node].node[.datacenter].[domain]`
* [node] — обязательная часть, имя узла;
* .node — указатель на то, что мы выполняем node lookup;
* [.datacenter] — необязательная часть, имя датацентра (consul “из коробки” может предоставлять discovery для нескольких датацентров в рамках одного кластера. По умолчанию используется имя dc1. Если имя датацентра не указано, то будет использован текущий ДЦ. То есть тот, в рамках которого запущен агент, к которому выполняется запрос);
* .[domain] — обязательная часть, приватный домен Consul первого уровня. Имеет значение `.consul` по умолчанию.
Таким образом, доменное имя для узла с именем, например, nodeservice, будет выглядеть так:
`nodeservice.node.consul.`
Как мы видим название датацентра пропущенно, но имя можно построить еще и так:
`nodeservice.node.dc1.consul.`
Несколько узлов с одинаковым именем в рамках одного ДЦ не допускаются.
#### Сервис
Запрос на поиск сервиса по имени выполняется на всех узлах кластера. В отличии от запроса на разрешение имени узла, запрос на поиск сервиса предоставляет больше возможностей. Кроме, собственно, IP-адреса сервиса (то есть А-записи) вы можете выполнить запрос на получение SRV-записи и узнать порты, на которых запущен сервис.
Вот так выглядит обычный запрос на поиск всех узлов, на которых запущен сервис с именем `rls`:
```
root@511cdc9dd19b:~# dig @127.0.0.1 -p 8600 rls.service.consul.
; <<>> DiG 9.9.5-3ubuntu0.7-Ubuntu <<>> @127.0.0.1 -p 8600 rls.service.consul.
; (1 server found)
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 26143
;; flags: qr aa rd; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 0
;; WARNING: recursion requested but not available
;; QUESTION SECTION:
;rls.service.consul. IN A
;; ANSWER SECTION:
rls.service.consul. 0 IN A 172.17.0.2
rls.service.consul. 0 IN A 172.17.0.3
;; Query time: 4 msec
;; SERVER: 127.0.0.1#8600(127.0.0.1)
;; WHEN: Thu Feb 18 07:23:00 UTC 2016
;; MSG SIZE rcvd: 104
```
Из этого ответа можно увидеть, что в составе кластера присутствуют два узла, на которых запущен сервис с именем `rls` и то, что DNS-интерфейс Consul вернул IP-адреса всех узлов. Если мы повторим запрос несколько раз, то увидим, что записи периодически меняются местами, то есть первое место не закреплено за первым найденным сервисом. Это и есть пример простой DNS-балансировки, о которой мы говорили выше.
Если мы запросим SRV-запись, то ответ будет таким:
```
root@511cdc9dd19b:/# dig @127.0.0.1 -p 8600 rls.service.consul. SRV
; <<>> DiG 9.9.5-3ubuntu0.7-Ubuntu <<>> @127.0.0.1 -p 8600 rls.service.consul. SRV
; (1 server found)
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 8371
;; flags: qr aa rd; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 2
;; WARNING: recursion requested but not available
;; QUESTION SECTION:
;rls.service.consul. IN SRV
;; ANSWER SECTION:
rls.service.consul. 0 IN SRV 1 1 80 agent-two.node.dc1.consul.
rls.service.consul. 0 IN SRV 1 1 80 agent-one.node.dc1.consul.
;; ADDITIONAL SECTION:
agent-two.node.dc1.consul. 0 IN A 172.17.0.3
agent-one.node.dc1.consul. 0 IN A 172.17.0.2
;; Query time: 5 msec
;; SERVER: 127.0.0.1#8600(127.0.0.1)
;; WHEN: Thu Feb 18 07:39:22 UTC 2016
;; MSG SIZE rcvd: 244
```
В `ANSWER SECTION` перечислены доменные имена узлов в формате, требуемом Consul (обратите внимание, узлов, но не сервисов!) и порты, на которых запущен запрашиваемый сервис. IP-адреса узлов (и, соответственно, сервисов) перечислены в `ADDITIONAL SECTION` ответа.
Формат имени сервиса для DNS-запроса выглядит так:
`[tag.][service].service[.datacenter].[domain]`
* [tag.] — необязательная часть. Используется для фильтрации сервиса по тегам. Если у нас есть сервисы с одинаковым именем, но разными тегами, то добавление названия тега поможет отфильтровать выдачу;
* [service] — обязательная часть, имя сервиса;
* .service — указатель на то, что мы выполняем service lookup;
* [.datacenter] — необязательная часть, имя датацентра;
* .[domain] — обязательная часть, приватный домен Consul первого уровня.
Таким образом, сервис с именем nginx и имеющий tag названный web, можно представить доменом:
`web.nginx.service.consul`
##### SRV-запросы на поиск сервисов в соответствии с RFC-2782
Помимо “обычного” построения доменного имени мы можем построить его по более строгим правилам [RFC-2782](https://www.ietf.org/rfc/rfc2782.txt) для выполнения запроса на получение SRV-записи. Формат имени выглядит так:
`_service._tag.service[.datacenter].[domain]`
Название сервиса и tag имеют underscore (\_) в виде префикса. (В оригинальном RFC вместо tag должно стоять название протокола, это сделано для предотвращения коллизий при запросе).
В случае использования имени в формате RFC-2782, сервис с именем nginx и имеющий tag названный web, будет выглядеть так:
`_web._nginx.service.consul`
Ответ будет точно таким же, как и в случае “простого” запроса:
```
root@511cdc9dd19b:/# dig @127.0.0.1 -p 8600 _rls._rails.service.consul. SRV
; <<>> DiG 9.9.5-3ubuntu0.7-Ubuntu <<>> @127.0.0.1 -p 8600 _rls._rails.service.consul. SRV
; (1 server found)
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 26932
;; flags: qr aa rd; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 2
;; WARNING: recursion requested but not available
;; QUESTION SECTION:
;_rls._rails.service.consul. IN SRV
;; ANSWER SECTION:
_rls._rails.service.consul. 0 IN SRV 1 1 80 agent-one.node.dc1.consul.
_rls._rails.service.consul. 0 IN SRV 1 1 80 agent-two.node.dc1.consul.
;; ADDITIONAL SECTION:
agent-one.node.dc1.consul. 0 IN A 172.17.0.2
agent-two.node.dc1.consul. 0 IN A 172.17.0.3
;; Query time: 6 msec
;; SERVER: 127.0.0.1#8600(127.0.0.1)
;; WHEN: Thu Feb 18 07:52:59 UTC 2016
;; MSG SIZE rcvd: 268
```
По умолчанию, все доменные имена в рамках Consul имеют TTL = 0, то есть совсем не кешируются. Нужно иметь это в виду.
#### HTTP API
HTTP REST API является основным средством управления кластером Сonsul и предоставляет очень широкий диапазон возможностей. В рамках API реализовано 10 endpoints, каждый из которых предоставляет доступ к конфигурации определенного функционального аспекта Consul. Подробное описание всех edpoints есть в [документации Consul](https://www.consul.io/docs/agent/http.html), а мы кратко опишем каждый из них для представления о возможностях API:
* acl — контроль доступа;
* agent — управление агентом Consul;
* catalog — управление узлами и сервисами кластера;
* coordinate — сетевые координаты;
* event — пользовательские события;
* health — проверки доступности;
* kv — Key/Value хранилище;
* query — подготовленные запросы;
* session — сессии;
* status — статус системы.
*acl*
Как можно понять из названия, acl управляет контролем доступа к сервисам Consul. Мы можем регулировать доступ на получение и изменение данных о сервисах, узлах, пользовательских событиях, а также управлять доступом к k/v-хранилищу.
*agent*
Управление локальным агентом Consul. Все операции, доступные на этом endpoint, затрагивают данные локального агента. Можно получить информацию о текущем состоянии агента, его роли в кластере, а также получить доступ к управлению локальными сервисами. Изменения, выполненные над локальными сервисами, будут синхронизированы со всеми узлами кластера.
*catalog*
Управление глобальным реестром Consul. Здесь сосредоточена работа с узлами и сервисами. В рамках этого endpoint можно регистрировать и отключать сервисы и, в случае работы с сервисами, использование этого раздела более предпочтительно нежели работа через `agent`. Работа через `catalog` проще, понятнее и способствует [анти-энтропии](https://www.consul.io/docs/internals/anti-entropy.html).
*coordinate*
Consul использует [сетевую томографию](https://en.wikipedia.org/wiki/Network_tomography) для вычисления сетевых координат. Эти координаты используются для построения эффективных маршрутов в рамках кластера и многих полезных функций, таких как, например, поиск ближайшего узла с заданным сервисом или переключение на ближайший датацентр в случае аварии. Функции API в этом разделе используются только для получения информации о текущем состоянии сетевых координат.
*event*
Обработка пользовательских событий. Пользовательские события используются для выполнения каких-либо действий в рамках кластера: например для автоматического деплоя, перезапуска сервисов, запуска определенных скриптов или иных действий в рамках процесса оркестрации.
*health*
Проверка текущего состояния узлов и сервисов. Данный endpoint используется только для чтения и возвращает текущее состояние узлов и сервисов, а также списки выполняемых проверок.
*kv*
Этот endpoint имеет только один метод и используется для управления данными в распределенном key/value-хранилище, предоставленным Consul. Единственный метод в этом endpoint выглядит так:
`/v1/kv/[key]`
Разница в обработке заключается в методе запроса. GET вернет значение по ключу, PUT сохранит новое значение или перезапишет старое, а DELETE удалит запись.
*query*
Управление подготовленными запросами (Prepared queries). Подобные запросы позволяют выполнять сложные манипуляции над конфигурацией Consul и могут быть сохранены и выполнены позже. Сохраненным запросам присваивается уникальный ID. C его помощью запрос может быть выполнен в любое время без необходимости повторной подготовки.
*session*
Механизм сессий в Consul используется для построения распределенных блокировок. Сессии представляют собой связующий слой между узлами, выполняемыми проверками и k/v-хранилищем. У каждой сессии есть имя и оно может быть сохранено в хранилище. Имя используется для реализации блокировок в рамках последовательных действий с узлами и сервисами в конкурентном режиме. Механизм работы сессий описан в [документации Consul](https://www.consul.io/docs/internals/sessions.html).
*status*
Этот endpoint используется для получении информации о статусе кластера. Здесь можно узнать текущего лидера и получить информацию обо всех участниках кластера.
#### Health Checks
Ранее мы говорили про равномерное распределение нагрузки с помощью DNS, а теперь рассмотрим механизм проверки состояния узлов и сервисов. Health check — это периодически выполняемая операция, по результатам которой можно определить состояние проверяемой системы. По факту это автоматический мониторинг, который поддерживает состояние кластера в работоспособном состоянии, вычищает неработающие узлы и сервисы и возвращает их в работу по факту восстановления работоспособности. Consul поддерживает несколько видов проверок:
* Script check — запуск определенного скрипта на определенном узле с заданной периодичностью. В зависимости от кода выхода (любой отличный от нуля код будет означать, что проверка не прошла) включает или выключает узел или сервис.
* HTTP Check — проверка, которая пытается загрузить указанный URL, и в зависимости от кода ответа включает или выключает проверяемый объект (любые 2xx — все нормально, код 429 Too Many Requests генерирует предупреждение, остальные коды говорят об ошибке).
* TCP Check — проверка, которая пробует установить tcp-соединение с заданным интервалом к указанному адресу и порту. Невозможность установить соединение означает, что проверка не пройдена.
* TTL Check — проверка, которая должна периодически обновляться через HTTP API. Суть ее в том, что если некий сервис не обновил эту проверку в рамках определенного интервала, то он помечается как неработающий. Это пассивная проверка, то есть сервис сам должен периодически отчитываться о том, что он работает. Если за заданный интервал отчет не поступил, то проверка считается не пройденной.
* Docker Check — проверка для сервисов, работающих в docker-контейнерах. Consul, используя Docker Exec API, может выполнить скрипт, находящийся внутри контейнера. Результат проверки будет зависеть от кода выхода, любой отличный от нуля “провалит” проверку.
#### K/V storage
Хранилище, предоставляемое Consul является распределенной key-value базой данных и может использоваться для сохранения любых данных, доступных для любого участника кластера (в соответствии с правилами ACL, конечно же). Сервисы могут сохранять в этом хранилище данные, которые необходимы для других участников кластера. Это могут быть значения конфигурационных опций, результаты каких-либо вычислений или, как мы указали выше, k/v-хранилище может использоваться для реализации распределенных блокировок при помощи механизма сессий. Использование k/v-хранилища позволит нам сделать кластер более эффективным и уменьшить процент ручного вмешательства. Сервисы могут корректировать свое состояние в зависимости от информации в хранилище, гарантированно предоставленным кластером. Обратите внимание: не стоит сохранять в это хранилище какие-либо данные, связанные с бизнес-логикой ваших сервисов. Хранилище, предоставляемое Consul, используется для хранения и распространения метаинформации о состоянии участников кластера, а не о данных, которые они обрабатывают.
#### Заключение
Трудно переоценить роль discovery-сервиса в процессе построения распределенной архитектуры на больших проектах. Consul отлично подходит на эту роль. Продукт развивается и не стоит на месте, реализовано много полезного функционала, необходимого для безболезненного обслуживания системы с большим количеством компонентов. Кроме того, Consul написан на Go и распространяется в виде одного исполняемого файла, что делает процесс его обновления и поддержки очень удобным. | https://habr.com/ru/post/278101/ | null | ru | null |
# PostgreSQL Antipatterns: навигация по реестру
Сегодня не будет никаких сложных кейсов и мудреных алгоритмов на SQL. Все будет очень просто, на уровне Капитана Очевидность — делаем **просмотр реестра событий** с сортировкой по времени.
То есть вот лежит в базе табличка `events`, а у нее поле `ts` — ровно то самое время, по которому мы хотим эти записи упорядоченно показывать:
```
CREATE TABLE events(
id
serial
PRIMARY KEY
, ts
timestamp
, data
json
);
CREATE INDEX ON events(ts DESC);
```
Понятно, что записей у нас там будет не десяток, поэтому нам потребуется в каком-то виде **постраничная навигация**.
#0. «Я у мамы погроммист»
-------------------------
```
cur.execute("SELECT * FROM events;")
rows = cur.fetchall();
rows.sort(key=lambda row: row.ts, reverse=True);
limit = 26
print(rows[offset:offset+limit]);
```
Даже почти не шутка — редко, но встречается в дикой природе. Иногда после работы с ORM бывает тяжело перестроиться на «прямую» работу с SQL.
Но давайте перейдем к более распространенным и менее очевидным проблемам.
#1. OFFSET
----------
```
SELECT
...
FROM
events
ORDER BY
ts DESC
LIMIT 26 OFFSET $1; -- 26 - записей на странице, $1 - начало страницы
```
> Откуда тут взялось число 26? Это примерное количество записей для заполнения одного экрана. Точнее, 25 отображаемых записей, плюс 1, сигнализирующая, что дальше в выборке хоть что-то еще есть и имеет смысл двигаться дальше.
>
>
>
> Конечно, это значение можно не «вшивать» в тело запроса, а передавать через параметр. Но в этом случае планировщик PostgreSQL не сможет опереться на знание, что записей должно оказаться относительно немного, — и запросто выберет неэффективный план.
И пока в интерфейсе приложения просмотр реестра реализован как переключение между визуальными «страницами», никто долго не замечает ничего подозрительного. Ровно до момента, когда в борьбе за удобство UI/UX не решают переделать интерфейс на «бесконечный скролл» — то есть все записи реестра рисуются единым списком, который пользователь может крутить вверх-вниз.
И вот, при очередном тестировании вас ловят на **дублировании записей** в реестре. Почему, ведь на таблице есть нормальный индекс `(ts)`, на который опирается ваш запрос?
Ровно потому, что вы не учли, что **`ts` не является уникальным ключом** в этой таблице. Собственно, и **значения у него не уникальны**, как у любого «времени» в реальных условиях — поэтому одна и та же запись в двух соседних запросах легко «перескакивает» со страницы на страницу за счет другого конечного порядка в рамках сортировки одинакового значения ключа.
На самом деле, тут скрыта еще и вторая проблема, которую заметить много сложнее — **некоторые записи не будут показаны** вовсе! Ведь «сдублировавшиеся» записи заняли чье-то место. Подробное объяснение с красивыми картинками можно [прочитать тут](https://habr.com/ru/post/481610/).
#### Расширяем индекс
Хитрый разработчик понимает — надо сделать ключ индекса уникальным, а самый простой способ — расширить его заведомо уникальным полем в качестве которого отлично подойдет PK:
```
CREATE UNIQUE INDEX ON events(ts DESC, id DESC);
```
А запрос мутирует:
```
SELECT
...
ORDER BY
ts DESC, id DESC
LIMIT 26 OFFSET $1;
```
#2. Переход на «курсоры»
------------------------
Некоторое время спустя к вам приходит DBA и «радует», что ваши запросы [адски грузят сервер своими конскими OFFSET](https://habr.com/ru/post/481610/), и вообще, пора бы перейти на **навигацию от последнего показанного значения**. Ваш запрос мутирует снова:
```
SELECT
...
WHERE
(ts, id) < ($1, $2) -- последние полученные на предыдущем шаге значения
ORDER BY
ts DESC, id DESC
LIMIT 26;
```
Вы облегченно вздохнули, пока не наступила…
#3. Чистка индексов
-------------------
Потому что однажды ваш DBA прочитал [статью про поиск неэффективных индексов](https://habr.com/ru/post/488104/) и понял, что **«непоследний» timestamp — это нехорошо**. И снова пришел к вам — теперь с мыслью, что вот тот индекс должен все-таки превратиться обратно в `(ts DESC)`.
Но что же делать с первоначальной проблемой «скакания» записей между страницами?.. А все просто — надо выбирать блоки с нефиксированным количеством записей!
Вообще, кто нам запрещает читать не «ровно 26», а «не менее 26»? Например, так, чтобы в следующем блоке оказались **записи с заведомо другими значениями `ts`** — тогда ведь и проблемы с «перепрыгиванием» записей между блоками не будет!
Вот как этого добиться:
```
SELECT
...
WHERE
ts < $1 AND
ts >= coalesce((
SELECT
ts
FROM
events
WHERE
ts < $1
ORDER BY
ts DESC
LIMIT 1 OFFSET 25
), '-infinity')
ORDER BY
ts DESC;
```
Что здесь вообще происходит?
1. Шагаем на 25 записей «вниз» и получаем «граничное» значение `ts`.
2. Если там уже ничего нет, то подменяем NULL-значение на `-infinity`.
3. Вычитываем весь сегмент значений между полученным значением `ts` и переданным из интерфейса параметром $1 (предыдущим «последним» отрисованным значением).
4. Если блок вернулся меньше чем с 26 записями — он последний.
Или то же самое картинкой:
Поскольку теперь у нас **выборка не имеет какого-то определенного «начала»**, то нам ничто не мешает «развернуть» этот запрос в обратную сторону и реализовать динамическую подгрузку блоков данных от «опорной точки» в обе стороны — как вниз, так и вверх.
#### Замечание
1. Да, в таком случае мы обращаемся к индексу дважды, но все «чисто по индексу». Поэтому вложенный запрос приведет всего лишь **к одному дополнительному Index Only Scan**.
2. Достаточно очевидно, что этой методикой можно пользоваться, только когда у вас значения `ts` могут пересечься лишь случайно, и **их немного**. Если же ваш типичный кейс — «миллион записей в 00:00:00.000», так делать не стоит. В смысле, не стоит допускать такого кейса. Но если уж так получилось, используйте вариант с расширенным индексом. | https://habr.com/ru/post/498740/ | null | ru | null |
# Небольшой экскурс в Linux на ARM и ArchLinux на Mele A1000/A2000
Всем привет.
Смотря видео на youtube, как запускают ubuntu на одноплатных компьютерах вроде Mele A1000 или MK802, решил я, что нужно что-то делать с производительностью и заодно запустить ArchLinux на этом устройстве, т.к. этого, почему-то, пока еще никто не сделал.
#### Проблема производительности
Почему мы видим, что все устройства на ARM и MIPS работают так медленно в качестве десктопных систем? Причин множество:
1. Все устройства разные. Некоторые поддерживают один набор команд, некоторые — другой. У некоторых есть FPU, у некоторых — нет. Некоторые ARMv5, другие ARMv6, третьи ARMv7
2. Неоптимизированность компиляторов.
3. Нерасторопность / бездействие производителей.
4. Сложность поддержки и нерасторопность мейнтейнеров дистрибутивов.
Если для x86 первое практически не имеет значения, т.к. у всех есть FPU и оптимизации под конкретный процессор дают не более 5-10% производительности, то ARM устройства могут получить колоссальный прирост, для Mele это что-то вроде от 30% до 150% на сложных задачах с плавающей точкой (как, например, декодирование видео).
Так как полноценной поддержки в mainline-ядре реальных устройств, а не тестовых плат, практически нет, мы вынуждены пользоваться ядром от производителя, которое хорошо, если третей ветки. Причем зачастую изменения в ядро вносятся через зад, из-за чего мы получаем в меню конфигурации отсутствующие зависимости между опциями и практически невозможность портировать эти изменения на более свежие ядра средствами энтузиастов (это, конечно, не у всех).
Мейнтейнеры дистрибутивов не хотят тратить силы, вычислительную мощность и место на дисках для дополнительных репозиториев, и очень долгое время компилировали все либо с эмуляцией FPU, либо с softfp(позволяет использовать FPU, но совместимо с эмуляцией), и с оптимизациями под ARMv5, но, примерно чуть больше года назад, когда Cortex-A8 пошел в массы, мейнтейнеры задумались и решили попробовать все компилировать с hardware floating point. Так, ubuntu 12.04 стал первым массовым дистрибутивом, в котором появился armhf репозиторий. Это большой прогресс, только это дает Cortex-A8 прирост в 20%-40%, по сравнению с softfp, все приложения теперь собираются под ARMv7, но этого недостаточно.
На сегодняшний день, есть 3 дистрибутива, у которых есть репозитории с hardware floating point: ArchLinux-ARM, Ubuntu и Fedora. Т.к. я люблю ArchLinux, выбор для меня очевиден.
##### Устройства
«Почему мейнтейнеры собирают пакеты без NEON?», спросите вы:
**ARMv7 без набора инструкций NEON** (например, Marvell Armada в устройстве CuBox)
**Cortex-A8** (ARMv7 + NEON, китайские устройства с Allwinner A10: Mele, MK802, MiniX)
**Cortex-A9 без NEON** (nVidia Tegra 2 в Toshiba AC100)
**Cortex-A9 с NEON**
Следует отметить, что VFP в Cortex-A9 уже практический такой же быстрый, как и NEON, и оптимизация под NEON скорее вопрос энергосбережения, нежели производительности.
##### Что было сделано
* Взят последний U-Boot и ядро из [dl.linux-sunxi.org/nightly/latest](http://dl.linux-sunxi.org/nightly/latest/)
* Перекомпилированы важные пакеты с NEON и оптимизациями под Cortex-A8 (glibc, xz, bzip2, gzip, bash, openssl, zlib)
* Перекомпилированы пакеты, до которых у меня дотянулись руки (mplayer2)
* Добавлен видеодрайвер и GLES библиотеки (не уверен на счет работоспособности)
* Все компилировалось Linaro GCC, т.к. он самый оптимизированный под ARM.
CFLAGS:
`march=armv7-a -mfloat-abi=hard -mfpu=neon -ftree-vectorize -mvectorize-with-neon-quad -mcpu=cortex-a8 -mtune=cortex-a8 -mthumb -O2 -pipe -fstack-protector --param=ssp-buffer-size=4 -D_FORTIFY_SOURCE=2`
Не работает аппаратное ускорение видео.
Пока непонятно, работает ли gles, т.к. glxinfo говорит, что direct rendering: yes, glxgears крутятся, но как-то не очень. В качестве сервера использовать можно.
Как все это записывать на флешку можно почитать по ссылке:
[www.cnx-software.com/2012/07/20/nightly-builds-for-allwinner-a10-u-boot-linux-kernel-and-hardware-packs](http://www.cnx-software.com/2012/07/20/nightly-builds-for-allwinner-a10-u-boot-linux-kernel-and-hardware-packs/)
Чтобы запустить интерфейс, нужно зайти по ssh root/root и набрать startx
Если у вас есть желание и возможность помочь, вы любите ArchLinux и хотите видеть его на китайских устройствах на Allwinner, пожалуйста, свяжитесь со мной.
И немножко еще информации: Allwinner работает с XBMC над видеоускорением в XBMC for Android. Будет настоящий STB, а то сейчас как-то даже нет ничего.
Скачать: [rghost.ru/39743296](http://rghost.ru/39743296) | https://habr.com/ru/post/146877/ | null | ru | null |
# @Once: однократные замыкания
В Swift 5.5 появилась возможность использовать обертки свойств на [параметрах функций и замыканий](https://github.com/apple/swift-evolution/blob/main/proposals/0293-extend-property-wrappers-to-function-and-closure-parameters.md). Это наконец позволило мне реализовать то, что я и многие другие люди всегда хотели видеть в Swift — способ каким-либо образом обеспечить, чтобы замыкание (closure) вызывалось ровно один раз.
Чтобы понять, зачем, вот вам простой пример:
// упс, здесь мы забываем вызвать *comletion(...)*!
// … бизнес-логика
// упс, мы забыли поставить `return` в операторе `if` выше, поэтому выполнение функции продолжается, и мы второй раз вызываем замыкание (с неправильным результатом!).
Код, в котором у вас есть функции с обработчиком завершения, который должен вызываться с успешным или неудачным значением в зависимости от результата работы, которую выполняет функция, очень распространен.
Если вы не будете осторожны, можно легко сделать ошибку, когда вы вообще не вызовете обработчик завершения или вызовете его более одного раза, особенно если в функции присутствует сложная бизнес-логика или обработка ошибок.
Каюсь, я сам совершал эту ошибку много раз, и иногда это бывает достаточно сложно или требует много времени — точно выяснить, почему ваш код работает не так, как ожидалось. После небольшой отладки и просмотра кода вы понимаете: «О! Я забыл вызвать обработчик завершения!» или «О! Я забыл проставить `return`!» и вы довольные идете и исправляете свой код. Все хорошо!
Хотя было бы неплохо, если бы ваш код мог просигнализировать вам: «Эй! Вы забыли вызвать это замыкание!»? Вот где пригодится обертка свойств `@Once`.
Вот наивная реализация:
Вы можете аннотировать параметр своей функции с помощью этой обертки свойства:
И теперь вы получите ошибку во время выполнения, если замыкание не было вызвано в теле ровно один раз!
*Не забывайте, что вы все еще можете использовать эту обертку свойства вне параметров функции или замыкания, то есть на локальных свойствах или свойствах инстанса, которые имеют тип замыкания, как вы уже это делали в более старых версиях Swift!*
Одним из ограничений этой обертки свойств является то, что она не работает с изолирующими (non-escaping) замыканиями, поскольку замыкание необходимо сохранить внутри обертки свойства для последующего выполнения. Невозможно доказать компилятору, что замыкание не сбежит, даже если вы точно знаете, что этого не произойдет (возможно, потому, что ваш код полностью синхронен). Поэтому вам нужно будет аннотировать ваши изолирующие замыкания `@escaping`, чтобы использовать эту технику, что на практике вам не совсем нужно, но, к сожалению, является единственным обходным путем.
Вы можете найти на [GitHub](https://github.com/theblixguy/Once) полный код, который поддерживает как пробрасывающие (throwing), так и не пробрасывающие типы функций. Код доступен в виде пакета Swift, который при необходимости можно легко добавить в кодовую базу.
---
> Материал подготовлен в рамках курса ["iOS Developer. Professional"](https://otus.pw/Rl8L/).
>
> Всех желающих приглашаем на двухдневный онлайн-интенсив [«Пишем современное iOS приложение на SwiftUI»](https://otus.pw/pnsd/). В первый день разберем особенности создания UI с помощью данного фреймворка. Во второй — напишем бизнес-логику с помощью нативных средств (Combine). Также будем использовать новинки, представленные на WWDC 2021, в том числе и async-await. Вебинар рассчитан на iOS разработчиков, уже имеющих опыт разработки iOS приложений и желающих познакомиться со SwiftUI. Также будет полезно тем, кто уже разрабатывает на SwiftUI, но хотел бы узнать о новинках. [**РЕГИСТРАЦИЯ**](https://otus.pw/pnsd/)
>
> | https://habr.com/ru/post/569650/ | null | ru | null |
# Как написать своё VoIP-приложение с работой в фоне под Windows Phone
В этой статье я бы хотел рассказать о том, как в минимум усилий написать своё простое VoIP-приложение с бэкэндом и работой в фоне на платформе Windows Phone 8.
До выхода Windows Phone 8 пользователей voip-приложений очень разочаровывала работа в фоне, которая, собственно, практически отсутствовала — максимум из того, что могли сделать разработчики, чтобы показать пользователю входящий звонок пока приложение в бэкграунде — это показать toast notification, который слабозаметен, еле слышен и быстро исчезает. С одной стороны, это не позволяло поедать батарейку как если бы приложение работало полноценно в фоне, но с другой — делало его малополезным инструментом. До выхода WP8, Microsoft подогревала интерес публики к новой версии платформы обещаниями интегрировать Skype в операционную систему и работу в фоне. Что ж, обещания они свои выполнили — теперь стало возможно:
* инициировать звонок на Skype через контактную книгу телефона
* продолжать разговор по Skype даже если вы целенаправленно или случайно свернете приложение (раньше если при разговоре вы случайно заденете кнопку поиска — разговор обрывался)
* и самое интересное: принимать входящие звонки с интерфейсом а-ля обычный gsm-звонок в условиях когда Skype не запущен (не в foreground) и более того — он в фоне ничего не делает (не поедает батарейку)
Microsoft не стало делать это эксклюзивными возможностями (кроме интеграции в контактную книгу) для своего продукта и открыло API, что дает возможность сторонним разработчикам реализовывать такие же сценарии, не будучи при этом привилегированным партнером (как было в WP7 с native sdk). И хотя так же красиво интегрироваться в контактную книгу не получится — можно воспользоваться ContactStore и Protocol handlers, чтобы изменить в контакте поле URL и сделать открытие приложение по клику).
В конце статьи приложены исходники двух проектов: один из них пример Microsoft Chatterbox, в котором объясняется, как работают бэкграунд процессы с симуляцией бэк-энда с входящими звонками и даже с видео; второй — мой проект с простым бэкэндом, который позволяет общаться по voip на двух устройствах и использует voip push notifications, но обо всем по порядку.
Архитектура VoIP приложения с работой в фоне
--------------------------------------------
Если вы задались целью написать полноценное voip приложение, то к сожалению (или к счастью) вам не обойтись без native компонента на C++ (потому как нормальное API для работы с аудио-девайсами не доступно из managed части) Если кратко, то voip — приложение, которое умеет работать в фоне, должно состоять из двух процессов:
* **Foreground** — собственно обычный процесс, в котором «бежит» интерфейс приложения
* **Background** — второй процесс, который, по сути, состоит из четырех агентов:
+ **VoipHttpIncomingCallTask** — запускается когда к нам приходит входящий звонок по пуш каналу (особый вид push уведомлений, будет описан ниже).
+ **VoipForegroundLifetimeAgent** – запускается когда наше приложение становится активным и работает до тех пор, пока приложение не свернули или закрыли.
+ **VoipCallInProgressAgent** – Запускается при звонке сигнализируя о том, что процессу выделено больше ресурсов процессора для поддержки звонка. Таким образом (де)кодирование видео и аудио надо начинать после этого события.
+ **VoipKeepAliveTask** – запускается периодически каждые 6 часов. По сути, он нужен для того, чтобы периодически напоминать вашему серверу, что приложение всё ещё установлено на телефоне
* **Out-of-process** — межпроцессный компонент, призванный решить проблему коммуникации между первыми двумя. На самом деле это всё тот же второй процесс.
Графически это выглядит так:
Как же написать своё VoIP приложение?
-------------------------------------
Начнем по порядку:
#### 1. Транспорт
Сперва разберемся с уровнем транспорта наших данных. Конечно, это очень простой пример, который я соорудил за день, поэтому никаких мегаумных штук тут не будет — вы сами понимаете: мало написать транспорт, запись и воспроизведение аудио — надо ещё чтобы это работало быстро без задержек даже на слабых каналах связи — но это тема ни одной книги. И так, для транспорта мы будем использовать очень удобный класс из нового API — DatagramSocket (он прост и работает по UDP что логичнее аудио\видео потоками (нам же не надо ожидать подтверждения доставки каждого аудио пакета, правда?). Благодаря async\await работа с ним очень проста:
```
const string host = "192.168.1.12";
const string port = "12398";
var socket = new DatagramSocket();
socket.MessageReceived += (s, e) =>
{
//читаем входящие данные в строку
var reader = e.GetDataReader();
string message = reader.ReadString(reader.UnconsumedBufferLength);
};
await socket.BindServiceNameAsync(host);
var stream = await socket.GetOutputStreamAsync(new HostName(host), port);
var dataWriter = new DataWriter(stream);
//отправляем строку на удаленный хост
dataWriter.WriteString("Hello!");
await dataWriter.StoreAsync(); //передает данные в системный буфер ОС для отправки
```
я настолько привык к async\await, что воспользовался этим же классом и для серверной части (о том, как использовать WinRT API в десктопном дотнете смотрите [тут](http://www.codeproject.com/Articles/457335/How-to-call-WinRT-APIs-from-NET-desktop-apps)). Проткол тоже очень прост: COMMAND!BODY – для нашего примера хватит.
#### 2. Запись голоса
В Managed части для записи данных с микрофона есть два класса:
* XNA Microphone
* AudioVideoCaptureDevice
В нашем примере мы будем использовать первый (он доступен ещё с WP7) так как лично я не смог разобраться в том, как проиграть аудио со второго без использования native api), но, понятное дело, для реализации серьезного voip приложения вам придется использовать второй способ (StartRecordingToSinkAsync, который отдает чистый несжатый поток данных с микрофона). И так, запись данных с микрофона организована всего парой строк:
```
_microphone = Microphone.Default;
_microphone.BufferDuration = TimeSpan.FromMilliseconds(500);
_microphoneBuffer = new byte[_microphone.GetSampleSizeInBytes(_microphone.BufferDuration)];
_microphone.BufferReady += (s, e) =>
{
_microphone.GetData(_microphoneBuffer);
//отправка байтов на сервер
};
_microphone.Start();
```
#### 3. Проигрывание аудио
В нашем примере мы будем использовать очень неоптимальный, но рабочий и небольшой код:
```
_soundEffect = new SoundEffect(e.Data, _microphone.SampleRate, AudioChannels.Mono);
_soundEffect.Play();
```
К сожалению, альтернатив нет и через managed часть нет возможности проигрывать аудио на динамике для звонков, а только на спикере, поэтому возможно появление эхо и прочих шумов (это же простой пример).
#### 4. VoIP push уведомления
Киллер-фичей нашего примера будет является то, что если вы установите это приложение на два девайса — вы сможете звонить через приложение на другой девайс без необходимости нахождения в foreground приложения на том девайсе. Сперва необходимо зарегистрировать Push URI для обоих девайсов на сервере вместе с каким-нибудь идентификатором пользователя (в Skype это произвольное имя, в Viber — номер телефона пользователя). Затем, когда девайс А захочет позвонить девайсу Б — он отправит на сервере команду, сервер найдет push uri для девайса Б и отправит на MPNS xml c некоторыми данными о звонящем с обязательным условием наличия в хедере запроса X-NotificationClass=4. До выхода WP8 было всего три класса Push notifications
* Tile
* Raw
* Toast
но как видите, с WP8 добавился новый четвертый класс — VoIP. MPNS по своим каналам отправляет этот пакет на клиента и поднимает специально запущенный для этих целей **ScheduledTaskAgent**. Если этот агент правильно отработает — пользователю отобразится экран входящего звонка (аналогичный обычному GSM-звонку). И так, что же должен сделать **ScheduledTaskAgent**?
```
var incomingCallTask = task as VoipHttpIncomingCallTask;
if (incomingCallTask != null)
{
//десериализуем XML с номером и именем звонящего
Notification pushNotification;
using (var ms = new MemoryStream(incomingCallTask.MessageBody))
{
var xs = new XmlSerializer(typeof(Notification));
pushNotification = (Notification)xs.Deserialize(ms);
}
VoipPhoneCall callObj;
var callCoordinator = VoipCallCoordinator.GetDefault();
//запрос на отображения gsm-call-like интерфейса
callCoordinator.RequestNewIncomingCall("/MainPage.xaml?incomingCall=" + pushNotification.Number,
pushNotification.Name, pushNotification.Number, new Uri(defaultContactImageUri), "Voip.Client.Phone",
new Uri(appLogoUri), "Я VoIP-push!", new Uri(logoUrl), VoipCallMedia.Audio,
TimeSpan.FromMinutes(5), out callObj);
callObj.AnswerRequested += (s, e) =>
{
s.NotifyCallActive(); //запустит наше приложение
//далее небольшой воркэрунд для примера:
//как я писал выше, у нас нет возможности проигрывать
//аудио на внутреннем динамике используя managed code, а NotifyCallActive включает
//именно его без возможности проигрывать звуки на внешнем,
//так что таким способом мы отключаем внутренний, и включаем внешний
await Task.Delay(3000);
s.NotifyCallEnded();
};
callObj.RejectRequested += (s, e) => s.NotifyCallEnded();
}
```
Стоит заметить, что VoIP-пуши в отличие от всех остальных видов, могут прилетать как в открытое приложение, так и если оно закрыто — Skype принимает входящие звонки только через пуши даже если он в данный момент в foreground — на самом деле спорное решение, т.к. voip пуши иногда тормозят. Увы, в нашем примере мы не сможем поднять разговор, если voip пуш прилетит когда приложение запущено — у нас в нашем примере нет нативного межпроцессного компонента, чтобы сообщить основному процессу об этом (и да, OnNavigatedTo,From не сработают при появлении UI входящего звонка, хотя возможно будет вызов события Obscured у фрейма, но мы не сможем достать номер звонящего) — поэтому в моем примере при звонке принимающая сторона должна выйти из приложения, чтобы корректно подхватить разговор.
Заключение
----------
Всего это хватило, чтобы написать простое VoIP-приложение за день. Увы, оно умеет разговаривать только через спикер, не умеет выключать экран при поднесении к уху (proximity sensor) и продолжать разговор, если приложение сворачивается — для всего этого необходим native компонент, который очень подробно описан в примере Microsoft Chatterbox — мой же пример попроще, но зато с серверной частью. Изначально я хотел рассказать только о VoIP-пушах, но получилось немного больше. Конечно, для реализации полноценных VoIP-приложений лучше смотреть в сторону быстро развивающегося WebRTC, который, к слову, [уже официально работает](http://habrahabr.ru/company/zingaya/blog/172841/) в хроме в Android, но, надеюсь, мой пример окажется кому-нибудь полезным.
Исходники:
* [Microsoft Chatter Box](http://code.msdn.microsoft.com/wpapps/ChatterBox-VoIP-sample-app-b1e63b8b)
* [Мой пример с сервером](http://cyclopsapps.cloudapp.net/MyVoipSample.zip) | https://habr.com/ru/post/174287/ | null | ru | null |
# Добавление библиотеки OpenCV в проект Android Studio
### Вступление
Добрый день, уважаемые читатели! Всем давно известно, что мобильные устройства всё чаще комплектуются мощным аппаратным обеспечением. Процессоры современных смартфонов почти сравнялись с настольными аналогами, а проблемы с возможной нехваткой оперативной и внешней памяти уходят на второй план. Сегодня уже не встретишь телефоны или планшеты без внушительной программной платформы вроде Android, iOS или Windows, а кроме того, все мобильные устройства имеют те или иные встроенные модули, вроде фотокамеры. В данной статье речь пойдёт о встраивании библиотеки компьютерного зрения OpenCV в проект приложения для Android. Вероятно, данная статья не имела бы никакой значимой ценности, однако все инструкции в ней предназначены для Android Studio, новой официальной среды разработки от Google. К тому же, в статье описывается статическая инициализация OpenCV в Android без использования OpenCV Manager. Ниже представлен план руководства:
1. Загрузка OpenCV SDK для Android
2. Установка OpenCV в проект Android Studio
3. Разработка примера приложения OpenCV для Android
Не будем терять времени и начнём работу.
### 1. Загрузка OpenCV SDK для Android
Для того, чтобы использовать OpenCV в своих приложениях, необходимо загрузить соответствующий SDK. Сделать это можно на официальном сайте [opencv.org](http://opencv.org/). На рисунке ниже показана ссылка на скачивание нужного архива:
В архив OpenCV SDK для Android входят двоичные файлы библиотек под разные архитектуры микропроцессоров, обёртка на языке программирования Java, которая использует **Java Native Interface (JNI)** для вызова функций из платформо-зависимых библиотек, исходные коды примеров программ и файлы .apk для установки OpenCV Manager. Следующий шаг — добавление модуля OpenCV в проект Android Studio.
### 2. Установка OpenCV в проект Android Studio
Импорт модуля OpenCV в проект Android Studio не представляет труда. Для этого нужно выбрать меню *File -> New -> Import Module...* и указать путь *sdk/java* из распакованного архива SDK. Все остальные настройки импорта менять не обязательно. На рисунке ниже показано окно мастера с указанием пути импорта модуля и его нового имени в проекте:
После импорта модуля в его build.gradle нужно обязательно обновить параметры *compileSdkVersion*, *buildToolsVersion*, *minSdkVersion* и *targetSdkVersion*, чтобы они совпадали с соответствующими параметрами из модуля приложения. После того, как модуль OpenCV был добавлен, его нужно присоединить в качестве зависимости к модулю приложения. Для этого нужно выбрать меню *File -> Project Structure...* и для модуля *app* указать зависимость от *opencv*. На рисунке ниже показано окно настройки зависимостей:
Последнее, что осталось сделать — добавить двоичные библиотеки OpenCV в проект, чтобы при сборке они были упакованы в .apk приложения. Для этого нужно скопировать папку *sdk/native/libs* из OpenCV SDK в папку проекта по пути *app/src/main*. Затем нужно переименовать папку ***libs*** в ***jniLibs***. Следует отметить, что не нужно упаковывать статические библиотеки OpenCV (расширение *.a*) в .apk и хранить их в проекте. В образовавшейся папке *jniLibs* для каждой архитектуры можно оставить только файлы с расширением *.so*. На рисунке ниже показана получившаяся структура папок в Проводнике Windows:
### 3. Разработка примера приложения OpenCV для Android
Для того, чтобы быстрее начать работу с OpenCV, разработаем простое приложение для вывода изображения с камеры. Ниже приведено содержимое исходных файлов, которые необходимо изменить для запуска программы:
**MainActivity.java**
```
package com.androidcv;
import android.app.Activity;
import android.os.Bundle;
import android.view.SurfaceView;
import android.view.WindowManager;
import org.opencv.android.CameraBridgeViewBase;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
import org.opencv.android.OpenCVLoader;
import org.opencv.core.Mat;
public class MainActivity extends Activity implements CvCameraViewListener2 {
private CameraBridgeViewBase mOpenCvCameraView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
setContentView(R.layout.activity_main);
mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.view);
mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
mOpenCvCameraView.setCvCameraViewListener(this);
}
@Override
public void onPause()
{
super.onPause();
if (mOpenCvCameraView != null)
mOpenCvCameraView.disableView();
}
@Override
public void onResume()
{
super.onResume();
OpenCVLoader.initDebug();
mOpenCvCameraView.enableView();
}
public void onDestroy() {
super.onDestroy();
if (mOpenCvCameraView != null)
mOpenCvCameraView.disableView();
}
public void onCameraViewStarted(int width, int height) {
}
public void onCameraViewStopped() {
}
public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
return inputFrame.rgba();
}
}
```
**activity\_main.xml**
```
```
**AndroidManifest.xml**
```
xml version="1.0" encoding="utf-8"?
```
На рисунке ниже показан результат работы приложения:
### Заключение
В заключение нужно сказать, что хотя статическое связывание библиотек OpenCV представляется удобным, разработчики предписывают использовать этот способ только на этапе отладки. При выпуске приложения, например, в Google Play, лучше использовать OpenCV Manager. | https://habr.com/ru/post/262089/ | null | ru | null |
# Что такое Windows PowerShell и с чем его едят? Часть 2: введение в язык программирования
*Исторически утилиты командной строки в Unix-системах развиты лучше чем в Windows, однако с появлением нового решения ситуация изменилась.*
[](https://habr.com/ru/company/ruvds/blog/487876/)
Для PowerShell можно писать сценарии на интерпретируемом мультипарадигменном языке, в котором есть элементы классического процедурного, объектно-ориентированного и даже функционального программирования: условный переход, циклы, переменные, массивы, хэш-таблицы, классы, обработка ошибок, а также функции, командлеты и конвейеры. [**Предыдущая статья**](https://habr.com/ru/company/ruvds/blog/487876/) была посвящена основам работы в среде, а сейчас мы предлагаем вниманию читателей небольшой справочник для программистов.
Оглавление:
-----------
[Комментарии](#section1)
[Переменные и их типы](#section2)
[Системные переменные](#section3)
[Области видимости](#section4)
[Переменные окружения (среды)](#section5)
[Арифметические операторы и операторы сравнения](#section6)
[Операторы присваивания](#section7)
[Логические операторы](#section8)
[Условный переход](#section9)
[Циклы](#section10)
[Массивы](#section11)
[Хэш-таблицы](#section12)
[Функции](#section13)
[Обработка ошибок](#section14)
Писать код можно в любом текстовом редакторе или с использованием интегрированной среды разработки — проще всего взять Windows PowerShell ISE из комплекта поставки серверных операционных систем Microsoft. Нужно это только для достаточно сложных скриптов: короткие наборы команд проще выполнять в интерактивном режиме.
### Комментарии
Использование комментариев считается частью хорошего стиля программирования наряду с правильными отступами и пробелами:
```
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
```
### Переменные и их типы
Переменные в PowerShell — это именованные объекты. Их названия могут включать символ подчеркивания, а также буквы и числа. Перед именем всегда используется символ $, а чтобы объявить переменную, достаточно указать интерпретатору допустимое имя:
Для инициализации переменной (присвоения ей значения) применяется оператор присваивания (символ =):
```
$test = 100
```
Объявить переменную можно с указанием ее типа в квадратных скобках (оператор приведения типов) перед именем или значением:
```
[int]$test = 100
$test = [int]100
```
Важно понимать, что переменные в PowerShell — это полноценные объекты (классы) со свойствами и методами, типы которых основаны на имеющихся в .NET Core. Перечислим основные:
| Тип (класс .NET) | Описание | Пример кода |
| --- | --- | --- |
| [string]
System.String | строка Unicode | $test = «тест»
$test = 'тест' |
| [char]
System.Char | символ Unicode (16 бит) | [char]$test = 'c' |
| [bool]
System.Boolean | булевский тип (логическое значение True или False) | [bool]$test = $true |
| [int]
System.Int32 | тридцатидвухразрядное целое число (32 бита) | [int]$test = 123456789 |
| [long]
System.Int64 | шестидесятичетырехразрядное целое число (64 бита) | [long]$test = 12345678910 |
| [single]
System.Single | число с плавающей точкой длиною в 32 бита | [single]$test = 12345.6789 |
| [double]
System.Double | число с плавающей точкой длиною в 64 бита (8 байт) | [double]$test = 123456789.101112 |
| [decimal]
System.Decimal | число с плавающей точкой длиною в 128 бит (обязательно указывать d на конце) | [decimal]$test = 12345.6789d |
| [DateTime]
System.DateTime | дата и время | $test = Get-Date |
| [array]
System.Object[] | массив, индекс элементов которого начинается с 0 | $test\_array = 1, 2, «тест», 3, 4 |
| [hashtable]
System.Collections.Hashtable | хэш-таблицы — ассоциативные массивы с именованными ключами, построенные по принципу: @{ключ = «значение»} | $test\_hashtable = @{one=«один»; two=«два»; three=«три»} |
PowerShell поддерживает неявное преобразование типов, кроме того тип переменной может меняться на ходу (например, при помощи оператора присваивания), если он не указан принудительно — в этом случае интерпретатор выдаст ошибку. Определить тип переменной из предыдущего примера можно при помощи вызова метода GetType():
```
$test.GetType().FullName
```
Существует некоторое количество командлетов для управления переменными. Их список в удобной форме выводится с помощью команды:
```
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
```
Для просмотра объявленных переменных и их значений можно использовать специальный командлет:
```
Get-Variable | more
```
Такой способ кажется чрезмерно громоздким, с переменными намного удобнее работать через операторы или обращаясь к их свойствам и методам напрямую. Тем не менее командлеты имеют право на существование, поскольку позволяют задать некоторые дополнительные параметры. Важно понимать, что пользовательские переменные определены только в рамках текущего сеанса. После закрытия консоли или завершения сценария они удаляются.
### Системные переменные
Помимо объявленных пользователем существуют встроенные (системные) переменные, которые не удаляются после завершения текущего сеанса. Делятся они на два типа, при этом данные о состоянии PowerShell хранятся в автоматических переменных, которым нельзя самостоятельно присвоить произвольные значения. К их числу относится, например, $PWD:
```
$PWD.Path
```
Для хранения пользовательских настроек нужны переменные предпочтений, значения которых можно изменить. К примеру, с помощью $ErrorActionPreference задается реакция интерпретатора команд на возникновение некритических ошибок.
Вдобавок к операторам и командлетам для обращения к объявленным переменным существует псевдонакопитель Variable:. Работать с ним можно по аналогии с другими накопителями, а переменные в этом случае напоминают объекты файловой системы:
```
Get-ChildItem Variable: | more
```
или
```
ls Variable: | more
```
### Области видимости
Для переменных в PowerShell существует понятие области видимости (Scope). Действие глобальной области (Global) распространяется на весь текущий сеанс — в нее входят, например, системные переменные. Локальные (Local) переменные доступны только в области, где они были определены: скажем внутри функции. Есть еще понятие области действия сценария (Script), но для команд скрипта она по сути является локальной. По умолчанию при объявлении переменных им задается локальная область действия, а чтобы это изменить, нужна специальная конструкция вида: $Global: переменная = значение.
Например, так:
```
$Global:test = 100
```
### Переменные окружения (среды)
Из PowerShell доступен еще один псевдонакопитель Env:, с помощью которого можно обратиться к переменным среды. При запуске оболочки они копируются из родительского процесса (т.е. из инициировавшей текущий сеанс программы) и обычно их первоначальные значения совпадают со значениями в панели управления. Для просмотра переменных окружения используется командлет Get-ChildItem или его псевдонимы (алиасы): ls и dir.
```
dir Env:
```
Эти переменные представляют собой последовательности байтов (или символов, если угодно), интерпретация которых зависит только от использующей их программы. Командлеты \*-Variable с переменными среды не работают. Чтобы обратиться к ним, придется использовать префикс диска:
```
$env:TEST = "Hello, World!"
```
### Арифметические операторы и операторы сравнения
В PowerShell есть следующие арифметические операторы: + (сложение), — (вычитание), \* (умножение), / (деление) и % (модуль или остаток от деления). Результат арифметического выражения вычисляется слева направо в соответствии с общепринятым порядком операций, а для группировки частей выражения применяются круглые скобки. Пробелы между операторами игнорируются, их используют только для облегчения восприятия. Оператор + также объединяет, а оператор \* повторяет строки. При попытке прибавить число к строке оно будет преобразовано в строку. Кроме того, в языке PowerShell есть множество операторов сравнения, которые проверяют соответствие между двумя значениями и возвращают логические True или False:
| Оператор | Описание | Пример кода |
| --- | --- | --- |
| -eq | Equal / Равно (аналог = или == в других языках) | $test = 100
$test -eq 123 |
| -ne | Not equal / Не равно (аналог <> или !=) | $test = 100
$test -ne 123 |
| -gt | Greater than / Больше (аналог >) | $test = 100
$test -gt 123 |
| -ge | Greater than or equal / Больше или равно (аналог >=) | $test = 100
$test -ge 123 |
| -lt | Less than / Меньше (аналог <) | $test = 100
$test -lt 123 |
| -le | Less than or equal / Меньше или равно (аналог <=) | $test = 100
$test -le 123 |
Существуют и другие подобные операторы, позволяющие, например, сравнивать строки с учетом символа подстановки или использовать регулярные выражения для поиска соответствия образцу. Их мы подробно рассмотрим в следующих статьях. Символы <, > и = для сравнения не используются, поскольку задействованы для других целей.
### Операторы присваивания
Помимо самого распространенного оператора = существуют и другие операторы присваивания: +=, -=, \*=, /= и %=. Они изменяют значение перед присвоением. Аналогично ведут себя унарные операторы ++ и --, которые увеличивают или уменьшают значение переменной — они тоже относятся к операторам присваивания.
### Логические операторы
Для описания сложных условий одного только сравнения недостаточно. Записать любые логические выражения можно с помощью операторов: -and, -or, -xor, -not и!.. Работают они как и в других языках программирования, при этом можно использовать круглые скобки, чтобы задать порядок вычисления:
```
("Тест" -eq "Тест") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
```
### Условный переход
Операторы ветвления в PowerShell стандартные: IF(IF…ELSE, IF…ELSEIF…ELSE) и SWITCH. Рассмотрим их использование на примерах:
```
[int]$test = 100
if ($test -eq 100) {
Write-Host "test = 100"
}
[int]$test = 50
if ($test -eq 100) {
Write-Host "test = 100"
}
else {
Write-Host "test <> 100"
}
[int]$test = 10
if ($test -eq 100) {
Write-Host "test = 100"
}
elseif ($test -gt 100) {
Write-Host "test > 100"
}
else {
Write-Host "test < 100"
}
[int]$test = 5
switch ($test) {
0 {Write-Host "test = 0"}
1 {Write-Host "test = 1"}
2 {Write-Host "test = 2"}
3 {Write-Host "test = 3"}
4 {Write-Host "test = 4"}
5 {Write-Host "test = 5"}
default {Write-Host "test > 5 или значение не определено"}
}
```
### Циклы
В языке PowerShell есть несколько разновидностей циклов: WHILE, DO WHILE, DO UNTIL, FOR и FOREACH.
Цикл с предусловием работает, если/пока оно выполняется:
```
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
```
Циклы с постусловием отработают хотя бы один раз, потому что проверка условия производится после выполнения итерации. При этом DO WHILE работает, пока условие истинно, а DO UNTIL — пока оно ложно:
```
[int]$test = 0
do {
Write-Host $test
$test = $test + 1
}
while ($test -lt 10)
[int]$test = 0
do {
Write-Host $test
$test = $test + 1
}
until ($test -gt 9)
```
Количество итераций цикла FOR известно заранее:
```
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
```
В цикле FOREACH осуществляет перебор элементов массива или коллекции (хэш-таблицы):
```
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
```
### Массивы
В переменных PowerShell хранятся не только единичные объекты (число, строка и т.д.), но и множественные. Самая простая разновидность таких переменных — массивы. Массив может состоять из нескольких элементов, из одного элемента или быть пустым, т.е. не содержать элементов. Для его объявления используется оператор @(), который понадобится нам в следующей статье — он очень важен для добавления в массив других массивов (создания многомерных массивов), передачи массивов в функции в качестве аргумента и тому подобных задач:
```
$test_array = @() #создаем пустой массив
```
При инициализации массива его значения перечисляются через запятую (специальный оператор ,):
```
$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов
```
В большинстве случаев оператор @() можно опустить:
```
$test_array = 1, 2, 3, 4
```
В этом случае массив из одного элемента инициализируется следующим образом
```
$test_array = , 1
```
Для обращения к элементам массива используется начинающийся с нуля целочисленный индекс и оператор индекса (квадратные скобки):
```
$test_array[0] = 1
```
Можно указать несколько индексов через запятую, в т.ч. повторяющихся:
```
$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]
```
Оператор `..` (две точки — оператор диапазона) возвращает массив целых чисел на определенном верхней и нижней границей отрезке. Например, выражение 1..4 выводит массив из четырех элементов @(1, 2, 3, 4), а выражение 8..5 — массив @(8, 7, 6, 5).
С помощью оператора диапазона можно инициализировать массив ($test\_array = 1..4) или получить срез (slice), т.е. последовательность элементов одного массива с индексами из другого. При этом отрицательное число -1 обозначает последний элемент массива, -2 — предпоследний и т.д.
```
$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]
```
Обратите внимание, что значения целочисленного массива могут быть больше максимального значения индекса массива с данными. В этом случае возвращаются все значения до последнего:
```
$test_array[0..100]
```
Если попытаться обратиться к единственному несуществующему элементу массива, возвращается значение $null.
В PowerShell массивы могут содержать элементы разных типов или быть строго типизированными:
```
$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
```
Где свойство $test\_array.count — количество элементов массива.
Пример создания строго типизированного массива:
```
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
```
### Хэш-таблицы
Еще один базовый тип переменных в языке PowerShell — хэш-таблицы, которые также называют ассоциативными массивами. Hashtable похожи на JSON object и строятся по принципу ключ-значение. В отличие от обычных массивов, доступ к их элементам осуществляется по именованным ключам, которые являются свойствами объекта (также можно использовать оператор индекса — квадратные скобки).
Пустая хэш-таблица объявляется с помощью служебного символа @ и операторных скобок:
```
$test_hashtable = @{}
```
При объявлении можно сразу создать ключи и присвоить им значения:
```
$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}
```
Для добавления элемента в хэш-таблицу нужно присвоить ей еще несуществующий ключ или воспользоваться методом Add(). Если присваивание делается с существующим ключом, его значение изменится. Для удаления элемента из хэш-таблицы используется метод Remove().
```
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")
```
Переменные этого типа можно передавать в качестве аргументов функциям и командлетам — в следующей статье мы изучим как это делается, а также рассмотрим еще один сходный тип — PSCustomObject.
### Функции
В языке PowerShell есть все необходимые для процедурного программирования элементы, включая функции. Для их описания используется служебное слово Function, после которого требуется указать имя функции и заключенное в операторные скобки тело. При необходимости передать в функцию аргументы их можно указать сразу после имени в круглых скобках.
```
function имя-функции (аргумент1, ..., аргументN)
{
тело-функции
}
```
Функция всегда возвращает результат — это массив результатов всех ее стейтментов, если их более одного. Если стейтмент один, возвращается единственное значение соответствующего типа. Конструкция return $value добавляет элемент со значением $value к массиву результатов и прерывает выполнение statement list, а пустая функция возвращает $null.
Для примера создадим функцию возведения числа в квадрат:
```
function sqr ($number)
{
return $number * $number
}
```
Отметим, что в теле функции можно использовать любые объявленные до ее вызова переменные, а вызов функций в PowerShell может показаться непривычным: аргументы (если они есть) не заключаются в круглые скобки и разделяются пробелами.
```
sqr 2
```
или так:
```
sqr -number 2
```
Из-за способа передачи аргументов саму функцию иногда приходится заключать в скобки:
```
function test_func ($n) {}
test_func -eq $null # функция не вызывалась
(test_func) -eq $null # результат выражения — $true
```
При описании функции можно присвоить аргументам значения по умолчанию:
```
function func ($arg = value) {
#тело функции
}
```
Существует и другой синтаксис для описания аргументов функции, кроме того параметры могут считываться из конвейера — все это пригодится в следующей статье, когда мы будем рассматривать экспортируемые модули и создание собственных командлетов.
### Обработка ошибок
В PowerShell существует механизм Try…Catch…Finally, позволяющий обрабатывать исключительные ситуации. В блок Try помещается код, в котором может возникнуть ошибка, а в блок Catch — ее обработчик. Если ошибки не было, он не выполняется. Блок Finally выполняется после блока Try вне зависимости от возникновения ошибки, а блоков Catch может быть несколько для исключений различных типов. Само исключение записывается в не требующую объявления переменную по умолчанию ($\_) и может быть легко извлечено. В примере ниже мы реализуем защиту от ввода некорректного значения:
```
try {
[int]$test = Read-Host "Введите число"
100 / $test
} catch {
Write-Warning "Некорректное число"
Write-Host $_
}
```
На этом рассмотрение основ программирования на языке PowerShell стоит закончить. В следующих статьях мы подробнее изучим работу с переменными разных типов, коллекции, регулярные выражения, создание функций, модулей и собственных командлетов, а также объектно-ориентированное программирование.
[Часть 1: основные возможности Windows PowerShell](https://habr.com/ru/company/ruvds/blog/487876/)
[Часть 3: передача параметров в скрипты и функции, создание командлетов](https://habr.com/ru/company/ruvds/blog/493366/)
[Часть 4: Работа с объектами, собственные классы](https://habr.com/ru/company/ruvds/blog/494978/)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/490924/ | null | ru | null |
# (Python) Парочка полезных декораторов
> `import should
>
>
>
> @should.give((5,2),7)
>
> @should.give(("aa","bbb"),"aabbb")
>
> @should.give(([1],[2,3]), [1,2,3])
>
> @should.give((1,1),1) # test
>
> def add(a,b):
>
> return a+b
>
>
>
> @should.throw((1,0), Exception)
>
> @should.throw((5,0), ZeroDivisionError)
>
> @should.throw((5,0), TypeError) # test
>
> @should.throw((5,1), TypeError) # test
>
> def div(a,b):
>
> return a/b`
> `>pythonw -u "should.py"
>
> [!] add(1, 1) should give 1, but got 2.
>
> [!] div(5, 1) should raise TypeError, but raised nothing.
>
> [!] div(5, 0) should raise TypeError, but raised ZeroDivisionError.
>
> >Exit code: 0`
Идея в том, чтоб описать тест-кейсы к функции в качестве декоратора. Тогда они будут выполнять двойную функцию:
* тестирование (автоматическая проверка при запуске кода после изменения)
* документация (примеры использования функции)
Реализация:
> `# file: should.py
>
>
>
> def render\_func\_args(f, args):
>
> return '%s(%s)' % (f.\_\_name\_\_, ', '.join(map(repr,args)))
>
>
>
> def \_inform(msg):
>
> print '[!]', msg
>
>
>
> def should(args, expected):
>
> def check(f):
>
> val = f(\*args)
>
> if val != expected:
>
> \_inform('%s should give %s, but got %s.' % \
>
> (render\_func\_args(f, args), repr(expected), repr(val)))
>
> def decor(f):
>
> check(f)
>
> return f
>
>
>
> return decor
>
>
>
> def should\_raise(args, ExcptClass):
>
> def check(f):
>
> excpt = None
>
> try:
>
> f(\*args)
>
> except Exception, ex:
>
> excpt = ex
>
>
>
> if excpt == None:
>
> \_inform("%s should raise %s, but raised nothing." % \
>
> (render\_func\_args(f, args), ExcptClass.\_\_name\_\_))
>
> elif not isinstance(excpt, ExcptClass):
>
> \_inform("%s should raise %s, but raised %s." % \
>
> (render\_func\_args(f, args), ExcptClass.\_\_name\_\_, excpt.\_\_class\_\_.\_\_name\_\_))
>
> def decor(f):
>
> check(f)
>
> return f
>
>
>
> return decor
>
>
>
> throw = should\_raise
>
> give = should
>
>
>
> if \_\_name\_\_=='\_\_main\_\_':
>
> import should
>
>
>
> @should.give((5,2),7)
>
> @should.give(("aa","bbb"),"aabbb")
>
> @should.give(([1],[2,3]), [1,2,3])
>
> @should.give((1,1),1) # test
>
> def add(a,b):
>
> return a+b
>
>
>
> @should.throw((1,0), Exception)
>
> @should.throw((5,0), ZeroDivisionError)
>
> @should.throw((5,0), TypeError) # test
>
> @should.throw((5,1), TypeError) # test
>
> def div(a,b):
>
> return a/b
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**UPD.** Тем кто не знаком с декораторами — [ссылка для ознакомления](http://www.google.ru/search?hl=ru&source=hp&q=%D0%BF%D0%B8%D1%82%D0%BE%D0%BD+%D0%B4%D0%B5%D0%BA%D0%BE%D1%80%D0%B0%D1%82%D0%BE%D1%80&btnG=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA+%D0%B2+Google&lr=&aq=f&oq=). | https://habr.com/ru/post/71427/ | null | ru | null |
# CRAWL динамических страниц для Google и Яндекс поисковиков (snapshots, _escaped_fragment_, ajax, fragment)
Всем мир!
Содержание статьи:
1. Что такое CRAWL
2. Динамический CRAWL
3. Задачи, инструменты, решение
4. Почитать
5. Выводы
#### 1. **Что такое CRAWL**
Это сканирование страниц сайта поисковыми системами с целью получить необходимую информацию. Результат выполнения данного сканирования является html представление в конечной точке (у каждой поисковой системы свои настройки, а именно грузить или нет js (с запуском или без), css, img и т.д.) или как это ещё называют «снимок» сайта.
#### 2. **Динамический CRAWL**
Здесь речь будет идти о динамическом CRAWL страницы, а именно когда у вас сайт имеет динамический контент (или как это называют Ajax контент). У меня проект с использованием Angular.js + HTML5 Router (это когда без domain.ru#!path, а вот так domain.ru/path ), весь контент меняется в и один единственный index.php и специальные настройки .htaccess, для того, чтобы после обновления страницы всё отобразилось как надо.
Это прописано в настройках роутера angular:
```
$locationProvider.html5Mode({
enabled: true,
requireBase: false
});
```
Это прописано в .htaccess:
```
RewriteEngine on
# Don't rewrite files or directories
RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^ - [L]
# Rewrite everything else to index.html to allow html5 state links
RewriteRule ^ index.php [L]
```
#### 3. **Задачи, инструменты, решение**
##### **Задачи:**
1. Отдавать динамический контент страницы такой, какой он становится после окончания рендеринга и инициализации приложения
2. Формируем, Оптимизируем и Сжимаем html снимок страницы
3. Отдаём поисковой системе html снимок
##### **Инструменты:**
1. Установленная NPM (npm — это пакетный менеджер node.js. С его помощью можно управлять модулями и зависимостями.)
2. Установленный модуль [html-snapshots](https://github.com/localnerve/html-snapshots) с помощью команды:
```
npm install html-snapshots
```
3. Правильная конфигурация
##### **Решение:**
Для быстродействия рекомендую выполнять «кравлинг» на localhost (локальном веб-сервере)
Для начала нужно добавить в главный index.php в meta tag в head:
```
```
**Пример sitemap.xml:**
```
xml version="1.0" encoding="UTF-8"?
http://localhost/domain.ru/www/product/30
2016-07-22T19:47:25+01:00
1.0
```
**Конфигурация server.js:**
```
var fs = require("fs");
var path = require("path");
var util = require("util");
var assert = require("assert");
var htmlSnapshots = require("html-snapshots");
var minify = require('html-minifier').minify;
htmlSnapshots.run({
//#1 С использованием SITEMAP
//input: "sitemap",
//source: "sitemap_localhost.xml",
//#2 Массив ссылок на страницы сайта
input: "array",
source: ["http://localhost/domain.ru/www/product/30"],
//protocol: "https",
// setup and manage the output
outputDir: path.join(__dirname, "./tmp"),
//Чистит директорию перед сохранением новых копий
outputDirClean: false,
// Селектор любого блока, который находится внутри и отображается после инициализации приложения
selector: "#product",
//Ограничить время загрузки до 12 секунд, а можно и больше
timeout: 120000,
//Настройки помогающие отображать контент быстрее для CRAWL
phantomjsOptions: [
"--ssl-protocol=any",
"--ignore-ssl-errors=true",
"--load-images=false"
]
}, function (err, snapshotsCompleted) {
var body;
console.log("completed snapshots:");
assert.ifError(err);
snapshotsCompleted.forEach(function(snapshotFile) {
body = fs.readFileSync(snapshotFile, { encoding: "utf8"});
//Убираем стили и их содержание
var regExp = /]\*?>.\*?<\/style>/ig;
var clearBody = body.replace(regExp, '');
//Производим замену доменного имени
var domain = /http:\/\/localhost\/domain.ru\/www/ig;
clearBody = clearBody.replace(domain, '//domain.ru');
//Производим оптимизацию html файла
clearBody = minify(clearBody, {
conservativeCollapse: true,
removeComments: true,
removeEmptyAttributes: true,
removeEmptyElements: true,
collapseWhitespace: true
});
//Записываем в файл
fs.open(snapshotFile, 'w', function(e, fd) {
if (e) return;
fs.write(fd, clearBody);
});
});
});
console.log('FINISH');
```
Запуск командой:
```
node server
```
**Понимание алгоритма:**
1. Сначала он «кравлит» все страницы
2. Создаёт файлы и называет папки согласно вашему url: product/30/index.hmtl (index.html, а можно и product/30.html кому как удобней на скорость не влияет)
3. После этого вызывает callback -> snapshotsCompleted, где производит оптимизацию каждого index.html снимка вашей страницы
**Снимки вашего сайта подготовлены, осталось отдать их поисковому боту при заходе:**
index.php
```
if (isset($_GET['_escaped_fragment_'])) {
if ($_GET['_escaped_fragment_'] != ''){
$val = $_GET['_escaped_fragment_'];
include_once "snapshots" . $val . '/index.html';
}else{
$url = "https://" . $_SERVER["HTTP_HOST"] . $_SERVER["REQUEST_URI"];
$arrUrl = parse_url($url);
$val = $arrUrl['path'];
include_once "snapshots" . $val . '/index.html';
}
}else {
include_once('pages/home.php');
}
```
[Объяснение:](https://prerender.io/documentation)
1. **html5 push state**
If you use html5 push state (recommended):
Just add this meta tag to the head of your pages
```
```
If your URLs look like this:
[www.example.com/user/1](http://www.example.com/user/1)
Then access your URLs like this:
[www.example.com/user/1?\_escaped\_fragment\_=](http://www.example.com/user/1?_escaped_fragment_=)
2. **hashbang**
If you use the hashbang (#!):
If your URLs look like this:
[www.example.com/#](http://www.example.com/#)!/user/1
Then access your URLs like this:
[www.example.com/?\_escaped\_fragment\_=/user/1](http://www.example.com/?_escaped_fragment_=/user/1)
Дополнительно, для тех у кого есть снимки, но нет оптимизации:
```
var fs = require("fs");
var minify = require('html-minifier').minify;
var path = require("path");
var util = require("util");
var assert = require("assert");
var htmlSnapshots = require("html-snapshots");
//Получение списка папок
var myPath = path.join(__dirname, "./tmp/domain.ru/www/");
function getFiles (dir, files_){
files_ = files_ || [];
var files = fs.readdirSync(dir);
for (var i in files){
var name = dir + '/' + files[i];
if (fs.statSync(name).isDirectory()){
getFiles(name, files_);
} else {
files_.push(name);
}
}
return files_;
}
var allFiles = getFiles(myPath);
//var allFiles = [ 'C:\\xampp\\htdocs\\nodejs\\crawler\\tmp\\domain.ru\\www\\/product/30/index.html' ];
var body;
allFiles.forEach(function(snapshotFile){
body = fs.readFileSync(snapshotFile, { encoding: "utf8"});
var regExp = /]\*?>.\*?<\/style>/ig;
var clearBody = body.replace(regExp, '');
var domain = /http:\/\/localhost\/domain.ru\/www/ig;
clearBody = clearBody.replace(domain, '//domain.ru');
clearBody = minify(clearBody, {
conservativeCollapse: true,
removeComments: true,
removeEmptyAttributes: true,
removeEmptyElements: true,
collapseWhitespace: true
});
var social = /.\*?<\/ul>/ig;
clearBody = clearBody.replace(social, '');
fs.open(snapshotFile, 'w', function(e, fd) {
if (e) return;
fs.write(fd, clearBody);
});
});
console.log('COMPLETE');
```
#### **4. Почитать**
[stackoverflow.com/questions/2727167/getting-all-filenames-in-a-directory-with-node-js](http://stackoverflow.com/questions/2727167/getting-all-filenames-in-a-directory-with-node-js) — работа с файлами в node.js
[github.com/localnerve/html-snapshots](https://github.com/localnerve/html-snapshots) — snapshots module doc
[perfectionkills.com/experimenting-with-html-minifier](http://perfectionkills.com/experimenting-with-html-minifier/) — options snapshots module doc
[yandex.ru/support/webmaster/robot-workings/ajax-indexing.xml](https://yandex.ru/support/webmaster/robot-workings/ajax-indexing.xml) — yandex crawler info
[developers.google.com/webmasters/ajax-crawling/docs/specification](https://developers.google.com/webmasters/ajax-crawling/docs/specification) — google crawler info
[www.ng-newsletter.com/posts/serious-angular-seo.html](http://www.ng-newsletter.com/posts/serious-angular-seo.html) — article
[prerender.io/js-seo/angularjs-seo-get-your-site-indexed-and-to-the-top-of-the-search-results](https://prerender.io/js-seo/angularjs-seo-get-your-site-indexed-and-to-the-top-of-the-search-results/) — article
[prerender.io/documentation](https://prerender.io/documentation) — article
[regexr.com](http://regexr.com/) — regexr
[stackoverflow.com/questions/15618005/jquery-regexp-selecting-and-removeclass](http://stackoverflow.com/questions/15618005/jquery-regexp-selecting-and-removeclass) — regexr
#### **5. Выводы**
Теперь смело можно писать любые SPA приложения не беспокоясь за их «кравлинг» поисковым ботом, также вы можете подобрать под свой набор инструментов нужную конфигурацию как для «сервера», так и для «клиента»!
*Всем профессиональных успехов!* | https://habr.com/ru/post/306644/ | null | ru | null |
# Стероиды для Munin
[Munin](http://munin-monitoring.org) очень неплохая штука для мониторинга серверов, особенно одного-двух. Однако если количество серверов растёт работает он всё хуже и хуже. Под катом рассказ как я разгонял его до мониторинга больше чем 1000 виртуалок (275K rrd файлов в системе).
##### Почему Munin
Munin прекрасен:
— не требователен по ресурсам (пока серверов мало);
— простая настройка (удобные умолчания, простой текстовый конфиг);
— просто пишутся плагины (и есть куча готовых плагинов).
Munin ужасен:
— удобные умолчания не изменяются;
— интеграция с Nagios бесполезна;
— неудобные группировки графиков;
— «не любит» долго работающих плагинов, нужно делать костыли;
— код внутри тоже не блещет красотой.
Базируется на rrd, это добавляет как плюсы, так и минусы.
Модель плагинов у Munin оказалась удобной, разработчик может добавить графики в роль не дожидаясь пока кто-то заведёт что-то в центральной базе. Это нам ещё аукнется размером конфига, но удобно же.
Главное, Munin уже был. Переходить на другую систему значит переделывать существующий софт и переучивать людей.
##### Проблемы
— стал наступать себе на хвост (не успевает завершиться за 5 минут);
— очень сильно грузит диск;
— неудобно править конфиги (постоянно забываешь добавить новый сервер или убрать старый);
— агрегированные графики сложно писать;
— не было интеграции с Nagios.
Вдобавок агрегированные графики лгут. Потому что если суммировать количество запросов с 10 серверов, а потом выключить 5, то исторические данные убавяться в 2 раза! Естественно, так как суммарный график вычисляется каждый раз и не сохраняется, поменялась формула — поменялся прошлый график.
##### И их решение
###### Разгоняем
Обязательно надо сделать генерацию графиков как CGI/FastCGI, это ускоряет но не сильно.
Радикально разогнать Munin можно только затратным способом, положить все rrd в память (tmpfs). Ничего другого, ни RAID, ни SSD не помогает, увы. 275K rrd занимают 14GB, что не так уж и много, сервер с 32GB RAM не редкость (ещё несколько GB сожрут процессы самого Munin). Зато диск может быть самый обычный.
Естественно, раз в пару часов надо сбрасывать на диск и паковать имеющиеся RRD на всякий случай. Упакованный архив прекрасно пишется на SATA диск.
Сам Munin не чистит rrd, поэтому надо чистить не используемые rrd
/usr/bin/find /mnt/ramdrive/ -type f -mtime +5 -delete
**Небольшое отступление про неизбежность использования памяти**Проблема всех подобных систем в том, что данные поступают «поперечно» (одно измерение с каждой метрики), а обрабатываются «продольно» (все измерения для одной метрики) и перетасовать этот поток очень непросто. Можно писать как rrd сразу «продольно» и ждать записи, можно писать в базу «поперечно» (просто добавлять записи по одной в большую таблицу) и потом медленно их читать.
В любом случае без большого кеша/индекса в памяти не обойтись.
Раз уж у нас много памяти, то update запускаем без ограничения процессов, это помогает с медленными плагинами. Только я взводил таймер для убийства munin-update, которые работают дольше 3 минут.
Следующим начинает тупить рисовалка графиков. Профилирование показало, что чем больше серверов, тем больше конфиг и он парсится при каждом запуске munin-graph-cgi. У меня конфиг дорос до 64 мегабайт и парсинг его занимал до 7 секунд (100% загрузка CPU). Решение очевидно, не надо парсить его повторно, но чтобы подставить этот костыль надо править код Munin.
munin-update будет читать и писать конфиг как обычно, плюс сохранять объект конфига при помощи модуля Storable. munin-graph будет читать Storable файл, если он есть.
Это разгоняет рисование графиков, но кушает память, 64 мегабайта конфига превращаются в 375MB виртуальной памяти на процесс.
Как ни странно это не большая проблема для munin-update, так как он сначала разворачивает конфиг в памяти, а потом делает fork. В итоге в top 1000 процессов с RSS в 250MB и всего 21GB RAM used (14 из них это rrd!)
Куда большая проблема с munin-graph, так как там каждый процесс честно кушает свои 400MB памяти, но пока памяти хватает.
Следующая проблема оказалась с запуском munin-html, он не успевал отрабатывать. Вылечилось запуском асинхронно, и несколькими fork в коде. HTML рисуются раз в 10, а не в 5 минут, но это и не нужно особенно, только если новый сервер добавить.
###### И делаем удобнее
Текстовые конфиги неудобно править руками, но очень удобно генерировать скриптом. Благо к тому времени у нас уже была база серверов с разбиением по системам (виртуалки) и по датацентрам (физические хосты). Простенький скрипт переписывает конфиг Munin на основании этой базы и группирует сервера по системам (Domain в терминах Munin). Новые сервера появляются автоматически, старые так же автоматически пропадают. Красота!
Следующая проблема это рисование агрегированных графиков.
План такой, скриптом делаем выборку нужных rrd, берём последнее значение из них и, например, складываем.
**Получается вот такой munin плагин для рисования суммы запросов по серверам**
```
#!/usr/bin/perl -w
use strict;
use warnings;
if($ARGV[0] && $ARGV[0] eq 'config') {
print <<<'EOS';
host_name Aggregated
graph_title Total requests
graph_args --base 1000 -l 0
graph_vlabel requests
graph_category Nginx
graph_info Total count of requests
total.label total requests
total.info total requests
EOS
exit(0);
}
my @rrd_files = `/bin/ls /mnt/ramdrive/munin/oMobile/*-nginx_log_access-total-d.rrd`;
my $sum = 0;
foreach my $filename (@rrd_files) {
next unless(-f $filename);
my $lastline = `/usr/bin/rrdtool fetch $filename AVERAGE -s -15M -e now | fgrep -v 'nan' | tail -n 1`;
if($lastline =~ m/^\d+: ([-+.0-9e]+)\s*$/) {
$sum+=$1;
}
}
print "total.value $sum\n";
exit(0);
```
Никогда так не делайте! Это только для демонстрации, он делает тучу ненужных exec, в продакшен обязательно использовать RRD.
Чаще всего делается или сумма, или группировка нескольких линий на один график (очень хорошо видно не выбивается ли кто-то из толпы). Но можно же и вычислять нечто более сложное. Например, дано среднее время обработки запроса на каждом сервере и количество запросов на сервер, тогда можно вычислить среднее время запроса по всей системе.
Обратите внимание на host\_name, так можно создать виртуальные хосты и домены в Munin и группировать интересные графики в них.
Если читать не только последнее значение из RRD, то можно ловить резкие взлёты и падения графиков. Как правило, резкое, процентов на 20, изменение количества запросов, времени ответа, LA и т.д. не к добру и требует внимания. Берём данные за последний час, день, неделю и сравниваем. Если расхождение большое, то можно послать алерт (passive check в Nagios, например).
##### Итого
— Любую систему, базирующуюся на rrd можно разогнать, если положить rrd файлы в память (tmpfs);
— Munin удобный для небольших проектов можно растянуть и на заметное количество серверов (у меня >1500 munin-node);
— Небольшой скрипт и можно нарисовать довольно сложные графики;
— Небольшой скрипт и можно анализировать тренды и репортить алерты на них. | https://habr.com/ru/post/146032/ | null | ru | null |
# Генератор умных перечислений, EnumGenerator
Привет всем!
Несколько лет назад меня начал беспокоить вопрос создания статических (создаваемых и изменяемых до процесса компиляции) перечислений. Перечислений я хотел не простых, которые реализованы в С/С++, а с набором дополнительных возможностей, в том числе и ассоциированными столбцами данных произвольного типа, своего рода статическая база данных с доступом по уникальному идентификатору.
Тогда в моем понимании ясно выделились три типа объектов, которые могут быть уникальным идентификатором: числовой индекс, числовой идентификатор, символьный идентификатор. При попытке применить каждый из них для решения задачи перехода от ключа к значению сформировались основные их недостатки и преимущества:
* Числовой индекс — это уникальное целочисленное значение, элемент последовательного массива, для С/С++ это диапазон [0;n), где n — размер массива. Если мы видим индекс 5, то это подразумевает, что обязательно есть и индексы [0;4]. Примеры: индекс классического С-массива, хеш-таблица, адрес ячейки физической памяти. Краткий вывод: скорость обработки максимальная, сопровождаемость минимальная.
* Числовой идентификатор — это уникальное целочисленное значение, которое лишено обязанности быть последовательным. Примеры: дескриптор произвольного (файл, сокет, устройство) объекта, идентификатор потока, адрес какой-то переменной или функции в процессе. Краткий вывод: скорость обработки высокая, сопровождаемость средняя.
* Символьный идентификатор — это уникальное строковое значение, которое, в отличие от чисел, само по себе наделено некоторым логическим смыслом. Примеры: препроцессорное определение с помощью #define, классическое перечисление с помощью enum, название переменной в программе, ключ в объекте json, значение в формате XML. Краткий вывод: скорость обработки минимальная, сопровождаемость максимальная.
Основная задача проекта EnumGenerator — сгенерировать перечисление, которое удобно, безопасно и эффективно объединяет эти идентификаторы в единую конструкцию. Чтобы к одному значению можно было обратиться тремя способами:
1. Очень быстро по числовому индексу. Для основного использования в тексте программы. Пример: обычное перечисление.
2. Быстро и гибко по числовому идентификатору. Для сохранения значения в энергонезависимое хранилища и безопасное восстановление из него. Для обмена данными с другими программами, которые могут иметь более старую или более новую версию этого же перечисления. Пример: база данных, протокол сетевого взаимодействия.
3. Удобно и наглядно по символьному идентификатору. Для сохранения значения в конфигурационный файлы, который может редактироваться человеком, и безопасное восстановление из него. Пример: файл конфигурации \*.ini, \*.json, \*.yaml,\*.xml.
Входные данные EnumGenerator, перечисление Color3 в таблице Excel:
Выходные данные EnumGenerator:
**Перечисление Color3 в файле 'Enums.hpp'**
```
class Color3
{
public:
enum Value
{
Black = 0, //! men in black
Blue = 1, //! blue ocean
Green = 2, //! green forest
Invalid = 3,
Red = 4, //! lady in red
White = 5 //! white snow
};
static const int ValueCount = 6;
static const Value ValueInvalid = Invalid;
Color3(Value val = ValueInvalid) : m_ValueCur(val) {}
Color3(const Color3 &other) : m_ValueCur(other.m_ValueCur) {}
explicit Color3(int val) : m_ValueCur(ValueInvalid)
{
int index = NS_JDSoft::NS_EnumGenerator::ValueFindLinear(IDInteger, ValueCount, val);
if (index >= 0) m_ValueCur = Value(index);
}
explicit Color3(const char * val) : m_ValueCur(ValueInvalid)
{
int index = NS_JDSoft::NS_EnumGenerator::StringFindBinary(StringValues, ValueCount, val);
if (index >= 0) m_ValueCur = Value(index);
}
Color3 &operator =(Value val) { m_ValueCur = val; return *this; }
Color3 &operator =(const Color3 &other) { m_ValueCur = other.m_ValueCur; return *this; }
bool operator ==(Value val) const { return m_ValueCur == val; }
bool operator ==(const Color3 &other) const { return m_ValueCur == other.m_ValueCur; }
bool isValid() const { return m_ValueCur != ValueInvalid; }
Value toValue() const { return m_ValueCur; }
int toInt() const { return IDInteger[m_ValueCur]; }
const char * toString() const { return StringValues[m_ValueCur]; }
static const char * enumName() { return "Color3"; }
private:
static const char * const StringValues[ValueCount];
static const int IDInteger[ValueCount];
Value m_ValueCur;
};
```
**Перечисление Color3 в файле 'Enums.cpp'**
```
const char * const Color3::StringValues[Color3::ValueCount]=
{
"Black",
"Blue",
"Green",
"Invalid",
"Red",
"White"
};
const int Color3::IDInteger[Color3::ValueCount] =
{
0,
255,
65280,
-1,
16711680,
16777215
};
```
Пример использования перечисления Color3 в тестовом проекте Qt:
```
#include "Enums.hpp"
...
// Создание объекта перечисления и проверка невалидности его значения
Color3 colorPen;
QCOMPARE(colorPen.isValid(), false); // isValid()
QVERIFY(colorPen == Color3::Invalid); // operator ==(Value val)
// Проверка правильности основных преобразований
QCOMPARE(colorPen.toValue(), Color3::Invalid); // toValue()
QCOMPARE(colorPen.toInt(), -1); // toInt()
QCOMPARE(colorPen.toString(), "Invalid"); // toString()
// Задание валидного значения
colorPen = Color3::Red; // operator =(Value val)
QCOMPARE(colorPen.isValid(), true);
// Проверка правильности основных преобразований
QCOMPARE(colorPen.toValue(), Color3::Red);
QCOMPARE(colorPen.toInt(), 0xFF0000);
QCOMPARE(colorPen.toString(), "Red");
// Создание объекта с известным значением
QCOMPARE(Color3(Color3::Green).toString(), "Green");
QCOMPARE(Color3(0x00FF00).toString(), "Green");
QCOMPARE(Color3("Green").toString(), "Green");
// Сравнение объектов
QVERIFY(Color3(0x0000FF) == Color3("Blue")); // operator ==(const Color3 &other)
```
**Как попробовать EnumGenerator?**
1. [Скачать](https://code.google.com/p/cpp-enum-generator/source/browse/) проект на свой компьютер, Download zip и распаковать его.
2. Запустить файл Enums.lua в интерпретаторе lua.
Самый простой способ для пользователей windows:
1) [Скачать](https://yadi.sk/d/nQaGB3sxdMgcZ) минимальную версию интерпретатора lua и распаковать его.
2) Щелкнуть правой кнопкой мыши по файлу 'Enums.lua', кликнуть «Открыть» или «Открыть с помощью» и выбрать распакованный файл 'lua.exe'.
3. Убедиться, что в директории сгенерировались файлы 'Enums.hpp' и 'Enums.cpp'. Готово! :)
**Как использовать EnumGenerator в своем проекте?**
1. Попробовать EnumGenerator как описано в предыдущем пункте.
2. Переместить директорию с файлом 'EnumGenerator.lua' в стабильное место.
*Путь к директории с файлом 'EnumGenerator.lua' будем называть 'ENUMGENERATOR\_PATH'.*
3. Открыть файл 'Enums.lua' и отредактировать его так, чтобы переменная EnumGenerator содержала полный путь к генератору.
*Для этого и последующих проектов это нужно сделать один раз.*
4. Скопировать файлы 'Enums.xls' и 'Enums.lua' в директорию своего проекта.
5. Отредактировать файл 'Enums.xls' в Excel или OpenOffice для своих перечислений.
6. Сохранить отредактированный файл 'Enums.xls' как есть, дополнительно сохранить его в формате [csv](https://ru.wikipedia.org/wiki/CSV) в файл 'Enums.csv' и закрыть редактор.
7. Запустить файл Enums.lua из директории своего проекта в интерпретаторе lua и убедиться, что генерация прошла успешно:
* При запуске в консольном режиме скрипт пишет «Successfully completed!».
* При запуске из другой программы код возврата интерпретатора равен 0.
Схема прохождения данных при использовании EnumGenerator:
**[Вот пример](https://cpp-enum-generator.googlecode.com/git/Enums.xls)**, который наглядно демонстрирует основные возможности использования генератора, файл Excel.
Рассмотрим часть этого файла более подробно:
**Структура входного файла:**
1. Файл состоит из независимых частей-блоков, [0;∞]. Каждая часть (Part) начинается словом «PartBegin» и заканчивается словом «PartEnd» в самой левой ячейке. После «PartBegin» в этой же ячейке в круглых скобках указываются обязательные и опциональные параметры этой части, пример: PartBegin(Type=Enum, Name=Country). Все строки между «PartBegin» и «PartEnd» являются телом части (PartData). Последовательность частей учитывается.
2. Тело части (PartData) состоит из 0-го столбца (самый левый), который определяет тип всей строки и последующих ячеек [0;∞]. Сейчас реализовано 3 типа: Header — заглавие данных, Comment — комментарий, ""(пустая строка) — содержит основные данные в соответствии с заглавием.
3. Заглавие данных (Header) описывает обязательный идентификатор столбца и возможные дополнительные параметры.
Надеюсь, это выглядит наглядным, простым и логичным.
Буду рад отзывам и советам по улучшению, спасибо!
Связанные ссылки:
[String enum — строковые enum](http://habrahabr.ru/post/236403/)
[Ещё одна реализация Enums для Python](http://habrahabr.ru/post/208066/) | https://habr.com/ru/post/240537/ | null | ru | null |
# Опыт команды PVS-Studio: повышение производительности C++ анализатора на Windows при переходе на Clang
С самого своего начала C++ анализатор PVS-Studio для Windows (тогда еще Viva64 версии 1.00 в 2006 году) собирался компилятором MSVC. С выходом новых релизов C++ ядро анализатора научилось работать на Linux и macOS, и структура проекта была переведена на использование CMake. Но под Windows сборка по-прежнему происходила с помощью компилятора MSVC. 29 апреля 2019 года разработчики Visual Studio объявили о включении в свою среду разработки набора утилит LLVM и компилятора Clang. И сейчас у нас наконец дошли руки, чтобы попробовать его в действии.
### Тестирование производительности
В качестве бенчмарка воспользуемся нашей утилитой для регрессионного тестирования анализатора под названием SelfTester. Суть её работы заключается в анализе набора разных проектов и сравнении результатов анализа с эталонными. Например, если при каких-то правках в ядре анализатора появились ложные предупреждения или пропали правильные, значит появилась регрессия, которую надо исправить. Более подробно про SelfTester можно прочитать в статье "[Лучшее – враг хорошего](https://pvs-studio.com/ru/b/0667)".
Среди тестовой базы – достаточно разнообразные по объёму кода проекты. Как правило, если рабочий компьютер или тестовый сервер не нагружен, то время тестирования SelfTester'ом на одной и той же версии ядра варьируется в пределах погрешности. В случае если производительность анализатора не уберегли, это значительно скажется на общем времени тестирования.
После того как сборка C++ ядра перешла на Clang, SelfTester стал проходить на 11 минут быстрее.
Выигрыш по производительности в 13% — это довольно заметно, учитывая, что достаточно просто поменять компилятор, не так ли?
Минусы тоже есть, но незначительные. Сборка дистрибутива замедлилась на 8 минут, а размер исполняемого файла подрос на 1,6 Мбайт (из них ~500 Кбайт из-за статической линковки рантайма).
Видимо, производительность достигается более долгим этапом LTO (большую часть сборки занимает именно линковка) и более агрессивным раскручиванием циклов и встраиванием функций.
Далее хочется поделиться подводными камнями, возникшими в процессе перехода.
### Генерация сборки под Clang
Скрипты CMake позволяют нам собирать свой код всеми мейнстримными компиляторами под нужные операционные системы.
Прежде всего необходимо установить компоненты компилятора Clang через Visual Studio Installer.
Clang-cl — это так называемый "драйвер", который позволяет использовать clang с параметрами от cl.exe. Таким образом, он должен прозрачно взаимодействовать с MSBuild, практически как родной компилятор.
Также можно воспользоваться официальными сборками от проекта LLVM, которые можно найти на их репозитории [GitHub](https://github.com/llvm/llvm-project/releases). Однако для них нужно установить дополнительный плагин, чтобы Visual Studio смогла найти компиляторы. Имя toolset'а будет *llvm*, а не *clangcl*, как показано дальше в примерах.
Указываем toolchain в команде генерации solution для Visual Studio:
```
cmake -G "Visual Studio 16 2019" -Tclangcl
```
Либо используем GUI:
Открываем получившийся проект, собираем. И, конечно же, получаем пачку ошибок.
### Чиним сборку
Хоть сlang-cl внешне и ведет себя как CL, под капотом это совсем другой компилятор, со своими приколами.
Мы стараемся не игнорировать предупреждения компиляторов, поэтому используем флаги /W4 и /WX. Однако Clang может генерировать дополнительные предупреждения, которые сейчас мешают сборке. Пока выключим их:
```
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
....
if (WIN32)
add_compile_options(-Wno-error=deprecated-declarations
-Wno-error=reorder-ctor
-Wno-error=format-security
-Wno-error=macro-redefined
-Wno-error=bitwise-op-parentheses
-Wno-error=missing-field-initializers
-Wno-error=overloaded-virtual
-Wno-error=invalid-source-encoding
-Wno-error=multichar
-Wno-unused-local-typedef
-Wno-c++11-narrowing)
....
endif()
endif()
```
Немного получше.
Компиляторы GCC и Clang имеют встроенную поддержку типа *int128*, в отличие от MSVC под Windows. Поэтому в своё время была написана обертка с реализацией *Int128* для Windows (на ассемблерных вставках и обернутая ifdef'ами, в лучших традициях C/C++). Поправим определения для препроцессора, заменив:
```
if (MSVC)
set(DEFAULT_INT128_ASM ON)
else ()
set(DEFAULT_INT128_ASM OFF)
endif ()
```
на
```
if (MSVC AND NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang")
set(DEFAULT_INT128_ASM ON)
else ()
set(DEFAULT_INT128_ASM OFF)
endif ()
```
Обычно библиотеку с builtin'ами линкеру (lld) передает драйвер компилятора, будь то clang.exe или clang-cl.exe. Но в данном случае линкером заправляет MSBuild напрямую, который не знает, что нужно её использовать. Соответственно, драйвер никак не может передать флаги линкеру, поэтому приходится разбираться самим.
```
if (CMAKE_GENERATOR MATCHES "Visual Studio")
link_libraries("$(LLVMInstallDir)\\lib\\clang\\\
${CMAKE_CXX_COMPILER_VERSION}\\lib\\windows\\\
clang_rt.builtins-x86_64.lib")
else()
link_libraries(clang_rt.builtins-x86_64)
endif()
```
Ура! Сборка заработала. Однако дальше при запуске тестов нас ждала куча ошибок сегментации:
Отладчик при этом показывает какое-то странное значение в *IntegerInterval*, а на самом деле проблема находится немного дальше:
В разных структурах для Dataflow-механизма активно применяется ранее упомянутый тип *Int128*, а для работы с ним используются SIMD-инструкции. И падение вызвано невыровненным адресом:
Инструкция MOVAPS перемещает из памяти набор чисел с плавающей запятой в регистры для SIMD-операций. Адрес при этом обязан быть выровнен, в его конце должен стоять 0, а оказалась 8. Придется помочь компилятору, задав правильное выравнивание:
```
class alignas(16) Int128
```
Порядок.
Последняя проблема вылезла из-за Docker-контейнеров:
Сборка под MSVC всегда делалась со статической линковкой рантайма, а для экспериментов с Clang рантайм переключили на динамический. Оказалось, что в образах с Windows по умолчанию не установлены Microsoft Visual C++ Redistributable. Решили вернуть статическую линковку, чтобы у пользователей не возникало таких же неприятностей.
### Заключение
Несмотря на то, что пришлось немного повозиться с подготовкой проекта, мы остались довольны ростом производительности анализатора более чем на 10%.
Последующие релизы PVS-Studio на Windows будут собираться с помощью компилятора Clang.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: [Alexey Govorov, Sergey Larin. PVS-Studio Team: Switching to Clang Improved PVS-Studio C++ Analyzer's Performance](https://habr.com/en/company/pvs-studio/blog/560270/). | https://habr.com/ru/post/560274/ | null | ru | null |
# Управляем сервером посредством СМС
Началось все с того, что я откопал в полке с железками USB модем huaweiE1550, купленный мной прошлым летом для организации резервного канала Интернет. Проработал он тогда недолго и за ненадобностью был убран в «закрома» до лучших времен. Первое что сделал, разлочил его для работы с МТС (так уж сложилось исторически, что я предпочитаю именно этого оператора). Изначально в голову пришла идея отправки смс с предупреждениями от Nagios, вместо почты. Бегло пробежавшись по Интернетам, наткнулся на smsd демона для отправки/приемки смс-ок из пакета smstools. После прочтения документации по этому зверю, в голову пришла идея о том, что можно принимать сообщения с нужных телефонов, с командами для сервера. Так и родилась идея «Управлять сервером посредством СМС», которая может применяться для чего угодно: перезагрузить сервер, выключить его, перезапустить демона, сбросить кеш, открыть порт на фаерволе для удаленного подключения по ssh.
#### Настраиваем модем
Для начала необходимо подружить наш модем и Linux (кстати, я использую Centos 5.5). Втыкаем модем в один из свободных usb-портов. Первое, с чем приходится столкнуться, это то что модем определяется как CD-ROM, а с CD-ROM-а как известно смс-ки не отправишь и тем более не получишь. Для того чтоб это дело нам поправить, необходимо всего лишь скормить модему эту команду: **AT^U2DIAG=0** (0 – только modem, 1 – modem + cd-rom, 255 – modem + cd-rom + cardreader, 256 – modem + cardreader). Если у вас есть под рукой компьютер, с установленной Windows, то открывайте HyperTerminal, подключайтесь к модему, вводите команду: **AT^U2DIAG=0** и пропускайте следующий шаг.
Итак, заставляем модем быть модемом, а не каким-то CD-ROM-ом под Linux. Для начала необходимо поставить пакеты usb\_modeswitch и minicom `yum --enablerepo=rpmforge install usb_modeswitch minicom`, затем создаем/правим **/etc/usb-modeswitch.conf**:
`DefaultVendor = 0x12d1
DefaultProduct = 0x1446
MessageEndPoint = "0x01"
MessageContent = "55534243000000000000000000000011060000000000000000000000000000"`
И перетыкаем модем в другой порт, необходимо подождать 5-10 секунд (необходимо чтоб модем определился как CD-ROM) и от root-а запускаем `usb_modeswitch` и видим примерно следующие:
`Looking for target devices ...
No devices in target mode or class found
Looking for default devices ...
Found default devices (1)
Accessing device 004 on bus 007 ...
Using endpoints 0x01 (out) and 0x81 (in)
Inquiring device details; driver will be detached ...
Looking for active driver ...
OK, driver found ("usb-storage")
OK, driver "usb-storage" detached
SCSI inquiry data (for identification)
-------------------------
Vendor String: HUAWEI
Model String: Mass Storage
Revision String: 2.31
-------------------------
USB description data (for identification)
-------------------------
Manufacturer: HUAWEI Technology
Product: HUAWEI Mobile
Serial No.: not provided
-------------------------
Setting up communication with interface 0 ...
Trying to send the message to endpoint 0x01 ...
OK, message successfully sent
Device is gone, skipping any further commands
-> Run lsusb to note any changes. Bye.`
Должны появится новые устройства ttyUSB
`ls /dev | grep ttyUSB`:
`ttyUSB0
ttyUSB1
ttyUSB2`
Запускаем `minicom –s` настраиваем последовательный порт на работу с /dev/ttyUSB0,
Выходим из настроек, запускается терминал, затем необходимо отдать команду **AT^U2DIAG=0** и получить в ответ **ok**
Процедура превращения модема в модем закончена, преступаем к установке/настройке smstools.
#### Smstools
Как ни странно, в огромных репозитариях rpmforge не нашлось места такому наиполезнейшему пакету как smstools. Но не беда, на просторах Интернета и на [сайте производителя](http://smstools3.kekekasvi.com) её достаточно. Я нашел пакет: smstools-3.0.10-4.el5.i386.rpm и «воспользовался» им rpm –i smstools-3.0.10-4.el5.i386.rpm. Настраиваем smstools, файл **/etc/sms.conf**:
`devices = huaweiE1550
logfile = /var/log/smsd.log
loglevel = 2
[huaweiE1550]
device = /dev/ttyUSB0
baudrate = 115200
rtscts = no
init = at+cpms="sm","sm",""
incoming = yes
incoming = high`
настройки примерно понятные, запускаем демона, `service smsd start` и проверяем сие чудо: `smssend 9128141111 ‘test message’` (не понимает кириллицу, необходимо конвертировать в [UCS-2BE](http://en.wikipedia.org/wiki/UTF-16/UCS-2), в рамках этой статьи рассматривать не буду) и ждать смс-ки на мобильник. Если заветное сообщение не пришло, ставим в конфиге **loglevel = 7** и идем за бубном. У меня поднялось все с первого раза.
#### smsctrl daemon
Итак разговаривать мы умеем, необходимо научиться слушать!
Если отправить смс-ку на номер симки в модеме, через некоторое время smsd создаст файл в /var/spool/sms/incoming/huaweiE1550.\* примерно следующего содержания:
`From: 79128141111
From_TOA: 91 international, ISDN/telephone
From_SMSC: 79126313431
Sent: 11-03-02 08:05:46
Received: 11-03-02 08:08:09
Subject: huaweiE1550
IMSI: 2500XXXXXXXXXXX
Report: no
Alphabet: ISO
UDH: false
Test message`
Соответственно эти файлики мы и будем проверять на наличие команд для управления сервером. Для этого два способа 1-й небольшой демон на bash-е, 2-й встроеный обработчик событий в smsd.
##### 1-й способ
```
#!/bin/sh
# SMSCtrl
# chkconfig: - 55 45
# description: Sms control, Egor N. Zuskin, 2011, http://www.it2k.ru/projects/smsctrl
. /etc/rc.d/init.d/functions
DAEMON=smsctrl
REFRESH_TIME=15
COMMAND_CHAR="#"
INCOMING_DIR=/var/spool/sms/incoming
ALLOW_PHONES="79128141111 79128141112"
SEND_BACK_REPORT=YES
to_log(){
text=$1
export LANG=en_EN
log_date=`date "+%b %d %H:%M:%S "`
log_host=`hostname -s`
echo "$log_date $log_host $DAEMON: $text" >> /var/log/$DAEMON.log
}
start() {
echo -n "Starting $DAEMON: "
$0 --daemon && success || failure
RETVAL=$?
echo
[ $RETVAL = 0 ] && touch /var/lock/subsys/$DAEMON
to_log "Starting ..."
return $RETVAL
}
stop() {
# Stop daemon.
echo -n "Shutting down $DAEMON: "
killproc $0
RETVAL=$?
to_log "Stopping ..."
echo
[ $RETVAL = 0 ] && rm -f /var/lock/subsys/$DAEMON
}
run() {
for File in $(ls $INCOMING_DIR); do
Allow=0
for Phone in $ALLOW_PHONES; do
cat $INCOMING_DIR/$File | grep "From: $Phone" > /dev/null 2>&1
[ $? -eq 0 ] && Allow=1
done;
[ $Allow -eq 0 ] && continue
cat $INCOMING_DIR/$File | grep "$COMMAND_CHAR"
[ $? -ne 0 ] && continue
FromPhone=`cat $INCOMING_DIR/$File | grep "From:" | cut -d " " -f2`
command=`cat $INCOMING_DIR/$File | grep "$COMMAND_CHAR" | cut -d "$COMMAND_CHAR" -f2`
to_log "Incoming command: $command from $FromPhone"
out=`$command`
if [ "$SEND_BACK_REPORT" = "YES" ]; then
smssend $FromPhone "$out"
to_log "Send sms to $FromPhone: $out"
fi
rm -f $INCOMING_DIR/$File
to_log "Deleting file $INCOMING_DIR/$File"
done
}
daemon() {
exec >/dev/null
exec 2>/dev/null
(
trap "" TERM
while [ true ]; do
run
sleep $REFRESH_TIME;
done;
)&
}
case "$1" in
--daemon)
daemon
;;
run)
run
;;
start)
start
;;
stop)
stop
;;
restart)
$0 stop
$0 start
exit $?
;;
status)
status $DAEMON
echo
;;
*)
echo "Usage: $DAEMON {start|stop|restart|status|run}"
exit 1
esac
exit 0
```
`COMMAND_CHAR="#" – Признак команды
INCOMING_DIR=/var/spool/sms/incoming – Директория для входящих смс-ок
ALLOW_PHONES="79128141111 79128141112" – Номера с которых разрешены команды
SEND_BACK_REPORT=YES – Отправлять вывод смс-ой обратно`
Чтобы не заморачиваться всякими пас фразами и т.д. было принято решение принимать команды только от определенных номеров (не проверял как будут выглядеть смс-ки от подменных номеров) и делать проверку на наличие спец символа перед командой, дабы отгородить от случайной смс-ки.
Сохраняем демона в **/etc/init.d/smsctrl**, `chkconfig --add smsctrl`, `service smsctrl start`
#### 2-й способ
Дописываем в **/etc/smsd.conf**:
`eventhandler = /root/bin/sms_event.sh`
создаем **/root/bin/sms\_events.sh**
```
#!/bin/bash
COMMAND_CHAR="#"
ALLOW_PHONES="79128141111 79128141112"
SEND_BACK_REPORT=YES
[ "$1" = "RECEIVED" ] || exit 0
to_log(){
text=$1
export LANG=en_EN
log_date=`date "+%b %d %H:%M:%S "`
log_host=`hostname -s`
echo "$log_date $log_host $text" >> /var/log/smsctrl.log
}
File=$2
Allow=0
for Phone in $ALLOW_PHONES; do
cat $File | grep "From: $Phone" > /dev/null 2>&1
[ $? -eq 0 ] && Allow=1
done;
[ $Allow -eq 0 ] && exit 0
cat $INCOMING_DIR/$File | grep "$COMMAND_CHAR"
[ $? -ne 0 ] && exit 0
FromPhone=`cat $File | grep "From:" | cut -d " " -f2`
command=`cat $File | grep "$COMMAND_CHAR" | cut -d "$COMMAND_CHAR" -f2`
to_log "Incoming command: $command from $FromPhone"
out=`$command`
if [ "$SEND_BACK_REPORT" = "YES" ]; then
smssend $FromPhone "$out"
to_log "Send sms to $FromPhone: $out"
fi
rm -f $File
to_log "Deleting file $File"
```
#### Проверка
Создаем файлик **/root/bin/test.sh** следующего содержания:
```
#!/bin/bash
ls –la /etc | grep $1
```
Затем берем в руки телефон и посылаем смс с текстом `#/root/bin/test.sh sms` на заветный номер и смотрим в лог `tail –f /var/log/smsctrl.log`, если все хорошо — в ответ прилетит смс-ка вида: `smsd.conf`
#### Заключение
У меня данное решение, по смс-ке открывает ssh порт для входящих подключений. Я думаю, это не единственное применение, достаточно включить немного воображения.
Полезные ссылки для настройки huaweiE1550 и smsd
1: [SMSTools 3 — шлюз для отправки SMS](http://www.lissyara.su/articles/freebsd/programms/smstools_3/)
2: [Нужна статья про смс-центр с модемом Huawei E1550?](http://forum.lissyara.su/viewtopic.php?f=14&t=27612)
3: [Как «приручить» МТС-модем Huawei E1550](http://rus-linux.net/nlib.php?name=/MyLDP/internet/modem-ru.html)
Спасибо за внимание, с нетерпением жду Ваших комментариев.
UPD По замечанию моего хорошего друга, дополнил реализацию обработки водящих смс сообщений средствами smsd. | https://habr.com/ru/post/114912/ | null | ru | null |
# Галлюцинируй как Трамп, или мини-анализ Рекуррентных Нейронных Сетей
Я уже довольно давно занимаюсь проблемами машинного обучения и глубокими архитектурами (нейронные сети), и мне необходимо было сделать мини-презентацию системы, генерирующую временные ряды для эмуляции различных процессов. Поскольку на серьезные темы лучше говорить с юмором, то я решил подобрать какой либо веселый пример, чтобы выступление слушалось с улыбками на лицах. Нам крупно повезло, поскольку мы живем в одно время с великим оратором, чьи речи заставляют сердца людей биться чаще. Я говорю о Дональде Трампе. Поэтому вполне естественно было бы создать систему, которая ~~галлюцинировала~~ говорила бы как Трамп.
#### Рекуррентные Нейронные Сети
Рекуррентные Нейронные Сети это тип искусственных нейронных сетей, разработанных для распознавания паттернов в последовательности данных, будь это текст, геном, почерк, произнесенные слова, или числовые последовательности, исходящие из сенсоров, рынка акций и правительственных агенств. Основным отличием Рекуррентных Нейронных Сетей (в дальнейшем РНН) от остальных архитектур, является так называемое наличие памяти. РНН сохраняет предыдущие значения в своем состоянии. Можно сказать, что РНН строит динамические модели, т.е. модели, которые меняются с течением времени таким образом, что дают возможность достигать достаточной точности, в зависимости от контекста примеров, которые были предоставлены.
[Неплохой туториал о данных архитектурах.](https://deeplearning4j.org/recurrentnetwork)
Также хочу порекомендовать отличный пост Андрея Карпатного, который является одним из ведущих исследователей Глубинного Обучения в мире, о невероятной эффективности РНН.
[The Unreasonable Effectiveness of Recurrent Neural Networks](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)
#### Модели и тренинг
Для построения модели мне необходимо было найти корпус речей Трампа. После небольшого поиска, я нашел выступления Трампа на дебатах, плюс несколько интервью и заявлений на различные темы. Я почистил файлы от дат, отметок поведения зала (смех и прочее), перевел в нижний регистр и объединил все в один файл под названием `speeches.txt`
Второй важный момент, это выбор фреймворка для построения моделей. При желании, можно написать систему с нуля, например для Python существует библиотека CudaMat, для выполнения матричных вычислениях на графических картах. Поскольку, в общем виде, проход по Нейронной Сети это набор матричных умножений с применением функций активации, то на базе CudaMat можно достаточно быстро реализовать различные архитектуры. Но я не буду изобретать велосипед и возьму, как пример, два фреймворка для Deep Learning систем.
Первый, это пожалуй самый распространенный и удобный фреймворк Torch на базе Lua. Lua это пожалуй самый быстрый интерпретируемый язык, с мощным нативным бэкендом для графических ускорителей и state-of-art JIT-компилятором. [Why-is-Lua-so-fast](https://www.quora.com/Why-is-Lua-so-fast) Lua активно используется в Deep Mind, достаточно зайти на их [GitHub](http://github.com/deepmind).
Второй, это DeepLearning4j — открытый фреймворк для построения Нейронных Сетей и распределенного обучения для JVM мира, активно поддерживаемый компанией SkyMind. К числу достоинств фреймворка относятся, легкость подключения визуализаций, наличие распределенного обучения (data-paralell), чувство комфорта для Java девелоперов. По сути, моей целью и было сравнить скорости обучения и подходы двух фреймворков.
Хочу также отметить тот момент, что все ниже перечисленное исполнялось на моем лаптопе MacBook Pro(2015), где нет NVIDIA GPU, и поэтому все запускалось на CPU, что ограничивало меня в выборе размера модели и времени, которое я мог потратить на подготовку презентации. Разница между CPU и GPU видна невооруженным взглядом.
GPU
CPU
#### Torch-RNN
Начнем с самого простого и быстрого. Установить систему можно отсюда [github.com/jcjohnson/torch-rnn](http://github.com/jcjohnson/torch-rnn) Но если ставить эту систему как есть на свою машину, то владельцы Маков столкнутся с проблемой несовместимости новой версии torch-hd5f с остальными зависимостями (и я думаю не только Маков, поскольку DeepMind в курсе этой проблемы). Эта проблема преодолевается, и для этого я отправляю вас [сюда](http://www.asaduddin.com/2017/03/torch-rnn-macos-installation-guide-2017-average-joe-edition/). Но лучше и проще всего, это взять готовый Docker image [отсюда](http://github.com/crisbal/docker-torch-rnn) и запустить контейнер.
Закидываем корпус речей в папку torch/torch-rnn/data/ под именем speeches.txt ([лежит тут](http://github.com/alextavgen/TrumpHallucinator/blob/master/trump-hallucinator/src/main/resources/speeches.txt)).
Запускаем контейнер следующей командой
```
docker run -v /Users//torch/torch-rnn/data:/data --rm -ti crisbal/torch-rnn:base bash
```
Флаг -v и путь после него означают, что я хочу отобразить путь из моей локальной файловой системы на контейнер Docker (в корневую систему /data/), поскольку в процессе тренинга модель записывает промежуточные результаты, то я не хочу потерять их после уничтожения контейнера. Да и в последующих запусках, я могу использовать готовую модель, как для продолжения тренинга так и для генерации.
Остальные команды идентичны как для контейнерного запуска, так и для запуска в родной системе.
Для начала, необходимо сделать предварительную обработку данных. Перевести в формат hd5f файл с корпусом речей. Пути к файлу написаны для контейнерной версии, поменяйте их на свой каталог.
```
python scripts/preprocess.py
--input_txt /data/speeches.txt
--output_h5 /data/speeches.h5
--output_json /data/speeches.json
```
Запускаем тренинг
```
th train.lua -batch_size 3 -seq_length 50 -gpu -1 -input_h5 /data/speeches.h5 -input_json /data/speeches.json
```
если вы запускаете на системе с GPU то флаг -gpu -0, он стоит по умолчанию. Поскольку у меня нет ускорителя, я указал ограничение на размер последовательности до 50 символов. Количество настроек достаточно большое. Я выбрал размер слоя РНН 128, 2 слоя, поскольку иначе мой тренинг мог затянуться очень и очень надолго. Количество эпох и прочих параметров я оставил по умолчанию, поскольку мне нужен был некий стартовый момент.
В процессе тренинга, модель время от времени скидывается на диск, и в дальнейшем можно продолжать тренинг с этих чекпоинтов. В документации это подробно описано. Также, при желании, можно выводить в процессе тренинга сэмплы модели, то есть видеть насколько модель продвигается в изучении структуры языка Дональда. Я покажу как обучается модель на примере DeepLearning4j.
Через несколько часов тренинг заканчивается и в каталоге data появляется новый каталог cv, где находится модель на различных этапах тренинга.
Для семплирования последовательности с модели вводим
```
th sample.lua -gpu -1 -sample 1 -verbose 1 -temperature 0.9 -checkpoint /data/cv/checkpoint_74900.t7 -length 2000
```
Флаг checkpoint показывает откуда брать модель, я установил последнюю запись. Температура достаточно важный параметр функции SoftMax, она показывает насколько детерменирована последовательность. Более высокие значения дают более шумный и стохастический выход, низкие могут повторять вход с незначительными изменениями. Допустимые значения от 0 до 1. Впрочем все это также задокументировано [тут](http://github.com/jcjohnson/torch-rnn/blob/master/doc/flags.md#sampling).
Результаты модели я покажу ниже.
#### DeepLearning4j
Фреймворк [DeepLearning4j](https://deeplearning4j.org/) не так популярен и знаменит как torch, в то же время он обладает рядом достоинств. Он основан на массивах ND4J, или как их называют NumPy для Java. Это массивы которые не находятся на куче, и работа с ними идет через нативные вызовы. Также у DeepLearning4j отличная система типов и достаточно интуитивно можно реализовывать все основные архитектуры, единственное, что от знания теории никуда не уйти.
Я выложил код [сюда](http://github.com/alextavgen/TrumpHallucinator). Код основывается на GravesLSTM Character модели, я использовал разработки Alex Black. Для отображения процесса тренировки модели, я подключил визуализацию данных. Параметры модели постарался подобрать похожими на torch модель. Но различия существуют, и ниже будет видно что происходит в процессе.
По словам Андрея Карпатного, обучение нейронных сетей это больше искусство чем наука. Параметры обучения играют исключительную роль. Нет универсальных правил, а только рекомендации и чувство интуиции. Каждый параметр должен подбираться под конкретный набор проблем. Даже начальная инициализация весов играет роль в том, сойдется ли модель или нет. Как пример, твит Андрея [a 20 layer model. weight init N(0,0.02): stuck completely. try weight init N(0, 0.05): optimizes right away. initialization matters a lot :\](http://twitter.com/karpathy/status/853054007668989953)
Я запускал тренинг с разным параметром learning rate. И вот что выходило.
Первый запуск с learning rate 0.1 и инициализацией XAVIER
Видно, что где-то начиная с шага 3000 модель застряла и функция потерь начала осциллировать вокруг одних и тех же значений. Одна из возможных причин была то, что при большом параметре обучения параметры проскакивают оптимум, и получается осцилляция, градиент скачет. В принципе это неудивительно, так как параметр обучения 0.1 достаточно большой, рекомендуется испытывать его в промежутке от 0.1 до 0.001, а то и меньше. Я начал с большего.
Я запустил систему с параметром 0.01 и вот результат.
Видно что градиентный спуск значительно замедлился, и что хоть градиент и неукоснительно снижается, это требует множества шагов и я прекратил обучение, так как у меня оно съедало мощность лаптопа.
Третий запуск системы с параметром обучения 0.05.
По результатам видно, что градиент спускался быстрее, но опять застрял в конце и начал осциллировать, что неудивительно, поскольку значение 0.05 не намного меньше 0.1
Оптимальный вариант, это задавать снижения параметров обучения в процессе. Яркий пример этому архитектура LeNet. Принцип таков, что мы начинаем с больших параметров и по мере спуска уменьшаем. Вот запуск с таким расписанием.
На нижнем графике видно, как на шаге 4000, размер обновления уменьшается, и одновременно с этим функция потерь пробивает барьер, и начинается дальнейший спуск. Я не доводил тренировку до конца, поскольку мой лаптоп нужен был мне для работы, и я проводил этот анализ буквально за пару дней в свободное время. Помимо всего, существует множество параметров обучения, как регуляризация, момент и прочие. При серьезной работе необходимо тщательно подбирать данные параметры, поскольку незначительные изменения могут оказать решающее значение на то, будет ли сходиться модель, или застрянет ли она на локальном минимуме.
#### Результаты
А теперь самое смешное и интересное. Как обучалась и что выдавала нам модель. На примере DeepLearning4j логов.
Поскольку в самом начале Рекуррентная Нейронная Сеть ничего не знает ни о языке, ни о структуре данных, мы ей начинаем скармливать корпус речей. Вот вывод после нескольких минибатчей (сэмплируем модель случайным посевом).
```
----- Sample 1 -----
Lеfs mint alo she g tor, torink.han, aulb bollg rurr Atans ir'd ciI anlot, ade dos rhant eot taoscare werang he ca m hltayeu.,hare they Woy theaplir horet
iul pe neaf it Yf therg. hhat anoy souk, thau do y RO Bury f
if. haveyhaled Dhorlsy Ato thinanse rank fourile DaniOn Ttovele yhinl ans anu he B
```
Видно, что модель уже понимает, что слова разделяются пробелами. Появляются даже некоторые местоимения как he, they.
```
----- Sample 2 -----
aly Eo, He, to bakk st I stire I'micgobbsh brond thet we sthe mikadionee bans. Whether job lyok,.
Whon not I ouuk.
Wewer they sas I dait ond we polntryoiggsiof, waoe have ithale. I bale bockuyte seemer I dant you I Fout whey
We kuow Soush Wharay nestibigiof, You knik is you know, boxw staretho bad
```
Видно, что наш Шариков уже сказал свой первый абырвалг. Модель правильно начинает схватывать местоимения I, he, we, you. Некоторые простые слова также присутствуют, как bad, know.
Идем дальше.
```
----- Sample 3 -----
cy doing to whit stoll.
Ho just to deed to was very minioned, now, Fome is a soild say and is is soudd and If no want nonkouahvion. if you beeming thet take is our tough us iss could feor youlk to at Lend and we do toted to start to pasted to doind the we do it.
I jind and I spongly stection Caread.
```
Уже выглядит как английский язык.
Всего после
Completed 340 minibatches of size 32x1000 characters
```
----- Sample 4 -----
Second. They left you asses, believe me, but I will have great people.I solling us some -- and you see something youve seen deterner to Mexico, we are building interest.
100,000. Im not going to be so bad.
It was so proud of me. Incredible and or their cities which I kept the same wealthy. They dont want them, were the world companies.
Yes, they get the fraud, except people deals 100. Its like never respaved us. Thats what were going to do an orfone thats seen this.
```
Каково. **Im not going to be so bad. It was so proud of me.** Знакомые нарциссические интонации.
А это? **They left you asses, believe me, but I will have great people.**
Потом, что то мы видели в Мексике и мы строим, видимо хотели стену, но появился интерес.
Заметьте, такие результаты модель стала выдавать очень быстро, всего то после 340 минибатчей. Поскольку я не доводил тренинг до конца на DeepLearning4j, то посмотрим на результаты модели на примере Torch-RNN.
```
So we’re going to run. But I was going to have all the manufacturing things as you know what we’re not going to be very soon to this country starting a president land the country. It’s the committed to say the greatest state. You know, I like Iran is so badly. I said, "I’m not as you know what? Why aren’t doing my sad by having any of the place so well, you look at 78%, I’ve done and they’re coming in the Hispanics are so many. The different state and then I mean, it’s not going to be these people that are politicians that they said, "You know, every poll said "We will bring it. I think we don’t want to talk about the stupid new of this country. We love it of money. It’s running the cary America great.
```
Видно как сеть начинает галлюцинировать. Размер сэмплов можно менять, указывая различные параметры, также есть разница в указании параметра температуры. Вот пример с низкой температурой — 0.15.
```
I want to take our country and they can be a great country and they want to do it. They want to take a look at the world is a lot of things are the worst thing that we have to do it. We have to do it. I mean, they want to tell you that we will be the world is a great country and they want to be a great country is going to be a great people. I mean, I want to be saying that we have to do it. They don’t know what they don’t want to say that we have to do it.
```
Видно, что сеть начинает заговариваться. Поскольку мистер Трамп говорит довольно простым языком, то наиболее вероятные переходы состояний в сети сводятся к простым конструкциям.
Недостатки данной модели видны невооруженным глазом.
* Размер данных для модели очень мал. Я не агрегировал все возможные речи и выступления, а собрал то, что удобно было быстро собрать. Для такого рода моделей размер данных играет самую важную роль, поскольку нейронные сети очень жадны до данных.
* Размер модели мал (количество слоев), поскольку я был ограничен в вычислительных ресурсах, и мне надо было сделать маленькую демонстрацию. Увеличив модель можно получать более интересные результаты.
Данный пример немного игрушечен, и в то же время, он показывает основные моменты в тренинге Нейронных Сетей. Если есть какие либо вопросы, или данная тема интересует, то могу в дальнейшем делиться информацией. Материалы на моем Твиттере — [@ATavgen](http://twitter.com/ATavgen) | https://habr.com/ru/post/326966/ | null | ru | null |
# Информационная безопасность как предмет: история преподавателя GeekBrains
Привет, Хабр. Меня зовут Владимир Душкевич, я специалист по информационной безопасности, преподаватель [факультета](https://geekbrains.ru/geek_university/security) «Информационная безопасность». Несколько лет назад я присоединился к команде GeekBrains и хочу рассказать об этом. В конце статьи будет небольшой анонс для тех читателей, кто тоже хотел бы стать частью нашей команды. Но это потом, а сначала моя история.
Все началось в 2018 г. — тогда я впервые услышал о GeekBrains. И, решив подтянуть навыки программирования, устроился на курсы. Тогда же узнал, что компания ищет преподавателя по информационной безопасности, и меня это заинтересовало. В то время я уже преподавал в Архангельском колледже телекоммуникаций (АКТ (ф) СПбГУТ) и карьера преподавателя в офлайне меня вполне устраивала. Но было интересно узнать, как все происходит, когда преподаешь по удаленке.
Немного о себе
--------------
Вуз я закончил еще в 2008 г. по специальности «Физика с дополнительной специальностью Информатика» в Поморском Государственном университете им. М.В. Ломоносова. Потом неоднократно получал дополнительное образование: в сфере информационной безопасности, Linux, сетевых и web-технологий. Профессионалу постоянно нужно учиться, чтобы знания и опыт не устарели — я это хорошо понимал и понимаю. В IT по-другому просто нельзя. К примеру, нельзя быть специалистом по защите информации без знания настройки антивирусной сети, поэтому последним сертификатом, который я получил, стал [сертификат компании DrWeb](https://training.drweb.com/all_certified) по администрированию DrWeb Enterprise Security Suite v.11. С другой стороны, бывает полезно взглянуть на безопасность со стороны злоумышленника, поэтому пришлось изучать техники, используемые в сетевых атаках. В частности, иногда приходится изучать подозрительные файлы, поэтому без знания техник не обойтись.
*Среда для динамического анализа вредоносного ПО.*
К сожалению, курсы по программированию, которые я решил пройти в GeekBrains, закончить не удалось, поскольку преподавательская работа в колледже отнимала массу времени. У нас как раз проходила аккредитация специальности 10.02.02 «*Информационная безопасность телекоммуникационных систем*», и мне пришлось составлять большое количество документов. То есть бюрократическая работа просто не оставила времени на учебу.
Теперь о том, как я попал в GeekBrains. В мае 2018 г. на портале hh.ru увидел вакансию преподавателя по информационной безопасности с дистанционным форматом работы. Захотелось попробовать себя в новом деле, и я решил откликнуться на вакансию. Со мной связался методист, сообщил, что нужно провести пробную трансляцию на YouTube с небольшим уроком. Я провел ее успешно, после чего меня пригласили преподавать.
Моя работа в GeekBrains
-----------------------
Сейчас я читаю два курса: безопасность серверной и клиентской части web-приложений. Первый курс посвящен общим вопросам информационной безопасности и ряду уязвимостей серверной части web-приложений. В частности, рассматриваются:
* методологии поиска уязвимостей;
* pentest и Bug Bounty;
* разведка;
* разведка 2.0;
* security misconfiguration;
* inclusion;
* remote code execution;
* non-RCE vulnerabilities.
На втором курсе рассматриваем уязвимости клиентской части и возможные способы защиты. Это интерактивный курс, на котором мы изучаем:
* что такое XSS;
* контексты XSS;
* классификацию XSS;
* эксплуатацию XSS;
* обход WAF;
* CSRF;
* content security policy;
* прочие уязвимости на клиенте.
Достоинства онлайн-преподавания
-------------------------------
Мне очень нравится работать удаленно. Кроме того, учебный процесс стал гораздо активнее, поскольку я стараюсь разбирать больше практического материала.
Например, мы рассматриваем на практике сценарии поиска уязвимостей OWASP Top 10, чего часто не хватает в образовательных учреждениях.
*Уязвимая среда Owasp Mutillidae используется на курсах для демонстрации уязвимостей.*
На малое количество практики в колледжах и вузах жалуются как студенты, так и преподаватели. Я работал в колледже девять лет, поэтому знаю, о чем говорю.
Для преподавателя удаленная работа хороша еще и тем, что здесь минимум бюрократии. В вузе или колледже постоянно приходится заполнять какие-то документы, готовить бумажные методические пособия, отчеты и т.п. Плюс в обычной ситуации преподаватель может использовать лишь узкий спектр методов работы. На удаленке все не так: здесь нет бюрократии, методы и средства решения задач выбирает сам преподаватель (в соответствии с концепцией курсов, конечно).
Например, на курсе мы используем Kali Linux (и утилиты из ее состава), а на моей предыдущей работе к использованию этой операционной системы относились скорее отрицательно.
*Сканер Nikto используется у нас на курсах для поиска уязвимостей.*
Еще на наших курсах можно корректировать и развивать программу, которую разработала компания, с чем в офлайн-преподавании большие проблемы. Я стараюсь дополнять курс информацией, интересной студентам, применяя свои практические навыки и опыт (по роду своей деятельности я занимаюсь практическими вопросами обнаружения и предотвращения атак, так что есть чем поделиться).
Я описываю не только положительный опыт, но и проблемы, которые могут возникнуть в работе специалиста по компьютерной безопасности. Например, эффект от использования некоторых утилит очень сильно зависит от настроек системы. Если чего-то не хватает, то привычный инструмент работать не будет. Об этом нужно рассказывать, демонстрируя все на практике. К примеру, можно заблокировать использование многих «нежелательных» утилит для анализа сервера и поиска информации на нем. Идея заключается в том, что у многих утилит значение поля`User_Agent` является уникальным. Один из методов блокировки — через файл `.htaccess` при наличии установленного и активированного модуля `mod_rewrite`. Содержимое файла будет таким (на примере Apache 2):
```
RewriteEngine on
RewriteCond %{HTTP_USER_AGENT} curl [NC,OR]
RewriteCond %{HTTP_USER_AGENT} ^$ [NC,OR]
RewriteCond %{HTTP_USER_AGENT} ^Acunetix [NC]
RewriteRule ^.* - [F,L]
```
Где:
* `curl` означает, что слово «curl» должно встречаться в поле `User_Agent`;
* `^` означает начало строки, то есть `^Acunetix` — строка, которая начинается на `Acunetix`;
* `^$` означает пустоту;
* `RewriteRule ^.* — [F,L]` — страница 403 (`Forbidden`, опция `[F]`); она возвращается, если выполняется хотя бы одно из условий.
В итоге запрос, содержащий `User_Agent` утилиты curl, будет заблокирован:
*Заблокированный запрос утилиты curl.*
Что получает выпускник курса по информационной безопасности?
------------------------------------------------------------
**Если говорить обо всем курсе,** то по завершении обучения студент получает:
* навыки работы с операционной системой Linux, азы программирования на Python и знание основных компонентов, из которых состоит web: URL, HTTP, HTML, JavaScript, Same Origin Policy и т.д.;
* навыки поиска уязвимостей в клиентской части web-приложений, эксплуатации клиентских уязвимостей, знание способов защиты, понимание принципов работы основных web-протоколов и механизмов защиты браузера;
* навыки поиска server-side-уязвимостей и понимание особенностей Bug Bounty, что позволит зарабатывать деньги с помощью Bug Bounty;
* навыки использования проводных и беспроводных сетей, понимание их устройства, знание способов обеспечения безопасности в сетях и умение тестировать параметры их безопасности;
* навыки обратного инжиниринга приложений, поиска и эксплуатации бинарных уязвимостей, знание основ криптографических протоколов.
**Что касается направлений, которые я веду в рамках курса,** то студенты:
* учатся находить уязвимости в клиентской и серверной части web-приложений;
* тестируют и проверяют различные уязвимости;
* выбирают механизмы защиты и составляют рекомендации по их внедрению;
* изучают виртуальный патчинг уязвимостей web-приложений, позволяющий настроить хорошую защиту от ряда известных опасных атак;
* рассматривают причины, которые приводят к возникновению уязвимостей, и признаки, позволяющие обнаружить проблему;
* изучают методы, использующиеся при сборе информации о web-приложении, что позволяет эффективнее тестировать найденные уязвимости или планировать защиту, закрывая уязвимую среду от злоумышленника.
В качестве заключения
---------------------
Достоинств у онлайн-преподавания много, наверное, даже больше, чем при работе в вузе или колледже. По крайней мере, если говорить о моем опыте работы.
А теперь тот самый анонс. Если хотите присоединиться к команде GeekBrains, то сейчас есть хорошая возможность: компания ищет новых преподавателей, авторов и ревьюеров, от backend-разработчиков до data scientist, от тестировщиков до специалистов по информационной безопасности. Все это можно совмещать с основной работой. Узнать подробнее, а также подать заявку, если предложение вас заинтересовало, можно по этой [ссылке](https://speakers.geekbrains.ru/). | https://habr.com/ru/post/524302/ | null | ru | null |
# Форензика и стеганография в видеофайле: разбор заданий online-этапа NeoQUEST-2015
 Прошедший online-этап ежегодного соревнования по кибербезопасности NeoQUEST-2015 был крайне богат на интересные и нетривиальные задания! В этой статье мы:
* займемся стеганографией видеофайлов и эзотерическим языком программирования Piet, разбирая задание «Истина внутри»
* влезем в шкуру компьютерного криминалиста, поработаем с TrueCrypt и ответим на вопрос «А был ли ключ?».
Отличная новость: утверждена дата «очной ставки» NeoQUEST-2015! Мероприятие состоится **2 июля** (четверг) в Санкт-Петербурге, в [КДЦ «CLUB HOUSE»](http://club-house.org/)! Как и прежде, вход бесплатный — нужно лишь зарегистрироваться на нашем [сайте](http://neoquest.ru).
##### **1. «Истина внутри» — стеганография в видео**
Скачиваем файл apple.avi, ссылка на который дана в задании. Обращаем внимание на подсказку в тексте легенды к заданию, намекающую на то, что сравнение полученного видео с оригинальным видео на канале Apple поможет понять, что делать дальше! Заходим на youtube.com, ищем на канале Apple наше видео.
Скачиваем его любым сервисом для сохранения видео с youtube.com в формате .flv. Почему в .flv? Ну не зря же в задании зачем-то упомянуты недавно установленные flv-кодеки.
Логично было бы сравнить эти два видео покадрово, для этого используем программное решение [ffmpeg](https://www.ffmpeg.org/). Разбиваем оба видео на кадры, каждое в свой каталог:
```
ffmpeg -i ./youtube.flv ./1/%d.png
ffmpeg -i ./apple.avi ./2/%d.png
```
Для сравнения подойдет синхронизация каталогов в Total Commander:
На скриншоте отображены кадры, которые различны в обоих видео, таких 24 штуки. Попытаемся сравнить какую-нибудь пару кадров, например, 21-ю. Для этого воспользуемся [ImageMagic](http://www.imagemagick.org/):
```
compare.exe 21.png 21.2.png diff.png
```
В левом верхнем углу видим прямоугольную область. При детальном исследовании понимаем, что в красном канале пикселей изменяется младший бит. Сокрытие информации в младших битах — довольно распространенный метод стеганографии. Имеем 24 кадра, с измененными младшими битами в прямоугольной области. 24 бита достаточно для того, чтобы закодировать 3 байта цвета пикселя.
Теперь нужно собрать из младших битов изображение, для этого используем Python и, например, [PIL](http://www.pythonware.com/products/pil/):
Нетрудно догадаться, что перед нами программа на эзотерическом языке программирования [Piet](https://ru.wikipedia.org/wiki/Piet). Придется немного повозиться с интерпретатором, после запуска которого программа выводит на экран сообщение, содержащее ключ к заданию:
«Hello! Secret Key: 8aec4bb34fbdd11c2aef4fea391b4fe2»
#### **2.«А был ли ключ?» — forensic и TrueCrypt**
Участникам был предоставлен дамп диска, в котором и нужно было найти ключ. Прохождение можно условно разделить на следующие этапы:
1. Монтирование диска
2. Поиск установленного программного обеспечения
3. Поиск зашифрованного логического диска
4. Поиск ключа шифрования тома
5. Поиск ключа к заданию
**Монтирование диска**
Windows 7 — 8.1 позволит подключить образ диска без дополнительного программного обеспечения. На других ОС для монтирования можно использовать Virtual Box, VMWare и другое ПО для виртуализации.
После монтирования в Windows 8.1 появятся 2 диска.
Содержимое системного диска:
Диск с пользовательскими данными, которые, конечно, интересуют нас в первую очередь:
###### **Поиск установленного программного обеспечения**
Необходимо включить отображение скрытых и системных файлов, после чего проверяем основные папки Program Files и Program Files(x86), где находится программа TrueCrypt. TrueCrypt — компьютерная программа для шифрования «на лету». Она позволяет создавать виртуальный зашифрованный логический диск, хранящийся в виде файла.
###### **Поиск зашифрованного логического диска**
В описании программы указано, что с помощью неё можно создать виртуальный зашифрованный логический диск. Чтобы найти этот диск, используем программу [TChunt](http://www.softpedia.com/get/System/File-Management/TCHunt.shtml).
```
tchunt.exe -d ../ > tchunt.txt
```
Откроем файл tchunt.txt
Файл X:\Users\JohnSmith\files и есть зашифрованный контейнер.
###### **Поиск ключа шифрования тома**
В корне диска есть папка Dali. Среди всех изображений есть файл key.jpg. Исходя из этого, можно предположить, что используется не пароль, а ключ-файл. При попытке подставить этот файл в качестве ключа для контейнера TrueCrypt сообщает о неверном пароле.
Из чего можно сделать вывод, что ключ либо спрятан в файле key.jpg, либо удалён, либо key.jpg совсем не имеет отношения к зашифрованному диску. Проверим наиболее простую версию — файл удалён (логичное действие, если за вами вдруг пришли!).
Восстанавливаем key-x.jpg и пробуем использовать его как ключ — виртуальный диск успешно монтируется!
###### **Поиск ключа к заданию**
На диске находится очень большое количество файлов (все — с расширением .jpg) и ключ, скорее всего, спрятан в одном из них. Попробуем проверить последние открытые файлы с таким расширением в системе, для этого необходимо зайти в реестр установленной ОС. Если жёсткий диск смонтирован на виртуальной машине, то достаточно выполнить команду regedit. Если нет, то необходимо подключить нужную часть реестра — hive.
Для этого необходимо нажать File > Load Hive и выбрать X:\Users\JohnSmith\NTUSER.dat. Далее переходим по пути: Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs\.jpg
Среди содержимого и указаны имена последних открытых файлов. Перебираем их и проверяем наличие ключа на изображении.
Ключ оказался на изображении «Петр I на псовой охоте.jpg»
#### **И это ещё не всё!**
Впереди — разбор остальных заданий online-этапа NeoQUEST-2015 и ожидание яркого и солнечного (несмотря на то, что в Питере) мероприятия «NeoQUEST-2015». Участников ожидает напряжённая борьба длиной в 8 часов, а гостей — конкурсы, доклады, практические мастер-классы, подарки и общение с коллегами! Напоминаем, что для этого — всего пара шагов: пройти [регистрацию](http://neoquest.ru/timeline.php?year=2015) и (для тех, кто не тут) купить билеты в Питер! | https://habr.com/ru/post/257737/ | null | ru | null |
# World of React Native. Уже можно играть! Геймплей, обзор
Привет! Я Илья, фронтенд-разработчик. В ЮMoney работаю четыре года. Занимался личным кабинетом интернет-магазинов на B2B-продукте ЮKassa. Последний год развиваю продукт для расчетно-кассового обслуживания ЮBusiness.
Что значит РКО
--------------
Юридическому лицу нельзя просто открыть счет в банке: нужен специальный счет. Закон регулирует денежный оборот компаний, поэтому созданы специальные системы для движения денег юрлиц. Одна из них — наш сервис ЮBusiness.
Есть веб-версия, есть приложения в App Store и Google Play.
Веб-версия ЮBusinessМобильное приложение ЮBusinessЯ приоткрою мир разработки на React Native, а тем, кто с ним знаком, расскажу о встреченных болях. Статья поможет вам, если вы смотрите на этот фреймворк и если вы уже начали с ним работать.
В начале 2020 года в ЮMoney появилось новое направление работы: мы решили создать продукт для расчетно-кассового обслуживания. Одним из требований бизнеса было запустить мобильное приложение. Это самый удобный путь обслуживания счетов.
Мы рассматривали два варианта: задействовать отдел мобильной разработки или воспользоваться новыми технологиями, которые позволяют фронтендерам самостоятельно создавать приложения, используя JavaScript.
Почему именно React Native?
---------------------------
У продакта был удачный опыт с React Native, его не нужно было обосновывать. С языком Dart для Flutter ни у кого опыта не было. Cordova и другие варианты не нативные, это WebView.
Как вы понимаете, мы выбрали RN, потому что:
* У нас классные мобильные разработчики. Сейчас их не хватает для всех команд, и на нашем проекте не было выделенного специалиста по мобилке.
* Для разработчиков это новая технология, возможность внедрить ее в прод и радоваться.
* Для продукта и продакта это возможность реализовывать фичи mobile first. Еще один плюс — простота сопровождения. Весь функционал на вебе и мобилке делают одни и те же люди. Нужно общаться с одной командой, а не синхронизировать две и более.
Начну с нашего знакомства с технологией. У нас в компании уже был не самый удачный опыт с RN: мы пытались частично внедрить его в наше мобильное приложение. Были проблемы с инициализацией приложения. Переход на него на доли секунды фризил приложение, чтобы запустить RN. Также фронтендеру было сложно делать интеграцию своего приложения с нативным.
Тестирование
------------
Чтобы писать код на RN, надо научиться тестировать. С юнит-тестами все довольно просто: ровно те же технологии, что и для веба. Уточнение: иногда нативные компоненты приходится мокать, потому что jest не всегда справляется.
Разработчики React Native советуют два фреймворка для интеграционного тестирования (https://reactnative.dev/docs/testing-overview): Detox и Appium. Мы выбрали Detox, так как с ним уже успешно работал наш разработчик.
**Как работает Detox?**
Detox открывает симулятор, запускает в нем приложение и начинает исполнять описание действия из тестов, клики/тапы/заполнения инпутов, делает по ходу снапшоты, чтобы сверяться. Отдельное спасибо тем, кто придумал название Detox: ища информацию, я узнал много чаев для похудения.
Начало разработки
-----------------
Итак, мы умеем писать тесты — пора начинать писать код. Структура приложения схожа с веб-приложением на React.
```
type Props = {
label: string;
placeholder: string;
};
const CardNumberComponent: React.FC = ({label, placeholder}) => {
return (
<>
);
};
export const CardNumber = memo(CardNumberComponent);
```
У нас есть набор компонент, которые рендерятся в каждой платформе в UI-элементы. Логика, компоненты — все реализуется как в веб-проекте.
Нативная часть
--------------
Настал момент задачек по внедрению логики, которую уже реализовали мобильные разработчики… Мы можем переиспользовать ее!
Здесь было минимум использований:
* переиспользуемый модуль мобильных разработчиков с авторизацией в нашей системе;
* реализованный ранее модуль для работы с ThreatMetrix — сервисом, который помогает обезопасить платежи;
* Threads-чаты.
Debug
-----
Ошибки случаются чаще, чем хотелось бы, поэтому необходим debug-инструмент. Но сначала расскажу о разработке на симуляторах и реальных устройствах.
Для iOS симулятор требует только Xcode. Запускаем сборку на выбранный симулятор и разрабатываем.
Инструменты для React-разработки под iOSДля работы с реальным устройством понадобятся:
* Xcode;
* iPhone;
* учетная запись разработчика в App Store, добавленная в компанию — разработчика приложения;
* UDID iPhone, добавленный в разрешенные девайсы для тестирования приложения;
* подключение по проводу к компьютеру для сборки приложения на iPhone.
Для Android на симуляторе требуется только Android Studio. Запускаем сборку на выбранный симулятор и… И все, разрабатываем.
Инструменты для React-разработки под AndroidДля работы с реальным устройством понадобится только Android Studio и устройство. Android можно собирать в дебаг-режиме на устройстве по общему Wi-Fi, не подключая смартфон к компьютеру по проводу.
У React Native есть дефолтный дебаггер. Он открывается в любом браузере и позволяет следить за консолью, профилировать приложение, использовать точки остановки — и на этом все. Этого функционала для полноценного debug катастрофически мало.
Следующий вариант — [React Native Debugger](https://github.com/jhen0409/react-native-debugger).
Он позволяет запускать приложение, которое внешне напоминает режим разработчика в Chrome. Здесь можно посмотреть на Redux Store, включить отслеживание network request, посмотреть на дерево React-компонент, попрофилировать работу приложения.
Network debugging
-----------------
Теперь подробнее о том, как использовать каждую из частей дебаггера.
Включаем network debugging — и все: дальше все запросы будут логироваться, их можно просматривать.
Ограничение дебага запросовОбратите внимание на ограничения дебага запросов. На нашем опыте столкнулись с нерабочими multipart/form-data-запросами при активированном network debugging.
React devtools
--------------
React Developer Tools не отличаются от браузера. Мы можем смотреть состояние компонент, искать их в дереве. Так же работает Element Inspector, который позволяет выбрать в UI элемент и перейти к этому компоненту в React Developer Tools.
Redux devtools
--------------
Redux Debugger. Как и в предыдущих пунктах, здесь все так же, как в вебе. Выбираем нужный instance и следим за всеми action, просматриваем store.
Дебаг стилей сыроват. Мы можем только посмотреть размеры элементов.
Есть еще один дебаггер — Flipper: [https://fbflipper.com](https://fbflipper.com/). Это модульный проект от разработчиков Facebook.
Инструмент для дебаггинга FlipperРабота со стилями на голову выше, чем у аналогов, из коробки есть просмотр логов/сетевых запросов. Можно устанавливать модули для Redux Store и писать их самому. Мы с ним еще не подружились, но в процессе.
Проблемы и особенности
----------------------
Теперь перейдем к интересным багам и особенностям. Забегу вперед и скажу, что раньше было гораздо больше багов, но их пофиксили мейнтейнеры. Первый важный момент: React Native еще даже не мажор, поэтому стабильность не на высоте.
Начну с одной из первых задач, с которой столкнулся, придя в команду. Дизайнер нарисовал заголовки и подзаголовки разной жирности: 400, 700, 800. Я открыл симулятор на iOS, добавил стили, что может быть проще? Но! Тестировщик вернул задачу обратно, сказал, нет жирности на Android. Я открыл симулятор Android и действительно: нет жирности у заголовков. Дальше я погуглил: естественно, это известная проблема. В качестве решения нам предлагают создать много шрифтов разной жирности. [https://github.com/facebook/react-native/issues/26193#issuecomment-525028689](https://github.com/facebook/react-native/issues/26193).
Шрифт на AndroidМы поговорили с дизайнером и решили не использовать это.
В моменте в приложении на Android появилась едва заметная полосочка во время анимации нажатия.
Рамка в пиксель на AndroidКак ужасно это выглядит! Дальше повторилась ситуация из предыдущей проблемы. Гуглю, и что мы видим? Это известная проблема. [https://github.com/facebook/react-native/issues/29010#issuecomment-636653305](https://github.com/facebook/react-native/issues/29010). Выходы такие: либо считаем размеры layout сами, либо используем костыльное решение: сдвиг на -1 пиксель.
KeyboardAvoidingView имеет ряд проблем с «прилипанием» элемента к клавиатуре.
Где не справляется обычный KeyboardAvoidingView:
* на экранах iOS со сворачивающимся хедером (параметр headerLargeTitle: true);
* на экранах, где нужен инпут, прилипающий к клавиатуре (из-за подскролла Android добавляет лишний паддинг).
[Для навигации мы используем react-navigation](https://github.com/react-navigation/react-navigation).
Раньше была масса проблем, сейчас многие исправлены. Но есть запомнившиеся особенности и недочеты, которые остались. Например, чтобы сделать модалку (botoom sheet) без стандартной анимации экрана модалки из библиотеки навигации, придется поплясать.
Такой компонент, у которого своя анимация, я хочу открыть по тапу на кнопку.
```
// ModalInit.txs
import {BottomSheet} from '../components/BottomSheet';
const ModalInit = () => Ю модалка;
```
Для этого придется сделать вложенный стек. Сначала создаем стек для кастомных модальных окон. Через параметры экрана выключаем показ хедера и делаем прозрачный фон.
```
// ModalStack.tsx
import {createNativeStackNavigator} from 'react-native-screens/native-stack';
import {ModalInit} from './ModalInit';
const Stack = createNativeStackNavigator();
/**
* Поднавигация экранов c BottomSheet'ами
*/
export function ModalsNavigationStack() {
return (
);
}
```
Далее берем созданный стек и помещаем его в root-стек, которому опять делаем фон прозрачным. Отключаем анимацию и выбираем stackPresentation = ‘transparentModal’.
```
// Root.tsx
import {createNativeStackNavigator} from 'react-native-screens/native-stack';
import {ModalsNavigationStack} from './ModalStack';
const Stack = createNativeStackNavigator();
const routes = [
];
/**
* Рутовая навигация
*/
export function RootNavigation() {
return {routes};
}
```
Только теперь будет работать кастомная модалка.
Еще одна проблема react-navigation: когда приходим на экран из другого стека, в нативном хедере на Android есть кнопка «Назад», а на iOS нет.
Особенность навигации на ReactПоэтому для iOS добавляем кастомную кнопку сами: https://github.com/software-mansion/react-native-screens/issues/576
Следующий момент не проблема RN, а особенность разработки на iOS. Для проверки добавления карты в Wallet сначала нужно пройти сертификацию Apple и получить право токенизировать карты.
Проверить токенизацию карты в Wallet не получится, пока не пройдено ревью.
Тестирование взаимодействия с Apple WalletПроходим ревью, получаем статус «Ожидает релиза». Перед релизом в консоли Apple можно выпустить до ста промокодов. По промокоду можно установить приложение из App Store и вот там протестировать логику токенизации. После этого в любой продуктовой сборке можно проверять токенизацию карт.
Выводы
------
* RN — платформа, которая довольно быстро развивается. Нужно учитывать, что она еще сыровата, хотя и готова к выходу на продакшн.
* Реализация сборки под iOS лучше, чем под Android. Если ваш главный потребитель — пользователь Android, стоит посмотреть другие варианты. Если нужны обе платформы или в приоритете iOS, RN отлично подходит.
Если посмотреть на изменения RN и его приложения за год, заметен рост. Правки issue ведутся, добавляется новый функционал, значит у платформы большой потенциал.
Мой рассказ основан на опыте использования RN на задачах ЮMoney. Поделитесь вашими впечатлениями от React Native в комментариях или задавайте вопросы по моему обзору. | https://habr.com/ru/post/570460/ | null | ru | null |
# Как видит компьютер
Задумывались ли Вы когда-нибудь, как компьютер находит нужные для обработки объекты из видеопотока? На первый взгляд, это выглядит задачей из разряда «высокого» программирования с применением огромного количества формул из математического анализа, дискретной математики и т.д., требует огромного количества знаний, чтобы написать хотя бы маленькую программу наподобие «Hello, world» в мире распознавания образов на видео. А если бы Вам сказали, что на самом деле сейчас осуществить вход в мир компьютерного зрения гораздо проще и после прочтения этой статьи Вы сможете написать свою программу, которая научит Ваш компьютер видеть и детектировать лица? Также в конце статьи Вас ждет бонус, который может повысить безопасность Вашего ПК с помощью компьютерного зрения.
Для того, чтобы Ваш компьютер начал понимать, что Вы ему показываете что-либо похожее на лицо, нам понадобится:
1. Компьютер;
2. Web-камера;
3. Python 3;
4. Ваш любимый редактор кода (PyCharm, Jupyter и т.д.).
Итак, после того, как Вы собрали всё необходимое по списку выше, мы можем приступить к непосредственному написанию нашей программы для распознавания лиц.
Для начала, качаем необходимые библиотеки Python с помощью команды в Командной строке:
```
pip install opencv-python; numpy
```
Коротко о том, зачем они нам нужны:
OpenCV. Эта библиотека – основа почти каждого современного проекта по компьютерному зрению. В ней хранятся сотни алгоритмов компьютерного зрения и обработки изображений. Изначально написана на C/C++, но в дальнейшем была переписана и на Python ввиду большой востребованности ее на данном языке.
Numpy. Будет помогать с внутренними вычислениями библиотеки OpenCV.
После окончания установки нужных нам библиотек открываем наш любимый редактор кода и начинаем писать нашу программу:
Присоединяем библиотеку компьютерного зрения OpenCV
```
import cv2 as cv
```
2. Захват видеопотока с Web-камеры производим с помощью метода VideoCapture(index), где index — порядковый номер нашей Web-камеры в системе. Если камера одна, то параметр будет равен 0.
```
capture = cv.VideoCapture(0)
```
3. Для получения видео воспользуемся методом read(), который возвращает нам флаг rtrn -показывает успешность захвата кадра из видеопотока и image — кадр нашего видеопотока (numpy-массив). Считывать данные из видеопотока будем непрерывно, пока не будет нажата клавиша Escape.
```
while True:
rtrn, image = capture.read()
cv.imshow("Capture from Web-camera", image) # Вывод кадра в окно с названием
if cv.waitKey(1) == 27: # Выход из программы по нажатию Esc
break
capture.release()
cv.destroyAllWindows()
```
Сохраняем наш файл, запускаем из командной строки с помощью python имя\_нашего\_файла.py. Теперь наша программа умеет принимать видеопоток с Web-камеры! А это значит, что мы уже на полпути к тому, чтобы компьютер мог распознавать лица.
4. Давайте сделаем так, чтобы наш компьютер также мог записывать видео в файл:
Указываем кодек для сохранения видео, указываем имя для сохраняемого файла, fps и размеры. Для нашей задачи мы берем кодек XVID.
```
import cv2 as cv
capture = cv.VideoCapture(0)
codec = cv.VideoWriter_fourcc(*'XVID')
```
5. Выводим последовательно кадры в окно video, а после сохраняем результат в переменную output. Затем данные из output, после завершения видеопотока, передадим в файл «saved\_from\_camera.avi»:
```
output = cv.VideoWriter('saved_from_camera.avi ', codec, 25.0, (640, 480))
while capture.isOpened():
rtrn, image = capture.read()
if cv.waitKey(1) == 27 or rtrn == False:
break
cv.imshow('video for save', image)
output.write(image)
output.release()
capture.release()
cv.destroyAllWindows()
```
После того как мы научились брать видео с Web-камеры и сохранять его в файл, то можно приступить к самому интересному – распознаванию лиц в видеопотоке. Для нахождения лица на кадрах мы будем использовать так называемые Признаки Хаара. Суть их в том, что если брать прямоугольные области на изображении, то по разности интенсивностей между пикселями смежных прямоугольников можно выделить особенности, присущие лицам.
Например, на изображениях с лицами область вокруг глаз темнее, чем около щек. Поэтому, одним из Признаков Хаара для лиц можно назвать 2 смежных прямоугольника у щек и глаз.
Существует большое количество других, более быстрых и точных методов детекции объектов на изображении, но для понимания общих принципов нам пока будет достаточно знать лишь Признаки Хаара.
Разработчики OpenCV уже провели работы по определению Признаков Хаара и предоставили всем желающим результаты для возможностей обработки видеопотока.
Приступим к написанию детектора лиц с нашей Web-камеры:
6. Первым делом, получим наши Признаки Хаара и определим параметры для захвата видеопотока. Файл с Признаками лежит по пути, где устанавливаются библиотеки Python. По умолчанию, они находятся в папке,
```
C:/Python3X/Lib/sitepackages/cv2/data/haarcascade_frontalface_default.xml
```
где X – Ваша подверсия Python 3.
```
import cv2 as cv
cascade_of_face = cv.CascadeClassifier('C:/Python3.X/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml ')
capture = cv.VideoCapture(0)
capture.set(cv.CAP_PROP_FPS, 25) # Частоту зададим 25 кадров в секунду
```
7. Далее, в цикле будем поочередно считывать кадры с Web-камеры и передавать его нашему детектору лиц:
```
while True:
rtrn, image = capture.read()
gr = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
faces_detect = cascade_of_face.detectMultiScale(
image=gr,
minSize=(15, 15),
minNeighbors=10,
scaleFactor=1.2
)
for (x_face, y_face, w_face, h_face) in faces_detect:
cv.rectangle(image, (x_face, y_face), (x_face + w_face, y_face + h_face), (0, 0, 255), 2)
cv.imshow("Image", image)
if cv.waitKey(1) == 27: # Esc key
break
capture.release()
cv.destroyAllWindows()
```
8. Теперь объединим всё в одно целое и получим программу, которая захватывает видео с Web-камеры, распознает на нем лица и сохраняет результат в файл:
```
import cv2 as cv
faceCascade = cv.CascadeClassifier('C:/Users/Zet/Desktop/Python/test_opencv/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml')
capture = cv.VideoCapture(0)
capture.set(cv.CAP_PROP_FPS, 25)
codec = cv.VideoWriter_fourcc(*'XVID')
output = cv.VideoWriter('saved_from_camera.avi', codec, 25.0, (640, 480))
while True:
rtrn, image = capture.read()
gr = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
faces_detect = faceCascade.detectMultiScale(
image=gr,
minSize=(15, 15),
minNeighbors=10,
scaleFactor=1.2
)
for (x_face, y_face, w_face, h_face) in faces_detect:
cv.rectangle(image, (x_face, y_face), (x_face + w_face, y_face + h_face), (255, 0, 0), 2)
cv.imshow("Image", image)
output.write(image)
if cv.waitKey(1) == 27: # Esc key
break
output.release()
capture.release()
cv.destroyAllWindows()
```
Все! Вы написали программу, которая является первым шагом в понимании того, как видит компьютер. Дальше можно улучшать распознавание лиц, например, чтобы компьютер узнавал определенных людей на видео с помощью обучения нейронных сетей. Также можно написать детектор, настроенный на распознавание более сложных объектов (например, отслеживание дорожного трафика) с возможностью их анализа. А также решать другие, не менее интересные задачи компьютерного зрения.
БОНУС
Применим программу на практике – будем отслеживать входы под учетной записью.
1. Зайдем в Планировщик заданий (можно найти через стандартный Поиск Windows);
2. Создадим Простую задачу, дадим ей название и краткое описание;
3. Нажимаем Далее и попадаем в пункт Триггер. Здесь выбираем событие, при котором будет происходить запуск нашего задания. Выбираем «При входе в Windows»;
4. Далее в действии указываем «Запустить программу»;
5. В Действии указываем путь до python.exe, а в Параметрах – путь до нашей программы:
Готово! В результате, при входе в систему будет записываться лицо вошедшего под учетной записью, а видео будет сохранено. Таким образом, можно отслеживать, кто работал за компьютером в Ваше отсутствие, с сохранением записи доказательств. | https://habr.com/ru/post/511216/ | null | ru | null |
# Создание модулей JS
Здравствуйте!
В этой статье я хочу рассказать вам о моём подходе к написанию модулей на JavaScript. Профессионалы вряд ли найдут для себя что-то новое, а вот новичкам, я думаю, будет полезно ознакомиться с предложенным подходом и аргументами в его пользу.
#### Модуль «с нуля»
В моей любимой IDE при создании нового js-файла в окно редактора тут же вставляется вот такой код:
```
(function (G, U){
"use strict";
var $ = G.jQuery,
bool = "boolean",
string = "string",
number = "number",
object = "object";
}(this, undefined));
```
Рассмотрим, что именно происходит в этих нескольких строках.
##### 1. Создание закрытого пространства имён.
Первым делом создаётся закрытое пространство имён путём помещения кода в самовызываемую анонимную функцию. При этом в анонимную функцию передаются два параметра `G` и `U`, которым присваиваются соответственно значения `this` и `undefined`. Вопрос: чему в данном случае будет равно `this`? Это зависит от того, с какой платформой идёт работа, но в любом случае это будет глобальное пространство имён, каковым в браузерах, например, является объект `window`.
##### 2. Использование строгого режима.
Вот эта строка включает строгий режим:
```
"use strict";
```
Я использую строгий режим по многим причинам. Мало того, что его наличие требуется для корректной валидации кода с помощью [JSLint](http://jslint.com), так ещё его использование блокирует многие небезопасные конструкции.
Казалось бы, совершенно невинный кусочек:
```
for (i = 0; i < items.length; i += 1){
//Что-то делаем
}
```
Какие тут могут быть подводные камни? Всё просто: где-то ранее в коде переменная `i` уже была объявлена, а этот цикл является вложенным:
```
for (i = 0; i < myArr.length; i += 1){
//Около 50 строк кода, обычно хватает, чтобы скрыть начало тела цикла
for (i = 0; i < myArr.length; i += 1){
//Что-то делаем
}
}
```
Такая проверка заставит вас не только определить все переменные до использования, но и вынудит лишний раз проверить аргументы циклов.
Кроме того, в строгом режиме обращение к необъявленной переменной приводит к ошибке исполнения, в то время как в обычном режиме интерпретатор JavaScript попытается создать эту переменную и присвоить ей некоторое значение.
Например:
```
alert("Ошибка доступа: "+ error);
```
Если переменная `error` не была ранее объявлена, в обычном режиме пользователь сможет любоваться сообщением `"Ошибка доступа: undefined"`. В строгом режиме эта переменная должна быть как минимум определена.
Что делать, если целевой браузер не поддерживает строгий режим? Ничего. Код, написанный для строгого режима, будет без проблем работать в нестрогом, а интерпретатор JavaScript просто проигнорирует строку `"use strict";`.
#### Приватные переменные модуля
После инструкции `"use strict";`, включающей строгий режим, идёт описание нескольких переменных. Как видите, я следую паттерну **«one var statement»**, так же рекомендуемому к применению. Согласитесь, описанная выше конструкция выглядит не так ужасно, как нижеприведённая:
```
var $ = G.jQuery;
var bool = "boolean";
var string = "string";
var number = "number";
var object = "object";
```
Переменные `bool`, `string`, `number` и `object` далее я описываю для большего удобства:
```
if (params.hasOwnProperty("title") && typeof params.title === string){ //где-то в коде
result.title = params.title;
}
```
К тому же, при использовании средств типа YUICompressor или Google Closure Compiler имена этих переменных будут сокращены до одно- или двух буквенных:
```
if (p.hasOwnProperty("title") && typeof p.title === s){
r.title = p.title;
}
```
Все объявленные здесь переменные будут приватными и видны только в пределах модуля. Если нам понадобится создать функцию-генератор для уникальных id элементов, сделать это будет очень просто:
```
(function (G, U){
"use strict";
var id = 0,
PREFIX = "my-library-id-prefix-";
function getNewId(){
id += 1;
return PREFIX + id.toString();
}
G.createId = getNewId; //Экспорт функции getNewId() в глобальное пространство имён под именем createId
}(this, undefined));
```
Но мы можем и не отправлять эту функцию на экспорт, а использовать как служебную внутри модуля:
```
function Div(params){ //Функция-конструктор для новых блоков
var id = getId(); //id блоков всегда будут уникальны, испортить генератор внешним кодом невозможно
this.show = function(){
$("", {
"id": id
});
}
}
```
##### Включение модуля в библиотеку
Возможно, все ваши модули будут оформлены в виде одной библиотеки, именуемой, например, JSui, и все функции должны вызываться вот так:
```
var newDiv = new JSui.Div({
width: 200,
height: 150
});
```
Можно было бы собрать всё в один файл, расширив единственный объект и экспортировав его в глобальное пространство имён, но отлаживать и редактировать несколько мелких модулей всегда проще, чем один большой. Поэтому мы будем использовать всего лишь одну глобальную переменную и при необходимости расширять её необходимыми свойствами. Я делаю это так:
Файл **divs.js:**
```
(function(G, U){
"use strict";
var UI= G.JSui || {};
//Код модуля
function Div(){
...
}
UI.Div = Div;
G.JSui = UI;
}(this, undefined));
```
Файл **labels.js:**
```
(function(G, U){
"use strict";
var UI= G.JSui || {};
//Код модуля
function Label(){
...
}
UI.Label = Label;
G.JSui = UI;
}(this, undefined));
```
Некоторые скажут, что присваивание `G.JSui = UI;` явно лишнее. Но не делайте поспешных выводов! Что, если указанный модуль подключается первым и глобальная переменная `JSui` ещё не определена? Локальной переменной `UI` будет присвоен пустой объект `{}`. Далее в коде модуля мы его расширяем, но экспорта в глобальное пространство имён не происходит до момента вызова строки:
```
G.JSui = UI;
```
Если же глобальный объект `JSui` уже определён, локальная переменная `UI` получает ссылку на него и расширяет его новыми свойствами и методами. В этом случае, действительно, указанное выше присваивание будет излишним, однако, не следует забывать тот простой факт, что при этом объект будет передан по ссылке и производительность не пострадает.
P. S. Я не коснулся темы разрешения зависимостей модулей, т.к. это отдельная тема, заслуживающая целой статьи. | https://habr.com/ru/post/231883/ | null | ru | null |
# Боль и анимация таблиц для iOS. Фреймворк Awesome Table Animation Calculator
Представим себе экран обычного мобильного приложения с уже заполненным списком ячеек. С сервера приходит другой список. Нужно посчитать разницу между ними (что добавилось/удалилось) и проанимировать `UICollectionView`.
«Простой» подход — полностью заменить модель с последующим вызовом `reloadData`. К сожалению, при этом теряются анимации и могут возникать другие нежелательные эффекты и тормоза. Куда интереснее редактировать списки аккуратно, анимированно. Попробовав это сделать несколько раз, я убедился, что это неимоверно трудно.
Раз проблема встретилась в нескольких проектах, нужно её обобщить и работать дальше с обобщённой реализацией. Интересная задача! Несколько дней борьбы с документацией, здравым смыслом, багами реализации таблиц в iOS, и получился код с достаточно простым интерфейсом, адаптирующийся к широкому кругу задач, про который я хочу рассказать.
> Конечно же, фреймворк в первую очередь решает мои собственные задачи. Если вам вдруг нужна фича, которая сейчас там отсутствует, пишите, спрашивайте, попробую доработать.
Чуть более формальное описание задачи
-------------------------------------
Представим, что у нас есть таблица, которая состоит из секций с ячейками.
> Таблицы или списки — это `UICollectionView` или `UITableView`, я их не буду различать в статье. Судя по одинаковым багам, внутри там один и тот же код, да и интерфейс похож.
Анимировать таблицу нужно уметь в двух случаях:
* поменялась сортировка таблицы (например, сортировали по именам, теперь сортируем по фамилиям)
* изменился какой-то кусок данных. Некоторые ячейки могут добавиться, некоторые измениться, некоторые удалиться.
Если изменилось что-то понятное (например, добавилась одна ячейка), то всё просто. Но что делать, если у нас чат, в котором сообщения могут редактироваться и удаляться пачками? Или список пользователей, который показывается из кэша, а потом получается с сервера и полностью обновляется?
> Для примера попробуйте представить адресную книгу, где была сортировка от А до Я, а потом она поменялась обратную. Последние секции должны переместиться наверх, и внутри секций ячейки должны пересортироваться. Какие индексы будут у перемещений? В какой последовательности система будет применять анимации? Все эти вопросы очень поверхностно описаны в документации, и приходится разбираться методом «тыка».
`ATableAnimationCalculator` представляет собой модель данных для таблицы, которая следит за текущим состоянием ячеек и, если ей сказать «вот тут новое что-то, посчитай разницу» — считает, выдавая список индексов ячеек и секций, требующих изменения (удаления, вставки, перемещения). После этого результат вычисления можно применить к таблице, обходя проблемы в реализации анимаций iOS.
Структура данных фреймворка
---------------------------
> В названиях первая буква «A» — это не префикс фреймворка, как можно подумать, а сокращение слова «Awesome». ;-)
Фреймворк состоит из:
* Модели:
+ Протокола `ACellModel`, который нужно реализовать в модели ячейки.
+ Класса `ASectionModel` (и `ASectionModelObjC` для поддержки Objctive-C), от которого необходимо отнаследовать модель секции. Класс, а не протокол, чтобы не повторять код, посвященный внутреннему устройству секций.
+ Протокола `ACellSectionModel`, реализация которого знает, как связать ячейки и секции.
* Основного алгоритма `ATableAnimationCalculator`.
* Результата работы алгоритма, структуры `ATableDiff` (с расширениями для UIKit'а, которые живут в отдельном файле).
Класс секции совсем простой. Он нужен для хранения индексов начала/конца, но, поскольку это подробности реализации, наружу торчит только инициализатор и индексы, которые могут быть полезны в целях отладки. Класс `ASectionModelObjC` ровно такой же, его нужно использовать, когда требуется поддержка Objective-C.
```
public class ASectionModel: ASectionModelProtocol {
public internal (set) var startIndex:Int
public internal (set) var endIndex:Int
public init()
}
```
Протокол ячейки не сложнее. Необходимо равенство ячеек, нужно проверять их содержимое на идентичность и уметь их копировать (зачем — в разделе про грабли).
```
public protocol ACellModel: Equatable {
// Копирующий конструктор
init(copy:Self)
// Сравнивает содержимое ячеек, чтобы найти те, которые нужно обновить
func contentIsSameAsIn(another:Self) -> Bool
}
```
Также есть протокол, связывающий ячейки и секции вместе. Он помогает понять, находятся ли две ячейки в одной секции и создать секцию по произвольной ячейке. Обратите внимание, что привязанный тип секции должен и наследоваться от класса `ASectionModel`, и реализовывать протокол `Equatable`.
```
public protocol ACellSectionModel {
associatedtype ACellModelType: ACellModel
associatedtype ASectionModelType: ASectionModelProtocol, Equatable
// Позволяет, не создавая секцию, проверять,
// в одной ли секции находятся ячейки
func cellsHaveSameSection(one one:ACellModelType, another:ACellModelType) -> Bool
// Создаёт секцию для ячейки
func createSection(forCell cell:ACellModelType) -> ASectionModelType
}
```
В классе `ATableAnimationCalculator` есть компаратор, который используется для сортировки ячеек, несколько методов для использования в `.dataSource` таблицы и методы для запуска вычисления изменений. Также для отладки может быть полезно поглядеть на списки ячеек и секций.
```
public class ATableAnimationCalculator: NSObject {
// Показываю тут тайпалиасы, чтобы было понятнее, что написано дальше
private typealias ACellModelType = ACellSectionModelType.ACellModelType
private typealias ASectionModelType = ACellSectionModelType.ASectionModelType
// Эти поля могут быть полезны для отладки
public private(set) var items:[ACellModelType]
public private(set) var sections:[ASectionModelType]
// Компаратор можно поменять. После смены нужно
// вызвать resortItems и проанимировать изменение при необходимости
public var cellModelComparator:(ACellModelType, ACellModelType)
public init(cellSectionModel:ACellSectionModelType)
}
public extension ATableAnimationCalculator {
// Эти методы напрямую могут (и должны) использоваться
// в соответствующих методах .dataSource и .delegate
func sectionsCount() -> Int
func itemsCount(inSection sectionIndex:Int) -> Int
func section(withIndex sectionIndex:Int) -> ACellModelType.ASectionModelType
func item(forIndexPath indexPath:NSIndexPath) -> ACellModelType
func item(withIndex index:Int) -> ACellModelType
}
public extension ATableAnimationCalculator {
// Этот метод просто возвращает diff, если изменения
// не затронули напрямую объекты (как, например, при смене сортировки)
func resortItems() throws -> DataSourceDiff
// Если набор данных поменялся целиком, можно его обработать этим методом.
// Получится своеобразный аналог reloadData, только анимированный.
func setItems(newItems:[ACellModelType]) throws -> DataSourceDiff
// Если поменялась часть данных, то проще всего воспользоваться этим методом.
func updateItems(addOrUpdate addedOrUpdatedItems:[ACellModelType],
delete:[ACellModelType]) throws -> DataSourceDiff
}
```
Калькулятор специально сделан максимально независимым, чтобы можно было его использовать где угодно. Для `UICollectionView` и `UITableView` написаны соответствующие расширения, которые позволяют анимированно применить к ним результаты вычислений:
```
public extension ATableDiff {
func applyTo(collectionView collectionView:UICollectionView)
func applyTo(tableView tableView:UITableView)
}
```
Пример использования фреймворка
-------------------------------
Поглядим на простую реализации секции, в которой есть только заголовок.
```
public class ASectionModelExample: ASectionModel, Equatable {
public let title:String
public init(title:String) {
self.title = title
super.init()
}
}
public func ==(lhs:ASectionModelExample, rhs:ASectionModelExample) -> Bool {
return lhs.title == rhs.title
}
```
В ячейке три поля:
* ID, который обеспечивает равенство ячеек. Именно по этому полю мы понимаем, что ячейка та же, только содержимое поменялось.
* Header. Обычно в ячейке есть поле (имя, фамилия или дата создания объекта), по которому создаётся секция. Тут таким полем является «заголовок».
* Text, текст, который выводится в ячейке и по которому мы производим сравнение содержимого.
```
class ACellModelExample: ACellModel {
var id:String
var header:String
var text:String
init(text:String, header:String) {
id = NSUUID().UUIDString // просто чтобы не париться с айдишками
self.text = text
self.header = header
}
required init(copy:ACellModelExample) {
id = copy.id
text = copy.text
header = copy.header
}
func contentIsSameAsIn(another:ACellModelExample) -> Bool {
return text == another.text
}
}
func ==(lhs:ACellModelExample, rhs:ACellModelExample) -> Bool {
return lhs.id == rhs.id
}
```
И, наконец, класс, который знает, как связать воедино ячейки и секции.
```
class ACellSectionModelExample: ACellSectionModel {
func cellsHaveSameSection(one one:ACellModelExample, another:ACellModelExample) -> Bool {
return one.header == another.header
}
func createSection(forCell cell:ACellModelExample) -> ASectionModelExample {
return ASectionModelExample(title:cell.header)
}
}
```
Теперь поглядим, как это всё прикрутить к `UITableView`. Сначала подключим калькулятор к методам `.dataSource'а` таблицы. Это сделать легко, так как калькулятор берёт на себя все запросы по количеству и получению элементов по индексам.
> Код намеренно сделан минимальным по размеру, реальный код должен быть более аккуратным и, пожалуйста, без восклицательных знаков. :-)
```
// Дженерик выводится из параметра конструктора
private let calculator = ATableAnimationCalculator(cellSectionModel:ACellSectionModelExample())
func numberOfSectionsInTableView(tableView:UITableView) -> Int {
return calculator.sectionsCount()
}
func tableView(tableView:UITableView, numberOfRowsInSection section:Int) -> Int {
return calculator.itemsCount(inSection:section)
}
func tableView(tableView:UITableView,
cellForRowAtIndexPath indexPath:NSIndexPath) -> UITableViewCell {
var cell = tableView.dequeueReusableCellWithIdentifier("generalCell")
cell!.textLabel!.text = calculator.item(forIndexPath:indexPath).text
return cell!
}
func tableView(tableView:UITableView, titleForHeaderInSection section:Int) -> String? {
return calculator.section(withIndex:section).title
}
```
Первое обновление данных обычно не нужно анимировать, поэтому просто установим список и вызовем, как обычно, `reloadData`. Калькулятор отсортирует (если проставлен компаратор) ячейки и разобьёт по секциям.
```
try! calculator.setItems([
ACellModelExample(text:"5", header:"C"),
ACellModelExample(text:"1", header:"A"),
ACellModelExample(text:"3", header:"B"),
ACellModelExample(text:"2", header:"B"),
ACellModelExample(text:"4", header:"C")
])
tableView.reloadData()
```
> Обновление может сломаться в случае, если не проставлен компаратор, и ячейки заранее сами не отсортированы. Ведь тогда может получиться, что одна и та же секция при этом окажется раскидана по разным частям списка, что плохо поддаётся анализу. :-)
Теперь, к примеру, добавим пару ячеек в разные секции и применим просчитанные анимации.
```
let addedItems = [
ACellModelExample(text:"2.5", header:"B"),
ACellModelExample(text:"4.5", header:"C"),
]
let itemsToAnimate = try! calculator.updateItems(addOrUpdate:addedItems, delete:[])
itemsToAnimate.applyTo(tableView:tableView)
```
Также можно поменять компаратор, после чего анимированно пересортировать ячейки.
```
calculator.cellModelComparator = { left, right in
return left.header < right.header
? true
: left.header > right.header
? false
: left.text < right.text
}
let itemsToAnimate = try! self.calculator.resortItems()
itemsToAnimate.applyTo(tableView:self.tableView)
```
Собственно, всё.
Подводные грабли при использовании
----------------------------------
Помните копирующий конструктор в модели ячейки? В нём нужно копировать ячейку целиком, и ID (из примера), и данные ячейки (заголовок, текст в примере). В противном случае может получиться, что при изменении данных в модели они поменяются и внутри данных алгоритма. После этого алгоритм не сможет определить, что ячейки обновились. Появятся неявные баги с необновлением ячеек, в которых тяжело разобраться.
Другое поле граблей скрывает алгоритм — сложное обновление таблиц и баги текущей реализации iOS. К примеру, сейчас в случае одновременного перемещения секций и ячеек внутри этих секций не отрабатывает обновление ячеек, приходится форсированно их просить порелоадиться. Нужно об этом помнить, если вы решите не использовать уже написанные методы, а реализовывать их самостоятельно.
В процессе тестирования я выяснил, что метод `performBatchUpdates` работает, скажем так, странно. В симуляторе он может выдать, например, `EXC_I386_DIV` (исключение деления на ноль). Иногда случается, что срабатывают ассерты (про которые неизвестно ничего, только номер строки в глубинах UIKit'а). Если вдруг у вас будут кейсы, когда все ломается, и они стабильно повторяются — пишите, я попробую встроить код, который их учтёт.
Использование в Objective-C
---------------------------
Можно попробовать использовать калькулятор в коде для Objective-C. Это не слишком удобно, и я не ставил перед собой цель поддерживать Objective-C, но возможно. Делается это так:
* Нужно реализовать все протоколы на Swift'е. При этом ячейка будет определена, например, так:
`@objc class ACellModelExampleObjC: NSObject, ACellModel`,
секция так:
`@objc public class ASectionModelExampleObjC: ASectionModelObjC` (тут важен базовый класс).
Модель для ячейки-секции не требует поддержки ObjC:
`class ACellSectionModelExample ObjC: ACellSectionModel`
* Создаем класс, который будет скрывать от Objective-C все внутренности и сложности вроде дженериков.
```
@objc
class ATableAnimationCalculatorObjC: NSObject {
private let calculator =
ATableAnimationCalculator(cellSectionModel:ACellSectionModelExampleObjC())
func getCalculator() -> AnyObject? {
return calculator
}
func setItems(items:[ACellModelExampleObjC], andApplyToTableView tableView:UITableView) {
try! calculator.setItems(items).applyTo(tableView:tableView)
}
}
```
После чего можно его использовать в Objective-C.
```
#import "ATableAnimationCalculator-Swift.h"
ATableAnimationCalculatorObjC *calculator = [[ATableAnimationCalculatorObjC alloc] init];
[calculator setItems:@[
[[ACellModelExampleObjC alloc] initWithText:@"1" header:@"A"],
[[ACellModelExampleObjC alloc] initWithText:@"2" header:@"B"],
[[ACellModelExampleObjC alloc] initWithText:@"3" header:@"B"],
[[ACellModelExampleObjC alloc] initWithText:@"4" header:@"C"],
[[ACellModelExampleObjC alloc] initWithText:@"5" header:@"C"],
]
andApplyToTableView:myTableView];
```
Как видно, в Swift потребуется вынести всю работу со структурой `ATableDiff`, а сам калькулятор будет выдаваться в Objective-C, как `id` (`AnyObject?`).
Обновление 0.9.12
-----------------
В комментариях предложили добавить методы для поддержки стандартного редактирования UITableView. Добавил. Пользоваться можно вот так:
```
let itemsToAnimate = try! calculator.removeItem(withIndex:indexPath) // для удаления
let itemsToAnimate = try! calculator.swapItems(withIndex:sourceIndexPath, toIndex:destinationIndexPath) // для перемещения
```
А добавление и так понятно. При этом только нужно учесть, что если вы собираетесь работать с перемещением ячеек, то нужно «выключить» `cellModelComparator`, либо проконтролировать, что он учитывает правильное положение ячеек при перемещении.
Заключение, замечания, исходники
--------------------------------
Код испытан на куче искусственных/случайных тестов. Насколько я вижу, он работает достаточно хорошо. Если вы видите какие-то недочёты или неучтённые случаи, пишите.
Использование дженериков и привязанных типов (associated types) ломает (судя по ответам на StackOverflow) совместимость с iOS 7, поэтому поддерживаются только iOS 8 и 9.
Исходники живут на GitHub, проект называется [`ATableAnimationCalculator`](https://github.com/bealex/AwesomeTableAnimationCalculator). Для интеграции можно включить исходниками к себе (там всего несколько файлов). Если нужен только алгоритм, можно подключить всё кроме расширений для UIKit'а.
Есть под в [CocoaPods](http://cocoapods.org):
```
pod 'AwesomeTableAnimationCalculator'
```
Поддерживается [Carthage](https://github.com/Carthage/Carthage):
```
github "bealex/AwesomeTableAnimationCalculator"
```
Если будут какие-то вопросы, задавайте либо тут, либо сразу в почту [alex@jdnevnik.com](mailto:alex@jdnevnik.com).
Благодарности
-------------
Спасибо [Евгению Егорову](https://eego.pro/) за улучшения в структуре и дополнительные тесткейсы, которые позволили улучшить алгоритм. | https://habr.com/ru/post/282509/ | null | ru | null |
# Интеграция с ВКонтакте на базе Open API
Социальная сеть ВКонтакте предоставляет широкие возможности для интеграции со сторонними сайтами. В основном эти возможности представлены уже готовыми виджетами. Однако, есть еще и [Open API](http://vkontakte.ru/developers.php?o=-1&p=Open+API), которое позволяет не только авторизовать пользователя, но и выполнить любой метод, доступный приложениям ВКонтакте ([ВКонтакте API](http://vkontakte.ru/developers.php?o=-1&p=%D0%9E%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B5+%D0%BC%D0%B5%D1%82%D0%BE%D0%B4%D0%BE%D0%B2+API)).
Попробуем создать небольшое приложение-игру, используя возможности Open API. Тренироваться будем на игре «Память», суть которой заключается в том, что надо очистить игровое поле, открывая по 2 одинаковых картинки. В качестве картинок будем использовать фотографии друзей игрока.
### Приступаем к работе
Прежде всего необходимо [создать новое приложение](http://vkontakte.ru/apps.php?act=add), указав его название и тип.
После этого переходим к настройкам приложения и указываем адрес сайта и базовый домен.
### Реализация
Создадим HTML страницу, которая будет содержать несколько блоков:
```
VK Memory
VK Memory
Для начала игры необходимо [авторизироваться](#)
Вы можете [начать новую игру](./index.html), [посмотреть таблицу рекордов](#) или [выйти](#).
```
Назначение блоков:
* **div#login-bar** — содержит ссылку для авторизации пользователя
* **div#logout-bar** — содержит ссылки для начала новой игры, просмотра статистики и выхода
* **div#game-container** — контейнер для игрового поля
Важным моментом является подключение JavaScript файла, содержащего методы Open API:
```
```
Основная функциональность нашего приложения будет располагаться в файле general.js, поэтому перейдем к его рассмотрению.
#### Инициализация Open API
Важной частью скрипта является инициализация API, которая заключается в вызове метода VK.init, в который передается объект, содержащий минимум одно поле — apiId — ID приложения (он отображается на странице настроек приложения):
```
VK.init({
apiId: 2151186
});
```
#### Авторизация
Для авторизации пользователя добавим обработчик для ссылки a#vk-login, который будет вызывать метод VK.Auth.login. Первым параметром передается callback-функция, а вторым — необходимые пользовательские настройки приложения, которые являются перечнем необходимых уровней доступа. В нашем случае необходим доступ только к списку друзей, поэтому обработчик для ссылки будет выглядеть так:
```
$('a#vk-login').click(function(event){
event.preventDefault();
VK.Auth.login(null, VK.access.FRIENDS);
});
```
#### Завершение сеанса
Для того, чтобы пользователь мог завершить сессию, добавим обработчик для ссылки a#vk-logout, который будет вызывать метод VK.Auth.logout. Первым параметром передается callback-функция, которая в нашем случае будет обновлять страницу:
```
$('a#vk-logout').click(function(event){
event.preventDefault();
VK.Auth.logout(function(){
refreshPage(false);
});
});
```
#### Отслеживание событий
Для того, чтобы перейти к игре (в нашем случае это заключается в обновлении страницы) после того как пользователь прошел авторизацию, необходимо подписаться на событие auth.login. Также подпишемся на событие auth.sessionChange, оно будет генерироваться, когда изменяются данные, связанные с авторизацией пользователя. Это необходимо для того, чтобы перейти к игре в том случае, если пользователь уже авторизирован ранее и только подтверждает доступ к списку друзей. Для добавления обработчика события необходимо вызвать метод VK.Observer.subscribe, который принимает два параметра — событие, на которое необходимо подписаться, и callback-функцию — обработчик события:
```
VK.Observer.subscribe('auth.login', function(response){
refreshPage(true);
});
VK.Observer.subscribe('auth.sessionChange', function(response){
refreshPage(true);
});
```
Метод refreshPage обновляет страницу, если пользователь не был ранее успешно авторизован:
```
function refreshPage(checkLogged)
{
if((checkLogged && !isLogged) || !checkLogged)
{
location.href = 'index.html';
}
}
```
#### Сбор начальных данных
Для проверки текущего статуса пользователя существует метод VK.Auth.getLoginStatus. Задействуем его, чтобы определить, авторизирован ли пользователь, и скрыть/показать необходимые из описанных выше блоков. Также, если пользователь уже авторизирован, сразу перейдем к началу игру. В метод VK.Auth.getLoginStatus передается один параметр — callback-функция, в которую, в свою очередь, передается объект, содержащий сессионные данные пользователя:
```
VK.Auth.getLoginStatus(function(response){
if(response.session)
{
// пользователь авторизирован
}
else
{
// пользователь не авторизирован
}
});
```
Для вызова любого метода ВКонтакте API служит метод VK.Api.call, который принимает три параметра — название метода, объект, представляющий собой параметры, передаваемые в указанный метод, и callback-функцию, в которую будет передан результат вызова метода. Для получения списка друзей необходимо вызвать метод friends.get. Метод не имеет обязательных параметров и в случае вызова без параметров вернет список всех друзей. Поскольку нам нужны фотографии друзей пользователя, передадим в метод параметр fields со значением 'photo\_rec', что соответствует квадратной фотографии со стороной 50 пикселей:
```
VK.Api.call('friends.get', {
fields: 'photo_rec'
}, function(data){
// обработка списка друзей
});
```
В случае возникновения ошибки, объект data будет содержать вложенный объект error, содержащий информацию об ошибке. Ошибка с кодом 7 говорит о том, что у приложения не хватает прав, то есть в нашем случае о том, что пользователь не разрешил доступ к списку друзей.
Если вызов метода завершен успешно, то объект data будет содержать поле response, которое является массивом объектов, каждый из которых представляет информацию об одном из друзей пользователя.
После того, как список друзей получен, отбираем из него тех, у кого задана фотография (то есть не является стандартной картинкой со знаком вопроса) и переходим к инициализации игры:
```
VK.Api.call('friends.get', {
fields: 'photo_rec'
}, function(data){
if(!data.error)
{
if(data.response.length > 0)
{
data.response.shuffle();
for(i = 0; i < data.response.length; i++)
{
var friend = data.response[i];
if(friend.photo_rec && friend.photo_rec.indexOf('images/question_c.gif') == -1)
{
photos.push({
photo: friend.photo_rec,
id: friend.uid
});
}
}
}
initGameField();
}
else
{
if(data.error.error_code == 7)
{
isLogged = false;
$('div#login-bar').show();
$('div#logout-bar').hide();
$.unblockUI();
}
else
{
showError(data.error.error_msg);
}
}
});
```
#### Подготовка игрового процесса
Подготовка игрового процесса заключается в том, что мы отбираем случайным образом необходимое количество фотографий (если у пользователя недостаточно друзей, информируем его об этом) и формируем таблицу, которая заполнена «обратной стороной» фотографий. Для каждой ячейки-фотографии добавляем обработчик, который при нажатии на фотографию:
* если уже открыто две фотографии, закрывает их
* отображает «лицевую сторону» фотографии, назначенной для этой ячейки
* если уже открыта одна фотография и она совпадает с текущей, то очищает обе ячейки (успешный ход)
В случае успешного хода вызывается метод ВКонтакте API getProfiles, который возвращает информацию об указанных пользователях. Список пользователей, для которых необходимо получить информацию, передается в качестве параметра uids. Вызов этого метода используется для отображения имени и ссылки на профиль пользователя, который был успешно отгадан.
Если очищено все поле, сохраняем текущий результат (количество шагов, за которое было очищено поле) в таблицу рекордов. Для этого служит метод setUserScore, который принимает единственный параметр — рекорд пользователя:
```
VK.Api.call('setUserScore', {
score: stepsCount
}, function(data){
if(data.error)
{
showError(data.error.error_msg, false);
}
});
```
Необходимо учесть, что в нашей игре лучший результат — это меньший результат, поэтому в идеале описанный метод не совсем подходит для сохранения результатов, поскольку при достижении максимально возможного количества рекордов, лучшие результаты будут вытеснены худшими.
#### Список чемпионов
Для получения таблицы рекордов используется метод getHighScores, который не имеет параметров. Метод возвращает массив объектов, каждый из которых содержит информацию о пользователе и его рекорд.
Чтобы пользователь мог посмотреть таблицу рекордов, добавим обработчик ссылки a#game-scores, который будет вызывать указанный выше метод, формировать таблицу результатов и показывать ее в диалоговом окне:
```
$('a#game-scores').click(function(event){
event.preventDefault();
VK.Api.call('getHighScores', {}, function(data){
if(!data.error)
{
var scoresTable = '';
if(data.response && data.response.length > 0)
{
for(i = 0; i < data.response.length; i++)
{
scoresTable = '| [' + data.response[i].user\_name + '](http://vkontakte.ru/id' + data.response[i].user_id + ') | ' + data.response[i].score + ' |
' + scoresTable;
}
scoresTable = '
| Пользователь | Результат |
' + scoresTable + '
';
}
else
{
scoresTable = 'Нет результатов';
}
$('#scores-dialog:ui-dialog').dialog('destroy');
$('#scores-dialog')
.html(scoresTable)
.dialog({
title: 'Таблица рекордов',
modal: true,
draggable: false,
resizable: false,
buttons: {
'Закрыть': function(){
$(this).dialog('close');
}
}
});
}
else
{
showError(data.error.error_msg, false);
}
});
})
```
Как видно из кода обработчика, каждая новая строка таблицы добавляется перед предыдущей, что связано с описанной выше особенностью результатов игры.
### Результат
Итоговый файл general.js можно посмотреть [здесь](http://vk-memory.fvds.ru/js/general.js), сама игра доступна по ссылке [VK Memory](http://vk-memory.fvds.ru/).
Для создания приложения были использованы плагины для jQuery [Pines Notify](http://pines.sourceforge.net/pnotify/) и [BlockUI](http://jquery.malsup.com/block/). Всю информацию об API ВКонтакте можно получить на [странице для разработчиков](http://vkontakte.ru/developers.php). | https://habr.com/ru/post/112923/ | null | ru | null |
# Эволюция юнит-теста
Много слов сказано о том, как правильно писать юнит-тесты, и вообще о пользе [TDD](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5). Потом ещё и какое-то [BDD](http://habrahabr.ru/blogs/testing/52929/) замаячило на горизонте. Приходится разбираться, что из них лучше и между ними какая разница. Может, это и есть причина, почему большинство разработчиков решили не заморачиваться и до сих пор не используют ни того, ни другого?
Коротко: BDD — это дальнейшее развитие идей TDD, стало быть, его и надо использовать. А разницу между TDD и BDD я попробую объяснить на простом примере.
Рассмотрим 3 ревизии одного юнит-теста, который я нашёл в одном реальном проекте.
#### Попытка номер №1
Первая версия этого юнит-теста была такой:
```
public class ReferenceNumberTest {
@Test
public void testValidate() {
assertFalse( ReferenceNumber.validate("1234567890123") );
assertFalse( ReferenceNumber.validate("1234567") );
assertTrue( ReferenceNumber.validate("12345678") );
}
}
```
Мы называем это *типичным* юнит-тестом. Он тестирует код, но и только. Больше никаких преимуществ у него нет. Именно после такого кода скептики делают вывод, что от юнит-тестов нет особой пользы.
#### Попытка номер №2
В какой-то момент пришёл разработчик и решил применить к этому коду некоторые "[best practices](http://www.devclub.eu/2010/09/26/video-keks-unit-tests/)" из TDD: разбить тест-метод на несколько маленьких, так чтобы каждый из них тестировал только одну вещь, и дать им соответствующие имена.
Вот что у него получилось:
```
public class ReferenceNumberTest {
@Test
public void testTooLong() {
String len13 = "1234567891111";
assertEquals(len13.length(), 13);
assertEquals(ReferenceNumber.validate(len13), false);
}
@Test
public void testTooShort() {
String len7 = "1234567";
assertEquals(len7.length(), 7);
assertEquals(ReferenceNumber.validate(len7), false);
}
@Test
public void testOk() {
String len8 = "12345678";
assertEquals(len8.length(), 8);
assertEquals(ReferenceNumber.validate(len8), true);
String len12 = "123456789111";
assertEquals(len12.length(), 12);
assertEquals(ReferenceNumber.validate(len12), true);
}
}
```
Мы называем это *хорошим* юнит-тестом. Он гораздо легче читается: по названиям переменных легко догадаться, что 13 символов — это слишком много, 7 — слишком мало, а 8 символов — это нормально.
#### Попытка номер №3
Спустя какое-то время приходит ещё один разработчик и замечает, что даже этот хороший юнит-тест не является вполне читабельным и не предоставляет достаточно информации о том, как работает класс ReferenceNumber. Его можно понять, но для этого всё-таки надо залезть в код и немножко подумать.
Разработчик продолжает процесс разбивки и переименования:
```
public class ReferenceNumberTest {
@Test
public void nullIsNotValidReferenceNumber() {
assertFalse(ReferenceNumber.validate(null));
}
@Test
public void referenceNumberShouldBeShorterThan13() {
assertFalse(ReferenceNumber.validate("1234567890123"));
}
@Test
public void referenceNumberShouldBeLongerThan7() {
assertFalse(ReferenceNumber.validate("1234567"));
}
@Test
public void referenceNumberShouldContainOnlyNumbers() {
assertFalse(ReferenceNumber.validate("1234567ab"));
assertFalse(ReferenceNumber.validate("abcdefghi"));
assertFalse(ReferenceNumber.validate("---------"));
assertFalse(ReferenceNumber.validate(" "));
}
@Test
public void validReferenceNumberExamples() {
assertTrue(ReferenceNumber.validate("12345678"));
assertTrue(ReferenceNumber.validate("123456789"));
assertTrue(ReferenceNumber.validate("1234567890"));
assertTrue(ReferenceNumber.validate("12345678901"));
assertTrue(ReferenceNumber.validate("123456789012"));
}
}
```
Мы называем это *спецификацией в стиле [BDD](http://habrahabr.ru/blogs/testing/52929/)*. Названия методов говорят почти на человеческом языке о том, как должен работать код. Мысленно вставив перед заглавными буквами пробелы, мы получаем спецификацию кода на английском языке. Чтобы понять, как работает класс, мы не должны залезать в код — достаточно прочитать называния. А если в ходе изменения кода в него внесли ошибку, и юнит-тест сломался, мы по названию сломавшегося тест-метода наверняка сможем определить, что за ошибка допущена в коде.
> Между прочим, этот пример эволюции юнит-теста я собирался показать на семинаре [devclub.eu](http://www.devclub.eu/2010/10/31/asolntsev-bdd/) по BDD в Таллине. И вот, за день до семинара я обнаружил, что я забыл скопировать исходный код самого класса ***ReferenceNumber***, который мы тут всю дорогу тестируем. Что делать? Паника! До семинара остался один день! Мне нужно было срочно самому написать его заново.
>
>
>
> А теперь посмотрите на эти три тест-класса и подумайте, какой из них помог мне восстановить логику класса ReferenceNumber.
>
>
#### И наконец, BDD
Можно сказать, третья версия отличается от предыдущих тем, что она описывает *поведение* класса. Это достигается за счёт использования таких слов как «should» и «contain»: «мой класс должен вести себя так-то и так-то», «мой метод должен делать то-то и то-то».
Так вот, идея BDD как раз и заключается в том, чтобы вместо слов «test» и «assert» использовать слова «spec» и «should». Да-да, разница всего лишь в словах, но именно это, по замыслу авторов BDD, и делает спецификации удобочитаемыми, а написание тестов спецификаций до кода — естественным для человеческого мозга.
Убедиться в этом вы можете, взглянув на тот же пример, переведённый с языка [JUnit](http://www.junit.org/) на язык [Easyb](http://www.easyb.org):
```
description "ReferenceNumber"
it "should not be null", {
ReferenceNumber.validate(null).shouldBe false
}
it "should be shorter than 13", {
ReferenceNumber.validate("1234567890123").shouldBe false
}
it "should be longer than 7", {
ReferenceNumber.validate("1234567").shouldBe false
}
it "should contain only numbers", {
ReferenceNumber.validate("1234567ab").shouldBe false
ReferenceNumber.validate("abcdefghi").shouldBe false
ReferenceNumber.validate("---------").shouldBe false
ReferenceNumber.validate(" ").shouldBe false
}
it "valid reference number examples", {
ReferenceNumber.validate("12345678").shouldBe true
ReferenceNumber.validate("123456789").shouldBe true
ReferenceNumber.validate("1234567890").shouldBe true
ReferenceNumber.validate("12345678901").shouldBe true
ReferenceNumber.validate("123456789012").shouldBe true
}
```
Отчёт о запуске этих тестов спецификаций фактически может служить документацией:
> Кроме it и should, в BDD есть и другие важные слова, такие как given, when и then, а также before и after, ну и вдобавок ensure, narrative и «should behave as». Также BDD подходит не только для юнит-тестов, но и для функциональных/интеграционных тестов, но это уже выходит за рамки данной статьи. Сейчас нас интересует уровень юнит-тестов. Цель данной статьи — показать, что их можно писать по-разному.
>
>
Осталось добавить, что библиотеки для написания BDD спецификаций есть и для других языков: Java ([JDave](http://www.jdave.org/examples.html), [JBehave](http://jbehave.org/reference/latest/getting-started.html)), Ruby ([RSpec](http://rspec.info/), [RBehave](http://blog.dannorth.net/2007/06/17/introducing-rbehave/), [Cucumber](http://cukes.info/)), Groovy ([Easyb](http://www.easyb.org/)), Scala ([Scala-test](http://www.scalatest.org/)), PHP ([Behat](http://everzet.com/Behat/)), CPP ([CppSpec](http://www.laughingpanda.org/projects/cppspec/example.html)), .Net ([SpecFlow](http://specflow.org/), [Shouldly](https://github.com/robconery/shouldly)), Python ([Lettuce](http://lettuce.it/), [Cucumber](https://github.com/aslakhellesoy/cucumber/wiki/Python)).
А если по независящим от вас причинам вы не можете пересесть с JUnit на что-то другое — тоже ничего, только помните о третьем примере. Кстати, в этом случае вам пригодится библиотека [Harmcrest](http://code.google.com/p/hamcrest/wiki/Tutorial).
Как завещал Козьма Прутков: товарищ, BDDи! | https://habr.com/ru/post/107262/ | null | ru | null |
# Перевод времени 26 октября 2014 года или ударим трудом по разгильдяйству
Госдума России приняла в июле законопроект о возврате к зимнему времени, а также об установлении новой системы часовых зон. В результате 26 октября 2014 года в большинстве регионов России время будет снова переведено на час назад, и в стране появятся 11 часовых зон вместо 9 существующих сейчас, причем их границы изменятся.
Если для обычных граждан это лишь лишний час поспать, то для системного администратора этот момент есть жуть жуткая. В данной статье я рассмотрю проблему обновления часовых поясов для Windows XP, Windows Server 2003 и системы электронной почты на базе MS Exchange 2003 с нативным клиентом Outlook. Не секрет, что эти системы никуда не делись и хотя и ХР и Exchange 2003 сняты со всех видов поддержки, включая даже премьер поддержку, они успешно используются как в малых так и больших организациях и событие, связанное с переводом стрелок на час назад актуально для них как никогда. Актуально еще и по той причине, что официальных обновлений для снятых с поддержки систем от компании Microsoft нет и не будет. Т.к. по роду деятельности мне пришлось готовить решение для этих систем, проводить некоторые тесты и т.п., то я решил поделиться с коллегами результатами своих трудов. Итак, кому актуально, добро пожаловать под кат. Будет интересно.
Немного общей информации
------------------------
С принятием Федерального закона Российской Федерации от 21.07.2014г. № 248-ФЗ «О внесении изменений в Федеральный закон „Об исчислении времени“ на территории Российской Федерации 26 октября 2014 года осуществляется перевод часов и устанавливаются соответствующие часовые зоны и значения времени. В результате большинство регионов России перейдет на 1 час назад, при этом будут созданы 3 новые часовые зоны и объединены 2 текущие часовые зоны в одну новую. Изменится конфигурация часовых зон – ряд регионов переместится в соседние или новые зоны. Переход на летнее и зимнее время в течении года по-прежнему осуществляться не будет.
23-го сентября 2014 г. корпорация Microsoft выпустила накопительное обновление (kb2998527) для операционных систем Windows для учета текущих изменений в порядке исчисления времени и разместила его для скачивания в Центре загрузки Microsoft (<https://support2.microsoft.com/kb/2998527/> ) и системе автоматического обновления Windows Update (<https://catalog.update.microsoft.com> ). Это обновление содержит последние изменения, принятые в России. В дополнение, в операционных системах Windows будет создана новая часовая зона для Республики Беларусь.
Изменение исчисления времени произойдет 26 октября 2014 года в 2:00 местного времени. В связи с этим в операционных системах Windows данные изменения отобразятся в момент изменения отсчета часов, следующего после 1ч:59м:59с.
что произойдет 26 октября 2014 года в 2:00 по местному времени
--------------------------------------------------------------
Часовые пояса в России изменятся и довольно существенно. Картина с сайта [Лента.ру](http://lenta.ru/news/2014/09/23/timemicrosoft/)
В итоге нас ожидает следующая веселая жизнь, а именно.
##### **Изменения в существующих часовых поясах**
после того, как вы установите обновление KB29985527 на ваши операционные системы, в существующих часовых поясах, прописанных в системах изменится следующие
| | | | | |
| --- | --- | --- | --- | --- |
| | **Новое название часового пояса** | **Новое отображаемое имя** | **Текущее название часового пояса** | **Текущее отображаемое имя** |
| 1 | Russia Time Zone 1 | (UTC+02:00) Kaliningrad (RTZ 1) | Kaliningrad Standard Time | (UTC+03:00) Kaliningrad, Minsk |
| 2 | Russia Time Zone 2 | (UTC+03:00) Moscow, St. Petersburg, Volgograd (RTZ 2) | Russian Standard Time | (UTC+04:00) Moscow, St. Petersburg, Volgograd |
| 3 | Russia Time Zone 4 | (UTC+05:00) Ekaterinburg (RTZ 4) | Ekaterinburg Standard Time | (UTC+06:00) Ekaterinburg |
| 4 | Russia Time Zone 5 | (UTC+06:00) Novosibirsk (RTZ 5) | North Central Asia Standard Time | (UTC+07:00) Novosibirsk |
| 5 | Russia Time Zone 6 | (UTC+07:00) Krasnoyarsk (RTZ 6) | North Asia Standard Time | (UTC+08:00) Krasnoyarsk |
| 6 | Russia Time Zone 7 | (UTC+08:00) Irkutsk (RTZ 7) | North Asia East Standard Time | (UTC+09:00) Irkutsk |
| 7 | Russia Time Zone 8 | (UTC+09:00) Yakutsk (RTZ 8) | Yakutsk Standard Time | (UTC+10:00) Yakutsk |
26 октября 2014 года в 2 часа ночи по местному времени часы пользовательских ПК, расположенные в данных часовых поясах будут автоматически переведены на зимнее время. Но не обошлось без исключений. Исключения составляют:
* в Республике Удмуртия и Самарской области следует выполнить ручное переключение на часовой пояс “Russian Time Zone 3” вместо автоматически установленного часового пояса RTZ 2 (Russian Time Zone 2);
* в Кемеровской области следует выполнить ручное переключение на часовой пояс “Russian Time Zone 6” вместо автоматически установленного часового пояса RTZ 5 (Russian Time Zone 5);
* в Забайкальском крае следует выполнить ручное переключение на часовой пояс “Russian Time Zone 7” вместо автоматически установленного часового пояса RTZ 8 (Russian Time Zone 8).
##### **Новые часовые пояса**
| | | | | |
| --- | --- | --- | --- | --- |
| | **Новое название часового пояса** | **Новое отображаемое имя** | **Текущее название часового пояса** | **Текущее отображаемое имя** |
| 1 | Russia Time Zone 3 | (UTC+04:00) Izhevsk, Samara (RTZ 3) | Отсутствует | Отсутствует |
| 2 | Russia Time Zone 10 | (UTC+11:00) Chokurdakh (RTZ 10) | Отсутствует | Отсутствует |
| 3 | Russia Time Zone 11 | (UTC+12:00) Anadyr, Petropavlovsk-Kamchatsky (RTZ 11) | Отсутствует | Отсутствует |
Компьютеры пользователей, расположенные в данных часовых поясах должны быть вручную настроены на соответствующий часовой пояс. В ином случае c 26 октября 2014 года c 2 часов ночи по местному времени отображение времени на этих компьютерах будет некорректное.
##### **Объединение часовых поясов**
| | | | | |
| --- | --- | --- | --- | --- |
| | **Новое название часового пояса** | **Новое отображаемое имя** | **Текущее название часового пояса** | **Текущее отображаемое имя** |
| 1 | Russia Time Zone 9 | (UTC+10:00) Vladivostok, Magadan (RTZ 9) | Vladivostok Standard Time | (UTC+11:00) Vladivostok |
| Magadan Standard Time | (UTC+12:00) Magadan |
Для компьютеров, настроенных на часовой пояс “Vladivostok Standard Time” изменение часового пояса произойдет автоматически. Для компьютеров, настроенных на часовой пояс “Magadan Standard Time” произойдет только корректировка времени. Компьютеры в этом часовом поясе должны быть вручную переключены на новый часовой пояс “Russia Time Zone 9”, как основной часовой пояс после 26 октября 2014 года.
Исключения для компьютеров, настроенных на “Magadan Standard Time”, составляют:
* в Магаданской области следует вручную переключиться на часовой пояс “Russian Time Zone 8”;
* в Чукотском Автономном округе (Чукотка) и Камчатский Край (Камчатка) следует вручную переключиться на часовой пояс “Russia Time Zone 11”.
Ожидаемые проблемы
------------------
Ну как без этого:
* для Windows XP не будет выпущено официальных обновлений для корректировки отображения времени (за исключением редакции Embedded);
* операционные системы Windows Server 2003 и Windows XP Embedded не будут после установки обновления KB2998527 автоматически перенастроены на новые часовые пояса (даже в случае их автоматической настройки для других ОС);
* почтовые клиенты Microsoft Outlook до версии 2007 включительно (версии Microsoft Outlook 2010 и более поздние не испытывают подобной проблемы) после перевода времени в два часа ночи 26 октября 2014 года будут некорректно отображать созданные ранее этой даты задания из календаря (время в них сдвинется на час назад), запланированные на дату позже 2х часов ночи 26 октября 2014 года.
* **ADD** гадкий МС выпустил кривой патч для Windows XP Embedded и Server 2003. Исправления ожидаются в декабре 2014 года. Или просто после 26 октября снимите галку с параметра „Автоматически переходить на летнее время и обратно“
Начинаем обновляться
--------------------
##### **Обновление Microsoft Windows XP Professional**
Для ХР у нас есть два варианта обновления:
* превращаем ХР в Embedded;
* вносим изменения в реестр напрямую.
**Превращаем ХР в Embedded**
Превращение начинается:
* запустить редактор реестра на целевой машине и перейти по пути HKEY\_LOCAL\_MACHINE\SYSTEM\WPA\;
* выделить раздел WPA правым кликом мышки и выбрать пункт контекстного меню Создать – Раздел;
* создать раздел с именем PosReady;
* внутри раздела PosReady создать параметр DWORD с именем Installed и присвоить ему значение 1.
После проведенной модификации на XP можно будет установить исправление kb2998527 от версии Embedded. Взять его можно из, например, каталога Windows Update по ссылке в самом начале.
По окончании установки необходимо вручную изменить часовой пояс. Для Московского времени придется +04:00 Абудаби изменить на +03:00 RTZ 2. Не забудьте проверить, что установлен флажок на „Автоматически переходить на летнее время и обратно“. В ином случае перевод времени будет некорректный. Поэтому если ваша ОС старше 2011 года и на ней сняли этот флажок, обратно он после установки исправления не вернется. Почему так сделала МС — я не понимаю.
После установки исправления от Embedded новые значения в разделе реестра WPA можно удалить. Удалить их можно до ребута. После ребута ОС удалить их не даст. К сожалению, я не могу сказать, на что может повлиять эта ветка реестра еще и/или установка исправления для Embedded.
**Вносим изменения в реестр напрямую**
Вторым вариантом изменения часовых поясов на Windows XP может быть прямое редактирование реестра. Удобно тогда, когда у вас куча ХР в, например, домене, требующих обновления. Тогда создаете файлы .reg и распространяете их через групповую политику. Для этого необходимо собрать эталонную ХР (например, на виртуалке), превратить ее в Embedded вышеуказанным способом, установить исправление kb2998527, установить корректный текущий часовой пояс и выгрузить две ветки реестра:
* HKEY\_LOCAL\_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones — база данных часовых поясов
* HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Control\TimeZoneInformation — текущий часовой пояс
Сохраните их под названиями (для удобства дальнейшего понимания) 3.reg и 4.reg. Создайте также два файла 1.reg и 2.reg со следующим содержимым соответственно:
[-HKEY\_LOCAL\_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones] — удаляет базу часовых поясов
[-HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Control\TimeZoneInformation] — удаляет значение текущего часового пояса
В итоге у нас будет четыре файла для распространения: 1.reg, 2.reg, 3.reg и 4.reg. В такой последовательности их и надо будет применить. Кстати, таким способом мы получаем два бонуса:
* не надо забивать голову флажком „автоматический переход на летнее время“ — он будет установлен автоматом
* не „поедут“ календари в Outlook (об этом ниже)
**ADD** все параметры из файлов 1.reg, 2.reg, 3.reg и 4.reg можно разместить в одном файле .reg. Так будет удобнее.
**Распространение через GPO**
Т.к. в среде 2003-ХР установленные предпочтения групповых политик достаточно редки, исправления в реестре будем делать простым скриптом. Для этого создадим файл с расширением .cmd следующего содержания:
`@echo off
IF EXIST c:\windows\ok.file (exit) ELSE (regedit /s \\contoso.internal\SYSVOL\contoso.internal\scripts\1.reg & regedit /s \\contoso.internal\SYSVOL\contoso.internal\scripts\2.reg & regedit /s \\contoso.internal\SYSVOL\contoso.internal\scripts\3.reg & regedit /s \\contoso.internal\SYSVOL\contoso.internal\scripts\4.reg & echo. 2>c:\windows\ok.file & tzchange.exe /c “Russian Standard Time”)`
Скрипт делает следующее: проверять, есть ли в папке Windows файл ok.file и если он есть, то завершает работу. Скрипт уже выполнялся. Если файла нет, то применяются значения из файлов .reg в указанной последовательности. Не забудьте, что файлы .reg должны быть доступны по сетевому пути. После применения в каталоге Windows создается файл ok.file и выполняется назначение текущего часового пояса, т.к. после изменения в реестре это не произойдет автоматом. Также можно вместо команды tzchange просто ребутнуть ПК (или дать команду shutdown -r). Как кому нравится.
Осталось сделать групповую политику. Идем в редактор групповых политик. Развернуть Computer Configuration – Windows Settings – Scripts. В левой части окна редактирования политики дважды кликнуть по пункту Startup. В окне редактирования свойств пункта Startup нажать кнопку Add и добавить созданный ранее файл .cmd по сетевому пути. Нажать ОК два раза и закрыть окно редактора групповой политики. Применить созданную политику к организационному подразделению, содержащему учетные записи целевых ПК. После перезагрузки целевых ПК политика применится.
##### **Обновление Microsoft Windows 2003 Server**
Для Microsoft Windows 2003 выпущено обновление kb2998527. Поэтому основная проблема заключается в том, чтобы перевести часовой пояс куда надо. Понятно, что это можно сделать вручную. А так же удалением значений реестра и добавлением необходимых (например, тем же способом что и для ХР). Для этого на эталонной машине с установленным обновлением и корректным часовым поясом необходимо выгрузить ветку реестра HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Control\TimeZoneInformation и сохранить ее под именем 2.reg. После чего создать файл 1.reg со следующим содержимым
[-HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Control\TimeZoneInformation].
Применить вышеуказанным способом через групповую политику к серверам Windows 2003 в указанной последовательности. Сначала файл 1, потом 2. И дальше на выбор или команда смены текущего часового пояса или просто ребут.
##### **Обновление заданий в календаре Outlook 2000-2007**
И последняя проблема в разрезе устаревших систем Microsoft, с которой пришлось столкнуться при тестировании переключения на зимнее время, это то, что в заданиях, которые были созданы до перехода на зимнее время на даты позже 26 октября „поехало“ время на час назад. Другими словами то, что было запланировано на 9 утра, стало после установки исправления kb2998527 на даты позже 26 октября запланировано на 8 утра. Что плохо. Кстати, при тестировании на ХР там, где применялись изменения для реестра напрямую (без „превращения“ ОС в Embedded) календари не „поехали“. Там, где ставилось обновление, все как надо — уехали.
Для этого у Microsoft есть утилита. На самом деле их две, одна выполняется на клиенте, другая напрямую на сервере Exchange. Но т.к. то, что выполняется на сервере Exchange может его поломать (и МС на это намекает) безопаснее побегать по машинам, если что, чем колдовать над восстановлением базы. Поэтому я рассмотрю только утилиту, которая выполняется на стороне клиента. Также я не буду рассматривать обновление календарей в служебных почтовых ящиках и общих папках. Все это рассмотрено в статье MS (она будет ниже) и к сути данного поста отношение имеет несколько косвенное.
Календари „едут“ практически на всех ОС после изменения часового пояса с версией Outlook от 2000 до 2007. Почему практически, потому как это стоит проверить. Может быть вам повезет и задачи останутся на месте. Например, в моих экспериментах календари в Outlook 2007 остались корректными в Windows 7. Но официальная позиция МС такая, что указанные версии Outlook „поедут“. Не требуют действий версии Outlook 2010 и 2013. Там все нормально всегда.
Итак, чтобы поправить работу „поехавших“ заданий в календарях, нам необходимо зайти на сайт <http://support2.microsoft.com/kb/930879/ru> и загрузить или 32-разрядную или 64-разрядную версию пакета средства обновления данных о часовых поясах.С этим никаких проблем нет. Проблема есть в массовом развертывании и в массовом же выполнении. Официально МС говорит буквально следующее „ставьте и запустите“. Что не всегда удобно. Поэтому перед мной появилась задача это все перевести на групповые политики.
В итоге выяснилось, что средство по исправлению календарей — OutlookTimeZoneMove.exe — не более чем архив, который можно расковырять тем же WinRAR. Что и было сделано. Из файла OutlookTimeZoneMove.exe был извлечен файл TZMove.msi. К сожалению, версии для х64 и х86 называются одинаково, поэтому не забудьте переименовать TZMove.msi в TZMove\_32.msi и TZMove\_64.msi, соответственно.
После этого данные файлы необходимо поместить на сетевую шару, доступную для пользователей домена для чтения и создать групповую политику для распространения. Придется создать две групповых политики и настроить из выполнение на ОС со своей разрядностью (например, через фильтры WMI), но эти настройки выходят за рамки данной статьи.
После создания групповой политики открыть ее на редактирование. Развернуть User Configuration – Software Settings. Кликнуть на пункт Software installation, выбрать пункт контекстного меню New – Package и добавить файл TZMove.msi по сетевому пути. Нажать ОК. В правой части окна редактирования политик выбрать двойным кликом созданный пакет и войти в его свойства. Перейти на закладку Deployment и установить переключатель тип распространения в Assignrd и в переключатель на пункте Install this application at logon.
Нажать ОК закрыть окно редактора групповой политики. Применить созданную политику к организационному подразделению, содержащему учетные записи целевых пользователей. После перезагрузки ПК и входа целевого пользователя средство управления корректировкой заданий в календаре Outlook будет развернуто на целевом ПК для целевого пользователя.
И нам остается это средство только запустить, ибо заставить пользователя сделать это самому достаточно тяжко. Сложность, на первый взгляд, заключается в том, что средство исправление ставится в трех вариантах пути к исполняемому файлу:
* Для 32x OS — “%PROGRAMFILES%\Microsoft Office\Office12\Office Outlook Time Zone Data Update Tool\tzmove.exe”
* Для 64х OS — “%PROGRAMFILES(x86)%\Microsoft Office\Office12\Office Outlook Time Zone Data Update Tool\tzmove.exe”
* Для Outlook 2010 64x — “%PROGRAMFILES%\Microsoft Office\Office14\Time Zone Data Update Tool for Microsoft Outlook\tzmove.exe”
Казалось бы, это проблема. Но на самом деле все оказалось просто. Создаем файл с расширением .cmd и добавляем туда следующее содержимое:
`@echo off
IF EXIST "%userprofile%\ok1.file" (exit) ELSE ("%PROGRAMFILES%\Microsoft Office\Office12\Office Outlook Time Zone Data Update Tool\tzmove.exe" /quiet & “%PROGRAMFILES(x86)%\Microsoft Office\Office12\Office Outlook Time Zone Data Update Tool\tzmove.exe” /quiet & “%PROGRAMFILES%\Microsoft Office\Office14\Time Zone Data Update Tool for Microsoft Outlook\tzmove.exe” /quiet echo. 2>"%userprofile%\ok1.file")`
Скрипт проверят, есть ли в папке профиля пользователя файл ok1.file и если он есть, скрипт завершает работу (он уже выполнялся). Если же файла нет, то скрипт пытается выполнить в „тихом“ режиме средство по корректировке заданий в календаре пользователя по все трем возможным путям. Один да и сработает. Не путь джедая, но зато быстро реализуется.Потом создает файл ok1.file и завершает работу.
После создания групповой политики открыть ее на редактирование. Развернуть User Configuration – Windows Settings – Scripts. В левой части окна редактирования политики дважды кликнуть по пункту Logon. В окне редактирования свойств пункта Logon нажать кнопку Add и добавить созданный ранее файл .cmd по сетевому пути.
Нажать ОК два раза и закрыть окно редактора групповой политики. Применить созданную политику к организационному подразделению, содержащему учетные записи целевых пользователей.
После перезагрузки целевого ПК входа целевого пользователя будет произведена «тихая» (не требующая взаимодействия с пользователем) корректировка заданий в календаре Outlook.
Вот и все, что я хотел рассказать. Надеюсь, это поможет тем, кто столкнулся с подобной проблемой. Буду рад ответить на вопросы и замечания.
Бонус для тех, кто дочитал до конца:
если вы не знаете, был ли установлен или сброшен флажок на ОС 2003 и ХР, где будут установлено исправление, просто удалите одно значение реестра, распространив файл .reg со следующим содержимым:
[HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Control\TimeZoneInformation]
“DisableAutoDaylightTimeSet”=- | https://habr.com/ru/post/239827/ | null | ru | null |
# WWDC22 hidden gems
For iOS developers, **WWDC** is always something of a New Year. We are presented with so many new products, and sometimes you can get lost in them. Most of my colleagues are trying to be in touch by watching **“Platform State of Union”** and all **“What’s new”** sessions. The event basically provides an opportunity to developers a glimpse of the features to expect from the software part. When Apple has a conference like this one, they want to make sure they have enough time to get everything done. In order to do this, they need to be able to work at their own pace and not worry about how long it will take them to get something done.
This means that if you have a small project, it may not be that important but once you move into larger projects with more people involved, every second saved can be worth several dollars in terms of money saved or profit made by the company. The platform tightly integrates programming languages, frameworks, and tools. Everyone gains when these three complement one another. Customers receive a consistent experience, such as scrolling that feels right every time. And developers may devote more time and attention to what distinguishes the app.
And it’s fine, you don’t need to spend so much time for this other unpopular stuff. However, in these, not-so-popular videos as couple of them may be called as “hidden gems” because of the content or a beautiful presentation/structure. Let me show couple of them!
Meet WeatherKit
---------------
[https://developer.apple.com/videos/play/wwdc2022/10003/](https://medium.com/r/?url=https%3A%2F%2Fdeveloper.apple.com%2Fvideos%2Fplay%2Fwwdc2022%2F10003%2F)
I think it’s always interesting to work with frame forces that people can use. This year Apple has added another one of these. Now your weather apps can be even better, more accurate, and faster. Technically, WeatherKit supports async/await, allowing it to be used in conjunction with SwiftUI. There’s a small price tag, but it seems to be cheaper than other competitors so far. The interface itself looks comfortable too.
As for the session itself, I liked the narrator. Everything is very dynamic, with [jokes and some easter eggs.](https://twitter.com/NovallSwift/status/1534597678297804801)
Apple Weather kit delivers current weather, 10-day hourly forecasts, daily predictions, and historical weather using high-resolution meteorological models integrated with machine learning and prediction algorithms. While the new iOS 16/iPadOS/macOS Ventura is powered by the Apple Weather Service, developers on those platforms may now access Apple's weather data in their own apps using WeatherKit. Adding the data to an app using Swift appears to be very simple, with API calls based on location—the data is also accessible via a REST API for other languages or use cases. Apple has always been about innovation, and that's never been more apparent than when it comes to their iOS platform.
They've always been able to make the most of their resources—and now, with the release of WeatherKit, they've made it easier than ever for developers to take advantage of all of the data available through Apple's servers.Now, developers don't have to worry about building their own weather API or paying for access to another platform's API—they can simply use WeatherKit and get all of the functionality that comes along with it. The possibilities are endless! Developers will be able to build apps with built-in weather features right out of the gate when Apple's software updates ship in the fall. **There's big news is that WeatherKit can also be used in web apps and android apps thanks to REST APIs,** so you can use its API to provide weather information in your web app — helping you keep your users on the platform longer and making sure they aren't getting bounced around between browsers.
What’s new in HealthKit
-----------------------
[https://developer.apple.com/videos/play/wwdc2022/10005/](https://medium.com/r/?url=https%3A%2F%2Fdeveloper.apple.com%2Fvideos%2Fplay%2Fwwdc2022%2F10005%2F)
I have already reported on this framework and was amazed at its full functionality. You can see my review here, but it’s in Russian. This year, Apple added even more features. Sounds cool to me! I will tell you why
Firstly, the support for triathlon trainings is fantastic, with breaks between activities. It seems that Apple itself, in the development, involved people themselves engaged in this crazy sport. And secondly, a vital feature has emerged for many people with glasses. I asked around my friends who have vision problems. And they shared that it’s very convenient to have it all on the phone. Thirdly, this hallmark gives a clear and current overview of health status. It consolidates health data from iPhone, Apple Watch, and third-party apps that are already in use, thus allowing anyone to track the health process. It recommends other helpful apps to round out their collection and makes it easy to learn about health matters.
As it was indicated, it is easy to put data at your fingertips, so you can see your trends over time and spot potential issues early. Equally, it allows users to manage their own health data, as well as family members' data. Surprisingly, with the new Health Records feature, medical data from multiple providers is consolidated in one place. It is important to note that it is designed to work with the new HealthKit framework. The powerful API can be intimidating at first but depending on any complex undertaking of a developer, the framework is pretty helpful. I believe apple has emphasized on optimization and am happy that the company is taking developer feedback seriously.
The data sharing feature is a great feature for securely storing fitness data as HealthKit Repo offers a centralized data store. A standardized and unified store for fitness data is offered by HealthKit. It will make it easier to create applications and gadgets that can exchange fitness-related data. Despite being slightly more complicated than Apple's other native applications, HealthKit allows users to compare all of their data on a single page, which is useful if they want to see how various aspects interact.
The session itself is exciting and easy, and I recommend watching it. Cheers!
The SwiftUI cookbook for navigation
-----------------------------------
[https://developer.apple.com/videos/play/wwdc2022/10054/](https://medium.com/r/?url=https%3A%2F%2Fdeveloper.apple.com%2Fvideos%2Fplay%2Fwwdc2022%2F10054%2F)
> Disclaimer: don’t watch this session hungry!
>
>
Preparing to navigate has always been difficult. But with the new updates in SwiftUI, they’ve tried to show us how to do it properly, clearly, neatly, and simply. I’m afraid I have to disagree with the approach, but the session allows us to sort out the problems and find the right solution. This makes it an ideal candidate to watch. The API makes it simple to describe the navigation style that best suits the demands of the app. You may simply save and restore selections, as well as alter the whole contents of a navigation stack, with strong programmatic control over the presentation of app’s views.
This is extremely handy for dealing with critical activities such as configuring your app's start state, managing transitions across size classes, and responding to deep links. Apps are all about translating concepts, code, and APIs into user experiences. And the best applications are those that can meet users right where they are. Since the new version of Async-Await has been released in Swift 5.5, it has become possible to make network calls without freezing the UI thread. When I first heard about this feature, I was inspired by the creativity in how the Navigation API can lead to valuable extensions in app development. I’m excited about this new API, but it has required more than just an update to our developer tools.
We’re going to build a UI that works on both iOS and Android, which means we will have to modify not only our app but also the way users navigate. Since all of this is done at runtime, it can take time and effort to catch everything up before releasing a polished experience that’s ready for adoption. When working with NavigationLink, it can be tempting to convert an optional-containing binding to a boolean rather than an optional one. The reason is simple and obvious: a navigation action that contains an optional component on its payload will pop the component upon completing a transition in which the component is present in the navigation link. While this is not necessarily a bad thing, forcing such behaviour can cause unintended side effects.
Demystify parallelization in Xcode builds
-----------------------------------------
[https://developer.apple.com/videos/play/wwdc2022/110364/](https://medium.com/r/?url=https%3A%2F%2Fdeveloper.apple.com%2Fvideos%2Fplay%2Fwwdc2022%2F110364%2F)
I like that recently they have started adding sessions with the prefix “demystify.” There was some cool about SwiftUIs last year. All the details of the technical implementation are captured and focused on. Sometimes when I watch other sessions, I miss this hardcore, under the hood. The session itself lets you understand the critical development mechanism — the process of building your app.
While you have a small project, it may not be that important, but once you move to a large company, every second you save can be worth several dollars to the business. So, it is crucial to understand and understand the parallelization process. And of course, the new tool, Build Timeline, is worth mentioning. Everything is excellent and convenient, as always.Xcode 14 adds parallelization of the build process for even faster build times for multi-core Macs. Apple has been putting up a lot of signs lately about the new `xbuild` tool. It's a great way to keep your code clean and organized, and that means faster build times for your products. Xcode 14 includes a number of improvements, but one that's definitely worth noting is the parallelization of some parts of the build process.
Xcode starts the compilation of a target as soon as the build and runs scripts are complete. This means that the next target to be built will start a little bit early compared to Xcode 13, since linking other operations can now be done in parallel. Xcode's build timeline shows you the steps that make up your build process, from when you change code to when the app is ready for distribution. It's a great way to see how your code changes affect the whole process. Xcode's visualizer also allows you to see how builds are parallelized (assistant editor).
Different colours indicate how much time is spent on each target, and empty space shows blocked tasks. Sandboxed shell scripts define their inputs/outputs and help in building system management dependencies. Eager linking happens when you use a pure Swift target, which means that those targets can be built without waiting for other parts of your project to be built before running through Xcode's interface. | https://habr.com/ru/post/700074/ | null | en | null |
# Pattern matching в Java 8
Многие современные языки поддерживают сопоставление с образцом (pattern matching) на уровне языка.
Язык Java не является исключениям. И в Java 16 будет добавлено поддержка сопоставление с образцом для оператора instanceof, как финальной фичи.
В будущем надеемся, что сопоставление с образцом будем расширено и для других языковых конструкций.
Сопоставление с образцом раскрывают перед разработчиком возможность писать код более гибко и красивее, при этом оставляя его понятным.
Но что если нельзя перейти с тех или иных причин на новые версии Java. Благо используя возможности Java 8, можно реализовать некоторые возможности pattern matching в виде библиотеки.
Рассмотрим некоторые паттерны, и как их можно реализовать с помощью простенькой библиотеки.
***Constant pattern*** позволяет проверить на равность с константами. В Java оператор switch позволяет проверить на равность числа, перечисления и строки. Но иногда хочется проверить на равность константы объектов используя метод equals().
```
switch (data) {
case new Person("man") -> System.out.println("man");
case new Person("woman") -> System.out.println("woman");
case new Person("child") -> System.out.println("child");
case null -> System.out.println("Null value ");
default -> System.out.println("Default value: " + data);
};
```
Подобный код можно написать следующим образом. При этом под капотом осуществляется сравнения значений и проверка их в операторе if. Можно использовать как форме утверждение так и как выражения.
Так же можно очень просто работать с диапазонами значений.
```
import static org.kl.jpml.pattern.ConstantPattern.*;
matches(data).as(
new Person("man"), () -> System.out.println("man"),
new Person("woman"), () -> System.out.println("woman"),
new Person("child"), () -> System.out.println("child"),
Null.class, () -> System.out.println("Null value "),
Else.class, () -> System.out.println("Default value: " + data)
);
matches(data).as(
or(1, 2), () -> System.out.println("1 or 2"),
in(3, 6), () -> System.out.println("between 3 and 6"),
in(7), () -> System.out.println("7"),
Null.class, () -> System.out.println("Null value "),
Else.class, () -> System.out.println("Default value: " + data)
);
```
***Tuple pattern*** позволяет проверить на равность нескольких переменных с константами одновременно.
```
var (side, width) = border;
switch (side, width) {
case ("top", 25) -> System.out.println("top");
case ("bottom", 30) -> System.out.println("bottom");
case ("left", 15) -> System.out.println("left");
case ("right", 15) -> System.out.println("right");
case null -> System.out.println("Null value ");
default -> System.out.println("Default value ");
};
for ((side, width) : listBorders) {
System.out.println("border: " + [side + "," + width]);
}
```
При этом кроме использования в форме switch, можно разложить на сопоставляющие или пройти последовательно в цикле.
```
import static org.kl.jpml.pattern.TuplePattern.*;
let(border, (String side, int width) -> {
System.out.println("border: " + side + "," + width);
});
matches(side, width).as(
of("top", 25), () -> System.out.println("top"),
of("bottom", 30), () -> System.out.println("bottom"),
of("left", 15, () -> System.out.println("left"),
of("right", 15), () -> System.out.println("right"),
Null.class, () -> System.out.println("Null value"),
Else.class, () -> System.out.println("Default value")
);
foreach(listBorders, (String side, int width) -> {
System.out.println("border: " + side + "," + width);
}
```
***Type test pattern*** позволяет одновременно сопоставить тип и извлечь значение переменной.
```
switch (data) {
case Integer i -> System.out.println(i * i);
case Byte b -> System.out.println(b * b);
case Long l -> System.out.println(l * l);
case String s -> System.out.println(s * s);
case null -> System.out.println("Null value ");
default -> System.out.println("Default value: " + data);
};
```
В Java для этого нам нужно сначала проверить тип, привести к типу и потом присвоить новой переменной. С помощью такого паттерна код стает на много проще.
```
import static org.kl.jpml.pattern.VerifyPattern.matches;
matches(data).as(
Integer.class, i -> { System.out.println(i * i); },
Byte.class, b -> { System.out.println(b * b); },
Long.class, l -> { System.out.println(l * l); },
String.class, s -> { System.out.println(s * s); },
Null.class, () -> { System.out.println("Null value "); },
Else.class, () -> { System.out.println("Default value: " + data); }
);
```
***Guard pattern*** позволяет одновременно сопоставить тип и проверить на условия.
```
switch (data) {
case Integer i && i != 0 -> System.out.println(i * i);
case Byte b && b > -1 -> System.out.println(b * b);
case Long l && l < 5 -> System.out.println(l * l);
case String s && !s.empty() -> System.out.println(s * s);
case null -> System.out.println("Null value ");
default -> System.out.println("Default: " + data);
};
```
Подобную конструкцию можно реализовать следующим образом. Чтобы упростить написания условий, можно использовать следующее функции для сравнения: lessThan/lt, greaterThan/gt, lessThanOrEqual/le, greaterThanOrEqual/ge, equal/eq, notEqual/ne. А для того чтобы опустить условия можно пременить: always/yes, never/no.
```
import static org.kl.jpml.pattern.GuardPattern.matches;
matches(data).as(
Integer.class, i -> i != 0, i -> { System.out.println(i * i); },
Byte.class, b -> b > -1, b -> { System.out.println(b * b); },
Long.class, l -> l == 5, l -> { System.out.println(l * l); },
Null.class, () -> { System.out.println("Null value "); },
Else.class, () -> { System.out.println("Default value: " + data); }
);
matches(data).as(
Integer.class, ne(0), i -> { System.out.println(i * i); },
Byte.class, gt(-1), b -> { System.out.println(b * b); },
Long.class, eq(5), l -> { System.out.println(l * l); },
Null.class, () -> { System.out.println("Null value "); },
Else.class, () -> { System.out.println("Default value: " + data); }
);
```
***Deconstruction pattern*** позволяет одновременно сопоставить тип и разложить объект на составляющие.
```
let (int w, int h) = figure;
switch (figure) {
case Rectangle(int w, int h) -> out.println("square: " + (w * h));
case Circle (int r) -> out.println("square: " + (2 * Math.PI * r));
default -> out.println("Default square: " + 0);
};
for ((int w, int h) : listFigures) {
System.out.println("square: " + (w * h));
}
```
В Java для этого нам нужно сначала проверить тип, привести к типу, присвоить новой переменной и только тогда через геттеры доступиться к полям класса.
```
import static org.kl.jpml.pattern.DeconstructPattern.*;
Figure figure = new Rectangle();
let(figure, (int w, int h) -> {
System.out.println("border: " + w + " " + h));
});
matches(figure).as(
Rectangle.class, (int w, int h) -> out.println("square: " + (w * h)),
Circle.class, (int r) -> out.println("square: " + (2 * Math.PI * r)),
Else.class, () -> out.println("Default square: " + 0)
);
foreach(listRectangles, (int w, int h) -> {
System.out.println("square: " + (w * h));
});
```
При этом чтобы получить составляющее, класс должен иметь один или несколько деконструирующих методов. Эти методы должны быть помечены аннотаций [Extract](https://habr.com/ru/users/extract/).
Все параметры должны быть открытыми. Поскольку примитивы нельзя передать в метод по ссылке, нужно использовать обертки на примитивы IntRef, FloatRef и т.д.
Чтобы уменьшить оверхед с использованием рефлексии, используется кеширования и приемы с стандартным классом LambdaMetafactory.
```
@Extract
public void deconstruct(IntRef width, IntRef height) {
width.set(this.width);
height.set(this.height);
}
```
***Property pattern*** позволяет одновременно сопоставить тип и доступиться к полям класса по их именам.
```
let (w: int w, h:int h) = figure;
switch (figure) {
case Rectangle(w: int w == 5, h: int h == 10) -> out.println("sqr: " + (w * h));
case Rectangle(w: int w == 10, h: int h == 15) -> out.println("sqr: " + (w * h));
case Circle (r: int r) -> out.println("sqr: " + (2 * Math.PI * r));
default -> out.println("Default sqr: " + 0);
};
for ((w: int w, h: int h) : listRectangles) {
System.out.println("square: " + (w * h));
}
```
Это упрощенная форма деконструирующего паттерна, где нужны только конкретные поля класса разложить.
Чтобы уменьшить оверхед с использованием рефлексии, используется кеширования и приемы с стандартным классом LambdaMetafactory.
```
import static org.kl.jpml.pattern.PropertyPattern.*;
Figure figure = new Rectangle();
let(figure, of("w", "h"), (int w, int h) -> {
System.out.println("border: " + w + " " + h));
});
matches(figure).as(
Rect.class, of("w", 5, "h", 10), (int w, int h) -> out.println("sqr: " + (w * h)),
Rect.class, of("w", 10, "h", 15), (int w, int h) -> out.println("sqr: " + (w * h)),
Circle.class, of("r"), (int r) -> out.println("sqr: " + (2 * Math.PI * r)),
Else.class, () -> out.println("Default sqr: " + 0)
);
foreach(listRectangles, of("x", "y"), (int w, int h) -> {
System.out.println("square: " + (w * h));
});
```
Также для упрощения именования полей можно использовать другой способ с ссылками на методы.
```
Figure figure = new Rect();
let(figure, Rect::w, Rect::h, (int w, int h) -> {
System.out.println("border: " + w + " " + h));
});
matches(figure).as(
Rect.class, Rect::w, Rect::h, (int w, int h) -> System.out.println("sqr: " + (w * h)),
Circle.class, Circle::r, (int r) -> System.out.println("sqr: " + (2 * Math.PI * r)),
Else.class, () -> System.out.println("Default sqr: " + 0)
);
foreach(listRectangles, Rect::w, Rect::h, (int w, int h) -> {
System.out.println("square: " + (w * h));
});
```
***Position pattern*** позволяет одновременно сопоставить тип и проверить значение полей в порядке объявления.
```
switch (data) {
case Circle(5) -> System.out.println("small circle");
case Circle(15) -> System.out.println("middle circle");
case null -> System.out.println("Null value ");
default -> System.out.println("Default value: " + data);
};
```
В Java для этого нам нужно сначала проверить тип, привести к типу, присвоить новой переменной и только тогда через геттеры доступиться к полям класса и проверить на равность.
Чтобы уменьшить оверхед с использованием рефлексии, используется кеширования.
```
import static org.kl.jpml.pattern.PositionPattern.*;
matches(data).as(
Circle.class, of(5), () -> { System.out.println("small circle"); },
Circle.class, of(15), () -> { System.out.println("middle circle"); },
Null.class, () -> { System.out.println("Null value "); },
Else.class, () -> { System.out.println("Default value: " + data); }
);
```
Также если разработчик не хочет проверять некоторые поля, эти поля должны быть помечены аннотаций [Exclude](https://habr.com/ru/users/exclude/). Эти поля должны быть объявлены последними.
```
class Circle {
private int radius;
@Exclude
private int temp;
}
```
***Static pattern*** позволяет одновременно сопоставить тип и деконструировать объект используя фабричные методы.
```
switch (some) {
case Result.value(var v) -> System.out.println("value: " + v)
case Result.error(var e) -> System.out.println("error: " + e)
default -> System.out.println("Default value")
};
```
Подобный до деконструирующего паттерна, но имя деконструирующих методов, которые помеченные аннотаций [Extract](https://habr.com/ru/users/extract/), должны быть указаны явно.
Чтобы уменьшить оверхед с использованием рефлексии, используется кеширования и приемы с стандартным классом LambdaMetafactory.
```
import static org.kl.jpml.pattern.StaticPattern.*;
matches(figure).as(
Result.class, of("value"), (var v) -> System.out.println("value: " + v),
Result.class, of("error"), (var e) -> System.out.println("error: " + e),
Else.class, () -> System.out.println("Default value")
);
```
***Sequence pattern*** позволяет проще обрабатывать последовательности данных.
```
List list = ...;
switch (list) {
case empty() -> System.out.println("Empty value")
case head(var h) -> System.out.println("list head: " + h)
case tail(var t) -> System.out.println("list tail: " + t)
default -> System.out.println("Default value")
};
```
Используя библиотечные методы можно просто работать с последовательностями данных.
```
import static org.kl.jpml.pattern.SequencePattern.*;
List list = List.of(1, 2, 3);
matches(figure).as(
empty() () -> System.out.println("Empty value"),
head(), (var h) -> System.out.println("list head: " + h),
tail(), (var t) -> System.out.println("list tail: " + t),
Else.class, () -> System.out.println("Default value")
);
```
Также для упрощения кода, можно использовать следующее функции, которые можно увидеть в современных языках как языковые фичи или функции.
```
import static org.kl.jpml.pattern.CommonPattern.*;
var rect = lazy(Rectangle::new);
var result = elvis(rect.get(), new Rectangle());
with(rect, it -> {
it.setWidth(5);
it.setHeight(10);
});
when(
side == Side.LEFT, () -> System.out.println("left value"),
side == Side.RIGHT, () -> System.out.println("right value")
);
repeat(3, () -> {
System.out.println("three time");
)
int even = self(number).takeIf(it -> it % 2 == 0);
int odd = self(number).takeUnless(it -> it % 2 == 0);
```
Как можно видеть pattern matching сильный инструмент, который намного упрощает написание кода. Используя возможности Java 8 можно сэмулировать возможности pattern matching самыми средствами языка.
Исходной код библиотеки можно посмотреть на github: [link](https://github.com/klappdev/jpml). Буду рад отзывам, предложениям по улучшению. | https://habr.com/ru/post/544560/ | null | ru | null |
# Ещё раз о неопределённом поведении или «почему не стоит забивать гвозди бензопилой»
Про неопределённое поведение [писали](http://habrahabr.ru/post/136283/) [не](http://habrahabr.ru/post/216189/) [раз](http://habrahabr.ru/post/229963/). Приводились цитаты из стандартов, объяснения их интерпретации, разного рода поучительные примеры, но, похоже, все люди, пытавшиеся об этом писать пропускали важный пункт: по-моему никто внятно так и не удосужился объяснить — откуда это понятие в языке, собственно, появилось, и, главное, кому оно адресовано.
Хотя на самом-то деле, если вспомнить историю Си, всё достаточно очевидно и, главное, логично. А все жалобы людей, «обжёгшихся» на неопределённом поведении для людей не забывших **что** такое Си и **зачем** он вообще существует звучат примерно как: «я тут гвозди бензопилой забивал… забивал и забивал, всё было хорошо, а потом я дёрнул за ручку и у неё коготки как забегают, задёргаются, мне руку оттяпало и полноги… ну кто так строит?».
Люди, которые знают что такое бензопила пытаются, конечно, объяснить, что за если за эту рукоятку дёрнуть, то так, в общем-то, и должно быть, но люди, считающие, что у них у руках такой себе молоток говорят «мимо» них, и, в результате, все остаются при своих.
Так какой же важный секрет люди упускают из виду?
Ответ прост: они забывают зачем это язык вообще существует и какие задачи решает.
Давайте вспомним что **вообще** такое Си и **для чего** он, собственно, изобретён. Все знают что это низкоуровневый язык. Все знают что это не переносимый язык (это вам не Java, да). Но многие забывают (или просто не задумываются) над тем **что** это за язык и **зачем** он, собственно, был придуман. Вернее какие-то базовые факты знают все (ах, да — UNIX, K&R — ох, конечно, ANSI и ISO — где-то слышал), но простейшие следствия из этих фактов как-то совершенно упускаются из виду. Что ведёт к совершенно жутчайшему непониманию места Си (и стандартов ANSI C и ISO C) в этом мире.
Так вот. Язык [Си](http://ru.wikipedia.org/wiki/%D0%A1%D0%B8_(%D1%8F%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) был создан, в общем-то, для одной-единственной цели: для написания операционной системы [UNIX](http://ru.wikipedia.org/wiki/UNIX). То есть низкоуровневого кода. Но, минуточку, если вы таки пойдёте по ссылке в Википедию, то обнаружите, что UNIX — она не только многозадачная и многопользовательская, но она ещё и **переносимая**.
И вот именно это-то сочетание и подводит нас к неопределённому поведению.
Действительно: как можно сделать какую-то программу переносимой? Очевидный вариант: написать её на **переносимом** языке, в описании которого подробно описать всё, что делают разные операторы, как обрабатывается переполнение, обращение к неинициализированному указателю и прочее, прочее. Ну так, как делает [Java](http://ru.wikipedia.org/wiki/Java) или [ECMAScript](http://ru.wikipedia.org/wiki/ECMAScript). Но это, как вы понимаете, неэффективно. Вам придётся в куче мест в коде проверки вставлять, какие-то места станут жутко неэффективными «на ровном месте» (сдвиг 1 на 129 на x86 даёт 2, а на ARM'е даёт 0, так что как бы вы ни определили значение выражения «1 << 129» вам на одном из процессоров придётся генерировать неэффективный код) и т.д. и т.п. Не самый лучший вариант для ядра OS. Да и вообще — что это за «низкоуровневый язык» где простейшие вещи транслируются в 10 команд ассемблера (и хорошо если в 10, а не в 100)?
Разработчики UNIX (и Си) пошли другим путём. Язык они сделали **не**переносимым, а вот написанный на нём UNIX — очень даже переносимым. Как этого добились? Запретами. Сдвиг на сильно большие величины на разных процессорах даёт разные результаты? Значит использовать такие сдвиги в программе **нельзя**. Сравнение указателей, ведущих в разные пересекающиеся сегменты в памяти дорого и сложно (вспомните [8086](http://ru.wikipedia.org/wiki/X86#.D0.A0.D0.B5.D0.B0.D0.BB.D1.8C.D0.BD.D1.8B.D0.B9_.D1.80.D0.B5.D0.B6.D0.B8.D0.BC_.28real_mode.29))? Значит использовать такие сравнения в программах **нельзя**. Один процессор при переполнении выбрасывает исключения, а другой «тихо» порождает отрицательное число? Значит использовать такую конструкцию в программе **нельзя**. И т.д. и т.п. Таких правил, призванных обеспечить переносимость кода накопились десятки и сотни.
Заметьте: эти правила — ориентированы **на программиста**, ни в коем случае не на разработчика компилятора. Это программисту нужен переносимый код, не компилятору. А для компилятора — эти правила, наоборот, дают простор для реализации. Если у нас сложение порождает отрицательные числа, а вычитание — бросает исключение, то что нам делать? Да неважно: программист же должен всё равно позаботится о том, чтобы такого не происходило! Именно это приводит к тому, что UNIX (и его «идейный наследник» Linux) поддерживают совершенно невероятное число платформ. И многие программы, написанные на этом непереносимом языке тоже работают в куда большем числе мест, чем программы написанные «на истинно переносимых языках» типа С# или Java. Дело в том, что переносимость в случае использования C# или Java возлагается в первую очередь на компилятор, а вот в Си — совсем не на него, а вовсе даже на программиста. И если программист всё делает аккуратно, то программа на Си заработает даже на таких платформах куда Java в принципе «не пролезет».
После того, как Си начал использоваться в куче разных мест помимо ядра UNIX люди собрались и написали стандарт (на самом деле и не один: их несколько, но они основываются друг на друге). И важной частью работы над этим стандартом был сбор и классификация всех этих **запретов, налагаемых на программиста**. Иначе как бы переносимости с одного компилятора на другой не добиться.
Например: можно ли использовать указатели, не указывающие «внутрь» массива? Вообще говоря нельзя, так как бывают всякие [iAPX 432](http://ru.wikipedia.org/wiki/IAPX_432) где это всё контролируется аппаратно. Но иногда очень хочется. Вспомните [begin](http://en.cppreference.com/w/cpp/iterator/begin) и [end](http://en.cppreference.com/w/cpp/iterator/end) из C++. Полуинтервал — он удобен. С зубовным скрежетом было решено, что да, один элемент «сверху» все реализации должны предоставлять. Вернее не сам элемент, а его адрес: обращаться к самому элементу лежащему «за краем массива», разумеется, нельзя, но взять его адрес — можно. Ну а там, где это нельзя аппаратно — пусть компилятор добавит один «невидимый» элемент. Ну и, в общем, много было разных решений, где обсуждалось — какие запреты программист ещё сможет «пережить», а какие — это уже «ни в какие ворота».
Правда некоторые из этих запретов оказались «на грани». Оказалось, например, что нельзя просто так взять и преобразовать `int` в `unsigned int`. Ну потому что бывает [дополнительный код](http://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4_(%D0%BF%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%B0)) и [обратный код](http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4). Тут уж комитет по стандартизации решил: «нет, ну пора и меру знать, это уж какие-то совсем безумные ограничения мы тут на программиста налагаем». Было принято «соломоново решение»: разрешить реализации выбрать один из вариантов (иногда явно перечисленных в стандарте, иногда нет), но обязать реализацию всегда использовать один и тот же подход. То есть реализация может быть с [дополнительным кодом](http://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4_(%D0%BF%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%B0)) или с [обратным кодом](http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4), но уж какой-то один вариант будет точно. И в любом случае можно преобразовать число из `int` в `unsigned int` и получить… ну хоть что-то.**Стандарт говорит даже чуть больше**Положительные числа, представимые в обоих вариантах при этом гарантированно сохраняются, что здорово облегчает жизнь.
Но таких вариантов (они называются "[поведение, определяемое реализацией](http://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5,_%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D1%8F%D0%B5%D0%BC%D0%BE%D0%B5_%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9) aka "[implementation-defined behavior](http://en.wikipedia.org/wiki/Unspecified_behavior)") мало. В основном запреты (получившие название "[неопределённого поведения](http://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D1%91%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5)" aka "[undefined behavior](http://en.wikipedia.org/wiki/Undefined_behavior)") были оставлены в стандарте и обязанность бороться с их последствиями возложили **на программиста**: если программист хочет, чтобы его Си программа работала на разных компиляторах, то **он** должен позаботится о том, чтобы беды не произошло. **Разработчики же компилятора могут делать в таких случаях что угодно** (в этом, собственно, весь смысл). **Кстати есть ещё одно близкое понятие**[Неуточняемое поведение](http://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D1%83%D1%82%D0%BE%D1%87%D0%BD%D1%8F%D0%B5%D0%BC%D0%BE%D0%B5_%D0%BF%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5) aka [unspecified behavior](http://en.wikipedia.org/wiki/Unspecified_behavior) — это когда возможны несколько вариантов и компилятор в каждом конкретном случае волен выбрать один из них (скажем стандарт не определяет какая из функций вычислится первый в выражении `f()+g()` и **в каждом конкретном случае** компилятор волен выбирать более удобный ему вариант, но всё-таки он должен сначала вычислить их обе, а уж потом результаты сложить). Цель — всё та же: облегчить работу разработчикам компиляторов.
Заметьте, что во многих случаях понять — нарушится запрет или нет по тексту программы не так-то просто. Например в стандарте Си запрещено использовать два одинаковых указателя, указывающие на объекты разных типов, которые используются вперемешку. А почему, собственно? Да очень просто: вспомните процессоры [8086](http://ru.wikipedia.org/wiki/Intel_8086) и [8087](http://ru.wikipedia.org/wiki/Intel_8087). Они работают параллельно и, в известной степени, независимо. Так что если специально не вставлять команды синхронизации, то хорошо известный трюк, когда число типа `float` интерпретируется как число типа `int` (или `long` на 16-битных компиляторах) может и не сработать! Искомого числа (который должен породить процессор [8087](http://ru.wikipedia.org/wiki/Intel_8087)) просто ещё не будет в памяти, когда процессор [8086](http://ru.wikipedia.org/wiki/Intel_8086) туда «придёт»!
Заметьте: запрещено не наличие двух указателей на объекты разных типов (иначе не было бы никакого смысла в [объединениях](http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%B4%D0%B8%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_(%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85))), запрещено их использование «вперемешку»: если положили `int`, то и вынимайте уж `int`, а если засунули `float`, то и вынимать нужно `float`. Понятно, что проконтролировать подобного рода запреты чрезвычайно сложно, да и не нужно — это же ограничение не на компилятор, а на программиста! Это **его** обязанность, не компилятора.
Правильная программа на Си обязана соблюдать эти запреты — иначе никакой переносимости не получится! Ну а раз программа **никогда** не нарушает эти запреты и **никогда** не вызывает неопределённого поведения, то грех этим не воспользоваться для ускорения программы, ведь правда? Например можно объявить переменную `p` до вызова `realloc`'а и после вызова `realloc`'а разными виртуальными переменными. Я надеюсь вы понимаете, зачем это нужно: ну, например, вы можете одну «виртуальную переменную» засунуть в регистр даже если адрес другой куда-то там передаётся… они же разные, друг на друга не влияют!
А дальше… имеем то, что имеем:
```
#include
#include
int main() {
int \*p = (int\*)malloc(sizeof(int));
int \*q = (int\*)realloc(p, sizeof(int));
\*p = 1;
\*q = 2;
if (p == q)
printf("%d %d\n", \*p, \*q);
}
$ clang -O realloc.c ; ./a.out
1 2
```
Но… это же жуть, качмар, как так может быть вообще? А вот так: раз вы вызвали `realloc`, то у вас теперь не две переменные в программе, а три: `p₁`, `p₂` и `q`. При этом переменная `p₂` не получила никакого значения, которое могло бы заставить её указывать на участок памяти, на который указывает `q` (она, собственно, никакого значения не получила, чем компилятор может и воспользоваться — но не обязан). Ну а стало быть значения `*p₂` и `*q` тоже разные. И мы знаем — какие: `*p₂` указывает на `1`, а `q` на `2`. Значит можем сразу передать эти значения в `printf`. Экономия! А вот проверку `p₂ == q` почему-то в `false` не удалось соптимизировать, Ну да ладно — может следующая версия компилятора и с этим справится.
Заметьте, что это результат порождается после длинных цепочек преобразований, каждое из которых осмысленно и логично. В предположении, конечно, что программист соблюдает «правила игры» и создаёт программу, которая не нарушает «запреты». Ну а если он их нарушил… ну что тут можно сказать — [ССЗБ](http://lurkmore.to/%D0%A1%D0%A1%D0%97%D0%91), нужно было вдумчивее «курить» документацию.
Вот, собственно, и всё: абсолютно естественное предложение (для людей, которые используют С для какой-то одной платформы) реализовывать операции [так как они соответствует здравому смыслу, а именно — свойствам целевой платформы](http://habrahabr.ru/post/229963/#comment_7785407) оказывается неестественным, если мы исходим из основной цели языка C: созданию быстрых, низкоуровневых, но, вместе с тем, **переносимых** программ. Для переносимых программ этого не нужно просто потому, что в их коде вообще никогда подобное поведение не должно встречаться. Ну а если вы используете бензопилу для забивания гвоздей, то… берегите свои пальцы!
И ровно по той же причине вопрос [можно привести ошибочный псевдокод, который теоретически может быть создан компилятором?](http://habrahabr.ru/company/pvs-studio/blog/239629/#comment_8057689) также бессмысленен: какой-такой псевдокод? Не будет там никакого псевдокода! Мы же обсуждаем не просто компилятор, а **хорошо оптимизирующий** компилятор! Он не просто **может**, но **обязан** этот код просто выкинуть к чертям собачьим: если код **обязательно** вызывает неопределённое поведение, то, в правильно написанной программе на Си, он никогда не вызывается и, стало быть, его можно выкинуть — что очевидно только уменьшит размер программы, а может и немного ускорить её. Сплошная выгода!
Разумеется в случаях конкретных компиляторов разработчики могут решить, что они выполнения части из этих правил требовать не будут. Например GCC предлагает аж три способа обращения с переполнением чисел со знаком: поведением по умолчанию (как описано в стандарте — когда он с радостью неописуемой может превратить [конечный цикл в бесконечный](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=33498)), режим [-fwrapv](https://gcc.gnu.org/onlinedocs/gcc-4.9.1/gcc/Code-Gen-Options.html#index-fwrapv-2571), когда поддерживается переполнение с использованием [дополнительного кода](http://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4_(%D0%BF%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%B0)) и режим [-ftrapv](https://gcc.gnu.org/onlinedocs/gcc-4.9.1/gcc/Code-Gen-Options.html#index-ftrapv-2570), когда эти случаи отлавливаются и выбрасывается исключение. А для случаев когда вам нужно писать код в котором разные типы могут перемешиваться есть не только [-fno-strict-aliasing](https://gcc.gnu.org/onlinedocs/gcc-4.9.1/gcc/Optimize-Options.html#index-fstrict-aliasing-924), но и атрибут типа [may\_alias](https://gcc.gnu.org/onlinedocs/gcc-4.9.1/gcc/Type-Attributes.html#Type-Attributes). И вообще много чего есть. Но это всё — расширения стандарта, которые, в большинстве случаев, нужно включать **явно**.
Если же вы досконально знаете поведение вашего конкретного процессора и хотите поиспользовать его особенности, то, увы, вынужден вас разочаровать: вы не только не вправе ожидать поведения, близкого к железу, а напротив — если поведение вашего процессора отличается от какого-то другого, то с вероятностью 99% эту его особенность использовать в Си **категорически запрещено**. И это — не недосмотр разработчиков какого-либо компилятора, а совсем даже наоборот — прямое следствие из базового принципа положенного в основу этого языка. | https://habr.com/ru/post/230777/ | null | ru | null |
# В поиске бесплатных билетов, исследование игры Аэрофлота: Миссия 2017
В преддверие Нового Года, разгребая тонны поздравительных писем, я наткнулся на предложение от Аэрофлота спасти Новый Год и получить 150 000 миль за первое место. Памятую о [прошлой их промо акции](https://habrahabr.ru/post/238463/) и имея слабость к ~~взлому~~анализу подобных мероприятий, я перешел по ссылке.
Промо было сделано в виде игры, суть которой заключалась в отгадывании точки на карте по изображению с Google StreetView и получение за это все очков, количество которых пропорционально точности ответа. На все про все дается 6 минут. Также между раундами предлагается [половить](http://mission2017.aeroflot.ru/mg/g2/)\[покидать](http://mission2017.aeroflot.ru/mg/g1/) подарки и [полетать на аэроплане](http://mission2017.aeroflot.ru/mg/g7/) за дополнительные очки. Шесть минут можно увеличить до десяти, правильно ответив на вопросы викторины. За хорошие результаты дают порядочное количество миль.
Просканив директории(для успокоения души) и не найдя ничего интересного(кроме торчащего в Интернет phpmyadmin), я приступил к анализу самой игры.
1) Первое, что нашел это Replay атака. Раунд не помечается, как сыгранный и один и тот же запрос можно посылать бесконечно, получаю профит.
```
for i in {0..50};
do torify curl 'http://mission2017.aeroflot.ru/ajax/round' --data 'val1=49&val2=9&game=563058&round=4974078&atype=map' & done;
```
Однако, эту уязвимость быстро закрыли.
2) Мини-игры реализовывали всю логику на своей стороне. И отправляли на сервер только итоги. Соответственно данные запросы можно было модифицировать и пролетать сотни тысяч км на своем аэроплане.
3) Викторина до конца промо была уязвима для Replay атак. Так что можно было накручивать себе время на игру. Минус этого метода в том, что по логике создателей, невозможно набрать более 10 минут времени, поэтому результат выбивался бы из ровного списка десятиминутников.
4) Но все вышеперечисленное — это хаки, которые можно отследить и наказать за них. Значит настало время писать бота! Скрипт игры представляет из себя неплохой необфусцированный код, с довольно ясными именованием функций и переменных. Примечательно, что в ответе на запрос к /ajax/round приходили верные координаты. Это обстоятельство позволяло замапить каждый url панорамы на координаты.
```
map = {"https://www.google.com/maps/embed/v1/streetview?pano=_EjgB69lOpQheNB4ldZWsA&key=AIzaSyAdpt2jitUXkLd8NtkNQ_Ee6THUA_DZ-K0" : {lat: 40.62, lon: 22.94},
"https://www.google.com/maps/embed/v1/streetview?pano=oIMBbAJeLJfwiwNtgiVl-g&key=AIzaSyAdpt2jitUXkLd8NtkNQ_Ee6THUA_DZ-K0" : {lat: 22.27, lon: 114.16},
...
}
```
Все дальнейшее остается всего лишь делом техники: определяем новую функцию через консоль разработчика, которая автоматом правильно отвечает на все вопросы с некоторой погрешностью и задержкой, пропускает или отправляет хорошие результаты по итогам мини-игр и позволяет ответить на викторину в мануальном режиме. В принципе и викторина автоматизируется, но просто было лень реализовывать.
Стоит отдать должно разработчикам(а может быть модераторам), у них был неплохой антифрод и все сомнительные участники банились. Я не смог выяснить все параметры по которым производился анализ на фрод, но два из них мне известен: скорость и точность ответа.
Правда, этих механизмов недостаточно для адекватного отсечения ботов. Что на мой взгляд и отображает [итоговые рейтинг](http://mission2017.aeroflot.ru/rating) промо акции.
Первые три уязвимости чисто логические, недостаточно проверок и тестов. Но остается проблема ботоводства, которую надо решать. Вот те минимальные меры(практически калька с [блога](https://frydaykg.blogspot.ru/2016/07/blog-post.html)), которые бы отсекли бОльшую часть ботоводов и сделали бы мир чище:
1) STO — Security Through Obscurity, отсекает ленивых и школьников. Обфускация и шифрование — наше все!
2) Плохая идея возвращать участнику координаты верной точки в чистом виде. Решить проблему можно по разному: возвращать результат в виде изображения или маски над ним, преобразовывать в другую систему координат с меньшей точностью.
3) Добавить больше клиент-серверного взаимодействия, например нажатие клавиш, перемещение курсора, клики. Данная мера усложнит написание ботов для мини-игр и добавит данных для проведения обратного теста Тьюринга.
Пункт три конечно дорогой и сложный, и в мире промо ему вряд ли найдется место, но пренебрегать пунктом два, а тем более мерой один, я бы не стал, учитывая то количество средств, которое создано под эти цели.
P.S. Все действия произведенные мной носят исследовательский характер, а выводы надеюсь послужат назиданием разработчикам промо. | https://habr.com/ru/post/318944/ | null | ru | null |
# Взлом пароля на Mac с Arduino и OpenCV
О том, как взламывали запароленный мак с помощью Arduino и OpenCV. По мотивам статьи [Брутфорсим EFI с Arduino](http://habrahabr.ru/post/240291/).
#### История
Началось всё как обычно — у моего друга заблокировали Mac Air, уведя аккаунт. И если iPhone можно восстановить, то Mac заблокировался с концами. Обращение в техподдержку ни к чему не привело, в сервисном центре предложили разблокировать за 1000 рублей и 1 день. Правда, обнаружили брак материнской платы, который не позволил им это сделать.
Прочитав статью [Брутфорсим EFI с Arduino](http://habrahabr.ru/post/240291/), решили повторить опыт. Правда, не было дисплея, зато было две ардуины — Uno и Mega2560. И ноутбук, который не очень жалко на ~33 часа оставить перебирать пароль. Решили сделать перебор с преферансом и поэтессами — пусть автоматика следит за перебором, а мы пьем чай.
#### Описание проблемы
Для начала — коротко о том, что мы вообще решали. Этот раздел для тех, кто не хочет внимательно читать статью, на которую я ссылался.
Если у Вас угнали аккаунт Apple, взломщик может заблокировать Ваш Mac удаленно, поставив четырехзначный числовой пароль по своему выбору. После этого невозможно включить мак, не введя этот пароль, причем этот пароль можно вводить в двух различных местах — перед входом в учетку свою (там отображаются 4 пустых односимволных поля для ввода, закрываемых звездочками) и при попытке войти в UEFI (в этом случае отображается поле для ввода любого количества символов, тоже закрытых звездочками). Если вводить много раз неправильный пароль в 4 поля, то ввод блокируется сначала на 5 минут, потом на 10, и так до часа. Для перебора не очень подходит. В случае UEFI повторять ввод можно примерно каждые 12 секунд (чуть меньше, на самом деле). Если посчитать максимальное время перебора, получим 33,(3) часа перебора, без учета времени на ввод символов и «ввода». Не смертельно, в принципе. Кажется, Apple есть о чем задуматься в плане безопасности.
Нам, однако, такая халатность в выборе сложности пароля (или задержки между вводами) только на руку.
Отмечу, что при вводе правильного пароля ввод не блокируется вообще, то есть, эти ~12 секунд — не время на проверку пароля, а искусственная задержка. Похоже, что можно влезть куда-то за этой задержкой и перебирать гораздо быстрее. Мы так не делали, но идея интересная.
##### Disclaimer
Всё происходящее в этой статье было законно (ибо производилось со своим маком), направлено на борьбу с мошенниками, контактная информация которых уже ушла куда следует. Использование материалов этой статьи для неправомерных (а равно и правомерных) действий ни при каких обстоятельствах не является ответственностью автора или сайта. Всё, что Вы делаете, Вы делаете на свой страх и риск. Автор или сайт не несут ответственности ни за какой ущерб, прямой или косвенный, причиненный материалами статьи. Короче, кто не спрятался, я не виноват.
##### Как перебирать?
Автор статьи «Брутфорсим EFI с Arduino» предложил замечательный способ подбора пароля — Ардуино прикидывается USB-клавиатурой и последовательно перебирает пароли. Я не буду повторять все тонкости подхода, ссылка на статью выше. Я опишу, что мы решили сделать по-другому и почему
1. Использовать компьютер постоянно. У нас не было дисплея, поэтому писать лог того, что было введено, было не по чему. Поэтому компьютер будет помнить, что вводилось
2. Распознавать изображение на мониторе мака. Нам показалось относительно несложным проверять, не взломан ли мак до сих пор, и вводить пароли только если не взломан. Всё равно компьютер используется.
3. Проверять, что введено именно четыре символа. Это было самым неожиданным изменением для нас. Обнаружилось, что иногда связка компьютер — ардуино — ардуино — мак вводила не все символы. Иногда пропускался ввод, и это было не очень страшно (можно добавить 3-4 ввода после пароля, они не мешают). Но иногда пропускались символы пароля. Почему — загадка. Решили смотреть на картинку и убеждаться, что все символы введены. Если нет — повторять ввод.
4. Перебирать пароли в произвольном порядке. Пароли в статье перебирались от 0000 до 9999, нам это не понравилось. Всего скорее, злоумышленник выбрал пароль, далекий и от 0000, и от 9999, чтобы подбирающий помучался. Поэтому решили сделать рандомизированный перебор. Какую злую шутку это с нами сыграло, читайте дальше.
#### Давайте же к сути!
Перебираем по такой схеме:
1. Компьютер формирует список паролей для перебора
2. Компьютер проверяет, что мак всё еще заблокирован
3. Компьютер отпарвляет очередной пароль ардуине Uno, которая, фактически, используется как USB<->SERIAL переходник и имеет простейшую программу, которая ничего не делает
4. С Uno данные читает Mega по Serial1. Именно поэтому использовали порядок Uno -> Mega, а не наоборот
5. Mega вводит данные в мак, считая себя клавиатурой.
6. Компьютер проверяет, что введено 4 символа на экране. Если нет, пароль помечается как невведенный
7. По той же схеме нажимается ввод
8. Пока поле для ввода пароля не пусто, ничего не делаем
9. Как только поле для ввода опустело, переходим на второй шаг.
##### Передача данных
Данные передавались через USB, становились serial, потом становились нажатиями клавиш. Ничего особенно интересного здесь не было, кроме потрянных символов. Путем отладки определили, что символы теряются на последнем этапе. То есть, символ с клавиатуры уходит, а в маке не регистрируется. Почему, осталось загадкой. Не стали разбираться, просто проверяли, что всё ввелось.
##### Распознавание замка
Пока мак заблокирован, рисуется замочек. Вот такой:
Давайте его искать с помощью OpenCV! Это же такое подходящее использование для микроскопа (на самом деле нет).
На удивление, OpenCV под .NET завелся с полпинка и двух NuGet пакетов (OpenCV.NET, OpenCV). Дальше немного кода.
```
lck = CV.LoadImage("D:\\mac-unlock\\lock.png", LoadImageFlags.Unchanged); //Load lock image file
Capture camera = Capture.CreateCameraCapture(-1); //Create camera object to capture image. Don't care about device index as the notebook has 1 camera device
var img = camera.RetrieveFrame(); //get camera image
IplImage res = new IplImage(new OpenCV.Net.Size(img.Width - tpl.Width + 1, img.Height - tpl.Height + 1), IplDepth.F32, 1); //Create image for matching results
OpenCV.Net.CV.MatchTemplate(img, lck, res, TemplateMatchingMethod.CorrelationCoefficientNormed); //Find lock image in camera image
double min, max;
OpenCV.Net.Point minloc;
OpenCV.Net.Point maxloc;
CV.MinMaxLoc(res, out min, out max, out minloc, out maxloc);
if (max < 0.88) //No lock image on the screen! Wow!
...
```
Этот простой код ищет изображение замка на экране. Находит отлично:
Зеленый прямоугольник — найденный замок. Никаких сложностей этот раздел не вызвал. OpenCV очень удивил и обрадовал.
##### Поле для ввода пароля
Если мы нашли замок на экране, можно поискать под ним поле для ввода пароля. Это делается относительно несложно при помощи обычной манипуляции пикселями изображения. Или делалось бы, если бы не камера. Есть две проблемы. Во-первых, разрешение камеры было 640\*480, что ужасно для анализа. Во-вторых, при непостоянном освещении камера вела себя совершенно непредсказуемо. То что-то засвечивалось, то что-то пропадало. Вторую проблему решили стабильными условиями освещения, первую — привязкой к размерам в пикселях и фильтрами.
Итак, замок есть, можно найти его центр и пойти вниз, пока не встретим два пика яркости.
На рисунке — яркости пикселов под замком.
Найдя два максимума на достаточном расстоянии, можно взять центр между ними и идти влево (считаем, что поле ввода пароля горизонтально). Когда нашли яркий пиксел, либо закончилось поле ввода, либо наткнулись на звездочку.
Поле ввода. Зеленый — рамка замочка. Белый — линия вниз, по которой ищем два максимума. Красный — найденные максимумы и первый яркий пиксел слева по центру.
Теперь, если первый яркий пиксел слева достаточно «слева», то поле ввода пустое. Если достаточно «справа», то введены 4 символа. Калибровка нужна, однако.
Во время калибровки искалось положение яркого пикселя при пустом поле ввода, потом вводились 4 символа, и искалось положение яркого пикселя. Эти значения сохранялись и дальше использовались как эталонные.
На этом заканчивается часть по работе с изображением, да и вообще пора переходить к результатам.
#### Результаты
Замочек не найден! После 33 часов работы пароль был подобран. Несмотря на рандомизацию, правильным оказался пароль под номером 35 с конца. Значением пароля было **2605**. Вероятность этого события составила 0.35%.
#### Литература, оборудование и код
В статье использованы:
Apple Mac Air
Lenovo Thinkpad T510
Arduino Uno (compatible)
Arduino Mega 2560 (compatible)
Литература:
[Брутфорсим EFI с Arduino](http://habrahabr.ru/post/240291/) — отсюда взято всё о работе с Ардуино как с клавиатурой и о принципе блокировки мака. Спасибо автору!
[Оф. сайт Arduino](http://arduino.cc/)
[Оф. сайт OpenCV](http://opencv.org/)
**[Код.](https://onedrive.live.com/redir?resid=9A6D39AA455E9403!1951&authkey=!AC5rNgz73qHslq0&ithint=file%2c7z)** Внимание, код ужасен. Он написан ad hoc и содержит следы экспериментов. Кроме того, он привязан к размерам моей камеры, поэтому может потребоваться модификация.
Вы можете делать с кодом всё, что угодно, если это не запрещено законом. | https://habr.com/ru/post/250347/ | null | ru | null |
# Учебник по Solidity: Все о модификаторах
### Что такое модификатор в Solidity?
В документации Solidity модификаторы определяются следующим образом:
> Модификаторы можно использовать для изменения поведения функций декларативным способом.
>
>
Из этого определения можно понять, что модификатор направлен на изменение поведения функции, к которой он присоединен.
Например, автоматическая проверка условий перед выполнением функции (для этого **модификаторы** в основном и используются).
Модификаторы **уменьшают избыточность кода**. Вы можете повторно использовать один и тот же модификатор в нескольких функциях, если вы проверяете одно и то же условие в смарт-контракте.
Когда использовать модификатор в Solidity?
------------------------------------------
Основное применение модификаторов - **автоматическая проверка условия перед выполнением функции**. Если функция не удовлетворяет требованию модификатора, возникает исключение, и выполнение функции прекращается.
Как создавать и использовать модификаторы?
------------------------------------------
**Модификаторы** могут быть созданы (объявлены) следующим образом:
```
modifier MyModifier {
// здесь код модификатора...
}
```
Вы можете написать модификатор с аргументами или без них. Если модификатор не имеет аргумента, можно опустить круглые скобки ().
```
modifier ModifierWithArguments(uint256 a) {
// ...
}
modifier ModifierWithoutArguments() {
// ...
}
modifier ModifierWithoutArguments {
// ...
}
```
Как работают модификаторы?
--------------------------
Давайте начнем с базовых примеров, приведенных ниже.
```
modifier OnlyOwner {
require(msg.sender == owner);
_;
}
```
### Символ \_;
Символ \_; называется подстановочным знаком. Он объединяет код функции с кодом модификатора*.*
Другими словами, тело функции (к которой присоединен модификатор) будет вставлено туда, где в определении модификатора появляется специальный символ \_;.
Используя термины документации Solidity, этот символ *"возвращает поток выполнения к исходному коду функции".*
Модификатор должен содержать символ \_; в своем теле. Это обязательно*.*
### Куда поместить \_; ?
Вместо \_; будет подставлена функция, поэтому выполнение функции зависит от того места, где вы укажите этот символ: до, посредине или после основного кода модификатора.
```
modifier SomethingBefore {
require(/* сначала проверьте что-нибудь */);
_; // возобновить выполнение функции
}
modifier SomethingAfter {
_; // запускаем сперва функцию
require(/* затем проверяем что-нибудь */)
}
```
Как показано в примере выше, вы можете поместить символ \_; в начало, середину или конец тела модификатора.
На практике наиболее безопасной схемой использования является размещение \_; в конце. В этом сценарии **модификатор** служит для последовательной проверки условий, то есть для того, чтобы сначала проверить условие, а затем продолжить выполнение функции. Приведенный ниже код демонстрирует это на примере:
```
function isOkay() public view returns(bool) {
// выполнить проверку истинности
return true;
}
function isAuthorised(address _user) public view returns(bool) {
// логика проверки авторизации _user
return true;
}
modifier OnlyIfOkAndAuthorised {
require(isOkay());
require(isAuthorised(msg.sender));
_;
}
```
Передача аргументов модификаторам
---------------------------------
Модификаторы также могут принимать аргументы. Как и в случае с функцией, перед именем модификатора нужно передать тип переменной и её имя в круглых скобках.
```
modifier Fee(uint _fee) {
if (msg.value >= _fee) {
_;
}
}
```
Используя приведенный выше пример, вы можете убедиться, что пользователь (или смарт-контракт), вызывающий одну из ваших функций смарт-контракта, отправил несколько eth для оплаты требуемого сбора.
**Давайте проиллюстрируем это на простом примере.**
Вы хотите, чтобы каждый пользователь, желающий забрать свои деньги, хранящиеся в смарт-контракте, *платил минимальную сбор в размере 2,5 % eth в пользу смарт-контракта.*
Модификатор с аргументами может исполнить такое поведение.
```
contract Vault {
modifier fee(uint256 _fee) {
if (msg.value != _fee) {
revert("Вы должны заплатить комиссию, чтобы снять свои эфиры");
} else {
_;
}
}
function deposit(address _user, uint256 _amount) external {
// ...
}
function withdraw(uint256 _amount) external payable fee(0.025 ether) {
// ...
}
}
```
Иной пример: нужно проверить, что функцию может вызывать только определенный адрес.
```
modifier notSpecificAddress (address _user) {
if (_user === msg.sender) throw;
_;
}
function someFunction(address _user) notSpecificAddress("0x......") {
// ...
}
```
Все аргументы вводимые в функцию можно использовать в модификаторе.
Применение нескольких модификаторов к функции.
----------------------------------------------
К одной функции можно применить несколько модификаторов. Это можно сделать следующим образом:
```
contract OwnerContract {
address public owner = msg.sender;
uint256 public creationTime = now;
modifier onlyBy(address _account) {
require(msg.sender == _account, "Отправитель не авторизован.");
_;
}
modifier onlyAfter(uint256 _time) {
require(now >= _time, "Функция вызвана слишком рано");
_;
}
function disown() public onlyBy(owner) onlyAfter(creationTime + 6 weeks) {
delete owner;
}
}
```
Модификаторы будут выполняться в том порядке, в котором они определены, то есть *слева направо.* Так, в приведенном выше примере функция будет проверять следующие условия перед запуском:
1. **onlyBy(...)** : является ли адрес, вызывающий смарт-контракт, владельцем?
2. **onlyAfter(...)** : является ли вызывающий владельцем смарт-контракта более 6 недель?
Переопределение модификаторов
-----------------------------
Как и функции, модификаторы, определенные в одном смарт-контракте, могут быть переопределены другими смарт-контрактами, которые являются производными от него. Как следует из документации Solidity:
* Модификаторы являются наследуемыми свойствами смарт-контрактов и могут быть переопределены производными смарт-контрактами.
Поэтому **символы, введенные в модификатор, не видны в функции** (*поскольку модификатор может измениться, если он будет переопределен в производном смарт-контракте)*.
Модификаторы с перечислениями
-----------------------------
Если ваш смарт-контракт содержит переменную типа **enum**, вы можете проверить значение, которое она содержит, передав один из доступных вариантов в качестве аргумента модификатору.
```
enum State { Created, Locked, Inactive }
State state;
modifier isState(State _expectedState) {
require(state == _expectedState);
_;
}
```
Модификаторы на практике
------------------------
### Только владелец или определенные пользователи
Можно использовать модификатор для проверки того, что функция может быть вызвана и выполнена только по определенному адресу.
```
modifier OnlyBy(address _account) {
require(msg.sender == _account, "отправитель не авторизован");
_;
}
```
### Поддержка нескольких администраторов
Или вместо того чтобы ограничивать вызов функции только одним определенным пользователем, мы можем дать это право запуска функции нескольким заранее определенным пользователям.
```
modifier onlyAdmins {
// функция isUserAdmin проверяет вхождение пользователя
// в список админов
if (!isUserAdmin(msg.sender)) throw;
_;
}
```
### Проверка данных
Еще один отличный вариант использования модификаторов - проверка вводимых данных.
Ниже приведены некоторые примеры, основанные на различных типах данных.
```
modifier throwIfAddressIsInvalid(address _target) {
if (_target == 0x0) throw;
_;
}
modifier throwIfIsEmptyString(string _id) {
if (bytes(_id).length == 0) throw;
_;
}
modifier throwIfEqualToZero(uint _id) {
if (_id == 0) throw;
_;
}
modifier throwIfIsEmptyBytes32(bytes32 _id) {
if (_id == "") throw;
_;
}
```
### Проверка истечения промежутка времени
```
modifier OnlyAfter(uint _time) {
require(now >= _time, "функция вызвана слишком рано!");
_;
}
```
### Возврат случайно отправленного eth
Мир блокчейна не допускает ошибок. Если eth или другие ценности были случайно отправлены не по адресу, то тут нет кого-то, к которому можно обратиться с претензиями, поскольку нет банка или центрального органа, контролирующего транзакции.
Однако вы можете подготовить свой смарт-контракт к непредвиденным ситуациям, сказав ему, что делать, когда пользователи ведут себя странно и шлют в ваши функции eth.
```
modifier refundEtherSentByAccident() {
if(msg.value > 0) throw;
_;
}
```
### Взимать сборы
Ваш смарт-контракт может взимать сборы с пользователей, которые хотят вызвать определенную функцию вашего смарт-контакта.
```
modifier Fee (uint _fee) {
if (msg.value >= _fee) {
_;
}
}
```
### Вернуть сдачу
Мы уже видели, как модификатор может быть использован для возврата eth, отправленных случайно на смарт-контракт. Но как насчет случая, когда пользователь отправляет больше eth, чем следовало бы?
Пример реализации выглядит следующим образом.
```
modifier GiveChangeBack(uint _amount) {
_;
if (msg.value > _amount) {
msg.sender.transfer(msg.value - _amount);
}
}
```
### Переключение между состояниями
Модификатор может быть использован для сложных образцов проектирования. К ним относится образец проектирования - [**Машина состояний.**](https://github.com/fravoll/solidity-patterns/blob/master/docs/state_machine.md)
### Предотвращение повторного вызова
Посмотрите на модификатор [*ReentrancyGuard*](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)из набора OpenZeppelin.
### Запретить смарт-контрактам взаимодействовать со смарт-контрактами
SUSHISWAP приводит отличный пример модификатора, который позволяет только **внешним учетным записям** (т.е. пользователям) требовать вознаграждения по своему смарт-контракту.
В результате это не позволяет другим смарт-контрактам вызывать функцию, к которой прикреплен модификатор.
```
modifier onlyEOA() {
require(msg.sender == tx.origin, "Must use EOA");
_;
}
```
### Проверка типа account’а
Этот модификатор дополняет предыдущий, который проверял, принадлежит ли address человеку или является смарт-контрактом. А этот модификатор проверяет есть ли по адресу код кода, используя опкод *extcodesize(...)* через assembly. Если есть, то это смарт-контракт.
```
modifier onlyHuman {
uint size;
address addr = msg.sender;
assembly { size := extcodesize(addr) }
require(size == 0, "разрешено только людям! (присутствует код по адресу)");
_;
}
```
Заключение
----------
Модификаторы позволяют снизить избыточность кода. При этом при помощи модификаторов можно создавать композицию чистых функций.
Какие самые интересные модификаторы вы писали или находили? Поделитесь в ответах.
Серия статей
------------
1. Учебник по Solidity. Всё о модификаторах
2. [Учебник по Solidity. Все об адресах](https://habr.com/ru/post/572456/) | https://habr.com/ru/post/572004/ | null | ru | null |
# Печатаем Flash в Firefox правильно
С давних времен у Flash-а и Firefox-а существует множество проблем.
Одна из них заключается в том, что [Flash контент не печатается в Firefox](https://bugs.adobe.com/jira/browse/SDK-12871).
[Мы](http://anychart.com) давным давно нашли workaround и выложили его фришной либой.
Прошло три года, а баг все еще существует и фикс все еще актуален.
Итак, представляю вам flash-print-fix. Небольшую библиотеку, которая позволяет добиться нормальной печати Flash содержимого в Firefox:
[code.google.com/p/flash-print-fix](http://code.google.com/p/flash-print-fix/)
#### Проблема
Вот так печатается Flex приложение в Firefox без танцев с бубном:
А вот так при использовании flash-print-fix:
#### Как это работает
Принцип очень простой:
1. Получаем скриншот с swf-ки в png
2. Кодируем png в base64 string
3. Добавляем в страницу картинку с src=«data:img/png;base64,...»
4. Прописываем css-ом скрытие Flash при печати и отображение картинки:
```
@media screen
.flashScreenshot { display: none; }
@media print
.printableFlashObj { display: none; };
.flashScreenshot { display: block; border: 0; outline: none; }
```
#### Как использовать flash-print-fix
* Качаем flash-print-fix: [code.google.com/p/flash-print-fix](http://code.google.com/p/flash-print-fix/)
* Добавляем swc к flex проекту
* Правим html код и добавляем в него js:
```
```
* Добавляем в flex проект инициализацию картинки, когда содержимое готово:
```
FlashPrintFix.initializeApp();
```
Все! Про головную боль при печати можно забыть.
**UPD:**
Лицензия библиотеки изменена с LGPL на MIT | https://habr.com/ru/post/114342/ | null | ru | null |
# Расшифровываем формулу Хабра-рейтинга или восстановление функциональных зависимостей по эмпирическим данным
Если вы когда-нибудь читали раздел [помощь](http://habrahabr.ru/info/help/karma/) на Хабре, то наверняка видели там прелюбопытнейшую строчку:
> Допустим, вы написали публикацию с рейтингом +100 — это добавило к вашему персональному рейтингу величину Х. Через несколько десятков дней этот самый Х вычтется, тем самым вернув вас на прежнее место.
то наверняка задавались вопросом, что это за *Х* и ~~с какого он района~~ чему он равен?
Сегодня мы ответим на этот вопрос.
*(измеряем Хабра-рейтинг в попугаях)*
#### Структура статьи
1. [Аналитический вывод](http://habrahabr.ru/post/249375/#analysis)
* [Основные предположения](http://habrahabr.ru/post/249375/#assumptions)
* [Вывод коэффициентов](http://habrahabr.ru/post/249375/#inference)
* [Финальная формула](http://habrahabr.ru/post/249375/#final_formula)
2. [Регрессия](http://habrahabr.ru/post/249375/#regression)
3. [Исключения](http://habrahabr.ru/post/249375/#exceptions)
4. [Устойчивая регрессия](http://habrahabr.ru/post/249375/#robust_regression)
5. [Скрипт и данные](http://habrahabr.ru/post/249375/#script_and_data)
6. [Почему скрывать функцию бесполезно](http://habrahabr.ru/post/249375/#why_hiding_is_fruitless)
7. [Что с этим можно сделать?](http://habrahabr.ru/post/249375/#what_can_we_do)
8. [Интерпретация формулы](http://habrahabr.ru/post/249375/#interpretation)
#### Аналитический вывод
В данной части, мы рассмотрим основные свойства, которым должна удовлетворять любая функция рейтинга, и, используя наши знания о предметной области, попробуем догадаться до конкретного вида функции.
##### Основные предположения
От чего в принципе зависит рейтинг? Рейтинг любого пользователя формируется при помощи действий других пользователей, а точнее их голосования за карму, топики и комментарии. Других способов воздействовать на показатели пользователей у Хабра-жителей нет. Значит, что наша функция принимает на вход значение кармы (рациональное), голосов по топикам (целое) и комментариям (целое) и возвращает рациональное число.
Более того, нам известно, что карма и голоса за комментарии и топики независимо друг от друга влияют на рейтинг, а значит, что наша тернарная функция распадается на некоторую композицию трех унарных. Предположим, что это некоторая сумма трех функций.
Каким граничным условиям должна удовлетворять **любая** функция рейтинга? Граничные условия — любой новый пользователь имеет рейтинг равный нулю; если пользователь не написал ни одного поста, значит, что вклад постов в рейтинг тоже равен нулю, etc.
Что ещё мы знаем об этих функциях? Они должны быть монотонно возрастающими и простыми для вычисления (то есть как-то просто выражаться через элементарные функции). Рассмотрим самый простой вариант — линейная зависимость по каждому из параметров.
##### Вывод коэффициентов
Используя граничные условия, мы можем легко вывести эти коэффициенты. Рассмотрим случай, когда только карма имеет вклад в рейтинг (т.е., нет постов и комментариев за последние 30 дней).
Подставим альфу равной одной десятой в формулу:
Получив первый коэффициент, мы можем взять другого пользователя, для которого один из неопределенных коэффициентов равен нулю и рассчитать второй коэффициент:
Подставим 4/5 за место беты в формулу:
И последний штрих.
##### Финальная формула
Взяв любого другого пользователя, и подставив все параметры, получим, что гамма равна 1/100.
Тогда, функция рейтинга от кармы *k*, голосов за топики *t* и за комментарии *c* равна
#### Регрессия
Понятно, что формула, выведенная по трем точкам, может быть неверна — есть бесконечное множество функций, проходящих через три точки. Поэтому эту гипотезу стоит проверить. Как? Давайте попробуем получить эти коэффициенты прямо из данных с помощью классической регрессии и сравнить с полученными.
Если наша гипотеза верна, то мы получим модель с коэффициентами сходными с аналитическими (и высокими параметрами уверенности в корректности модели).
Данные по рейтингу и соответствующим параметрам кармы, голосов за посты и комментарии (там много других интересных и вкусных данных по Хабру) доступны здесь:
[github.com/SergeyParamonov/HabraData/blob/master/users\_rating.csv](https://github.com/SergeyParamonov/HabraData/blob/master/users_rating.csv)
Приступим,
```
1478 users regular regression
Call:
lm(formula = rating ~ karma + topic_score + comment_score - 1, data = data)
Coefficients:
Estimate Std. Error t value Pr(>|t|)
karma 0.1017172 0.0006097 166.842 < 2e-16 ***
topic_score 0.7862749 0.0020999 374.428 < 2e-16 ***
comment_score 0.0153159 0.0031884 4.804 1.72e-06 ***
```
Как мы видим, значение коэффициентов по карме и постам фактически совпадает, причем, судя по параметрам, модель довольно уверена в оценке этих двух параметров. Но что же с третьим параметром (вклад комментариев в рейтинг)? И откуда вообще взялась разница в коэффициентах, если известно, что функция должна быть детерминированной?
#### Исключения
Казалось бы, классическая регрессия серьезно противоречит полученной нами формуле — расходится в оценке третьего параметра на 50% и не совпадает идеально по двум другим. Однако известно, что классическая регрессия невероятно неустойчива к статистическим выбросам. Давайте взглянем на них, то есть на набор точек, чьё значение рейтинга существенно отличается от полученной нами аналитической формулы.
```
>data$dif <- abs(rating - karma/10 - topic_score*0.8 - comment_score/100)
>print(data[data$dif > 2, ])
user rating karma topic_score comment_score dif
akrot 80.21 25.00 91 13 4.780
anegrey 60.30 31.50 114 15 34.200
Guderian 56.02 119.00 32 6 18.460
ilusha_sergeevich 154.27 157.75 177 11 3.215
ParyshevD 69.27 42.00 130 7 39.000
PatapSmile 48.75 246.00 0 0 24.150
rw6hrm 38.81 33.00 71 1 21.300
varagian 81.34 170.00 50 34 24.000
```
Тут можно заметить, что автор данной статьи находится в списке. Почему? Потому что имеется статья написанная 30 дней назад, а значит она не попала в выборку данных, но при этом голоса пропадают в течение трех дней. Отсюда возникает разница в рейтинге и показаниях полученной формулы.
Но это верно не для всех точек, например возьмём запись *Guderian*. У него не имеется граничных статей в последние 30 дней. Откуда же разница? Всё очень просто. TM неправильно посчитали ему рейтинг на Хабре, так как его статья переехала на megamozg, и как раз по ней у него есть недостающие голоса по статьям.
Бинго! Мы объяснили откуда берутся неподходящие точки:
* граничные статьи, написанные от 30 до 33 дней назад, с исчезающими голосами;
* переезды и деление Хабра;
* статьи, убранные в черновики или оффтопики (НЛО или автором).
Но всё это звучит, как подгонка под ответ, а не красивая верификация гипотезы, не правда ли? И тут на помощь нам приходит…
#### Устойчивая регрессия
Пусть у нас есть набор точек-выбросов в выборке и он небольшой, ну например до 5%, и достаточная выборка по пользователям (экспериментально хватает 1500 с верхом), то используем методы регрессии, устойчивой к выбросам ([robust regression](http://www.ats.ucla.edu/stat/r/dae/rreg.htm), а вот тут [интересный KDD tutorial](http://www.dbs.ifi.lmu.de/~zimek/publications/KDD2010/kdd10-outlier-tutorial.pdf) по теме).
Попробуем использовать метод прямо из коробки:
```
library("MASS")
...
Call: rlm(formula = rating ~ karma + topic_score + comment_score - 1, data = data)
Coefficients:
Value Std. Error t value
karma 0.10 0.00 23463021.30
topic_score 0.80 0.00 54494665.88
comment_score 0.01 0.00 448681.05
```
Вуаля, коэффициенты найдены и они в точности совпадают с полученными аналитически.
#### Скрипт и данные
Скачать можно [здесь](https://github.com/SergeyParamonov/HabraData/blob/master/regression_users.R) и применить на [этих](https://github.com/SergeyParamonov/HabraData/blob/master/users_rating.csv) данных.
Для тех кому не хочется далеко ходить за скриптом:
**R код регрессии**
```
library("MASS")
data <- read.csv("users.csv", header=T, stringsAsFactors=F)
names(data) <- c("user","rating","karma","topic_score","comment_score")
fit <- lm(data=data, rating ~ karma + topic_score + comment_score - 1)
print("regular regression")
print(summary(fit))
fit <- rlm(data=data, rating ~ karma + topic_score + comment_score - 1)
print("robust regression")
print(summary(fit))
attach(data)
data$dif <- abs(rating - karma/10 - topic_score*0.8 - comment_score/100)
print(data[data$dif > 2, ])
```
#### Почему скрывать функцию бесполезно
Тут конечно же внимательный читатель может сказать: «Ну вот, теперь TM придется придумывать новую тайную функцию подсчета рейтинга», и именно поэтому в этой части мы обсудим почему скрывать функцию рейтинга в принципе бесполезно.
Приведем основные свойства рейтинга:
* рейтинг зависит только от действий других пользователей и каналов для голосования, которых всего три: голоса за посты, комментарии и карму;
* голоса за посты, карму и комментарии независимы друг от друга т.е. функция всегда раскладывается в некоторую композицию трех независимых унарных функций от постов, комментариев и кармы;
* каждая из этих функций должна быть просто и быстро вычислима, так как показатели рейтинга нужно все время пересчитывать для большого числа пользователей;
* по этой же причине, она должна быть выразима в элементарных и монотонно возрастающих функциях;
* функция должна быть детерминированной и без шума, i.e., для двух пользователей с равными показателями кармы, голосов за посты и комментарии рейтинг должен быть одинаковый (за эффективный период = 30 дней).
Всё это позволяет по элементарно собранным данным восстановить эту функцию **автоматически**, используя методы устойчивой регрессии и подбора унарных функций отдельно друг от друга. Введение шума, недетерминированных элементов и вероятностей всего лишь немного усложнит задачу и возможно незначительно повлияет на точность параметров.
Security through obscurity и здесь не работает.
#### Что с этим можно сделать?
Когда я писал [Хабра-монитор](http://www.habr-analytics.com/monitor) (это часть [Хабра-аналитики](http://www.habr-analytics.com/), если вы пишите на Хабр, то возможно ресурс будет вам полезен), который отображает изменение параметров статьи во времени, первое, что хотелось прикрутить — это изменение голосов во времени. По ряду причин этот параметр недоступен для просмотра перед голосованием за пост. Имея аналитическую функцию для рейтинга пользователя, можно всегда вывести рейтинг его текущей статьи (при условии, что она одна и у него нет статей, по которым голоса «пропадают» в данный момент).
Фактически, имея данную функцию можно к монитору (картинка ниже) прикрутить параметр *рейтинг статьи*.
Еще это позволит [СоХабру](http://sohabr.net) прикрутить рейтинг статей.
#### Интерпретация формулы
Голоса за комментарии практически не имеют вклада в рейтинг, даже [самые](http://habrastats.comyr.com/za_vse_vremya_luchshie_vse.html) рейтинговые комментарии за всю историю Хабра (~400+) прибавляют к рейтингу 4-5 очков, то есть столько же сколько статья набравшая 6-7 плюсов.
Карма потеряла свой вес по отношению к рейтингу, ранее у неё был коэффициент 0.5, а сейчас 0.1, что делает топ гораздо более динамичным (ранее войти в топ-10 было практически нереально).
Каждые 5 голосов за статью приносят 4 очка к рейтингу, то есть умножив на 0.8 голоса статьи, получим прибавку к рейтингу. На данный момент, это самый существенный и фактически единственный определяющий рейтинг пользователя фактор.
И ещё, *Х = 80*.
P.S. утверждение ([отсюда](http://habrahabr.ru/info/help/karma/#rating))
> [...] со временем рейтинг примет значение половины кармы.
уже неверно. | https://habr.com/ru/post/249375/ | null | ru | null |
# «Каких Марин?» или управляем контроллером через bluetooth с помощью мобильного приложения на Xamarin (Android)
В прошлой [статье](https://habr.com/ru/post/497324/) я пообещал рассказать, о том как подключать CANNY 3 tiny с помощью UART к bluetooth. И поскольку на этих майских особо не разгуляешься, было принято решение провести время с пользой и таки сдержать обещание. Но просто подключить контроллер к Bluetooth адаптеру HC-06, было бы слишком просто для Хабра.
Поэтому мы не просто всё подключим, но еще и напишем для нашей схемы примитивнейшее приложение для Android используя C# и Xamarin.
Если вы любите мониторить «концевики» и герконы, так как это люблю я, милости прошу под кат.
Вот о чем пойдет речь сегодня:
[Часть I: Введение](#I)
[Часть II: Подключение схемы и программа для CANNY 3 tiny](#II)
[Часть III: Пишем приложение на Xamarin для Android](#III)
[Часть IV: Заключение](#IV)
Часть I: Введение
------------------
Начну с хорошего, если не считать вставок программного кода на C#, то в этот раз статья будет сравнительно небольшая, потому что основные приемы работы с контроллером мы разобрали раньше. Чтобы не повторяться лишний раз, вот список статей, в которых мы уже разбирали основные приёмы работы с контроллером CANNY:
1. [«Раз, два, три – ёлочка гори!» или мой первый взгляд на контроллер CANNY 3 tiny](https://habr.com/ru/post/482948/) — в этой статье мы разбирали что из себя представляет контроллер, а также азы работы в среде разработки CannyLab.
2. [«У Предназначения масса обличий...» или автоматизируем управление автолампой с помощью CANNY 3 tiny и фоторезистора](https://habr.com/ru/post/489764/) — в этой статье мы разбирали работу с USB Virtual COM-port, подключение датчиков к АЦП, а также высокочастотный ШИМ на выходах контроллера.
3. [«Как зеницу ока...» или делаем простенькую охранную систему на базе микроконтроллера (CANNY или Arduino) и Raspberry PI](https://habr.com/ru/post/497324/) — в этой статье мы разбирали работу с UART, а также повторили ранее пройденное.
При подготовке данной статьи я использовал следующее железо: контроллер CANNY 3 tiny, bluetooth адаптер HC-06, концевой выключатель (концевик Trema-модуль), геркон, старые проводные наушники, макетную плату, провода, «крокодилы».
Мы будем собирать систему, которая с помощью мобильного приложения мониторит состояние двух датчиков и при необходимости может в ручном режиме подавать звуковой сигнал.
Все что будет изложено в данной статье, выдумано чисто в учебно-демонстрационных целях. Я просто хотел показать, некоторые приемы работы с контроллером, а также, чтобы купленные в свое время железки хоть как-то отработали свою стоимость.
Несмотря на далекий от реальности характер решаемой задачи мы представим, что делаем систему мониторинга за раздвижной дверью купе. Когда она начнет движение, сработает геркон, а в конце пути даст сигнал концевик. Если нам надо будет привлечь внимание, например, чтобы дверь обратно закрыли, мы подадим «писклявый» сигнал через динамик. Правда динамика у меня нет, но зато есть старые наушники.
*Ну и, как всегда, примечание. Настоятельно не рекомендую использовать, материалы данной статьи, как истину в последней инстанции. Многие вещи я сам делал в первый раз, их наверняка можно сделать лучше.*
Часть II: Подключение схемы и программа для CANNY 3 tiny
--------------------------------------------------------
Для начала, чтобы никого в авторских правах не обидеть уточню, что идею подключить контроллер к HC-06, по управлять им через приложение «Serial bluetooth terminal» и некоторые приемы при разработке диаграммы, я позаимствовал с [форума](https://forum.canny.ru/viewtopic.php?pid=8533), но само собой я их адаптировал под свою задачу.
Схема подключения выглядит следующим образом:
Концевик и геркон подключены к выводам контроллера №6 и №5, наушники к выводу №4 (у него есть ВЧ ШИМ), UART RX – это вывод № 1, UART TX – вывод № 2, вывод № 3 используется для подачи «+5В», вывод «-» — для связи с «землей».
Вот как это выглядит в сборе:
Диаграмму (программу) для СANNY 3 tiny я разрабатывал в CannyLab версии 1.42, возможно в других версиях среды разработки и с другими контроллерами, надо будет внести изменения в диаграмму.
Вот, что получилось:
Блоки связанные с настройкой контроллера и отправкой сообщения по UART, разбирали в [прошлой статье](https://habr.com/ru/post/497324/#II).
Разберём подробней два оставшихся.
Блок «**Получение сообщения по UART»**, отвечает за включение сирены(наушников). В принципе он нужен, чтобы разобрать пример, получения сообщения по UART.
Вначале мы проверяем есть ли полученные данные в UART, если есть, то подаем на вход «Е» D-триггера единицу, в таком случае триггер копирует значение со входа “D” в который мы запишем первые два символа из сообщения пришедшего по UART. Я не хотел всё усложнять поэтому дальше мы используем простую схему. Предполагаем, что по UART к нам придет любое число от 00 до 99, переводим это число из символьной формы в числовую (рекомендую почитать как [работает блок конвертера](https://wiki.canny.ru/index.php/%D0%9A%D0%BE%D0%BD%D0%B2%D0%B5%D1%80%D1%82%D0%B5%D1%80_%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8_%D1%81%D0%B8%D0%BC%D0%B2%D0%BE%D0%BB%D0%BE%D0%B2_%D0%B2_%D1%87%D0%B8%D1%81%D0%BB%D0%BE) у меня с ним был небольшой «затык»). Дальше любое значение ">0" на входе детектора переднего фронта вызывает единичный сигнал, который включит на 5 секунд выход №4, работающий в режиме ВЧ ШИМ.
Вы можете в настройках поиграться с периодом заполнения ВЧ ШИМ, от этого будет зависеть, звук в наушниках.
Перейдем к блоку **«Формирование сообщения»**. Его реализация на первый взгляд может показаться необычной. Объясняется это тем, что я толком не разобрался как работать с программой Serial bluetooth terminal и с аналогичным bluetooth протоколом в Xamarin.
Забегу немножко вперёд и скажу, что я так и не научился гарантированно получать на смартфоне отправленное с контроллера сообщение. Если с проводным UART в прошлой статье все было очевидно, то с Bluetooth на практике вместо отправленного сообщения может прочитаться только его часть и смысл передаваемой команды нарушиться.
Я решил, что самое простое решение — это передавать одно число, которое гарантированно дойдет до адресата без потерь.
В нашем случае мы мониторим дискретное состояние геркона и концевика. То есть у нас всего 4 возможные комбинации: геркон и концевик выключены, включен только кто-то один, оба включены.
Поскольку геркон и концевик дают дискретный сигнал (0/1) нужно как-то их различить. Для этого умножим значение сигнала геркона на 2. Теперь получается, что сумма сигналов даст нам значения от 0 до 3.
Теперь разберем не очевидный вариант с прибавлением к этому значению пятидесяти. Дело в том, что CannyLab передает в UART пару символов, то есть вместо 3 допустим 03, но как я говорил есть риск потери части информации. Например, из значения 01, программа на смартфоне может прочитать только первый «0», а это уже будет ошибка.
Можно было бы заморочиться и преобразовать данные, заменив, например символ «D1» регистра какой-нибудь буквой или пробелом, но я решил сделать проще. Я превратил значение 01 в 51 (02 в 52 и т.д.). Пятерка не несет сигнала и я ее вырезаю на уровне программы для смартфона. Таким образом, у нас всегда гарантированно остается полезная часть сообщения.
Загружаем программу в контроллер, нажимаем «запустить», если все работает как задумано, то HC-06 начнет периодически мигать красным светодиодом.
Далее сопрягаем смартфон с адаптером. Теперь можно проверить работоспособность в приложении «Serial Bluetooth terminal» или любом другом с похожим функционалом.
Запишите адрес Bluetooth адаптера, он нам пригодится в следующей главе.
Как видите данные приходят, в зависимости от состояния датчиков, а если отправить «11», то в наушниках послышится противный писк. Можно было бы на этом и остановиться, но давайте набросаем примитивное приложение.
Программу для контроллера и исходный код программы для смартфона можно скачать с [GitHub](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/5.Canny/6.Canny-Xanarin_Bluetooth_Android)
Хотелось бы отметить, что вам не обязательно реализовывать всё в железе именно на контроллерах CANNY, вы вполне можете написать программу для Arduino или другого любимого вами контроллера. Изначально я и сам планировал написать дополнительно еще и версию скетча для Arduino, но поскольку убил почти все майские праздники, на подключение CANNY и приложение для смартфона у меня уже просто не осталось сил.
Часть III: Пишем приложение на Xamarin для Android
--------------------------------------------------
Я знаю, что Xamarin скажем мягко – не самое популярное решение для мобильной разработки. И возможно у вас уже возник вопрос: **«Почему я его выбрал?»**. Ответить на него мне бы хотелось словами из одноименной песни Псоя Короленко:
Честно, нет никаких объективных причин. Просто пару лет назад я учил азы C# и все хотел посмотреть, что такое Xamarin. И теперь из-за «самоизоляции» наконец-то дошли руки.
Ну и еще раз напомню. Я первый раз встречаюсь с Xamarin и это мое первое приложение для Android. Не стоит слепо копировать мой кривой код, если вдруг вы сможете найти более красивое решение, воспользуйтесь им.
При разработке своей программы я опирался на [этот материал](http://alejandroruizvarela.blogspot.com/2014/01/bluetooth-arduino-xamarinandroid.html). Статья не особо разжевана, да еще и на испанском, поэтому я всё-таки счел уместным поделиться с вами своей вариацией на эту тему.
Я собирал программу в Visual studio 2019 community edition.
Первым делом создадим новый пустой проект для Android (Xamarin), как на картинке.
Я вносил изменения только в три файла, целиком их можно просмотреть на [GitHub](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/5.Canny/6.Canny-Xanarin_Bluetooth_Android), а тут разберем только важные части:
**AndroidManifest.xml**
В стандартный шаблон добавлены 2 разрешения:
```
```
**activity\_main.xml**
Был убран контейнер по умолчанию (RelativeLayout). Вместо него был добавлен, контейнер LinearLayout просто потому, что он проще. В данном контейнере все элементы выравниваются по вертикали, растягиваясь на всю ширину экрана.
```
```
Любому человеку немного знакомому с HTML вёрсткой или XML не составит труда разобраться со структурой пользовательского интерфейса. У нас есть три доступных только для чтения текстовых поля (TextView), один переключатель(Switch), который работает по сути как чекбокс и одна самая обычная кнопка(Button). Элементы можно разместить на форме путем перетаскивания из конструктора, а в окне свойств или в коде задать им более удобные Id, текстовые заглушки и другие параметры.
Осталось описать логику программы.
**MainActivity.cs**
Ниже под спойлером код целиком для удобства
**Полный код MainActivity.cs**
```
// based on http://alejandroruizvarela.blogspot.com/2014/01/bluetooth-arduino-xamarinandroid.html
// for this article https://habr.com/ru/post/500454/
// based on http://alejandroruizvarela.blogspot.com/2014/01/bluetooth-arduino-xamarinandroid.html
// for this article https://habr.com/ru/post/500454/
using Android.App;
using Android.OS;
using Android.Support.V7.App;
using Android.Runtime;
using Android.Widget;
using System.Linq;
using System;
using System.IO;
using Java.Util;
using Android.Bluetooth;
using System.Threading.Tasks;
namespace _6.Canny_Xanarin_Bluetooth_Android
{
[Activity(Label = "Control Canny 3 tiny via bluetooth", Theme = "@style/AppTheme", MainLauncher = true)]
public class MainActivity : AppCompatActivity
{
Button startSiren;
TextView rSwitch;
TextView EndSensor;
Switch bltSwitch;
TextView status;
private Java.Lang.String dataToSend;
private BluetoothAdapter mBluetoothAdapter = null;
private BluetoothSocket btSocket = null;
private Stream outStream = null;
// don't forget change addres to your device:
private static string address = "98:D3:91:F9:6C:F6";
// MY_UUID can be saved as is
private static UUID MY_UUID = UUID.FromString("00001101-0000-1000-8000-00805F9B34FB");
private Stream inStream = null;
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.activity_main);
startSiren = FindViewById(Resource.Id.startSiren);
rSwitch = FindViewById(Resource.Id.rSwitch);
EndSensor = FindViewById(Resource.Id.EndSensor);
status = FindViewById(Resource.Id.status);
bltSwitch = FindViewById(Resource.Id.bltSwitch);
startSiren.Click += startSiren\_ClickOnButtonClicked;
bltSwitch.CheckedChange += bltSwitch\_HandleCheckedChange;
CheckBt();
}
private void CheckBt()
{
mBluetoothAdapter = BluetoothAdapter.DefaultAdapter;
if (!mBluetoothAdapter.Enable())
{
Toast.MakeText(this, "Bluetooth Off",
ToastLength.Short).Show();
}
if (mBluetoothAdapter == null)
{
Toast.MakeText(this,
"Bluetooth does not exist or is busy", ToastLength.Short)
.Show();
}
}
void startSiren\_ClickOnButtonClicked(object sender, EventArgs e)
{
if (bltSwitch.Checked)
{
try
{
dataToSend = new Java.Lang.String("11");
writeData(dataToSend);
System.Console.WriteLine("Send signal to siren");
}
catch (System.Exception execept)
{
System.Console.WriteLine("Error when send data" + execept.Message);
}
}
else status.Text = "bluetooth not connected";
}
void bltSwitch\_HandleCheckedChange(object sender, CompoundButton.CheckedChangeEventArgs e)
{
if (e.IsChecked)
{
Connect();
}
else
{
status.Text = "bluetooth not connected";
if (btSocket.IsConnected)
{
try
{
btSocket.Close();
System.Console.WriteLine("Connection closed");
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
public void Connect()
{
BluetoothDevice device = mBluetoothAdapter.GetRemoteDevice(address);
System.Console.WriteLine("Connection in progress" + device);
mBluetoothAdapter.CancelDiscovery();
try
{
btSocket = device.CreateRfcommSocketToServiceRecord(MY\_UUID);
btSocket.Connect();
System.Console.WriteLine("Correct Connection");
status.Text = "Correct Connection to bluetooth";
}
catch (System.Exception e)
{
Console.WriteLine(e.Message);
try
{
btSocket.Close();
System.Console.WriteLine("Connection closed");
}
catch (System.Exception)
{
System.Console.WriteLine("Impossible to connect");
status.Text = "Impossible to connect";
}
System.Console.WriteLine("Socket Created");
}
beginListenForData();
}
public void beginListenForData()
{
try
{
inStream = btSocket.InputStream;
}
catch (System.IO.IOException ex)
{
Console.WriteLine(ex.Message);
}
Task.Factory.StartNew(() => {
byte[] buffer = new byte[1024];
int bytes;
while (true)
{
try
{
bytes = inStream.Read(buffer, 0, 1024);
System.Console.WriteLine("bytes " + bytes.ToString());
if (bytes > 0)
{
RunOnUiThread(() => {
string valor = System.Text.Encoding.ASCII.GetString(buffer).Replace("5",String.Empty);
// transform string for deleate all symbols except 1-4(command from canny).
string command = new string(valor.Where(char.IsDigit).ToArray());
if (command.Length > 0)
{
status.Text="data successfully readed";
System.Console.WriteLine("command " + command);
switch (Int32.Parse(command))
{
case 0:
rSwitch.Text = "reed switch - disconnected ";
EndSensor.Text = "end sensor - not pressed ";
break;
case 1:
rSwitch.Text = "reed switch - disconnected ";
EndSensor.Text = "end sensor - pressed ";
break;
case 2:
rSwitch.Text = "reed switch - connected ";
EndSensor.Text = "end sensor - not pressed ";
break;
case 3:
rSwitch.Text = "reed switch - connected ";
EndSensor.Text = "end sensor - pressed ";
break;
}
}
});
}
}
catch (Java.IO.IOException)
{
RunOnUiThread(() => {
EndSensor.Text = "End sensor status - undefined";
rSwitch.Text = "Reed switch status - undefined ";
});
break;
}
}
});
}
private void writeData(Java.Lang.String data)
{
try
{
outStream = btSocket.OutputStream;
}
catch (System.Exception e)
{
System.Console.WriteLine("Error with OutputStream when write to Serial port" + e.Message);
}
Java.Lang.String message = data;
byte[] msgBuffer = message.GetBytes();
try
{
outStream.Write(msgBuffer, 0, msgBuffer.Length);
System.Console.WriteLine("Message sent");
}
catch (System.Exception e)
{
System.Console.WriteLine("Error with when write message to Serial port" + e.Message);
status.Text = "Error with when write message to Serial port";
}
}
public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Android.Content.PM.Permission[] grantResults)
{
Xamarin.Essentials.Platform.OnRequestPermissionsResult(requestCode, permissions, grantResults);
base.OnRequestPermissionsResult(requestCode, permissions, grantResults);
}
}
}
```
Теперь по частям.
Блоки с подключением пространств имен, объявлением класса и т.п. я пропущу.
Создаём переменные с которыми позже свяжем элементы пользовательского интерфейса:
```
Button startSiren;
TextView rSwitch;
TextView EndSensor;
Switch bltSwitch;
TextView status;
```
Дальше идет, код из примера на который я опирался. Переменные (поля) необходимые для работы тех или иных методов.
```
private Java.Lang.String dataToSend;
private BluetoothAdapter mBluetoothAdapter = null;
private BluetoothSocket btSocket = null;
private Stream outStream = null;
// don't forget change addres to your device:
private static string address = "98:D3:91:F9:6C:F6";
// MY_UUID can be saved as is
private static UUID MY_UUID = UUID.FromString("00001101-0000-1000-8000-00805F9B34FB");
private Stream inStream = null;
```
Нам здесь важно вбить адрес вашего модуля HC-06 в поле address.
Поскольку это мой первый опыт разработки для смартфонов в том числе работы с Xamarin, я решил ничего не усложнять поэтому адрес устройства, как и в исходном примере, жестко зафиксирован. Если хотите вы можете посмотреть [эту статью](https://acaliaro.wordpress.com/2017/02/07/connect-a-barcode-reader-to-a-xamarin-forms-app-via-bluetooth/), там похоже реализован перебор доступных Bluetooth устройств.
Идем дальше.
```
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.activity_main);
startSiren = FindViewById(Resource.Id.startSiren);
rSwitch = FindViewById(Resource.Id.rSwitch);
EndSensor = FindViewById(Resource.Id.EndSensor);
status = FindViewById(Resource.Id.status);
bltSwitch = FindViewById(Resource.Id.bltSwitch);
startSiren.Click += startSiren\_ClickOnButtonClicked;
bltSwitch.CheckedChange += bltSwitch\_HandleCheckedChange;
CheckBt();
}
```
Этот метод создается автоматически, наша задача связать в нем объекты UI с полями класса, а также привязать обработчики для реакций на события (`startSiren.Click и bltSwitch.CheckedChange`).
Проверяем подключение по Bluetooth:
```
private void CheckBt()
{
mBluetoothAdapter = BluetoothAdapter.DefaultAdapter;
if (!mBluetoothAdapter.Enable())
{
Toast.MakeText(this, "Bluetooth Off",
ToastLength.Short).Show();
}
if (mBluetoothAdapter == null)
{
Toast.MakeText(this,
"Bluetooth does not exist or is busy", ToastLength.Short)
.Show();
}
}
```
Включение сирены. По сути просто отправка символов «11» в контроллер:
```
void startSiren_ClickOnButtonClicked(object sender, EventArgs e)
{
if (bltSwitch.Checked)
{
try
{
dataToSend = new Java.Lang.String("11");
writeData(dataToSend);
System.Console.WriteLine("Send signal to siren");
}
catch (System.Exception execept)
{
System.Console.WriteLine("Error when send data" + execept.Message);
}
}
else status.Text = "bluetooth not connected";
}
```
Проверка состояния переключателя (если смещен в право значит включён):
```
void bltSwitch_HandleCheckedChange(object sender, CompoundButton.CheckedChangeEventArgs e)
{
if (e.IsChecked)
{
Connect();
}
else
{
if (btSocket.IsConnected)
{
try
{
btSocket.Close();
System.Console.WriteLine("Connection closed");
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
```
При включении начинаем соединение с Bluetooth.
Реализация непосредственно подключения:
```
public void Connect()
{
BluetoothDevice device = mBluetoothAdapter.GetRemoteDevice(address);
System.Console.WriteLine("Connection in progress" + device);
mBluetoothAdapter.CancelDiscovery();
try
{
btSocket = device.CreateRfcommSocketToServiceRecord(MY_UUID);
btSocket.Connect();
System.Console.WriteLine("Correct Connection");
status.Text = "Correct Connection to bluetooth";
}
catch (System.Exception e)
{
Console.WriteLine(e.Message);
try
{
btSocket.Close();
System.Console.WriteLine("Connection closed");
}
catch (System.Exception)
{
System.Console.WriteLine("Impossible to connect");
status.Text = "Impossible to connect";
}
System.Console.WriteLine("Socket Created");
}
beginListenForData();
}
```
А вот один из самых важных методов — непосредственно считывание данных:
```
public void beginListenForData()
{
try
{
inStream = btSocket.InputStream;
}
catch (System.IO.IOException ex)
{
Console.WriteLine(ex.Message);
}
Task.Factory.StartNew(() => {
byte[] buffer = new byte[1024];
int bytes;
while (true)
{
try
{
bytes = inStream.Read(buffer, 0, 1024);
System.Console.WriteLine("bytes " + bytes.ToString());
if (bytes > 0)
{
RunOnUiThread(() => {
string valor = System.Text.Encoding.ASCII.GetString(buffer).Replace("5",String.Empty);
// transform string for deleate all symbols except 1-4(command from canny).
string command = new string(valor.Where(char.IsDigit).ToArray());
if (command.Length > 0)
{
status.Text="data successfully readed";
System.Console.WriteLine("command " + command);
switch (Int32.Parse(command))
{
case 0:
rSwitch.Text = "reed switch - disconnected ";
EndSensor.Text = "end sensor - not pressed ";
break;
case 1:
rSwitch.Text = "reed switch - disconnected ";
EndSensor.Text = "end sensor - pressed ";
break;
case 2:
rSwitch.Text = "reed switch - connected ";
EndSensor.Text = "end sensor - not pressed ";
break;
case 3:
rSwitch.Text = "reed switch - connected ";
EndSensor.Text = "end sensor - pressed ";
break;
}
}
});
}
}
catch (Java.IO.IOException)
{
RunOnUiThread(() => {
EndSensor.Text = "End sensor status - undefined";
rSwitch.Text = "Reed switch status - undefined ";
});
break;
}
}
});
}
```
Многие элементы метода я оставил как в примере, как я понимаю вначале создается соединение с потоком данных, если в буфере с прочитанными данными, что-то есть то оно считывается в переменную `valor`. При этом как я и обещал, цифру «5» мы просто удалим.
Дальше мы убираем из считанного сообщения все символы кроме цифр `string command = new string(valor.Where(char.IsDigit).ToArray());`
Ну а после уже все просто в зависимости от того какое число нам пришло, выводим тот или иной статус в UI.
Эти два метода я кардинально не менял:
```
private void writeData(Java.Lang.String data)
{
try
{
outStream = btSocket.OutputStream;
}
catch (System.Exception e)
{
System.Console.WriteLine("Error with OutputStream when write to Serial port" + e.Message);
}
Java.Lang.String message = data;
byte[] msgBuffer = message.GetBytes();
try
{
outStream.Write(msgBuffer, 0, msgBuffer.Length);
System.Console.WriteLine("Message sent");
}
catch (System.Exception e)
{
System.Console.WriteLine("Error with when write message to Serial port" + e.Message);
status.Text = "Error with when write message to Serial port";
}
}
public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Android.Content.PM.Permission[] grantResults)
{
Xamarin.Essentials.Platform.OnRequestPermissionsResult(requestCode, permissions, grantResults);
base.OnRequestPermissionsResult(requestCode, permissions, grantResults);
}
}
}
```
Как я понимаю в данном блоке кода реализованы отправка сообщения и обработчик события на зарос разрешения доступа к Bluetooth.
Ну вот и все осталось настроить [подключение смартфона](https://docs.microsoft.com/ru-ru/xamarin/android/get-started/installation/set-up-device-for-development) для [отладки приложения](https://docs.microsoft.com/ru-ru/xamarin/android/deploy-test/debugging/debug-on-device?tabs=windows).
Как ни странно, но все работает:
Часть IV: Заключение
---------------------
Вот как работа программы выглядит в натуре:
Вот таким был мой первый опыт разработки приложений для смартфона на Android.
Хотелось бы отметить, что VS 2019 и Xamarin на моем стареньком компьютере работают очень медленно.
При первой сборке проекта, я реально успел съесть еще этих мягких французских булок да выпить чаю. Также само приложение получилось откровенно убогое, переключатель «вкл/выкл» работает очень не удобно, но с другой стороны учитывая, что я лишь немного знаком с базовыми приёмами разработки для .NET, а также то, что я вообще не программист, я смог даже не проходя целиком ни одного туториала и ни одного урока, за день набросать свое первое приложение. Поэтому порог вхождения для создания элементарного приложения получается достаточно низкий.
Я так понимаю, контроллеры CANNY можно использовать при тюнинге автомобилей, особенно отечественных так, что вполне можно сделать какую-нибудь «фичу» и написать к ней приложение для смартфона. Главное помнить, что при питании от бортовой сети автомобиля на выходах контроллера будет тоже напряжение что и на входе (например, 12 В вместо 5 В). Не забудьте защитить Bluetooth адаптер, чтобы он ненароком не вышел из строя.
Статья оказалась для меня очень трудоёмкой, надеюсь, что все было не зря и она вам понравиться. | https://habr.com/ru/post/500454/ | null | ru | null |
# Сжатие без потерь — главная концепция в нашей жизни
[](https://habr.com/ru/company/ruvds/blog/712652/)
Бывало так, что из долгой поездки вы помните только несколько моментов? А все отпуска за много лет сливаются в единое целое? А из школьного класса помните фамилии только нескольких человек? Это вовсе не потеря памяти, как может показаться. Наоборот, это признак крайне развитого интеллекта, который научился эффективно сжимать данные.
На самом деле воспоминания из памяти можно вытянуть (разархивировать) через регрессивный гипноз. Просто в данный момент они не нужны, поэтому хранятся в сжатом виде ~~на ленточных накопителях~~ в дальних уголках памяти.
Все мы знаем и используем компьютерные архиваторы: ZIP, RAR, Brotli и т. д. Но мало кто видит в них модель интеллекта. Это даже как-то странно на первый взгляд. Хотя если подумать, то идеальное сжатие — это синоним *понимания*.
Если взглянуть на теорию сжатия информации, а также на растущую сложность алгоритмов, которые переходят на нейросети, то на наших глазах как будто появилось и развивается некое живое существо. Можно пофантазировать, что когда-нибудь его сложность станет настолько выше нашего понимания, что любую информацию в мире оно сможет сжать до цифры «42».
Если без шуток, все алгоритмы сжатия делятся на две большие категории: сжатие с потерями и без потерь. Первая категория часто используется для сжатия фото, видео и звука, то есть аналоговых нейронных сигналов (зрение, слух), вторая — для цифровых. Сжатие без потерь используется в архивации данных и резервном копировании. Во многом полагается на поиск дубликатов в массиве цифровой информации.
Первым в мире архиватором можно считать код Морзе (1838), который для кодирования более частых букв в английском языке (e, t) использует более короткие коды.
[История компьютерных алгоритмов сжатия без потерь](https://ethw.org/History_of_Lossless_Data_Compression_Algorithms) берёт начало в 1949 году, когда Клод Шеннон и Роберт Фано изобрели алгоритм Шеннона — Фано, в котором коды символов в блоке основаны на вероятности появления символа. Вероятность появления символа обратно пропорциональна длине кода, что приводит к более короткому способу представления данных.
Через два года пришла очередь студента Дэвида Хаффмана, который учился в группе у Роберта Фано в MIT и подготовил курсовую работу, где описал самый эффективный на то время метод бинарного кодирования, ныне известный как [код Хаффмана](https://en.wikipedia.org/wiki/Huffman_coding) (изображён на КДПВ), похожий на код его преподавателя.
▍ Эпоха LZ77
------------
В конце 1970-х компьютеры стали более популярными и появился первый софт для сжатия резервных копий. Сначала он использовал коды Хаффмана, а в 1977 году был изобретён революционный [алгоритм Лемпеля — Зива — Уэлча](https://en.wikipedia.org/wiki/Lempel%E2%80%93Ziv%E2%80%93Welch) (LZ77) — первый алгоритм с использованием словарей. В частности, там изначально использовался динамический словарь (также известен как скользящее окно), который идеально подходит для поиска повторяющихся последовательностей битов.
*Иерархия алгоритмов сжатия без потерь общего назначения с 1977 по 2011 годы*
LZ77 определил разработку архиваторов на десятилетия, с дальнейшими техническими усовершенствованиями и множеством ответвлений, изображённых на диаграмме вверху. Использование LZ78 (со статическим словарём) было затруднено из-за появления в 1984 году производного алгоритма LZW, который удалось запатентовать с требованием лицензионных отчислений. После этого владелец патента начал подавать в суд на других разработчиков и даже конечных пользователей [за использование формата GIF без лицензии](https://www.theregister.com/1999/09/01/unisys_demands_5k_licence_fee).
С распространением интернета в 80-90-е годы производные алгоритмы LZ77 легли в основу новых форматов сжатия файлов: ZIP (1989), GIF (1987), PNG (1994), RAR (комбинация [PPM](https://ethw.org/History_of_Lossless_Data_Compression_Algorithms#PPM) и LZSS, 1993) и др. Первым массовым архиватором стал опенсорсный ARC в 1985 году и PKARC (ZIP) в 1989 году. Затем производные LZ77 начали использоваться буквально везде, включая HTTP и SSL.
▍ Новые алгоритмы. Нейросети. Сжатие на GPU
-------------------------------------------
С одной стороны, большинство современных архиваторов используют базовые техники, но внедряются и принципиально новые подходы. В начале 2000-х получил популярность алгоритм [PAQ](https://en.wikipedia.org/wiki/PAQ), основанный на смешивании контекста (context mixing, CM, о нём ниже), а в 2019 году известный программист Фабрис Беллар представил уникальный архиватор [NNCP](https://bellard.org/nncp/), спроектированный на нейросетевой архитектуре [трансформер](https://en.wikipedia.org/wiki/Transformer_(machine_learning_model)) (в 2021 году вышла вторая версия). Основные принципы описаны в научных статьях [2019](https://bellard.org/nncp/nncp.pdf) и [2021](https://bellard.org/nncp/nncp_v2.1.pdf) гг. Последняя версия 3.1 — и она уже вышла на первое место в мире по коэффициенту сжатия стандартного массива текстов Large Text Compression Benchmark (109 байт англоязычной Википедии). С этого началось использование нейросетей в сжатии данных.
[Текущие лидеры](http://mattmahoney.net/dc/text.html) Large Text Compression Benchmark (всего 122 участника):
| Программа | Результат сжатия enwik9 (байт) | Размер разархиватора (zip) | Общий размер (enwik9+программа) | Время (нс/байт) | Алгоритм |
| --- | --- | --- | --- | --- | --- |
| | | | | арх. | разарх. | |
| nncp 3.1 | 108 378 032 | 201 620 | 108 579 652 | 212 766 | 210 970 | Tr |
| cmix 19 | 111 470 932 | 223 485 | 111 694 417 | 605 110 | 601 825 | CM |
| tensorflow-compress 4 | 113 542 413 | 55 283 | 113 597 696 | 291 394 | 290 803 | LSTM |
| cmix-hp (10.06.2021) | 113 712 798 | 0 | 113 712 798 | 189 420 | 194 280 | CM |
| starlit (31.05.2021 | 114 951 433 | 0 | 114 951 433 | 173 953 | 171 682 | CM |
В пятёрку лидеров вошли [nncp](https://bellard.org/nncp/), [cmix](http://www.byronknoll.com/cmix.html), [tensorflow-compress](https://github.com/byronknoll/tensorflow-compress), [cmix-hp](https://github.com/byronknoll/cmix-hp) и [starlit](https://github.com/amargaritov/starlit). Большинство участников топ-20 используют алгоритм смешивания контекста (CM), хотя у отдельных разработок вроде NNCP уникальные алгоритмы сжатия. Видны множественные эксперименты с нейросетями. Описание всех программ и алгоритмов см. [здесь](http://www.mattmahoney.net/dc/index.html).
CMIX и многие другие архиваторы 2002–2019 годов используют смешивание контекста с предварительной обработкой по словарю — в своё время революционную технику, когда несколько статистических моделей интеллектуально комбинируются таким образом, что прогнозируют следующий символ лучше, чем любая из моделей сама по себе.
[PAQ](https://en.wikipedia.org/wiki/PAQ) (2002) — один из наиболее перспективных алгоритмов CM, с момента его создания было создано десятки вариантов, причём некоторые достигли рекордных коэффициентов сжатия.
Архиватор CMIX считался мировым лидером по сжатию до появления NNCP. Он основан на коде paq8hp12any и paq8l (современные модели из семейства PAQ).
Из других новинок последних лет можно упомянуть алгоритм [Brotli-G](https://gpuopen.com/brotli-g-sdk-announce/), основанный на обычном Brotli (классический LZ77 + код Хаффмана), но оптимизированный для GPU. То есть получается сжатие с аппаратным ускорением. Учитывая потенциальное использование нейросетей, такое аппаратное ускорение весьма уместно. По эффективности Brotli в числе аутсайдеров, но это первый в мире архиватор на GPU. Да и он изначально создавался для шифрования трафика в интернете и был ориентирован в первую очередь на скорость в реальном времени, а не на сжатие. Поддержка есть во всех современных браузерах.
▍ Сжатие информации как эквивалент интеллекта
---------------------------------------------
Понятно, почему Фабрис Беллар решил использовать нейросети именно для сжатия данных. Это очень логично в свете того, что некоторые учёные [соотносят сжатие данных с общим интеллектом](http://mattmahoney.net/dc/rationale.html).
Дело в том, что эффективное сжатие требует *понимания* данных. Чем лучше понимание, тем больше паттернов, куда эти данные укладываются. И тем эффективнее сжатие. Например, в миллиардах цифр на экране мы вдруг увидели координаты точек окружности, и тогда можем сжать терабайты информации в три числа (координаты центра и радиус). Почти как в анекдоте про школьника с архиватором, который всё архивирует в 1 байт, только разархивировать не может.
Таким образом, сжатие информации требует её понимания. Отсюда аналогия с интеллектом, который тоже находит смысл в окружающих явлениях. В миллиардах хаотических событий окружающего мира мы видим физические объекты и даже абстрактные понятия, и «сжимаем» их до одного слова, схемы или образа.
В качестве примера можно вспомнить [диаграммы Фейнмана](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D1%8B_%D0%A4%D0%B5%D0%B9%D0%BD%D0%BC%D0%B0%D0%BD%D0%B0), которые «сжимают» описание сложных физических процессов до одной простой картинки.
*Первая опубликованная диаграмма Фейнмана под названием «Фундаментальное взаимодействие» показывает классический случай, когда два электрона обмениваются виртуальным фотоном, [источник](https://commons.wikimedia.org/w/index.php?curid=1601027)*
Это и есть работа интеллекта. Ричард Фейнман получил Нобелевскую премию по сути за самое эффективное сжатие информации.
Грубо говоря, один человек умеет сжимать и понимать только простые объекты (минимальное сжатие, средний IQ), а другой более сложные (максимальное сжатие информации, высокий IQ), которые не поддаются пониманию первого архиватора. Чем выше коэффициент сжатия информации, тем качественнее и эффективнее модель данных для окружающего мира.
Кстати, на этом тезисе основан [компрессионизм](https://ceur-ws.org/Vol-1419/paper0045.pdf) — теория мышления на основе сжатия данных. По сути, если рассматривать человеческий разум и интеллект в таком виде, то сжатие данных — это главная концепция в нашей жизни.
Авторы приводят примеры сжатия данных, которые основаны на понимании определённых высокоуровневых концепций. Например, бесконечная последовательность чисел
`4, 6, 8, 12, 14, 18, 20, 24...`
… сжимается до одной фразы «нечётные простые числа +1»
Здесь также понятна связь между сжатием данных и прогнозированием будущего. Это как в жизни: если у вас более качественная модель сжатия (понимания) мира, то вы лучше предсказываете поступки других людей. [Теорема о кодировании информации Леонида Левина (1974)](https://www.mathnet.ru/php/archive.phtml?wshow=paper&jrnid=ppi&paperid=1039) демонстрирует, что с высокой вероятностью **самая компактная модель и оказывается самой верной** (бритва Оккама).
В [научной работе 2009 года](https://arxiv.org/abs/0812.4360) Шмидхубер предложил рассматривать сжатие данных как простой принцип, который объясняет существенные аспекты субъективной красоты, новизны, удивления, интересности, внимания, любопытства, творчества, искусства, науки, музыки и шуток. Он утверждает, что данные становятся временно интересными, как только наблюдатель учится предсказывать (т. е. сжимать) их лучшим образом, делая их субъективно более простыми и «красивыми».
С этой точки зрения любопытство можно рассматривать как желание создать и обнаружить закономерности, которые позволяют достичь прогресса в сжатии, при этом уровень любопытства связан с требуемыми усилиями.
Аналогичным образом [теория Магуайра о субъективной вероятности (2013)](https://arxiv.org/abs/1405.6142), а также [теория простоты Дессаллеса (2011)](https://hal-imt.archives-ouvertes.fr/file/index/docid/601487/filename/CogSci2008.pdf) рассматривают сжатие данных как ключевую объяснительную конструкцию в феномене удивления. Когда люди сталкиваются со стимулом, который ожидается как случайный, но оказывается сжимаемым, это вызывает реакцию удивления (или смеха).
Согласно Магуайру, люди часто полагаются на сжатие данных, а не на теорию вероятности для принятия решений во многих сценариях реального мира. Если подумать, то [сжатие и есть понимание](https://arxiv.org/abs/1904.10258). Главная концепция в нашей жизни.
В свете этой концепции интересно следить за конкурсами на лучшее сжатие текстов из Википедии на натуральном языке, такими как [Large Text Compression](http://mattmahoney.net/dc/text.html) (109 первых байт из enwiki-20060303-pages-articles.xml) и [Hutter Prize](http://prize.hutter1.net/) (108 первых байт, приз 500 тыс. евро, на фото справа — последний победитель — Артемий Маргаритов из Эдинбурга). По мнению учёных-компрессионистов, [идеальное сжатие текста эквивалентно тесту Тьюринга](http://mattmahoney.net/dc/rationale.html) для машин.
Возможно, сильный ИИ сможет сформироваться где-то в симбиозе чат-ботов (речь) и архиваторов (понимание смысла).
С одной стороны, сжатие рассматривается как [ключ к идеальному математическому определению интеллекта](https://link.springer.com/book/10.1007/b138233). С другой стороны, создать идеальную модель сжатия настолько же трудно, как и познать принципы мышления. Или даже невозможно в силу потенциального противоречия теореме Гёделя, из которой можно сделать выводы о невычислимости функции сознания, а также о существовании [принципиально непознаваемых явлений](https://baguzin.ru/wp/gregori-hajtin-predely-dokazuemosti/) (предел Хайтина).
> **[Играй в нашу новую игру прямо в Telegram!](https://t.me/ruvds_community/130)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=alizar&utm_content=szhatie_bez_poter_glavnaya_koncepciya_v_nashej_zhizni) | https://habr.com/ru/post/712652/ | null | ru | null |
# Необычные системные вызовы на Linux
[](https://habrastorage.org/webt/ej/cn/w4/ejcnw4zqrqo_wee6kw-evxqziui.png)
Что видит программист, начиная работать с языком C? Он видит `fopen`, `printf`, `scanf` и ещё много других функций. Видит он и всякие `open` и `mmap` — казалось бы, зачем их выделять? Но, в отличие от первой группы, эти две функции при выполнении на ядре Linux являются системными вызовами (*на самом деле нет*, почти никогда системный вызов нельзя просто вызвать как функцию, и поэтому `libc` содержит обёртки, перепаковывающие аргументы и иногда, как в случае с тем же `open`, заменяющие старые системные вызовы более общими новыми). Вообще, в отличие от тысяч библиотечных функций, доступных на типичной GNU/Linux системе, интерфейс ядра имеет довольно ограниченное количество точек входа — порядка нескольких сотен, зато то, что для user space — crash (например, обращение к отсутствующей странице), для ядра — default mode of operation.
В этой статье я расскажу некоторые интересные на мой взгляд факты. В ней не будет `futex`-ов и прочих скучных (наверное) деталей реализации. Будет преимущественно то, что вызывало у меня реакцию «А что, так можно было?!?».
Во первых, некоторые комментарии к тексту до ката: некоторые системные вызовы имеют опциональный интерфейс в виде функции из shared object под названием [vDSO](http://man7.org/linux/man-pages/man7/vdso.7.html), подкладываемого ядром в процесс. Таких функций немного (что-то около четырёх, но конкретное количество, видимо, может зависеть от версии ядра и архитектуры) — это всякие `time` и `gettimeofday`, которые, с одной стороны, часто используются, а с другой — их удалось реализовать без переключения в контекст ядра.
Во-вторых, не всегда SIGSEGV заканчивается крешем процесса, но об этом мы ещё поговорим, когда речь зайдёт о `userfaultfd`.
**DISCLAIMER:** помните, что используя большинство из представленных здесь возможностей, вы завязываете свою программу на Linux. Это нормально, если таким способом вы делаете опциональную оптитимизацию для конкретного типа систем или дополнительную возможность, которой иначе бы просто не было. Но в противном случае рекомендую подумать о том, как сделать кросс-платформенный fallback.
Общие вопросы
-------------
Для начала, как можно всё это отлаживать? Конечно же, нам поможет `strace`! Поскольку набор системных вызовов ограничен, и большинство `strace` знает «в лицо», то он покажет не просто «передан указатель 0x12345678», а опишет, что в этой структуре передаётся в ту или иную сторону. Если `strace` достаточно свежий, то с помощью параметра `-k` его можно попросить выдавать стек вызовов.
**Выглядит это как-то так**
```
$ strace -k sleep 1
execve("/bin/sleep", ["sleep", "1"], 0x7ffe9f9cce30 /* 60 vars */) = 0
> /lib/x86_64-linux-gnu/libc-2.30.so(execve+0xb) [0xe601b]
> /usr/bin/strace(+0x0) [0xa279c]
> /usr/bin/strace(+0x0) [0xa41d2]
> /usr/bin/strace(+0x0) [0x7090b]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xf3) [0x271e3]
> /usr/bin/strace(+0x0) [0x7112a]
brk(NULL) = 0x558936ded000
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_error+0x20b) [0x1ccdb]
> /lib/x86_64-linux-gnu/ld-2.30.so(__get_cpu_features+0x1cd2) [0x1b872]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x203c]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x1108]
arch_prctl(0x3001 /* ARCH_??? */, 0x7fff593c0070) = -1 EINVAL (Недопустимый аргумент)
> /lib/x86_64-linux-gnu/ld-2.30.so(__get_cpu_features+0x1e25) [0x1b9c5]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x203c]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x1108]
access("/etc/ld.so.preload", R_OK) = -1 ENOENT (Нет такого файла или каталога)
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_error+0x10cb) [0x1db9b]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x3c12]
> /lib/x86_64-linux-gnu/ld-2.30.so(__get_cpu_features+0x1e7b) [0x1ba1b]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x203c]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x1108]
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_error+0x1238) [0x1dd08]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_debug_state+0x73a) [0x11d4a]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_exception_free+0x908) [0x189c8]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0xa362]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x41b5) [0xeb35]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_exception+0x65) [0x1ca85]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x4603) [0xef83]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x3c55]
> /lib/x86_64-linux-gnu/ld-2.30.so(__get_cpu_features+0x1e7b) [0x1ba1b]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x203c]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x1108]
fstat(3, {st_mode=S_IFREG|0644, st_size=254851, ...}) = 0
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_error+0x1009) [0x1dad9]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_debug_state+0x761) [0x11d71]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_exception_free+0x908) [0x189c8]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0xa362]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x41b5) [0xeb35]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_exception+0x65) [0x1ca85]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x4603) [0xef83]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x3c55]
> /lib/x86_64-linux-gnu/ld-2.30.so(__get_cpu_features+0x1e7b) [0x1ba1b]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x203c]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x1108]
mmap(NULL, 254851, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fc49621c000
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_error+0x1426) [0x1def6]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_debug_state+0x79d) [0x11dad]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_exception_free+0x908) [0x189c8]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0xa362]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x41b5) [0xeb35]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_exception+0x65) [0x1ca85]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x4603) [0xef83]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x3c55]
> /lib/x86_64-linux-gnu/ld-2.30.so(__get_cpu_features+0x1e7b) [0x1ba1b]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x203c]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x1108]
close(3) = 0
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_error+0x10fb) [0x1dbcb]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_debug_state+0x780) [0x11d90]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_exception_free+0x908) [0x189c8]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0xa362]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x41b5) [0xeb35]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_exception+0x65) [0x1ca85]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x4603) [0xef83]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x3c55]
> /lib/x86_64-linux-gnu/ld-2.30.so(__get_cpu_features+0x1e7b) [0x1ba1b]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x203c]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x1108]
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_error+0x1238) [0x1dd08]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x7d40]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0xa3a8]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x41b5) [0xeb35]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_exception+0x65) [0x1ca85]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x4603) [0xef83]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x3c55]
> /lib/x86_64-linux-gnu/ld-2.30.so(__get_cpu_features+0x1e7b) [0x1ba1b]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x203c]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x1108]
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\360r\2\0\0\0\0\0"..., 832) = 832
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_error+0x12f8) [0x1ddc8]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x7d79]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0xa3a8]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x41b5) [0xeb35]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_catch_exception+0x65) [0x1ca85]
> /lib/x86_64-linux-gnu/ld-2.30.so(_dl_rtld_di_serinfo+0x4603) [0xef83]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x3c55]
> /lib/x86_64-linux-gnu/ld-2.30.so(__get_cpu_features+0x1e7b) [0x1ba1b]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x203c]
> /lib/x86_64-linux-gnu/ld-2.30.so() [0x1108]
...
Много динамической линковки
...
brk(NULL) = 0x558936ded000
> /lib/x86_64-linux-gnu/libc-2.30.so(brk+0xb) [0x11755b]
> /lib/x86_64-linux-gnu/libc-2.30.so(__sbrk+0x67) [0x117617]
> /lib/x86_64-linux-gnu/libc-2.30.so(__default_morecore+0xd) [0x9fd3d]
> /lib/x86_64-linux-gnu/libc-2.30.so(thrd_yield+0x2725) [0x9a745]
> /lib/x86_64-linux-gnu/libc-2.30.so(thrd_yield+0x3943) [0x9b963]
> /lib/x86_64-linux-gnu/libc-2.30.so(thrd_yield+0x3b2b) [0x9bb4b]
> /lib/x86_64-linux-gnu/libc-2.30.so(thrd_yield+0x4d9e) [0x9cdbe]
> /lib/x86_64-linux-gnu/libc-2.30.so(textdomain+0x740) [0x3be70]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x1d35) [0x35515]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0xbdf) [0x343bf]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x215) [0x339f5]
> /bin/sleep() [0x25f0]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xf3) [0x271e3]
> /bin/sleep() [0x287e]
brk(0x558936e0e000) = 0x558936e0e000
> /lib/x86_64-linux-gnu/libc-2.30.so(brk+0xb) [0x11755b]
> /lib/x86_64-linux-gnu/libc-2.30.so(__sbrk+0x91) [0x117641]
> /lib/x86_64-linux-gnu/libc-2.30.so(__default_morecore+0xd) [0x9fd3d]
> /lib/x86_64-linux-gnu/libc-2.30.so(thrd_yield+0x2725) [0x9a745]
> /lib/x86_64-linux-gnu/libc-2.30.so(thrd_yield+0x3943) [0x9b963]
> /lib/x86_64-linux-gnu/libc-2.30.so(thrd_yield+0x3b2b) [0x9bb4b]
> /lib/x86_64-linux-gnu/libc-2.30.so(thrd_yield+0x4d9e) [0x9cdbe]
> /lib/x86_64-linux-gnu/libc-2.30.so(textdomain+0x740) [0x3be70]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x1d35) [0x35515]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0xbdf) [0x343bf]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x215) [0x339f5]
> /bin/sleep() [0x25f0]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xf3) [0x271e3]
> /bin/sleep() [0x287e]
openat(AT_FDCWD, "/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
> /lib/x86_64-linux-gnu/libc-2.30.so(__open64_nocancel+0x4c) [0x11679c]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x1ce9) [0x354c9]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0xbdf) [0x343bf]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x215) [0x339f5]
> /bin/sleep() [0x25f0]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xf3) [0x271e3]
> /bin/sleep() [0x287e]
fstat(3, {st_mode=S_IFREG|0644, st_size=8994080, ...}) = 0
> /lib/x86_64-linux-gnu/libc-2.30.so(__fxstat64+0x19) [0x1107b9]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x1e33) [0x35613]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0xbdf) [0x343bf]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x215) [0x339f5]
> /bin/sleep() [0x25f0]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xf3) [0x271e3]
> /bin/sleep() [0x287e]
mmap(NULL, 8994080, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fc495795000
> /lib/x86_64-linux-gnu/libc-2.30.so(mmap64+0x26) [0x11baf6]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x1e5d) [0x3563d]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0xbdf) [0x343bf]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x215) [0x339f5]
> /bin/sleep() [0x25f0]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xf3) [0x271e3]
> /bin/sleep() [0x287e]
close(3) = 0
> /lib/x86_64-linux-gnu/libc-2.30.so(__close_nocancel+0xb) [0x1165bb]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x1eab) [0x3568b]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0xbdf) [0x343bf]
> /lib/x86_64-linux-gnu/libc-2.30.so(setlocale+0x215) [0x339f5]
> /bin/sleep() [0x25f0]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xf3) [0x271e3]
> /bin/sleep() [0x287e]
nanosleep({tv_sec=1, tv_nsec=0}, NULL) = 0
> /lib/x86_64-linux-gnu/libc-2.30.so(nanosleep+0x17) [0xe5d17]
> /bin/sleep() [0x5827]
> /bin/sleep() [0x5600]
> /bin/sleep() [0x27b0]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xf3) [0x271e3]
> /bin/sleep() [0x287e]
close(1) = 0
> /lib/x86_64-linux-gnu/libc-2.30.so(__close_nocancel+0xb) [0x1165bb]
> /lib/x86_64-linux-gnu/libc-2.30.so(_IO_file_close_it+0x70) [0x92fc0]
> /lib/x86_64-linux-gnu/libc-2.30.so(fclose+0x166) [0x85006]
> /bin/sleep() [0x5881]
> /bin/sleep() [0x2d27]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_secure_getenv+0x127) [0x49ba7]
> /lib/x86_64-linux-gnu/libc-2.30.so(exit+0x20) [0x49d60]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xfa) [0x271ea]
> /bin/sleep() [0x287e]
close(2) = 0
> /lib/x86_64-linux-gnu/libc-2.30.so(__close_nocancel+0xb) [0x1165bb]
> /lib/x86_64-linux-gnu/libc-2.30.so(_IO_file_close_it+0x70) [0x92fc0]
> /lib/x86_64-linux-gnu/libc-2.30.so(fclose+0x166) [0x85006]
> /bin/sleep() [0x5881]
> /bin/sleep() [0x2d4d]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_secure_getenv+0x127) [0x49ba7]
> /lib/x86_64-linux-gnu/libc-2.30.so(exit+0x20) [0x49d60]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xfa) [0x271ea]
> /bin/sleep() [0x287e]
exit_group(0) = ?
+++ exited with 0 +++
> /lib/x86_64-linux-gnu/libc-2.30.so(_exit+0x36) [0xe5fe6]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_secure_getenv+0x242) [0x49cc2]
> /lib/x86_64-linux-gnu/libc-2.30.so(exit+0x20) [0x49d60]
> /lib/x86_64-linux-gnu/libc-2.30.so(__libc_start_main+0xfa) [0x271ea]
> /bin/sleep(+0x0) [0x287e]
```
Правда, тут не отображаются имена файлов с исходным кодом и номера строк. Вам поможет `addr2line` (если эта информация в принципе присутствует, конечно).
Есть и второй вопрос: некоторые системные вызовы не имеют обёрток в `libc`. Тогда можно воспользоваться универсальной обёрткой под названием [`syscall`](http://man7.org/linux/man-pages/man2/syscall.2.html):
```
syscall(SYS_kcmp, getpid(), getpid(), KCMP_FILE, 1, fd)
```
Файл — это очень уж странный предмет...
---------------------------------------
Системные вызовы — это не только способ попросить ядро обратиться к оборудованию от имени процесса. Это ещё и универсальное API, понятное всем библиотекам в системе. Значит, если в библиотеке не поддержали нужную вам функциональность, возможно, она автоматически получится, если правильно попросить ядро. К тому же, часть «настроек» процесса наследуется при `execve`, поэтому таким образом можно попробовать обойтись без сложных костылей, просто правильно сформировав состояние перед запуском процесса (что-то вроде «зачем вручную перекладывать `stderr` в файл, если можно просто открыть файл и сделать его FD #2 для дочернего процесса»).
Как-то раз мне потребовалось вычитать из файла последовательность сетевых пакетов. В какой-то момент количество костылей превысило все разумные пределы, и я решил, что вряд ли `libpcap` будет сложнее, чем то, что я написал, к тому же, это стандарт, и для открытия этих файлов существуют общепринятые инструменты. Оказалось, что пользоваться `libpcap` для чтения дампов примерно настолько же сложно, как и `fopen` для чтения файлов: вы просто открываете дамп с помощью `pcap_(f)open_offline` и вычерпываете пакеты через `pcap_next_ex`. Всё! Ну, ещё стоит закрыть дамп по завершению работы...
Но вот незадача: похоже, `libpcap` не умеет читать из памяти. Может, и умеет конечно, если покопаться, но для нашей «лабораторки» представим, что не умеет.
Итак, модельный пример: мы ждём на `stdin` некую последовательность байтов, после которой идёт выровненный на 4 байта дамп. Я понимаю, что можно использовать буферизованный ввод и какой-нибудь `ungetc` (поскольку `libpcap` всё равно требует `FILE *`), но в общем случае мы, может, на ходу распаковываем, например, или библиотека может непосредственно работать с `read` / `write`.
### Решение 1: memfd\_create
Системный вызов `memfd_create` позволяет создать «вообще анонимный» файловый дескриптор. Файл находится в памяти и существует, пока на него открыт хоть один дескриптор. В простейшем случае, вы просто получаете такой дескриптор, записываете в него данные через `write`, перематываете `lseek`, и с помощью `fdopen` даёте о нём знать `libc`:
```
int fd = memfd_create("pcap-dump-contents", 0);
write(fd, buf, length);
lseek(fd, 0, SEEK_SET);
FILE *file = fdopen(fd, "r");
```
Имя файла, передаваемое первым аргументом, будет отображаться в символьной ссылке в `/proc//fd`:
```
$ ls -l /proc/31747/fd
итого 0
lr-x------ 1 trosinenko trosinenko 64 ноя 10 13:12 0 -> /path/to/128test.pcap
lrwx------ 1 trosinenko trosinenko 64 ноя 10 13:12 1 -> /dev/pts/17
lrwx------ 1 trosinenko trosinenko 64 ноя 10 13:12 2 -> /dev/pts/17
lrwx------ 1 trosinenko trosinenko 64 ноя 10 13:12 23 -> '/home/trosinenko/.cache/appstream-cache-AH3OA0.mdb (deleted)'
lrwx------ 1 trosinenko trosinenko 64 ноя 10 13:12 3 -> '/memfd:pcap-dump-contents (deleted)'
lrwx------ 1 trosinenko trosinenko 64 ноя 10 13:12 57 -> 'socket:[41036]'
```
### Решение 2: open с флагом O\_TMPFILE
В Linux, начиная с какой-то версии, при создании файла можно [`указать опцию O_TMPFILE`](http://man7.org/linux/man-pages/man2/open.2.html) и имя каталога вместо имени файла. В итоге файл, как (приблизительно) говаривал один литературный персонаж, *вроде он есть, но его как бы нет*… Пишутся ли данные на диск — не знаю, но наверное, это зависит и от файловой системы (кстати, она должна поддерживать этот режим). Файл всё так же исчезает при закрытии последней ссылки, но его можно прикрепить к дереву каталогов с помощью [`linkat`](http://man7.org/linux/man-pages/man2/linkat.2.html):
```
int fd = open(".", O_RDWR | O_TMPFILE, S_IRUSR | S_IWUSR);
assert(fd != -1);
assert(write(fd, buffer + offset, len - offset) == len - offset);
assert(lseek(fd, 0, SEEK_SET) == 0);
const char *link_to = getenv("LINK_TO");
if (link_to != NULL) {
char path[128];
snprintf(path, sizeof(path), "/proc/self/fd/%d", fd);
linkat(AT_FDCWD, path, AT_FDCWD, link_to, AT_SYMLINK_FOLLOW);
}
```
Кроме возможности не мучаться с именованием файла, это даёт возможность заполнить файл, настроить права и т. д., а потом атомарно прилинковать в дерево каталогов.
**Пример (для обоих подходов)**
```
#define _GNU_SOURCE
#ifdef NDEBUG
// Чтобы спокойно использовать assert с сайд-эффектами в примерах
# undef NDEBUG
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
// Идентификатор файла в формате PCAP (один из возможных -- см. спецификацию)
static const uint32\_t pcap\_mgc = 0xA1B2C3D4;
char buffer[1 << 20];
int main()
{
int len = read(0, buffer, sizeof(buffer));
// По какой-то причине у нас сначала идёт "мусор",
// который никогда не содержит pcap\_mgc, а потом
// выровненный на 4 байта дамп. Просто для примера...
int offset = -1;
for (int i = 0; i < len; i += 4) {
if (\*(uint32\_t \*)(buffer + i) == pcap\_mgc) {
offset = i;
break;
}
}
if (offset >= 0) {
printf("Found PCAP dump at offset %d\n", offset);
} else {
fprintf(stderr, "No PCAP dump found.\n");
exit(1);
}
// Теперь сделаем так, чтобы libpcap считал, что читает
// данные из файла.
#if 0
int fd = memfd\_create("pcap-dump-contents", 0);
assert(fd != -1);
assert(write(fd, buffer + offset, len - offset) == len - offset);
assert(lseek(fd, 0, SEEK\_SET) == 0);
#else
int fd = open(".", O\_RDWR | O\_TMPFILE, S\_IRUSR | S\_IWUSR);
assert(fd != -1);
assert(write(fd, buffer + offset, len - offset) == len - offset);
assert(lseek(fd, 0, SEEK\_SET) == 0);
const char \*link\_to = getenv("LINK\_TO");
if (link\_to != NULL) {
char path[128];
snprintf(path, sizeof(path), "/proc/self/fd/%d", fd);
linkat(AT\_FDCWD, path, AT\_FDCWD, link\_to, AT\_SYMLINK\_FOLLOW);
}
#endif
raise(SIGSTOP); // Чтобы посмотреть в /proc/PID/fd/
// Теперь попробуем открыть дамп и что-нибудь вывести...
FILE \*file = fdopen(fd, "r");
char errbuf[PCAP\_ERRBUF\_SIZE];
pcap\_t \* dump = pcap\_fopen\_offline(file, errbuf);
assert(dump != NULL);
struct pcap\_pkthdr \*hdr;
const uint8\_t \*data;
while (pcap\_next\_ex(dump, &hdr, &data) == 1) {
printf("Read packet: full length = %d bytes, available %d bytes.\n", hdr->len, hdr->caplen);
}
return 0;
}
```
```
$ fallocate -l 128 zero128
$ cat zero128 test.pcap > 128test.pcap
$ ./memfd < 128test.pcap
Found PCAP dump at offset 128
Read packet: full length = 105 bytes, available 105 bytes.
Read packet: full length = 105 bytes, available 105 bytes.
Read packet: full length = 66 bytes, available 66 bytes.
Read packet: full length = 385 bytes, available 385 bytes.
Read packet: full length = 66 bytes, available 66 bytes.
...
```
userfaultfd: обработка ошибок памяти в userspace
------------------------------------------------
Думаю, не будет чего-то сильно нового в том, чтобы сказать, что в UNIX-like системах файловые дескрипторы на что только не указывают. Например, на Linux это может быть сокет, pipe, eventfd или даже ссылка на ebpf-программу. Но, возможно, этот пример вас всё-таки удивит. В начале статьи я говорил о том, что для ядра page faults — обычное дело: своп, copy-on-write, вот это всё… Когда же пользовательский процесс «промахивается», ему отправляется SIGSEGV. Насколько я знаю, возврат управления из обработчика SIGSEGV, сгенерированного ядром, является undefined behavior, и тем не менее, существует библиотека [GNU libsigsegv](https://www.gnu.org/software/libsigsegv/), обобщающая особенности обработки ошибки доступа к памяти на различных платформах, даже Windows **(ВНИМАНИЕ: лицензия GPL, если не готовы под ней же распространять свою программу, то не используйте libsigsegv)**. Не так давно в Linux появился абсолютно задокументированный способ, называется [`userfaultfd`](http://man7.org/linux/man-pages/man2/userfaultfd.2.html): с помощью одноимённого системного вызова вы открываете файловый дескриптор, чтение и запись в который специальных структур являются командами.
Имея такой файловый дескриптор, вы можете пометить некий диапазон виртуальных адресов вашего процесса. После этого при первом обращение к каждой помеченной странице памяти, обратившийся поток заснёт, а чтение из файлового дескриптора вернёт информацию о произошедшем. После чего обработчик заполнит ответную структуру с указателем на данные, которые нужно использовать для инициализации «проблемной» страницы, ядро её проинициализирует и разбудит обратившийся поток. При этом предполагается наличие отдельного потока, в чьи обязанности входит чтение команд из дескриптора и выдача ответов. *Вообще говоря, через `userfaultfd` можно получать и другую информацию, например, некоторые уведомления об изменении карты виртуальной памяти процесса.*
**Пример использования**
```
#define _GNU_SOURCE
#ifdef NDEBUG
// Чтобы спокойно использовать assert с сайд-эффектами в примерах
# undef NDEBUG
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
// По-хорошему, нужно спросить sysconf...
#define PAGE\_SIZE 4096
#define PAGE\_MASK (PAGE\_SIZE - 1)
static void \*thread\_fn(void \* arg)
{
int uffd = (intptr\_t)arg;
struct uffd\_msg msg;
// Интересно, как заработает с hugepages...
uint8\_t \*replacement\_page = mmap(NULL, PAGE\_SIZE, PROT\_READ | PROT\_WRITE, MAP\_PRIVATE | MAP\_ANONYMOUS, -1 ,0);
while(1)
{
assert(read(uffd, &msg, sizeof msg) > 0);
// Бывают разные типы сообщений, обрабатываем только одно
if (msg.event == UFFD\_EVENT\_PAGEFAULT) {
uintptr\_t addr = msg.arg.pagefault.address;
fprintf(stderr, "Fault: addr = 0x%zx\n", addr);
// Округляем адрес вниз до размера страницы
uint8\_t \*page\_addr = (uint8\_t \*)((uintptr\_t)addr & ~PAGE\_MASK);
// Заполняем "подменную" страницу, не "сбойную"!
memset(replacement\_page, 0xAB, PAGE\_SIZE);
// просим ядро инициализировать страницу
struct uffdio\_copy copy;
copy.src = (uintptr\_t)replacement\_page;
copy.dst = (uintptr\_t)page\_addr;
copy.mode = 0; // флаги, здесь -- по умолчанию
copy.copy = 0; // возвращаемое значение -- сколько байтов скопировали или ошибка
copy.len = PAGE\_SIZE;
assert(ioctl(uffd, UFFDIO\_COPY, ©) != -1);
}
}
}
static int init\_userfaultfd(void)
{
// Открываем дескриптор
int uffd = syscall(\_\_NR\_userfaultfd, 0);
// Говорим, поддержку чего мы от него ожидаем
struct uffdio\_api api;
api.api = UFFD\_API;
api.features = 0;
assert(ioctl(uffd, UFFDIO\_API, &api) != -1);
fprintf(stderr, "UFFD open\n");
// Запускаем поток-обработчик
pthread\_t thread;
memset(&thread, 0, sizeof(thread));
// Хмм... допустимо ли хранить int в void \*?
pthread\_create(&thread, 0, thread\_fn, (void \*)(intptr\_t)uffd);
return uffd;
}
static void register\_region(int uffd, void \* aligned\_addr, size\_t size)
{
struct uffdio\_register reg;
memset(®, 0, sizeof reg);
reg.range.start = (uintptr\_t)aligned\_addr;
reg.range.len = size;
reg.mode = UFFDIO\_REGISTER\_MODE\_MISSING;
assert (ioctl(uffd, UFFDIO\_REGISTER, ®) != -1);
}
int main()
{
void \*addr = mmap(NULL, PAGE\_SIZE, PROT\_READ | PROT\_WRITE, MAP\_PRIVATE | MAP\_ANONYMOUS, -1, 0);
int uffd = init\_userfaultfd();
register\_region(uffd, addr, PAGE\_SIZE);
fprintf(stderr, "Before reading\n");
fprintf(stderr, "Data at %p: %x\n", addr, \*(volatile int \*)addr);
return 0;
}
```
```
$ ./userfaultfd
UFFD open
Before reading
Fault: addr = 0x7f46f40d5000
Data at 0x7f46f40d5000: abababab
```
«Ключевой вопрос математики: не всё ли равно» ©
-----------------------------------------------
Что, если вам нужно узнать, ссылается ли этот файловый дескриптор на `stdin`? Казалось бы, `if (fd == 0) ...` — и все дела. Ну, окей...
```
#define _GNU_SOURCE
#include
#include
int main()
{
int fd = dup(0);
printf("stdin is fd %d, too\n", fd);
if (fd == 0)
printf("stdin");
else
printf("not stdin");
return 0;
}
```
```
$ gcc kcmp.c -o kcmp
$ ./kcmp
stdin is fd 3, too
not stdin
```
Упс… Дескриптор-то вроде как один, но алиасы разные. Нам поможет [CRIU](https://www.criu.org/Main_Page) — Checkpoint/Restore In Userspace. Без паники, я не предлагаю сдампить процесс, посмотреть на результат и загрузить обратно. Просто для нужд своих userspace-инструментов, разработчики из этого проекта, как я понял, добавили в ядро системный вызов `kcmp`: ему передаются два PID, тип ресурса и, собственно, два ресурса, а он говорит, указывают ли они на одну и ту же сущность ядра:
```
#define _GNU_SOURCE
#include
#include
#include
#include
int main()
{
int fd = dup(0);
printf("stdin is fd %d, too\n", fd);
int pid = getpid();
if (syscall(SYS\_kcmp,
pid, pid, KCMP\_FILE /\* не путать с \_FILES! \*/,
0 /\* stdin fd \*/, fd) == 0)
printf("stdin\n");
else
printf("not stdin\n");
if (syscall(SYS\_kcmp,
pid, pid, KCMP\_FILE,
1 /\* stdout fd \*/, fd) == 0)
printf("stdout\n");
else
printf("not stdout\n");
return 0;
}
```
```
$ ./kcmp
stdin is fd 3, too
stdin
stdout
```
Опять двадцать пять! Подождите ка, а что если...
```
$ ls -l /proc/self/fd
итого 0
lrwx------ 1 trosinenko trosinenko 64 ноя 10 14:45 0 -> /dev/pts/17
lrwx------ 1 trosinenko trosinenko 64 ноя 10 14:45 1 -> /dev/pts/17
lrwx------ 1 trosinenko trosinenko 64 ноя 10 14:45 2 -> /dev/pts/17
lrwx------ 1 trosinenko trosinenko 64 ноя 10 14:45 23 -> '/home/trosinenko/.cache/appstream-cache-AH3OA0.mdb (deleted)'
lr-x------ 1 trosinenko trosinenko 64 ноя 10 14:45 3 -> /proc/17265/fd
lrwx------ 1 trosinenko trosinenko 64 ноя 10 14:45 57 -> 'socket:[41036]'
```
Ага, тот неловкий момент, когда пытаешься понять, где ошибка, а она оказалась в твоём понимании происходящего. Логично считать, что bash точно так же поступает и с моей программой, как и с `ls`!
```
$ ./kcmp < kcmp.c
stdin is fd 3, too
stdin
not stdout
```
Не буду утверждать, что это работает всегда и идеально — для этого нужно самому его использовать много и по-разному, но как best effort инструмент для каких-нибудь эвристик наверняка может пригодиться.
Обо всём и понемножку
---------------------
Знаете ли вы, ...
* … что ядро содержит в себе JIT-компилятор для байткода из userspace? Так вот, для целей фильтрации пакетов и прочей трассировки ядро [поддерживает eBPF-байткод](http://man7.org/linux/man-pages/man2/bpf.2.html). В процессе загрузки он проверяется на безопасность, терминируемость (а значит, как я понимаю, даже теоретически не может быть Тьюринг-полным) и т. д., после чего либо JIT-ится, либо интерпретируется. Кстати, не путайте его с его предшественником, BPF.
* … что обработчики сигналов можно запускать на отдельном стеке? Если нет, то вот описание системного вызова [`sigaltstack`](http://man7.org/linux/man-pages/man2/sigaltstack.2.html).
* … что можно просто предупредить ядро о том, что некоторый файл пригодится позже: [`readahead`](http://man7.org/linux/man-pages/man2/readahead.2.html)
А ещё в процессе просмотра списка системных вызовов я нашёл `oldolduname`... | https://habr.com/ru/post/475184/ | null | ru | null |
# Как подружить QML с чужим OpenGL контекстом. Часть III: Обработка пользовательского ввода
В данной статье я попытаюсь рассказать о том как передавать события мыши и клавиатуры в [QQuickWindow](http://doc.qt.io/qt-5/qquickwindow.html), в случае его использования в связке с [QQuickRenderControl](http://doc.qt.io/qt-5/qquickrendercontrol.html). Причиной того, что этому необходимо уделять специальное внимание, является то, что в случае использования QQuickRenderControl, никакого окна на самом деле не создается, соответственно у QQuickWindow нет абсолютно никакой возможности получать какие либо события, и их приходится эмулировать. То же самое касается изменения размеров — об этой операции так же необходимо оповещать в явном виде.
*Для тех кто пропустил предыдущие части:*
* [*Часть I*](http://habrahabr.ru/post/247477)
* [*Часть II*](http://habrahabr.ru/post/248103)
#### **Как инициируютя события в Qt**
Отправка события в Qt осуществляется с помощью метода
[```
bool QCoreApplication::sendEvent(QObject* receiver, QEvent* event)
```](http://doc.qt.io/qt-5/qcoreapplication.html#sendEvent)где,
* receiver — получатель сообщения, в нашем случае это экземпляр QQuickWindow (или его потомка);
* event — это экземпляр конкретного типа события;
#### **Передача событий мыши**
Для корректного функционирования достаточно реализовать 3 события мыши:
QEvent::MouseButtonPress:
```
QPointF mousePoint( 150, 201 );
Qt::MouseButton button = Qt::LeftButton;
Qt::MouseButton buttons = Qt::LeftButton | Qt::RightButton;
Qt::KeyboardModifiers modifiers = Qt::AltModifier;
QMouseEvent mouseEvent( QEvent::MouseButtonPress, mousePoint, mousePoint, button, buttons, modifiers );
QCoreApplication::sendEvent( quickWindow, &mouseEvent );
```
где,
* mousePoint — текущая позиция мыши в координатах QQuickWindow;
* button — кнопка мыши вызвавшая данное событие;
* buttons — все кнопки мыши нажатые в момент генерации события;
* modifiers — нажатые на клавиатуре клавиши-модификаторы (Ctrl, Alt, Shift и т.д.);
*mousePoint используется дважды, поскольку в первый раз передается в координатах QQuckWindow, второй раз в screen координатах. Но поскольку: а) окно на самом не создается, б) трактуется всегда как окно верхнего уровня, в) его позицией мы управляем самостоятельно — передаем одно и то же значение (как будто окно находится всегда в верхнем левом углу экрана), а при установке позиции окна, просто будем этот факт учитывать.*
QEvent::MouseMove:
```
QPointF mousePoint( 170, 198 );
Qt::MouseButton button = Qt::NoButton;
Qt::MouseButton buttons = Qt::LeftButton | Qt::RightButton;
Qt::KeyboardModifiers modifiers = Qt::AltModifier;
QMouseEvent mouseEvent( QEvent::MouseMove, mousePoint, mousePoint, button, buttons, modifiers );
QCoreApplication::sendEvent( quickWindow, &mouseEvent );
```
*Поскольку причиной события передвижения мыши является сам факт передвижения мыши, а не какая-либо из кнопок, переменной button присваивается значение Qt::NoButton.*
QEvent::MouseButtonRelease:
```
QPointF mousePoint( 160, 251 );
Qt::MouseButton button = Qt::LeftButton;
Qt::MouseButton buttons = Qt::RightButton;
Qt::KeyboardModifiers modifiers = Qt::AltModifier;
QMouseEvent mouseEvent( QEvent::MouseButtonRelease, mousePoint, mousePoint, button, buttons, modifiers );
QCoreApplication::sendEvent( quickWindow, &mouseEvent );
```
*button в данном случае означает кнопку являвшуюся причиной данного события, но в данном случае она была *отпущена*, соответственно в buttons она присутствовать уже не может (иначе Qt начинает обрабатывать это событие неверно).*
#### **Передача событий клавиатуры**
Аналогично, для корректной обработки событий клавиатуры, достаточно реализовать 2 события:
QEvent::KeyPress:
```
Qt::Key qtKey = Qt::Key_Space;
QKeyEvent keyEvent( QEvent::KeyPress, qtKey, Qt::NoModifier );
QCoreApplication::sendEvent( quickWindow, &keyEvent );
```
QEvent::KeyRelease:
```
Qt::Key qtKey = Qt::Key_Space;
QKeyEvent keyEvent( QEvent::KeyRelease, qtKey, Qt::NoModifier );
QCoreApplication::sendEvent( quickWindow, &keyEvent );
```
#### **Изменение размеров**
Как уже упомяналось выше, offscreen окна в Qt трактутся как окна верхнего уровня, поэтому используем соответствующий метод:
```
QSize newSize( 320, 240 );
quickWindow->setGeometry( 0, 0, newSize.width(), newSize.height() );
```
Помимо изменения размеров собственно окна, желательно так же изменить размеры FBO, т.к. в противном случае либо получим пикселизацию (при увеличении размера), либо бессмысленное расходование ресурсов (т.к. размер FBO будет больше чем требуется):
```
if( context->makeCurrent( offscreenSurface ) ) {
destroyFbo();
createFbo();
context->doneCurrent();
}
```
Поскольку изменить размер FBO невозможно, просто удаляем текущий и создаем новый ( см. детали в [Первой части](http://habrahabr.ru/post/247477/) ).
На этом все.
Примеры реализации, как обычно, доступены на [GitHub](https://github.com/RSATom/WebChimera/blob/master/src/Mac/Chimera_Mac.mm#L176)
Ну и как и прежде, коментарии, вопросы, здоровая критика — приветствуются.
*Продолжение следует...* | https://habr.com/ru/post/249383/ | null | ru | null |
# Отступ 8px у body: история стиля, который никому не нужен
Во всех браузерах элементу body через таблицу стилей по умолчанию добавляется внешний отступ 8px. Но почему именно 8px? Разбираемся вместе с автором книги *Jump Start Sass: Get Up to Speed With Sass in a Weekend* к старту [курса по Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_130722&utm_term=lead).
---
### Исходные значения против браузерных значений по умолчанию
У каждого свойства в CSS есть исходное значение, одинаковое для всех элементов во всём вебе. Для [display](https://www.w3.org/TR/css-display/#the-display-properties) — это inline, а для [каждого](https://www.w3.org/TR/css-box/#margin) свойства margin — 0.
Исходные значения применяются, когда другие не заданы в каскаде или не наследуются откуда-то ещё. Чтобы явно вернуть стилям их исходное значение, используется ключевое слово initial.
Но ограничиваться исходными значениями скучно. Когда у всех элементов все свойства одинаковы, ссылка, абзац, заголовок или список внешне неразличимы. Вот пример с [полным](https://www.miriamsuzanne.com/2019/11/02/most-normal/) сбросом стилей CSS:
```
/* you can't get any more 'reset' than this */
* { all: initial !important; }
```
Потому и нужны стили браузера: от одного элемента к другому у них разные значения по умолчанию. Есть блочные элементы display: block (элементы группировки контента, абзацы, списки, заголовки и т. д.), в них используются отступы — для лучшего удобства восприятия.
Чтобы вернуть любому свойству элемента стиль браузера по умолчанию, применяется ключевое слово revert. При этом из источника автора удаляются любые стили. Но стили пользовательского происхождения встречаются редко, поэтому в итоге часто это стили из браузера.
### Стандартизация значений браузера по умолчанию
Стили браузера важны, но зачастую их замечают, только когда они кажутся «неправильными» или неожиданными. Решают эту проблему «сбросами» и «нормализацией».
* Сбросами удаляют значения по умолчанию, чтобы «сделать холст чище».
* С помощью нормализаторов значения по умолчанию в браузерах становятся более согласованными.
В рабочей группе CSS и у поставщиков браузеров также есть понимание, что лучше, когда стили по умолчанию в разных браузерах более согласованные. Хотя в браузерах доступны любые стили, большинство значений по умолчанию там можно отследить до (отличающейся от нормативной) [таблицы](https://drafts.csswg.org/css2/#html-stylesheet) стилей по умолчанию в спецификациях CSS.
Не уверена, есть ли где-то более новая версия (не нашла её).
Таблица стилей CSS 2.2 по умолчанию
```
html, address,
blockquote,
body, dd, div,
dl, dt, fieldset, form,
frame, frameset,
h1, h2, h3, h4,
h5, h6, noframes,
ol, p, ul, center,
dir, hr, menu, pre { display: block; unicode-bidi: embed }
li { display: list-item }
head { display: none }
table { display: table }
tr { display: table-row }
thead { display: table-header-group }
tbody { display: table-row-group }
tfoot { display: table-footer-group }
col { display: table-column }
colgroup { display: table-column-group }
td, th { display: table-cell }
caption { display: table-caption }
th { font-weight: bolder; text-align: center }
caption { text-align: center }
body { margin: 8px }
h1 { font-size: 2em; margin: .67em 0 }
h2 { font-size: 1.5em; margin: .75em 0 }
h3 { font-size: 1.17em; margin: .83em 0 }
h4, p,
blockquote, ul,
fieldset, form,
ol, dl, dir,
menu { margin: 1.12em 0 }
h5 { font-size: .83em; margin: 1.5em 0 }
h6 { font-size: .75em; margin: 1.67em 0 }
h1, h2, h3, h4,
h5, h6, b,
strong { font-weight: bolder }
blockquote { margin-left: 40px; margin-right: 40px }
i, cite, em,
var, address { font-style: italic }
pre, tt, code,
kbd, samp { font-family: monospace }
pre { white-space: pre }
button, textarea,
input, select { display: inline-block }
big { font-size: 1.17em }
small, sub, sup { font-size: .83em }
sub { vertical-align: sub }
sup { vertical-align: super }
table { border-spacing: 2px; }
thead, tbody,
tfoot { vertical-align: middle }
td, th, tr { vertical-align: inherit }
s, strike, del { text-decoration: line-through }
hr { border: 1px inset }
ol, ul, dir,
menu, dd { margin-left: 40px }
ol { list-style-type: decimal }
ol ul, ul ol,
ul ul, ol ol { margin-top: 0; margin-bottom: 0 }
u, ins { text-decoration: underline }
br:before { content: "\A"; white-space: pre-line }
center { text-align: center }
:link, :visited { text-decoration: underline }
:focus { outline: thin dotted invert }
/* Begin bidirectionality settings (do not change) */
BDO[DIR="ltr"] { direction: ltr; unicode-bidi: bidi-override }
BDO[DIR="rtl"] { direction: rtl; unicode-bidi: bidi-override }
*[DIR="ltr"] { direction: ltr; unicode-bidi: embed }
*[DIR="rtl"] { direction: rtl; unicode-bidi: embed }
@media print {
h1 { page-break-before: always }
h1, h2, h3,
h4, h5, h6 { page-break-after: avoid }
ul, ol, dl { page-break-before: avoid }
}
```
Некоторые стили по умолчанию здесь кажутся очевидными: блочные элементы должны отображаться блоками, табличные — таблицами, а элементы списка — списками. В заголовках текст крупнее и выделен жирным. Другие стили — довольно произвольные. Пройдя ~⅓ кода, видим:
```
body { margin: 8px; }
```
Понятно, что по краям документа нужен интервал по умолчанию, но почему 8px? Откуда он взялся?
### Ничто и никогда не исчезает бесследно
Таблица стилей по умолчанию нужна здесь для согласованности не только между браузерами, но и во времени. Весь веб рассчитан на прямую и обратную совместимости. Это не значит, что он статичен, ведь новые функции появляются всё время. Но они никогда не должны нарушать работу имеющихся сайтов.
Хотя в редких случаях — при проблемах с конфиденциальностью или безопасностью — это происходит. Подобных ситуаций стараются избегать. И часто в браузерах прекращается использование какой-то функции, например старого элемента marquee, без фактического удаления поддержки.
Ситуация со стилями по умолчанию в браузере аналогичная. Поскольку CSS впервые реализован в браузерах, там есть стили по умолчанию. И, хотя в браузерах иногда добавляются новые значения по умолчанию, старое значение по умолчанию удаляется очень редко — слишком велика возможность нарушить работу сайтов, при создании которых оно использовалось.
В сегодняшних браузерах многие стили по умолчанию — это те же значения по умолчанию, что были во время появления HTML-элемента.
### Спецификация: чистота против реальности
Есть ещё одно правило, которое влияет на разработку — даже отличающихся от нормативных — стандартов, соответствовать которым официально необязательно, например таблиц стилей по умолчанию:
> Стандарт не имеет смысла, если он не описывает реальность.
>
>
Успешный стандарт должен быть предписывающим, то есть должен указывать браузерам, что реализовывать и ретроактивно дескриптивным (описывать, чтó в браузерах реализовано фактически). Теоретически идеальная спецификация бесполезна, если в ней нет точного описания веба.
Новые стандарты часто пишутся для объяснения принципа работы новой функции, реализуемой в соответствии с этими стандартами в браузерах. Но это лишь первый этап сложного процесса. Существующие стандарты регулярно пересматриваются. В них вносятся изменения, касающиеся фактической работы функций после реализации.
В идеале, когда реализация не соответствует спецификации, нужно считать это проблемой браузера и исправить её. А иногда требуется обновление спецификации. Это зависит от величины изменений, количества связанных с ними браузеров и сайтов.
Это не единственный способ получить [ошибку](https://wiki.csswg.org/ideas/mistakes) в дизайне CSS. Но их труднее устранить, когда они появляются таким образом. Опять же, согласованность в браузерах и во времени важнее теоретической чистоты самих стандартов.
### Внешний отступ во всех элементах body
В прошлом месяце я решила проследить истоки этого стиля:
```
body { margin: 8px; }
```
Зная, что он является частью таблицы стилей по умолчанию, я предположила, что это устаревший стиль, который появился в одном из первых браузеров и в конце концов был стандартизирован ради согласованности веба и браузера.
Но откуда он взялся изначально? Я задала вопрос в Твиттере, и в итоге отследить стиль в целом удалось.
#### Шаг первый. Спецификация
Алан Стернс — один из нынешних руководителей рабочей группы CSS — указал мне на первую спецификацию с отступом 8px в таблице стилей по умолчанию:
> «Сама спецификация [появилась](https://w3.org/TR/2003/WD-CSS21-20030128/sample.html) в 2003 году. В версии предыдущего года был внутренний отступ 8px».
>
>
> «Ой, ошибся на год. Внутренний отступ был в 2003 году. В 2004-м [изменён](https://w3.org/TR/2004/CR-CSS21-20040225/sample.html) на внешний».
>
>
Интересен переход от внутреннего отступа к внешнему. Но в этих таблицах стилей спецификации, скорее всего, стиль не создавался с нуля, описывалась какая-то прежняя реальность браузера.
#### Шаг 2. Первые браузеры
Есть ссылки, по которым я иногда перехожу, когда хочу почитать об истории CSS. Мои любимые — это документы-источники:
* Каскадные таблицы стилей HTML — [предложение](https://www.w3.org/People/howcome/p/cascade.html) **Хокона Ли**. Оно стало CSS.
* [Исторические](https://www.w3.org/Style/History/) предложения по таблице стилей.
Кроме того, есть отличные статьи о появлении CSS:
* [Краткая история](https://www.w3.org/Style/CSS20/history.html) CSS до 2016 года от соавтора оригинальной спецификации CSS Берта Боса.
* [Оглядываясь](https://css-tricks.com/look-back-history-css/) на историю CSS Джея Хоффмана о хитростях CSS.
* [Языки](https://eager.io/blog/the-languages-which-almost-were-css/), которые чуть не стали CSS Зака Блума.
Очень рекомендую почитать: вы поймёте принцип работы этого языка и то, почему он именно такой. Оттуда я [узнала](https://www.w3.org/Style/CSS20/history.html) о первых браузерах с CSS, но ответа на вопрос о внешнем отступе body не получила/
> «Кстати, IE3 был первым коммерческим браузером с CSS. Это 1996 год. Затем в Netscape 4 добавили поддержку. Но раньше этих двух CSS тестировался на Argo и Arena… Как давно это было???»
>
>
#### Шаг третий. Архивы www-talk и www-style
Конечно, большинство этих исторических предложений по стилю изначально написаны как электронные письма списка рассылки [www-talk@w3.org](https://lists.w3.org/Archives/Public/www-talk/) или позже на специально отведённый для них список рассылки [www-style@w3.org](https://lists.w3.org/Archives/Public/www-style/). Оба списка хорошо архивированы, по ним возможен поиск. Это одно из преимуществ среды, созданной кучкой гиков, помешанных на информатике.
Порывшись в архивах, я наткнулась на [письмо](https://lists.w3.org/Archives/Public/www-style/1998Mar/0092.html) Тодда Фарнера за март 1998 года:
> «В моей последней [редакции](http://www.verso.com/agitprop/corestyle/base.html) «Базовой таблицы стилей» задан внешний отступ 0, а внутренний — 8 пикселей. Ранее внешний был 8 пикселей, внутренний — 0, а позиция фонового изображения — -8px».
>
> …
>
>
Это ветка почтовой переписки, посвящённой правильной обработке фоновых изображений. Не совсем по теме, но есть внешние/внутренние отступы 8px элемента body.
#### Шаг четвёртый. The wayback machine
Ссылка на редакцию выше не сработала, поэтому я рванула на [The WayBack Machine](https://web.archive.org/). Нет ли там архивной копии? Есть, и не одна!
Сначала я попала в [базовую](https://web.archive.org/web/19990222082453/http://www.verso.com/agitprop/corestyle/base.html) таблицу стилей от 22 февраля 1999 года, которая последний раз менялась 7 ноября 1998 года. Затем перешла к самому первому архиву страницы — [базовой](https://web.archive.org/web/19990222082453/http://www.verso.com/agitprop/corestyle/base.html) таблице стилей от 30 января 1998 года. Последнее изменение было 04.07.2022 в 16:39:51 по Гринвичу: в тот самый момент я загрузила страницу. Что? Просматривая исходный код, я обнаружила следующее:
```
This is a work in progress, last modified
document.write(document.lastModified);
quite recently GMT...
```
Значит, document.lastModified обновляется в The WayBack Machine при каждой загрузке страницы?
#### Базовая таблица стилей
Вот то, что мы искали: [исходная](https://web.archive.org/web/19990222082453/http://www.verso.com/agitprop/corestyle/base.html) таблица стилей по умолчанию, по-прежнему в разработке. Примечательны несколько цитат:
> «В базовой таблице стилей описывается «согласованный по умолчанию» рендеринг всех элементов HTML 4.0 в браузерах-потомках Mosaic (Netscape Navigator и Microsoft Internet Explorer). И … фиксируется статус-кво, чтобы идти дальше».
>
>
Выше перечислены основные браузерные движки того времени, оба корнями восходят к Mosaic.
«Якобы нейтральная в браузере Mosaic таблица стилей по умолчанию — это простая адаптация нормативного стиля для (печатных) научных работ в Европе (cf. Wanning, Frank; Internationaler Typographie und wissenschaftliche Textverarbeitung; Haag + Herchen, 1996).
Вполне допустимо с учётом того, что Интернет появился в ЦЕРН. Но в свете гораздо большего распространения Интернета в коммерции, развлечениях, журналистике и гуманитарных науках, а также глубоко укоренившегося доминирования на рынке браузеров на основе Mosaic справедливо утверждать, что «правильный» HTML заражён ненадлежащим стилем, как раком или вирусом.
В результате распространения вируса таблицы стилей по умолчанию (браузера Mosaic) из научного сообщества ЦЕРН в Интернете появились поколения инструментов-мутантов и авторов, которые неправильно используют разметку исключительно для вызова определённых эффектов этой таблицы. Примеры сигнатур — использование для создания вертикальных пробелов и табличных структур для нетабулярной информации.
Высокая надёжность таких манипуляций приводит к гротескной каннибализации HTML за пределами академических кругов и рыночному успеху архитектурно несовместимых расширений HTML для облегчения симптомов.
Чтобы обратить вспять эту эпидемию, необходимо сначала изолировать вирус и подвергнуть его гены точным и всесторонним манипуляциям. Базовая таблица стилей — это модель CSS1 вируса таблицы стилей по умолчанию (браузера Mosaic) и первый шаг к разработке «стилевых антител», то есть полноценных альтернативных таблиц стилей для HTML».
Вот и всё. Эта таблица стилей нужна для захвата того, что уже происходило до существования CSS в браузерах на основе Mosaic, и воссоздания этих стилей в CSS. Интервал 8px в элементе body появился раньше CSS! Похоже, истоки стиля напрямую восходят к внутренним правилам Mosaic (ещё до появления CSS), поэтому остаётся один вопрос: представить его как внутренний или внешний отступ.
Базовая таблица стилей Тодда Фарнера (черновой вариант)
```
A, ABBR, ACRONYM, ADDRESS, BDO, BLOCKQUOTE, BODY, BUTTON, CITE, CODE, DD, DEL,
DFN, DIV, DL, DT, EM, FIELDSET, FORM, H1, H2, H3, H4, H5, H6, HTML, IFRAME, IMG, INS,
KBD, LABEL, LI, OBJECT, OL, P, Q, SAMP, SPAN, STRONG, SUB, SUP, UL, VAR,
APPLET, B, BIG, CENTER, DIR, FONT, HR, I, MENU, PRE, S, SMALL, STRIKE, TT, U {
background: transparent;
width: auto;
height: auto;
text-decoration: none;
margin: 0;
padding: 0;
border: 0;
float: none;
clear: none;
vertical-align: baseline;
list-style-image: none;
list-style-type: disc;
list-style-position: outside;
}
ADDRESS, BLOCKQUOTE, BODY, DD, DIV, DL, DT, FIELDSET, FORM, H1, H2, H3, H4, H5,
H6, OL, P, UL, CENTER, DIR, HR, MENU, PRE {
display: block;
}
A, ABBR, ACRONYM, APPLET, BDO, BUTTON, CITE, CODE, DEL, DFN, EM, IFRAME, IMG,
INS, KBD, LABEL, OBJECT, Q,
SAMP, SPAN, STRONG, SUB, SUP, VAR, B, BIG, FONT, I, S, SMALL, STRIKE, TT, U {
display: inline;
}
LI {
display: list-item;
}
/* Begin tree of inherited properties and cascades. */
/* Describes the default type, color, and link decoration specs of
Mosaic-derivative browsers to the extent and degree of granularity that users
may typically override. Uncomment for "factory settings." */
HTML {
font-family: "Times New Roman", Times;
font-size: medium;
color: black;
background-color: #BFBFBF;
}
PRE, TT, CODE, KBD, SAMP {
font-family: "Courier New", Courier;
}
A:link, A:visited, A:active {
text-decoration: underline;
}
A:link {
color: #0000FF;
}
A:visited {
color: #7F007F;
}
A:active {
color: #0000FF;
}
end pre-CSS user settings */
HTML {
line-height: 1.12;
word-spacing: normal;
letter-spacing: normal;
text-transform: none;
text-align: left;
text-indent: 0;
white-space: normal;
}
BODY {
padding: 8px;
}
H1 {
font-size: xx-large;
margin: .67em 0;
}
H2 {
font-size: x-large;
margin: .75em 0;
}
H3 {
font-size: large;
margin: .83em 0;
}
H4, P, BLOCKQUOTE, FIELDSET, FORM, UL, OL, DL, DIR, MENU {
margin: 1.12em 0;
}
H5 {
font-size: small;
margin: 1.5em 0;
}
H6 {
font-size: x-small;
margin: 1.67em 0;
}
H1, H2, H3, H4, H5, H6, B, STRONG {
font-weight: bolder;
}
BLOCKQUOTE {
margin-left: 40px;
margin-right: 40px;
}
I, CITE, EM, VAR, ADDRESS {
font-style: italic;
}
PRE, TT, CODE, KBD, SAMP {
font-family: monospace;
}
PRE {
white-space: pre;
}
BIG {
font-size: larger;
}
SMALL, SUB, SUP {
font-size: smaller;
}
SUB {
vertical-align: sub;
}
SUP {
vertical-align: super;
}
S, STRIKE, DEL {
text-decoration: line-through;
}
HR {
border: 1px inset; /* questionable */
}
OL, UL, DIR, MENU, DD {
padding-left: 40px;
}
OL LI {
list-style-type: decimal;
}
UL LI {
list-style-type: disc;
}
UL UL, UL OL, UL MENU, UL DIR, MENU UL, MENU OL, MENU MENU, MENU DIR, DIR UL,
DIR OL, DIR MENU, DIR DIR, OL UL, OL OL, OL MENU, OL DIR {
margin-top: 0;
margin-bottom: 0;
}
OL UL, UL UL, MENU UL, DIR UL, OL MENU, UL MENU, MENU MENU, DIR MENU, OL DIR, UL
DIR, MENU DIR, DIR DIR {
list-style-type: circle;
}
OL OL UL, OL UL UL, OL MENU UL, OL DIR UL, OL OL MENU, OL UL MENU, OL MENU MENU,
OL DIR MENU, OL OL DIR, OL UL DIR, OL MENU DIR, OL DIR DIR, UL OL UL, UL UL UL,
UL MENU UL, UL DIR UL, UL OL MENU, UL UL MENU, UL MENU MENU, UL DIR MENU, UL OL
DIR, UL UL DIR, UL MENU DIR, UL DIR DIR, MENU OL UL, MENU UL UL, MENU MENU UL,
MENU DIR UL, MENU OL MENU, MENU UL MENU, MENU MENU MENU, MENU DIR MENU, MENU OL
DIR, MENU UL DIR, MENU MENU DIR, MENU DIR DIR, DIR OL UL, DIR UL UL, DIR MENU
UL, DIR DIR UL, DIR OL MENU, DIR UL MENU, DIR MENU MENU, DIR DIR MENU, DIR OL
DIR, DIR UL DIR, DIR MENU DIR, DIR DIR DIR {
list-style-type: square;
}
U, INS {
text-decoration: underline;
}
CENTER {
text-align: center;
}
CAPTION, COL, COLGROUP, LEGEND, TABLE, TBODY, TD, TFOOT, TH, THEAD, TR {
background: transparent;
text-decoration: none;
margin: 1px;
padding: 1px;
border: none;
float: none;
clear: none;
}
TABLE, TBODY, TFOOT, THEAD, TR {
display: block;
background-position: top left;
width: auto;
height: auto;
}
CAPTION, LEGEND, TD, TH {
display: inline;
vertical-align: baseline;
font-size: 1em;
line-height: 1.33em;
color: black;
word-spacing: normal;
letter-spacing: normal;
text-transform: none;
text-align: left;
text-indent: 0;
white-space: normal;
}
TH {
font-weight: bolder;
text-align: center;
}
CAPTION {
text-align: center;
}
/* not part of the legacy browser default sheet, but an obvious enhancement */
OL OL LI {
list-style-type: lower-alpha;
}
OL OL OL LI {
list-style-type: lower-roman
}
```
### Средство от вируса таблицы стилей по умолчанию (браузера Mosaic)?
План сработал не совсем так, как представлял Тодд Фарнер. Эта базовая таблица стилей продолжает существовать, при этом ряд стилей на основе Mosaic остаётся нетронутым. Для HTML нет полноценных альтернативных таблиц стилей — по крайней мере у w3c или поставщиков браузеров. И те, и другие слишком увлечены обратной совместимостью, чтобы вносить какие-либо радикальные изменения в стили веба по умолчанию.
Изменения если и будут, то разве что со стороны веб-авторов, которые могут подключить новую таблицу стилей, не беспокоясь об обратной совместимости. Конечно, можно пытаться создать новую полноценную таблицу стилей с помощью различных сбросов и нормализаторов. Однако при сбросах обычно слишком много удаляется (в надежде, что авторы вернут всё обратно), а с нормализаторами часто больше беспокойства о согласованности в браузерах, чем об улучшенных стилях.
Именно это привело Джен Симмонс к созданию [CSS Remedy](https://github.com/jensimmons/cssremedy). Я одна из основных участников, хотя в последнее время в проекте было немного работы. Цель — переосмыслить для современного Интернета таблицу стилей по умолчанию. Что было бы придумано сейчас, если бы нас не сдерживало то, что сделано в Mosaic почти 30 лет назад? Впереди ещё много дискуссий, но в [строке](https://github.com/jensimmons/cssremedy/blob/master/css/remedy.css#L47) 47 основной таблицы стилей CSS Remedy бесспорно одно:
```
body { margin: 0; }
```
В CSS Remedy в целом нет стремления сделать всё красиво — просто попробовать прийти к лучшему значению по умолчанию. Ещё есть проекты с менее гибким подходом для полностью разработанных стилей базовых элементов HTML.
В прошлом месяце Робин Рендл поделился мыслями о [The Smallest CSS](https://www.robinrendle.com/notes/the-smallest-css/), отвечающим на вопрос о том, какой наименьший CSS можно написать, чтобы HTML выглядел сколько-нибудь прилично. Это отличное исследование, которое вместилось в ~15 строках CSS.
А ещё мне нравятся [бесклассовые](https://css-tricks.com/no-class-css-frameworks/) фреймворки, полностью основанные на написании семантического html и без специальных селекторов. Взгляните и на [эти](https://github.com/dbohdan/classless-css) бесклассовые CSS-библиотеки.
Мне и самой не терпится попробовать что-то подобное. Посмотрим. Возможно, и этот сайт уже пора освежить. А мы поможем вам прокачать навыки или с самого начала освоить профессию, актуальную в любое время:
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_130722&utm_term=conc)
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_130722&utm_term=conc)
Выбрать другую [востребованную профессию](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_130722&utm_term=conc).
 | https://habr.com/ru/post/676666/ | null | ru | null |
# Ни дня без спорта — 2: перепрограммируем китайский браслет
У людей, занимающихся спортом, частым спутником на пробежках или заездах является смартфон с различными приложениями. С велосипедом проще, можно закрепить смартфон, к примеру, на руль и смотреть выдаваемые с датчиков данные. А что делать, если ты бежишь или едешь на лыжах? Можно закрепить смарт на руку, для этого есть специальные чехлы (в том числе поворотные). Но это неудобно и порой громоздко. К тому же русский витязь прямо не ходит.
В интернете есть различные статьи, в которых энтузиасты делают свои смарт-часы. Самостоятельно изготавливают или печатают корпус. Делают начинку. Но на алиэкспрессе много уже готовых устройств. Например, как на фото ниже. Если верить описанию, то прям супер устройство: измеряет пульс, давление, калории и еще чего-нибудь.
Откроем и посмотрим, что внутри.
**А на самом деле**
А на самом деле в браслете используются нанотехнологии. Он может измерять пульс и давление даже дистанционно на любом объекте. Помигают два зеленых светодиода и функция Random() выдает значение. Но, в общем, мне и не нужно, так как пульсометр у меня уже [есть](https://habr.com/ru/post/493384/).
Мозгом данного браслета является чип PHY6202 от производителя из Поднебесной Fengjia Microelectronics. Внутри у него Cortex-M0 и стандартный набор периферии. Память: 512кБ Flash, 138кБ SRAM и 128кБ ROM. В ROM содержится стек BLE и UART загрузчик, т.к. программируется чип через UART. Китайские товарищи заботливо вывели для UART контакты. Для перехода в режим UART bootloader нужно вывод TM подтянуть к высокому уровню и сбросить чип.
Утилиты и SDK для PHY6202 (а также для его старшего брата PHY6212) можно найти [тут](http://wiki.phyplusinc.com/doku.php).
Непосредственно для программирования чипа предусмотрена утилита PhyPlusKit. В документации есть список команд: стирание, запись и др. Подробности в документе PHY62XX\_UART\_FlashWrite\_Protocol по ссылке выше (на китайском). Честно говоря, список команд описан не полный. PhyPlusKit использует еще одну команду **rdreg** (чтение любого регистра).
Приступим. Разбираем, припаиваем нужные контакты к UART-USB переходнику и вперед.
SDK содержит много примеров. Сама по себе она, на мой взгляд, кривовата и сыровата. Приходится иногда править исходники, т.к. они не рассчитаны на только «внешнее» использование. Вот функция замера уровня батареи из Battery Service. Зачем она там вообще непонятно.
```
static uint8 battMeasure( void )
{
uint8 percent;
percent = 95;
return percent;
}
```
Не SDK, а один сплошной пример.
Распиновка браслета такая:
| | |
| --- | --- |
| 1) акселерометр | SDA P32
SCL P33 |
| 2) LCD | SDA P25
SCL P31
RS P00
Reset P01
CS P02
LED P34 |
| 3) сенсорная кнопка | P03 |
| 4) вибромоторчик | P20 |
| 5) USB Vin (индикация подключения к USB) | P15 |
| 6) Vbat | P14/AIO3 |
| 7) Green LED (вдруг помигать захочется) | P23 |
Дисплей стандартный (на алиэкспрессе их полно) на ST7735 с разрешением 80\*160. Работает по SPI. Под него есть готовые библиотеки, но лучше сделать свою лайт-версию, под свой размер шрифта и свои символы. Дисплей цветной, но это на улице не сильно актуально, т.к. контрастность невысокая (с грустью вспомнил трансфлективные дисплеи от сименсовских телефонов). Да и стекло тонированное. Будем для отображения текста использовать белый цвет, его видно лучше всего.
Сенсорная кнопка сделана на чипе Tontec TTP233D-HA6.
Акселерометр неизвестный, но сканирование шины I2C показало, что он использует регистры как у всех ST акселерометров. Больше всего он похож на LIS2DH12. Вроде все управляющие регистры соответствуют.
Чтобы вывести свою информацию на браслет, нам нужен свой BLE-сервис для передачи данных. Что-то вроде SPP. Дополнительно можно добавить Battery Service и обновление прошивки через BLE.
За основу проекта возьмем пример прошивки для обновления OTA и переделаем под свои нужды. Добавим сервис для батарейки. Для передачи данных можно использовать пример реализации кастомного сервиса из SDK. Он использует один сервис FF01 и в нем одну характеристику FF02.
**Спойлер**
Все примеры из SDK при инициализации для всех GPIO выводов делают подтяжку к 0, для снижения потребления. Но есть один нюанс. С дисплея и акселерометра питание не снимается, даже когда процессор спит или выключен. И если в акселерометре выполнена подтяжка линий к питанию, то получится через этот pull-up и последующий pull-down (а он равен 100 кОм) будет просто так течь ток с десяток микроампер. Так на практике и оказалось. Изначально с родной прошивкой браслет в выключенном состоянии потреблял около 40 мкА, а если убрать «лишние» pull-down, то можно получить 15 мкА (столько по даташиту кушает спящий дисплей).
К работающим сервисам прикручиваем:
1. обработку прерываний по сенсорной кнопке. Помимо включения экрана и включения/выключения самого браслета, сделаем распознавание однократного и двойного нажатия с передачей команды через нашу FF02 характеристику.
2. вывод данных полученных со смартфона через ту же характеристику на дисплей.
3. короткое включение вибромоторчика для привлечения внимания.
4. используя акселерометр, включение экрана при резком взмахе рукой (настроить сложновато, т.к. при беге и так машешь руками).
Хорошо, браслет готов. Проверку делаем через nRFConnect, она позволяет и читать, и писать значения характеристик. На экране пульс, время, дистанция и еще один таймер (например, для вывода времени отставания или опережения графика, т.е. своеобразный pacemaker, но это только со своего приложения можно получить).
Надо теперь где-то взять данные, чтобы их передать. Я на данный момент пользуюсь приложением Strava, хотя она мне нравится все меньше. Пожалуй, самый простой способ получить от нее время пробежки и расстояние (правда, с округлением до 100 м) из уведомлений в статусбаре. Для этого надо написать приложение с сервисом для прослушивания уведомлений. Особого труда это не составляет. А вот пульс будем читать напрямую с BLE или ANT+ пояса. Ну а поскольку у нас есть уведомления от браслета о нажатии кнопок, то надо куда-нибудь их использовать. Например, можно, отправляя сообщения через BroadCastReceiver, ставить Страву на паузу и снова запускать. А лучше когда-нибудь сделать свою Страву with bells and whistles. Приложение требует прав для доступа к местоположению (это нужно для работы с BLE) и прав на доступ к уведомлениям.
Осталось проверить в деле. К сожалению зима закончилась еще в феврале, поэтому цикл из картинки в начале статьи уже завершился. Но можно и пробежаться. Акселерометр частенько включает экран без надобности, может быть его стоит выключить совсем. А сенсорная кнопка может среагировать на каплю, упавшую со лба.
А напоследок хорошая новость. Браслет уже с завода поддерживает обновление OTA через приложение PhyApp (лежит там же где и SDK, изначально на китайском языке). Поэтому, имея уже готовую прошивку, даже разбирать браслет не требуется. Прошивай и пользуйся. Для этого нужно установить приложение, положить в «корень» телефона прошивку (HEX, а не HEXF, т.к. последний содержит bootloader, который у нас уже есть с завода), подключиться к браслету и через кнопку OTA залить прошивку в браслет. После прошивки браслет будет выключен, для включения нужно подержать кнопку 2 сек.
В целом часы и браслеты на PHY62 можно без проблем переделать во что угодно.
Ссылки:
1. [исходники](https://github.com/greyfox13/StravaNotifier) и APK android-приложения (писалось под Android 8.1, под 9кой вроде работает, под другими не проверял);
2. [HEX файл](https://github.com/greyfox13/Phy6202Wrist) прошивки через BLE, и HEXF — для прошивки через UART (исходники мне не жалко, но нужно понять, что по лицензионному соглашению я могу выложить, а что нет, кто в этом спец пишите) + переведенное на английский язык приложение PhyApp для прошивки OTA.
3. браслет покупался [тут](https://www.aliexpress.com/item/33034606922.html), но гарантировать, что начинка будет аналогичная, я не могу, т.к. много одинаковых по виду, но с разным чипом. Есть вроде варианты с экраном побольше, в которых тоже стоят PHY6202. А вообще бывают часы/браслеты с разными чипами (Phy+, Telink, и даже nRF).
PS Вообще очень похоже, что SDK для PHY62 была создана на основе SDK от Texas Instruments для их BLE чипов. | https://habr.com/ru/post/499774/ | null | ru | null |
# Google раскрыла незакрытую уязвимость в Edge и IE
Сотрудники подразделения Project Zero опубликовали информацию о незакрытом баге в браузерах Internet Explorer и Edge. Баг позволяет осуществить атаку с удалённым исполнением кода через аварийное прекращение работы браузера. Впервые о нём было сообщено в Microsoft ровно три месяца назад — 25 декабря 2016 года. Компания Microsoft до сих пор не удосужилась выпустить патч, поэтому Google выложила информацию в открытый доступ.
В подробностях баг описан на [странице баг-трекера Chromium](https://bugs.chromium.org/p/project-zero/issues/detail?id=1011).
Судя по описанию, баг содержится в путанице классов *HandleColumnBreak
OnColumnSpanningElement*. На странице баг-трекреа есть 17-строчный пример, с помощью которого можно обрушить этот процесс. Основное внимание здесь следует уделить переменным *rcx* и *rax*.
```
.class1 { float: left; column-count: 5; }
.class2 { column-span: all; columns: 1px; }
table {border-spacing: 0px;}
function boom() {
document.styleSheets[0].media.mediaText = "aaaaaaaaaaaaaaaaaaaa";
th1.align = "right";
}
| | |
| --- | --- |
```
«Злоумышленник может повлиять на rax, изменяя свойства таблицы, такие как border-spacing и width для первого th элемента, — сказано в сообщении Project Zero. — Таким образом, созданной веб-странице нужно лишь указать *rax* в памяти, которая уже под контролем».
Информация об уязвимости опубликована в соответствии со стандартным условием о 90 днях «молчания», которое принято в Google и большинстве других хакерских организаций, которые специализируются на поиске уязвимостей. В соответствии с этими правилами, первым делом информация сообщается компании-разработчику, чтобы она исправила баг. Если она этого неделает, то в течение 90 дней (или иного интервала) информация об эксплуатации уязвимости выкладывается в открытый доступ. С этого момента кто угодно может легко использовать баг в Windows (IE), который работает практически на всех компьютерах под Windows в мире. Вы можете за несколько минут установить трояны на сотни тысяч компьютеров и заработать миллионы долларов.
Предполагается, что такой мощный стимул — повсеместная эксплуатация бага — стимулирует разработчика быстрее выпустить патч. Эта логика действует в том случае, когда баг реально уже эксплуатируется.
В прошлый раз такая несогласованность действий Google и Microsoft возникла в [ноябре 2016 года](https://habrahabr.ru/post/314142/). Тогда специалисты Google Threat Analysis Group опубликовали факт наличия опасной уязвимости в Windows [всего через 10 дней](https://security.googleblog.com/2016/10/disclosing-vulnerabilities-to-protect.html) после того, как сообщили о ней в Microsoft. У редмондской компании просто физически не было времени, чтобы проверить баг, протестировать его на всех конфигурациях, подготовить патч, протестировать его на всех конфигурациях — и выкатить обновление в Windows Update. Google пошла на такой шаг, потому что обнаруженная уязвимость уже активно эксплуатировалась хакерами. По [регламенту](https://security.googleblog.com/2013/05/disclosure-timeline-for-vulnerabilities.html) Google Threat Analysis Group, срок публикации информации об активно эксплуатируемых уязвимостях составляет 7 дней. Можно сказать, что в данном случае компании Microsoft дали поблажку.
Компания Google не первый раз разглашает информацию о незакрытых уязвимостях в Windows. То же самое она сделала несколько раз в прошлом году, за что её [подвергли критике коллеги из Microsoft](https://blogs.technet.microsoft.com/msrc/2015/01/11/a-call-for-better-coordinated-vulnerability-disclosure/). Якобы такие действия подвергают опасности миллионы пользователей Windows. Однажды ситуация была даже интереснее, потому что Microsoft специально просила Google подождать ещё несколько дней с разглашением — дать им время выпустить патч для Windows 8.1, но Google не отступилась. Принципы есть принципы.
Кажется, что у двух компаний просто разные взгляды на проблему. Google считает, что информирование пользователей об опасности только повышает общую безопасность и заставит раньше выпустить патч. Microsoft считает, что незачем выносить грязное бельё на публику.
[Статистика за 2015-2016 годы](https://docs.google.com/spreadsheets/d/1nqBd7zmg6grVBEws_UPXFBIdZT_0ISjIaHPK4cJvjII/edit) показывает минимальное количество уязвимостей у Edge и Safari: 134 и 191, соответственно. В то же время у IE и Chrome найдено по 346. Но оцените степень опасности этих уязвимостей. У Edge уязвимости на исполнение кода — 74 (55,22% от общего количества), у IE — 239 (69,08%), у Safari — 132 (69,11%). В то время как у Chrome — всего десять штук за два года, из них восемь в 2015 году и две в 2016 году (2,89% от общего количества).
[Полная версия таблицы](https://docs.google.com/spreadsheets/d/1nqBd7zmg6grVBEws_UPXFBIdZT_0ISjIaHPK4cJvjII/edit). Примечание: в таблице учтены найденные уязвимости во всех версиях браузеров
В настоящее время баг зарегистрирован под идентификатором CVE-2017-0037. | https://habr.com/ru/post/355622/ | null | ru | null |
# Беззахватные алгоритмы: модель «сделай, запиши,(поручи другому)»
*Следуя совету хабрапублики, пробую новый вариант перевода термина "**lock-free**"*
В [прошлый раз](http://habrahabr.ru/blogs/system_programming/118515/) мы видели «беззахватный по духу» алгоритм, где захват был реализован так, что поток, обращающийся к захваченным данным, не ждёт их освобождения, а отправляется «обходным путём» (вычисляет требуемый результат, не пользуясь услугами кэша). В своём следующем посте Реймонд объясняет, как данный алгоритм можно усовершенствовать на случай, когда «обходного пути» нет. Алгоритм, однако, остаётся беззахватным: каждый поток продолжает работать, не дожидаясь освобождения захваченных данных.
В общей переменной теперь нужны два служебных бита: вдобавок к флагу захвата, как в прошлом примере, — флаг «поручена новая работа»; а если порученная работа сложная, то кроме флага, нужно будет где-то хранить ещё и её параметры. Например, в общей переменной можно хранить указатель на (выравненный в памяти) объект с параметрами, а в свободных младших битах указателя — два названных флага.
Перед выполнением действия над объектом, первым делом мы его захватываем, атомарно устанавливая соответствующий флаг. Если окажется, что объект уже был захвачен, — поручим выполнение нашего действия захватившему потоку, установив второй флаг.
Если же объект удалось захватить, то после завершения работы с ним снимаем флаг захвата и одновременно проверяем, не поручили ли нам новую работу. (Т.е. не было ли обращений к объекту за то время, пока мы его держали захваченным.) Если есть работа, то мы выполним и её; и так далее, пока однажды при разблокировке объекта отложенной работы не окажется. Мы не вправе оставить объект в состоянии «не захвачен, но есть работа».
Получившаяся модель «сделай, запиши,(поручи другому)» сплетена из множества циклов на случай всевозможных неудач. Каждая атомарная операция заключается в цикл; выполнение отложенной работы осуществляется в цикле; и каждый раз, когда вызов `InterlockedCompareExchange` выявляет перезапись использованных данных, нужно откатить всю сделанную работу, и выполнять её с начала. Модель выходит весьма запутанная. Реймонд характеризует её так: «Во всём мире, пожалуй, лишь пятеро смогут её верно реализовать, и я к этим пятерым не отношусь.» Тем не менее, в качестве иллюстрации он приводит пример объекта под названием GroupWait, который поддерживает две операции: * AddWait: Добавить в список новый хэндл события.
* SignalAll: Установить все события в списке, автоматически удаляя каждое событие одновременно с его установкой. Чтобы событие установилось при следующем вызове SignalAll, его нужно добавить в список снова.
Реализован объект просто как список хэндлов. Понятно, что его можно было бы реализовать и без мудрёной беззахватной модели: например, при помощи [атомарных функций над списками](http://msdn.microsoft.com/en-us/library/ms684121.aspx), реализованных начиная с Windows XP. Задача выбрана лишь для того, чтобы сопроводить словесное описание примерным кодом. Не принимайте GroupWait за образец реализации потоко-безопасного списка.
Итак, младшие два бита указателя мы задействуем для хранения двух флагов: флага захвата, указывающего, что некий поток выполняет операцию над списком; и флага работы, указывающего, что пользователь потребовал установку событий в то время, пока список был захвачен.
```
// WARNING! IF YOU USE THIS CODE YOU ARE AN IDIOT - READ THE TEXT ABOVE
struct NODE;
NODE *Node(LONG_PTR key) { return reinterpret_cast(key); }
enum {
Locked = 1,
Signalled = 2,
};
struct NODE {
NODE \*pnNext;
HANDLE hEvent;
LONG\_PTR Key() { return reinterpret\_cast(this); }
NODE \*Ptr() { return Node(Key() & ~(Locked | Signalled)); }
};
#define NODE\_INVALID Node(-1)
class GroupWait {
public:
GroupWait() : m\_pnRoot(NULL) { }
~GroupWait();
BOOL AddWait(HANDLE hEvent);
void SignalAll();
private:
NODE \*m\_pnRoot;
};
```
Поскольку объединяем в одном значении указатель на элемент списка и пару флагов, то для удобства стоит определить методы, преобразующие используемые типы один в другой: `Node` возвращает указатель, `Key` — числовое значение, и `Ptr` — годный к использованию указатель (без флагов в младших битах).
Изображать наши значения будем как битовые поля вида `p|S|L`: p — указатель на следующий элемент списка; S — флаг работы; и L — флаг захвата. Установленный флаг S означает, что нужно обработать все элементы списка, начиная *со следующего* — представьте себе его обозначенным не внутри элемента, а на исходящей стрелке.
Например:
```
m_pnRoot
+--------+-+-+
| * |0|1|
+---|----+-+-+
|
v
+--------+-+-+---------+
A | * |1|?| hEvent1 |
+---|----+-+-+---------+
|
v
+--------+-+-+---------+
B | * |?|?| hEvent2 |
+---|----+-+-+---------+
|
v
+--------+-+-+---------+
C | NULL |?|?| hEvent3 |
+--------+-+-+---------+
```
Изображён объект GroupWait, содержащий три хэндла. Сброшенный флаг S в голове списка означает, что никто не требовал установить событие hEvent1. Напротив, установленный флаг S в элементе A означает, что нужно обойти все элементы после A и установить соответствующие события — а именно, hEvent2 и hEvent3. В частности, значение флага S в элементах B и C не имеет значения; эти элементы будут обработаны в любом случае, потому что того требует флаг S в элементе A. Таким образом, значение флага S в последнем элементе списка вообще никогда не имеет значения.
Флаг L используется только в голове списка; во всех остальных элементах он не имеет значения.
Итак, приготовления завершены; добавляем в список новый хэндл.
```
BOOL GroupWait::AddWait(HANDLE hEvent)
{
NODE *pnInsert = new(nothrow) NODE;
if (pnInsert == NULL) return FALSE;
pnInsert->hEvent = hEvent;
NODE *pn;
NODE *pnNew;
do {
pn = InterlockedReadAcquire(&m_pnRoot, NODE_INVALID);
pnInsert->pnNext = pn;
pnNew = Node(pnInsert->Key() | (pn->Key() & Locked));
} while (InterlockedCompareExchangeRelease(&m_pnRoot, pnNew, pn) != pn);
return TRUE;
}
```
Мы добавляем в начало списка новый элемент, и следим, чтобы флаг L из старого элемента перешёл в новый: иначе может получиться, что другой поток уже захватил список, а мы его ненароком «освободили». Флаг S в добавляемом элементе сброшен: никто ещё не требовал установить новое событие. Добавляем элемент в голову списка мы по знакомой модели «сделай, запиши,(попытайся снова)» — проверяя, что никто не изменил список за нашей спиной. Обратите внимание, что «проблемы ABA» не возникает: даже если неизменившееся значение `m_pnRoot` указывает уже на другой объект, то мы всё равно используем только сам указатель, а не содержимое объекта.
Простота метода AddWait необычна для модели «сделай, запиши,(поручи другому)»: в случае неудачи нам нечего перепоручить — вся работа заключается в одной записи в память. Расплачиваться за эту простоту будут остальные методы, в которых придётся предусмотреть обработку элементов, добавленных в список за то время, пока он был захвачен.
Метод SignalAll получается настолько сложным, что читать его лучше по частям.
```
void GroupWait::SignalAll()
{
NODE *pnCapture;
NODE *pnNew;
do {
pnCapture = InterlockedReadAcquire(&m_pnRoot, NODE_INVALID);
if (pnCapture->Key() & Locked) {
pnNew = Node(pnCapture->Key() | Signaled);
} else {
pnNew = Node(Locked);
}
} while (InterlockedCompareExchangeAcquire(&m_pnRoot,
pnNew, pnCapture) != pnCapture);
if (pnCapture->Key() & Locked) return;
...
```
Если список захвачен, то единственное, что от нас требуется — установить в его голове флаг S. Если же список свободен, то попытаемся его захватить, и одновременно «украдём» все элементы списка, записывая вместо головы «заглушку» `NULL|0|1`. В обоих случаях перезапись головы списка осуществляется по модели «сделай, запиши,(попытайся снова)» — повторяем попытки, пока запись не удастся.
Установив флаг S, мы перепоручили нашу работу потоку, захватившему список. Установленный флаг S в голове списка означает, что обработать нужно все следующие за головой элементы списка — т.е. вообще все элементы списка; как раз то, что нам нужно. Поток, захвативший список, проверит флаг при освобождении списка, и выполнит работу за нас.
Если же список не был захвачен, то нашим действием мы его захватили. «Украденные» элементы не видны другим потокам, так что одновременный вызов SignalAll с разных потоков не приведёт к многократной установке событий.
```
...
NODE *pnNext;
NODE *pn;
for (pn = pnCapture->Ptr(); pn; pn = pnNext) {
SetEvent(pn->hEvent);
pnNext = pn->pnNext->Ptr();
delete pn;
}
...
```
Обход «украденного» списка реализован очень прямолинейно, безо всякой заботы о потоко-безопасности; просто берём элемент за элементом, устанавливаем событие, и удаляем элемент. Единственная особенность — вызов `Ptr` для удаления флагов из указателя на следующий элемент.
Теперь список надо разблокировать. Для начала:
```
...
pnCapture = pnNew;
...
```
В начале метода мы записали `pnNew` в `m_pnRoot`, и если это значение так и сохранилось в голове списка — значит, мы легко отделались: никто не обращался к списку за то время, пока мы с ним работали.
```
...
for (;;) {
pnNew = Node(pnCapture->Key() & ~Locked);
if (InterlockedCompareExchangeRelease(&m_pnRoot,
pnNew, pnCapture) == pnCapture) {
return;
}
...
```
Вначале проверим, изменился ли список: если нет, достаточно его лишь разблокировать — и готово. Иначе начинаем новый цикл: нужно выполнить всю отложенную работу, накопившуюся, пока список был захвачен.
```
...
pnCapture = InterlockedReadAcquire(&m_pnRoot, NODE_INVALID);
NODE *pnNew = Node(pnCapture->Key() & ~(Locked | Signaled));
NODE **ppn = &pnNew
NODE *pn;
NODE *pnNext;
BOOL fSignalSeen = FALSE;
for (pn = pnNew; pn->Ptr(); pn = pnNext) {
pnNext = pn->Ptr()->pnNext;
if (fSignalSeen) {
SetEvent(pn->Ptr()->hEvent);
delete pn->Ptr();
} else if (pn->Key() & Signaled) {
fSignalSeen = TRUE;
(*ppn) = Node(Locked); // украсть, оставив захваченным
SetEvent(pn->Ptr()->hEvent);
delete pn->Ptr();
} else {
ppn = &pn->Ptr()->pnNext;
}
}
} // снова попытаемся разблокировать
} // конец функции
```
Чтобы выполнить отложенную работу, мы обходим список, пока не найдём установленный бит S. В первом элементе, в котором бит S установлен, мы обнуляем исходящий указатель, чтобы «украсть» остаток списка; затем, обходя этот остаток, мы устанавливаем каждое событие, и удаляем элемент. Как и прежде, мы «крадём» список затем, чтобы одновременный вызов с нескольких потоков не привёл к многократной установке события. В конце, когда работа выполнена, мы снова пытаемся разблокировать список — в расчёте на то, что однажды новой работы не окажется, и мы сможем с полным правом выйти из функции.
---
Как видите, основная идея модели «сделай, запиши,(поручи другому)» достаточно проста, но от её реализации с учётом всех тонкостей может разболеться голова. Лучше всего оставить реализацию таких штук системным программистам, у которых достаточно времени, терпения и способностей, чтобы со всем этим справиться. Например, в интервью "[Arun Kishan: Inside Windows 7 — Farewell to the Windows Kernel Dispatcher Lock](http://channel9.msdn.com/shows/Going+Deep/Arun-Kishan-Farewell-to-the-Windows-Kernel-Dispatcher-Lock/)" архитектор, работавший над ядром Windows, рассказывают о применении именно этой модели. | https://habr.com/ru/post/118850/ | null | ru | null |
# Работа с ICQ в Java
#### Предыстория
Как-то раз мы решили создать [свой собственный микроблоггинг](http://joyreactor.ru) ~~с блекджеком и шлюхами~~ c шахматами и поэтессами. Сначала сделали сайт, но быстро стало понятно, что для реализации идеи его недостаточно. Необходимо было работать с сообщениями через Jabber и ICQ.
Начали с простого — с джаббера. Никаких проблем тут не возникло — мы писали на Java, поэтому прикрутили [Smack API](http://www.igniterealtime.org/projects/smack/) и все заработало. Но, как это не печально, но самым популярным IM протоколом все еще является ICQ…
#### Задача
Итак, задача: залогиниться в ICQ, принимать и отправлять сообщения, понимать X-статусы, работать с кириллицей.
Рассмотрим пути решения.
#### Пути решения
\* [icq java library](http://www.google.ru/search?q=icq+java+library) — найти и использовать некий аналог Smack API для ICQ
\* [PyICQt](http://code.google.com/p/pyicqt/) — использовать личный ICQ транспорт и работать с ним через то же самое Smack API
\* забить на ICQ и продолжать использовать православный Jabber — без комментариев)))
##### icq java library
Методом глубинного гугления по вышеупомянутому запросу "[icq java library](http://www.google.ru/search?q=icq+java+library)" удалось найти следующее:
Библиотека — Последнее обновление
[exeQ](http://sourceforge.net/projects/exeqlib/) — 2539 дней назад
[OpenMIM](http://sourceforge.net/projects/openmim/) — 240 дней назад
[joscar](http://code.google.com/p/joscar/) — < 30 дней назад
*Параметр «Последнее обновление» характеризует заброшенность библиотеки. При выборе библиотеки ICQ совершенно необходимо учитывать ее заброшенность.* Дело в том, что владельцем ICQ является корпорация AOL. Там работают очень добрые и веселые люди, которые ради лулзов меняют протокол ICQ примерно пару раз в год, из-за чего сторонние клиенты и библиотеки ВНЕЗАПНО перестают работать до тех пор, пока авторы их не починят.
По понятным причинам из перечисленных библиотек пристального внимания заслуживает только joscar, однако на момент написания статьи у него были серьезные проблемы с кириллицей, однако есть надежда, что в ближайшем будущем они будут устранены.
Тем временем мы переходим к следующему способу.
##### PyICQt
Бытует мнение, что ICQ-транспорт — это зло. И это правда, но есть один нюанс: **публичный ICQ-транспорт — это зло.**
Проблемы в работе публичных ICQ-транспортов связаны с тем, что сервера ICQ жестко ограничивают количество соединений с одного клиентского IP, поэтому транспорт может нормально обслуживать только очень небольшое число клиентов.
Публичный транспорт нас не устраивает, значит придется поднять свой собственный.
Процедура установки/настройки PyICQt+EJabberd достаточно проста и описана, например, [здесь](http://sviver88.blogspot.com/2009/07/icq-pyicq-ejabberd-freebsd.html). Нас больше интересует клиентская часть.
Итак, мы подняли jabber-сервер, расположенный по адресу jabber.joyreactor.ru и icq-транспорт на нем с адресом icq.jabber.joyreactor.ru.
Теперь нужно создать пользователя, от имени которого будем подключаться:
`ejabberdctl register username jabber.joyreactor.ru password`
Далее логинимся от его имени на наш сервер любым jabber-клиентом и добавляем нашему пользователю icq-транспорт с помощью Service Discovery. Все готово! Можно переходить к Java.
Нам потребуется [Smack API](http://www.igniterealtime.org/downloads/index.jsp#smack):
> import org.jivesoftware.smack.\*;
а также следующая информация:
> Roster.setDefaultSubscriptionMode(SubscriptionMode.accept\_all);
>
> XMPPConnection icqConnection = new XMPPConnection(ICQ\_HOST);
>
> icqConnection.connect();
>
> SASLAuthentication.supportSASLMechanism("PLAIN", 0); // Для подключения к EJabberd
>
> icqConnection.login(ICQ\_LOGIN, ICQ\_PASS);
>
>
Подключаемся:
> Roster.setDefaultSubscriptionMode(SubscriptionMode.accept\_all);
>
> XMPPConnection icqConnection = new XMPPConnection(ICQ\_HOST);
>
> icqConnection.connect();
>
> SASLAuthentication.supportSASLMechanism("PLAIN", 0); // Для подключения к EJabberd
>
> icqConnection.login(ICQ\_LOGIN, ICQ\_PASS);
>
>
ставим обработчики:
> RosterListener rosterListener = new RosterListener() {
>
> public void entriesAdded(Collection<String> arg0) {
>
> Roster roster = connection.getRoster();
>
> RosterGroup gr = roster.getGroup("Users");
>
> if(gr == null)
>
> gr = roster.createGroup("Users");
>
> for(String entry : arg0 ) {
>
> try {
>
> String[] groups = {"Users"};
>
> if(roster.getEntry(entry) == null)
>
> roster.createEntry(entry, null, groups);
>
> } catch (XMPPException ex) {
>
> //TODO: Handle exception.
>
> }
>
> }
>
> }
>
> public void entriesUpdated(Collection<String> arg0) {
>
> Roster roster = connection.getRoster();
>
> RosterGroup gr = roster.getGroup("Users");
>
> if(gr == null)
>
> gr = roster.createGroup("Users");
>
> for(String entry : arg0 ) {
>
> try {
>
> String[] groups = {"Users"};
>
> if(roster.getEntry(entry) == null)
>
> roster.createEntry(entry, null, groups);
>
> } catch (XMPPException ex) {
>
> //TODO: Handle exception.
>
> }
>
> }
>
> }
>
> public void entriesDeleted(Collection<String> arg0) { }
>
> public void presenceChanged(Presence packet) {
>
> try {
>
> org.jivesoftware.smack.packet.Presence prs = (org.jivesoftware.smack.packet.Presence) packet;
>
> if(!prs.getFrom().split("@")[1].equalsIgnoreCase(ICQ\_TRANSPORT))
>
> //TODO: Process presence.
>
> } catch (Exception ex) {
>
> //TODO: Handle exception.
>
> }
>
> }
>
> };
>
> PacketListener icqListener = new PacketListener() {
>
> public void processPacket(Packet packet) {
>
> try {
>
> org.jivesoftware.smack.packet.Message msg = (org.jivesoftware.smack.packet.Message) packet;
>
> if(msg.getType() != org.jivesoftware.smack.packet.Message.Type.error &&
>
> msg.getFrom().split("@")[1].equalsIgnoreCase(ICQ\_TRANSPORT))
>
> //TODO: Process message.
>
> } catch (Exception ex) {
>
> //TODO: Handle exception.
>
> }
>
> }
>
> };
>
> icqConnection.getRoster().addRosterListener(icqRosterListener);
>
> icqConnection.addPacketListener(icqListener, new PacketTypeFilter(org.jivesoftware.smack.packet.Message.class));
>
>
отправляем сообщение:
> org.jivesoftware.smack.packet.Message message = new org.jivesoftware.smack.packet.Message("587641264"+"@"+ICQ\_TRANSPORT);
>
> message.setBody("Hello world!!!");
>
> icqConnection.sendPacket(message);
#### Мораль
Во время решения поставленной задачи столкнулись с множеством проблем, главная из которых — быстрое устаревание протокола ICQ. Обойти смогли только с помощью личного ICQ-транспорта, который, как выяснилось, настраивается относительно несложно.
Исходники [тут](http://code.assembla.com/empaty/subversion/nodes/em).
Было бы интересно послушать про аналогичный опыт у вас. | https://habr.com/ru/post/79911/ | null | ru | null |
# Нахождение 3-го элемента от конца связного списка в Java
*От переводчика:
Данная статья является переводом [статьи](http://javarevisited.blogspot.com/2016/07/how-to-find-3rd-element-from-end-in-linked-list-java.html?m=1#ixzz50JB6C7d9), опубликованной в блоге javarevisited. Она может быть интересна как новичкам, так и опытным программистам при подготовке к собеседованиям. В дальнейшем, планируется перевод цикла статей об алгоритмах и рецептах решений проблем как типового, так и академического характера. С удовольствием принимаются конструктивные предложения и замечания как по качеству перевода, так и по выбору новых статей*
Нахождение 3-го элемента от конца в односвязном списке или n-го узла от хвоста является одним из каверзных и часто задаваемых вопросов по проблемам односвязных списков на собеседованиях. Задача, в данном случае, в том, чтобы решить проблему всего в один проход цикла, т.е., нельзя снова пройтись по связному списку и нельзя идти в обратном направлении, т.к. список односвязный. Если вы когда-нибудь решали проблемы связных списков, например, [нахождение длины](http://javarevisited.blogspot.com/2016/05/how-do-you-find-length-of-singly-linked.html), вставки или удаления элементов, вы должны уже быть знакомы с вопросом обхода списков. В данной статье мы используем тот же самый алгоритм, который мы использовали для [нахождения срединного элемента связного списка в один проход цикла](http://javarevisited.blogspot.com/2012/12/how-to-find-middle-element-of-linked-list-one-pass.html). Этот алгоритм также известен как **«алгоритм черепахи и зайца»** из-за скорости двух указателей, используемых алгоритмом для обхода односвязного списка.
Если вы помните, алгоритм использует два указателя — быстрый и медленный. Медленный указатель начинает обход, когда быстрый достигает N-ого элемента, например, для нахождения 3-го элемента от конца, второй указатель начнет обход, когда первый указатель достигнет 3-го элемента.
После этого, оба указателя двигаются на один шаг за итерацию, пока первый указатель не будет указывать на *null*, что говорит о достижении конца связного списка. В этот момент, второй указатель указывает на 3-й или N-й узел от конца. Проблема решена, вы можете либо вывести значение узла, либо вернуть ссылку вызывающей стороне в соответствии с вашими требованиями.
Это одна из многих проблем структур данных и и алгоритмических проблем, с которыми вы столкнетесь на типичном собеседовании (см. [Cracking the Coding Interviews](https://www.amazon.com/dp/098478280X/?tag=javamysqlanta-20)). Поскольку связанный список является популярной структурой данных, вопросы по нахождению в цикле и определению длины связанных списков, так же как и освещаемый в данной статье, довольно популярны.
Программа на Java по нахождению N-го узла от хвоста связанного списка
---------------------------------------------------------------------
Далее приведен полный листинг программы на Java по нахождению N-го элемента от конца односвязного списка. Данная программа решает задачу в один проход, т.е., обход связного списка производится только один раз. Как вы видите, мы использовали всего один цикл while в методе getLastNode(int n). Данный метод принимает целочисленный параметр и может использоваться для нахождения n-го элемента от конца связного списка, например, для 2-го элемента от хвоста, необходимо 2 шага, а для получения 3-го элемента списка — 3.
Класс [SinglyLinkedList](http://www.java67.com/2016/01/how-to-implement-singly-linked-list-in-java-using-generics-example.html) представляет собой односвязный список в Java. Это тот же класс, который мы использовали ранее в статьях об односвязных списках, например, о реализации связного списка в Java. Это коллекция класса Node, представляющего собой узел связного списка. Он содержит часть данных и ссылку на следующий узел. Класс *SinglyLinkedList* также содержит ссылку на голову, т.е. [первый узел](http://www.java67.com/2015/07/how-to-add-element-at-first-and-last-position-of-linked-list-java.html) связного списка.
Далее приведено визуальное объяснение нахождения 2-го элемента от хвоста односвязного списка. Видно, как быстрый и медленный указатели проходят по списку, и когда быстрый указатель указывает на хвост, медленный указывает на n-й узел от конца.
Как программист, вы должны знать основные структуры данных и алгоритмы, например, что такое связный список, ее достоинства и недостатки и когда его использовать, например, он хорош для частого добавления и удаления элементов, но уже не так хорош для поиска, т.к. поиск элемента в связном списке занимает O(n) времени. Вы можете прочесть больше о связных списках в хороших книгах о структурах данных и алгоритмах, как, например, [Введение в алгоритмы](http://www.amazon.com/dp/0072970545/?tag=javamysqlanta-20) Томаса Х. Кормена — одной из лучших книг для изучения этой темы.
Поначалу, вам может не понравиться эта книга, так как ее немного трудно понять из-за темы и стиля изложения, но вы должны следовать ей и обращаться к ней время от времени, чтобы понимать ключевые структуры данных, например, массивы, связные списки, деревья и т.д.
N-й узел от конца в односвязном списке
--------------------------------------
```
public class Practice {
public static void main(String args[]) {
SinglyLinkedList list = new SinglyLinkedList();
list.append("1");
list.append("2");
list.append("3");
list.append("4");
System.out.println("связный список : " + list);
System.out.println("Первый узел от конца: " + list.getLastNode(1));
System.out.println("Второй узел от конца: " + list.getLastNode(2));
System.out.println("Третий узел от конца: " + list.getLastNode(3));
}
}
/**
* Реализация структуры данных в виде связного списка на Java
*
* @author Javin
*
*/
class SinglyLinkedList {
static class Node {
private Node next;
private String data;
public Node(String data) {
this.data = data;
}
@Override
public String toString() {
return data.toString();
}
}
private Node head; // Голова - это первый узел связного списка
/**
* проверяет, пуст ли список
*
* @возвращает true если связный список пуст, т.е., узлов нет
*/
public boolean isEmpty() {
return length() == 0;
}
/**
* добавляет узел в хвост связного списка
*
* @param data
*/
public void append(String data) {
if (head == null) {
head = new Node(data);
return;
}
tail().next = new Node(data);
}
/**
* возвращает последний узел или хвост данного связного списка
*
* @return последний узел
*/
private Node tail() {
Node tail = head;
// Находит последний элемент связного списка, известный как хвост
while (tail.next != null) {
tail = tail.next;
}
return tail;
}
/**
* метод возвращающий длину связного списка
*
* @return длину, т.е, число узлов в связном списке
*/
public int length() {
int length = 0;
Node current = head;
while (current != null) {
length++;
current = current.next;
}
return length;
}
/**
* получения n-го узла от конца
*
* @param n
* @return n-й узел от последнего
*/
public String getLastNode(int n) {
Node fast = head;
Node slow = head;
int start = 1;
while (fast.next != null) {
fast = fast.next;
start++;
if (start > n) {
slow = slow.next;
}
}
return slow.data;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
Node current = head;
while (current != null) {
sb.append(current).append("-->");
current = current.next;
}
if (sb.length() >= 3) {
sb.delete(sb.length() - 3, sb.length());
}
return sb.toString();
}
}
```
*Вывод
связный список: 1-->2-->3-->4
первый узел от конца: 4
второй узел от конца: 3
третий узел от хвоста:*
Вот и все о **нахождении 3-го элемента с конца связного списка в Java**. Мы написали программу, решающую задачу в один проход с использованием подхода с двумя указателями, также известного как алгоритм зайца и черепахи, т.к. один указатель медленней второго. Это один из полезных приемов, т.к. вы можете использовать такой же алгоритм для определения цикла в связном списке, как показано [тут](http://javarevisited.blogspot.com/2013/05/find-if-linked-list-contains-loops-cycle-cyclic-circular-check.html). Вы также можете творчески подойти к использованию этого алгоритма при решении других проблем, когда необходим обход по связанному списку и манипулирование узлами одновременно. | https://habr.com/ru/post/345246/ | null | ru | null |
# Техники повторного использования кода и разбиения сложных объектов на составные
В этой статье я опишу различные техники повторного использования кода и разбиения сложных объектов на части, с которыми я столкнулся. Постараюсь объяснить, почему классическое наследование, а также некоторые другие популярные подходы не работают в сложных случаях, и какие есть альтернативы.
Возможно многих удивит, что в основе большинства подходов повторного использования кода и создания составных объектов лежат стандартные структуры данных – массив, список, словарь, дерево, граф.
Т.к. в последние годы я пишу на JavaScript и React, то они будут использоваться в некоторых примерах. Да и в целом, периодически я буду упоминать React и другие веб-технологии. Тем не менее, думаю, что значительная часть статьи должна быть понятна и полезна разработчикам из других стеков.
Для некоторых подходов я добавил схемы, чтобы показать, как организованы составляющие сложных объектов. Будет часто упоминаться [агрегация](https://ru.wikipedia.org/wiki/%D0%90%D0%B3%D1%80%D0%B5%D0%B3%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)) (агрегирование/делегирование/включение) и [композиция](https://en.wikipedia.org/wiki/Object_composition).
**Чтобы разделить логику одного сложного объекта на составные части, существуют несколько механизмов:**
* Разделение функционала на классы/объекты и смешивание их полей, методов в одном объекте.
* Вынесение части функционала в обертки и помещение в них основного объекта, либо вкладывание объектов один в другой с организацией списка вложенных объектов.
* Вынесение части функционала в отдельные объекты/функции и помещение их в основной объект.
* Разделение функционала объекта на независимые части и использование какого-то внешнего механизма для организации нужного поведения с использованием этих частей.
В статье же я разделил техники/паттерны в зависимости от получаемой структуры данных, используемой для хранения составляющих сложного объекта.
[**1) Объединение (смешивание) функционала нескольких объектов в одном**](#mixing)— **Смешивание и примеси (миксины)** —[**Классическое наследование**](#class)— [**Множественное наследование и интерфейсы**](#multiple-inheritance)
[**2) Композиция/агрегация с использованием списка**](#list)— **Прототипное наследование** — [**Паттерн декоратор и аналоги**](#decorator)
[**3) Композиция/агрегация с использованием одноуровневых структур данных (ссылка, массив ссылок, словарь)**](#array)— **Паттерн стратегия** — [**Entity Component (EC)**](#ec)
[**4) Композиция/агрегация с вынесением логики вне объекта и его составляющих**](#ecs)— **Entity Component System (ECS)**
[**5) Композиция/агрегация с использованием графов**](#graph)— **Паттерн State machine**
[**6) Композиция/агрегация с использованием деревьев**](#tree)— **Паттерн composite и другие древовидные структуры** — [**Behaviour tree**](#behaviour-tree)
[**7) Смешанные подходы**](#mixed)— **React hooks**
Объединение (смешивание) функционала нескольких объектов в одном
----------------------------------------------------------------
### Смешивание и примеси (миксины)
Самый простой, но ненадежный способ повторного использования кода – объединить один объект с другим(и). Подходит лишь для простых случаев, т.к. высока вероятность ошибки из-за замещения одних полей другими с такими же именами. К тому же, так объект разрастается и может превратиться в антипаттерн God Object.
Существует паттерн примесь (mixin/миксина), в основе которого лежит смешивание.
**Примесь** – это объект, поля и методы которого смешиваются с полями и методами других объектов, расширяя функциональность объекта, но который не используется сам по себе.
Можно добавить несколько миксин к одному объекту/классу. Тогда это схоже с множественным наследованием.
### Классическое наследование
**Здесь описывается классическое наследование, а не то, как наследование классов устроено в JS.**
Подразумеваю, что читатель уже знаком с понятиями "наследование" и "множественное наследование". В отличие от простого смешивания, в классическом наследовании есть ряд строгих правил и механизмов, которые позволяет избежать множество проблем. В основе классического наследования лежит все то же смешивание - члены нескольких объектов объединяются в один объект.
При наследовании происходит копирование членов родительского класса в класс-наследник. При создании экземпляра класса тоже происходит копирования членов класса. Я не исследовал детали этих механизмов, к тому же они явно отличаются в различных языках. Подробнее с этой темой можно ознакомиться в 4-ой главе книги "[Вы не знаете JS: this и Прототипы Объектов](https://github.com/azat-io/you-dont-know-js-ru/blob/master/this%20%26%20object%20prototypes/ch4.md#%D0%BF%D0%BE%D0%BB%D0%B8%D0%BC%D0%BE%D1%80%D1%84%D0%B8%D0%B7%D0%BC)".
**Когда можно использовать наследование, а когда не стоит?**Наследования не стоит использовать в качестве основной техники для повторного использования кода для сложных объектов. Его можно использовать совместно с композицией для наследования отдельных частей сложного объекта, но не для самого сложного объекта. Например, для React компонентов наследование плохо, а для частей (вроде объектных аналогов custom hooks) из которых мог быть состоять компонент-класс, наследования вполне можно использовать. Но даже так, в первую очередь стоит рассматривать разбиение на большее число составляющих или применения других техник, вместо наследования.
При возможности появления сложной иерархии наследование (более 2-х уровней, где первый уровень иерархии – родитель, а второй уровень - наследники) тоже не следует использовать наследование.
### Множественное наследование и интерфейсы
При использовании множественного наследования получаются довольно запутанные иерархии классов. Поэтому во многих языках отказались от множественного наследования реализации. Но множественное наследование по-прежнему применяют при наследовании абстракций в виде интерфейсов.
Интерфейсы есть, например, в Typescript. Реализация нескольких интерфейсов в одном классе отчасти похоже на наследование, но с их использованием «наследуется» только описание свойств и сигнатура методов интерфейса. Наследование реализации не происходит.
Интерфейсы следует понимать не как наследование, а как контракт, указывающий, что данный класс реализует такой-то интерфейс. Плохо, когда один класс реализует слишком много интерфейсов. Это означает, что-либо интерфейсы слишком сильно разбиты на части, либо у объекта слишком большая ответственность.
Композиция/агрегация с использованием списка
--------------------------------------------
### Прототипное наследование
При прототипном наследовании уже не происходит смешивания родительского объекта и его наследника. Вместо этого наследник ссылается на родительский объект (прототип).
При отсутствии свойства (поле, метод и т.д.) в объекте, происходит поиск этого свойства в цепочке прототипов. То есть часть функционала делегируется вложенному объекту, который тоже может делегировать функционал вложенному объекту внутри себя. И так далее по цепочке. Прототип на любом уровне цепочки может быть только один.
Стоит отметить, что в JavaScript операции записи/удаления работают непосредственно с объектом. Они не используют прототип (если это обычное свойство, а не сеттер). Если в объекте нет свойства для записи, то создается новое. [Подробнее об этом](https://learn.javascript.ru/prototype-inheritance#operatsiya-zapisi-ne-ispolzuet-prototip).
**Цепочка прототипов организована как стек (Last-In-First-Out или LIFO).** Какой объект добавлен в цепочку последним (если считать от итогового объекта-контейнера), к тому обращение будет первым.
Также существует вариант, когда при создании нового объекта с прототипом, создается копия прототипа. В таком случае используется больше памяти (хотя это проблема разрешаема), но зато это позволяет избежать ошибок в других объектах из-за изменения прототипа конкретного объекта.
### Паттерн Декоратор и аналоги
[**Декоратор**](https://refactoring.guru/ru/design-patterns/decorator) (wrapper/обертка) позволяет динамически добавлять объекту новую функциональность, помещая его в объект-обертку. Обычно объект оборачивается одним декоратором, но иногда используется несколько декораторов и получается своего рода цепочка декораторов.
**Цепочка декораторов устроена как стек (LIFO).** Какой объект добавлен в цепочку последним (если считать от итогового объекта-контейнера), к тому обращение будет первым.
Цепочка декораторов похожа на цепочку прототипов, но с другими правилами работы с цепочкой. Оборачиваемый объект и декоратор должны иметь общий интерфейс.
На схеме ниже пример использования нескольких декораторов на одном объекте:
Как в случае с прототипами, зачастую можно подменять декораторы во время выполнения. Декоратор оборачивает только один объект. Если оборачивается несколько объектов, то это уже что-то другое.
**HOF (higher order function) и HOC** **(Higher-Order Component)** - паттерны с похожей идей. Они оборачивают функцию/компонент другой функцией/компонентом для расширения функционала.
**HOF** - функция, принимающая в качестве аргументов другие функции или возвращающая другую функцию в качестве результата. Примером HOF в JS является функция bind, которая, не меняя переданную функцию, возвращает новую функцию с привязанным к ней с помощью замыкания значением. Другим примером HOF является карринг.
**HOC** - чистая функция, которая возвращает другой компонент (а он уже содержит в себе произвольную логику), который внутри себя "рендерит" переданный компонент. При этом сам переданный компонент не меняется, но в него могут быть переданы props.
Также стоит упомянуть **композицию функций.** Это тоже своего рода обертка. С помощью этой техники создаются цепочки вложенных функций:
```
const funcA = сompose(funcB, funcC, funcD);
```
или же менее читабельный вариант:
```
const funcA = ()=> {
funcB( funcC( funcD() ) ) ;
};
```
То же самое можно получить такой записью:
```
function funcA() {
function funcB() {
function funcC() {
function funcD()
}
}
}
```
Недостатком последнего варианта является жесткая структура функций. Нельзя поменять их очередность или заменить одну из функций без создания новой аналогичной цепочки или ее части. funcC нельзя использовать без funcD, а funcB без funcC и без funcD. В первых же двух примерах – можно. Там функции независимы друг от друга.
### Итого
Прототипное наследование и использование декораторов гибче, чем подходы со смешиванием.
Часто говорят: «предпочитайте композицию наследованию». Стоит учесть, что существует множество вариантов композиции с различной эффективностью в той или иной ситуации. Только от простой замены наследования на композицию, вряд ли получиться решить проблемы без появления новых проблем. Нужно еще выбрать подходящую замену.
Когда по аналогии с иерархией наследования используется несколько уровней вложения одних объектов в другие, получается иерархия вложенных объектов. Почти то же самое, что и наследование, только с возможностью подменять объекты в иерархии. Конечно, в случае декораторов этого обычно избегают и вместо иерархии получается цепочка. В цепочке декораторов выходит так, что каждый следующий используемый декоратор помимо своих членов классов должен реализовать члены всех остальных объектов в цепочке. В итоге, по аналогии с наследованием, снова получается раздутый объект с множеством полей и методов. На схеме выше был пример такого объекта - DecoratorC.
Зачастую при использовании нескольких декораторов на одном объекте не добавляют новые поля и методы, а лишь подменяют реализацию уже существующих членов объекта. Остается другой недостаток – из-за большой вложенности довольно сложно разобраться, что же делает итоговый составной объект, т.к. для этого надо пройтись по цепочке вложенных объектов.
Как видите, по-прежнему остаются довольно серьезные проблемы. Но, есть другие решения, о которых рассказано в следующих главах.
Композиция/агрегация с использованием одноуровневых структур данных (ссылка, массив ссылок, словарь)
----------------------------------------------------------------------------------------------------
Под одноуровневой структурой данных я подразумеваю структуру, элементы которой не ссылаются на другие элементы.
### Паттерн стратегия
Паттерны декоратор и стратегия служат для одной цели – с помощью делегирования расширить функциональность объекта. Но делают они это по разному. Хорошо описана эта [разница по ссылке](https://refactoring.guru/ru/design-patterns/strategy): «[**Стратегия**](https://refactoring.guru/ru/design-patterns/strategy) меняет поведение объекта «изнутри», а [**Декоратор**](https://refactoring.guru/ru/design-patterns/decorator) изменяет его «снаружи».»
Паттерн Cтратегия описывает разные способы произвести одно и то же действие, позволяя динамически заменять эти способы в основном объекте (контексте).
На схеме ниже пара примеров связи стратегий с основным объектом.
К похожим способам (использование ссылки) расширения функционала объекта и повторного использования кода можно отнести события в HTML элементах и директивы в Angular и Vue.
```
// html
// vue
```
### Entity Component (EC)
Я не знаю, как называется данный паттерн. В книге [Game Programming Patterns](https://martalex.gitbooks.io/gameprogrammingpatterns/content/) он называется просто "Компонент", а [по ссылке](http://entity-systems.wikidot.com/) его называют системой компонентов/сущностей. В статье же я буду называть его **Entity Component (EС)**, чтобы не путать с подходом, который будет описан в следующей главе.
**Сначала пройдемся по определением:**
* **Entity (сущность)** – объект-контейнер, состоящий из компонентов c данными и логикой. В React и Vue аналогом Entity является компонент. В Entity не пишут пользовательскую логику. Для пользовательской логики используются компоненты. Компоненты могут храниться в динамическом массиве или словаре.
* **Component** – объект со своими данными и логикой, который можно добавлять в любую Entity. В React компонентах похожим аналогом являются custom hooks. И описываемые здесь компоненты и пользовательские хуки в React служат для одной цели – расширять функционал объекта, частью которого они являются.
Обычно Entity может содержать вложенные entities, тем самым образуя дерево entities. Не думаю, что это является неотъемлемой его частью, а скорее является смешиванием нескольких подходов.
Данный паттерн похож на паттерн стратегия. Если в объекте использовать динамический массив со стратегиями, организовать их добавление, удаление и получение определенной стратегии, то это будет похоже на Entity Component. Есть еще одно серьезное отличие - контейнер не реализует интерфейс компонентов или методы для обращения к методам компонентов. Контейнер только предоставляет доступ к компонентам и хранит их. Получается составной объект, который довольно своеобразно делегирует весь свой функционал вложенным объектом, на которые он ссылается. Тем самым EC избавляет от необходимости использования сложных иерархий объектов.
**Плюсы EC**
* Низкий порог вхождения, т.к. в основе используется простая одноуровневая структура данных.
* легко добавлять новую функциональность и использовать код повторно.
* можно изменять составной объект (Entity) в процессе выполнения, добавляя или удаляя его составляющие (компоненты)
**Минусы**
* для простых проектов является ненужным усложнением из-за разбиение объекта на контейнер и компоненты
В одной из своих следующих статей я опишу применение этого подхода для React компонентов. Тем самым я покажу, как избавиться от первых двух недостатков компонентов на классах, описанных в документации React-а:
[Трудно повторно использовать логику состояний между компонентами](https://ru.reactjs.org/docs/hooks-intro.html#its-hard-to-reuse-stateful-logic-between-components).
[Сложные компоненты становятся трудными для понимания](https://ru.reactjs.org/docs/hooks-intro.html#complex-components-become-hard-to-understand).
Этот подход используется с самого начала выхода движка Unity3D для расширения функционала элементов (объектов) дерева сцены, включая UI элементы, где вы можете [получше ознакомится с данным подходом](https://docs.unity3d.com/ru/2019.4/Manual/UsingComponents.html). Но в таком случае придётся потратить не мало времени на изучение движка.
**Итого**
Паттерн стратегия сам по себе не очень мощный, но если развить его идею, можно получить довольно эффективные техники. К такой можно отнести Entity Component.
В случае использования EC может появиться новая проблема – при большом количестве компонентов, связанных между собой в одном объекте, становиться сложно разобраться в его работе. Выходом может стать некий компонент, который контролирует взаимодействия между компонентами в одной Entity или в группе вложенных Entities. Такой подход известен как паттерн [Посредник](https://refactoring.guru/ru/design-patterns/mediator) (Mediator).
Но даже “посредника“ будет недостаточно для более сложных случаев. К тому же он не является универсальным. Для каждой Entity с множеством связанных компонентов придёться реализовывать новый тип “посредника”. Есть и другой выход. EC можно комбинировать с другими подходами на основе графов и деревьев, которые будут описаны позже.
Композиция/агрегация с вынесением логики вне объекта и его составляющих
-----------------------------------------------------------------------
### Entity Component System (ECS)
Я не работал с этим подходом, но опишу то, как я его понял.
В ECS объект разбивается на 3 типа составляющих: сущность, компонент (один или несколько), система (общая для произвольного числа объектов). Этот подход похож на EC, но объект разбивается уже на 3 типа составляющих, а компонент содержит только данные.
**Определения:**
* **Entity** – его основное назначение, это идентифицировать объект в системе. Зачастую Entity является просто числовым идентификатором, с которым сопоставляется список связанных с ним компонентов. В других вариациях Entity также может брать на себя роль контейнера для компонентов. Как и в EC подходе, в Entity нельзя писать пользовательский код, только добавлять компоненты.
* **Component** - объект с определенными данными для Entity. Не содержит логики.
* **System** - в каждой системе описывается логика. Каждая система перебирает список компонентов определенных типов или компоненты определенных entities и выполняет логику с использованием данных в компонентах. Может извлекать компоненты из entities. Результатом выполнения системы будет обновление данных в компонентах. В некоторых случаях системы могут быть обычными функциями, получающими на вход нужные данные.
Также может быть некий объект-менеджер (или несколько менеджеров), который хранит все системы и объекты, а также периодически запускает все системы. Здесь уже реализация произвольная.
**Пример простой ECS:** Допустим есть несколько объектов, у которых есть идентификаторы. Несколько из этих объектов ссылаются на компоненты Position, в которых хранятся текущие координаты x, y, и на компонент Speed, который содержит текущую скорость. Есть система Movement, которая перебирает объекты, извлекает из них компоненты Position и Speed, вычисляет новую позицию и сохраняет новые значения x, y в компонент Position.
Как я уже говорил, реализации ECS могут отличаться. Например:
**a) entity является** [**контейнером для своих компонентов**](http://entity-systems.wikidot.com/artemis-entity-system-framework)
**b)** **компоненты содержится в массивах/словарях. Entity является просто идентификатором,** по которомуопределяется компонент, связанный с сущностью. [Раз](http://jmonkeyengine.ru/wiki/jme3/contributions/entitysystem/introduction-2), [два](http://entity-systems.wikidot.com/fast-entity-component-system#java) и [три](https://www.chris-granger.com/2012/12/11/anatomy-of-a-knockout/).
На схеме изображен первый вариант, когда entity ссылается на свои компоненты.
**Плюсы ECS**
* Слабое сцепление составляющих объекта, поэтому легко добавлять новую функциональность комбинирую по-разному составляющие.
* Проще тестировать, т.к. нужно тестировать только системы. Компоненты и сущности тестировать не нужно.
* Легко выполнять многопоточно.
* Более эффективное использование памяти, кэша и, следовательно, большая производительность.
* Легко реализовать сохранение всего приложения, т.к. данные отделены от функционала.
**Минусы ECS**
* Высокая сложность, не стандартный подход.
* для простых проектов является ненужным усложнением.
Так как я занимаюсь фронтенд разработкой, а она по большей части относится к разработки UI, то упомяну, что ECS используется в игре [World of Tanks Blitz для разработки UI](https://www.youtube.com/watch?v=nu8JJEJtsVE).
**Итого**ECS является хорошей альтернативой созданию сложных иерархий наследования. В ECS можно создать иерархии наследования для компонентов или систем, но вряд ли от этого почувствуется выгода. Скорее, быстро почувствуются проблемы от таких попыток.
Как и в аналогичном случае с EС, системы в данном подходе можно комбинировать с подходами на основе графов и деревьев. В таком случае логика по-прежнему будет реализована в системах, а хранение данных в компонентах. Но, я не знаю, эффективно ли совмещение этих подходов на практике. В первую очередь нужно стремиться реализовывать системы попроще, а уже потом рассматривать комбинацию с другими подходами.
Композиция/агрегация с использованием графов
--------------------------------------------
К данному способу повторного использования кода я отнес паттерн «машина состояний» (State machine/Finite state machine/конечный автомат).
Аналогом машины состояний простой является switch:
```
switсh (condition) {
case stateA: actionA();
case stateB: actionB();
case stateC: actionC();
}
```
Недостатком является то, что он может сильно разрастить, а также у разработчика может не быть возможности добавить новые состояния в систему.
Для сложных случаев каждое состояние с логикой можно вынести в отдельный объект и переключаться между ними.
В более сложных случаях можно разделить на большее число составляющих: состояние, действие, переход, условие перехода, событие.
Также существуют **иерархические машины состояний**, где состояние может содержать вложенный граф состояний.
Я уже описывал паттерн “Машина состояний” и его составляющие, и вкратце писал о иерархической машине состояний в статье "[Приемы при проектировании архитектуры игр](https://habr.com/ru/post/255561/#state_machine)"[в главе "машина состояний](https://habr.com/ru/post/255561/#state_machine)".
**Преимущества использования машины состояний:**[Хорошо описано по этой ссылке](https://refactoring.guru/ru/design-patterns/state).
Добавлю, что становится легче предусмотреть, обработать и протестировать все возможные случаи работы контекста (подсистемы), т.к. видны все его состояния и переходы. Особенно, если состояния являются просто объектами с данными и отделены от остальной логики и отображения.
**Где при разработке UI можно использовать машину состояний?**Например, для логики сложной формы, у которой поведение и набор полей немного отличается в зависимости от роли пользователя и других параметров. Каждый объект-состояние может описывать состояние всех компонентов формы (активный, видимый, фиксированный текст элемента в таком-то состоянии и т.д.), отображение которых может отличаться в зависимости от роли пользователя и других параметров. Компоненты формы получают часть объекта-состояния, которая им нужна для своего отображения.
**Другие примеры использования в UI:**[state-machines-in-user-interfaces](https://24ways.org/2018/state-machines-in-user-interfaces/)
[xstate](https://xstate.js.org/docs/) (библиотека для JS, которую можно использовать c React, Vue, Svelte)
[react-automata](https://github.com/MicheleBertoli/react-automata) (библиотека для React)
[Машины состояний и разработка веб-приложений](https://habr.com/ru/company/ruvds/blog/346908/)
**Подходит ли State machine в качестве основного механизма повторного использования кода и разбиения сложных объектов на составные части?**
Иногда он так и используется. Но, он мне кажется сложноватым и не всегда подходящим для использования в качестве основного. Зато он точно хорош в качестве дополнительного, когда нужно организовать взаимодействия между несколькими объектами или частями составного объекта.
Стоит учитывать, что граф может получиться слишком сложным. Если у вас обычный код получается запутанным, то и граф скорее всего получится запутанным. В сложном графе нужно стремиться уменьшать количество связей, группировать состояния.
Композиция/агрегация с использованием деревьев
----------------------------------------------
### Паттерн composite и другие древовидные структуры
Деревья часто встречается в разработке. Например, объекты в JavaScript могут содержать вложенные объекты, а те также могут содержать другие вложенные объекты, тем самым образую дерево. XML, JSON, HTML, DOM-дерево, паттерн [Комповщик](https://refactoring.guru/ru/design-patterns/composite) (Composite) – все это примеры древовидной композиции.
Дерево является графом, в котором между любыми 2-мя его узлами может быть только один путь. Благодаря этому, в нем гораздо проще разобраться, чем в графе получаемом с помощью машины состояний.
### Behaviour tree
Интересным вариантом композиции является [Behaviour tree](https://en.wikipedia.org/wiki/Behavior_tree_(artificial_intelligence,_robotics_and_control)) (дерево поведения). Это организация логики программы (обычно AI) или ее частей в виде дерева.
В дереве поведения в качестве узлов выступают управляющие блоки - условие, цикл, последовательность действий, параллельное выполнение действий и блоки действий. В теории, могут быть реализованы и другие управляющие блоки, вроде switch case, асинхронного блока и других аналогов управляющих конструкций языка, но я не встречал подобного. Код действий для деревьев поведения пишет разработчик. Обычно решения для деревьев поведений содержат визуальный редактор для их создания и отладки.
Я уже описывал деревья поведений в прошлом [в этой статье](https://habr.com/ru/post/255561/#behaviour_tree).
Более наглядный пример схемы готового дерева из плагина banana-tree Дерево поведения можно рассматривать как аналог обычной функции с вложенными функциями. Я думаю, понятно, что схему выше можно перевести в функцию с вложенными функциями, условиями и циклами.
Если в функции написать слишком много кода или же в ней будет слишком много вложенных условий, то она будет нечитабельна и с ней будет тяжело работать. Аналогично и с деревьями поведения. Их следует делать как можно проще и с меньшей вложенностью блоков с циклами и условиями.
Деревья поведения позволяют создавать сложную логику с помощью комбинации более простых действий. Сложная логика тоже может быть оформлена в виде узла дерева (в виде действия или поддерева). Также деревья поведения предоставляют единый механизм для разработки в таком стиле. Этот подход мотивирует выносить функционал в отдельные настраиваемые объекты, зачастую предоставляет наглядное средство для отладки, упорядочивает и уменьшает связи между объектами, позволяет избежать жесткой зависимости составляющих.
Для простых случаев, как обычно, этот подход будет ненужным усложнением.
Смешанные подходы
-----------------
Для более эффективной организации кода можно комбинировать некоторые подходы. Например, в качестве узлов машины состояний можно использовать деревья поведения.
Довольно многое можно отнести к смешанным подходам. Entity Component в Unity3D реализован так, что позволяет хранить не только компоненты, но и вложенные сущности. А для пользовательских компонентов можно использовать наследование в простых случаях, либо объединить компоненты с более продвинутыми техниками (паттерн mediator, машина состояний, дерево поведения и другие).
Примером смешивания подходов является анимационная система Mecanim в Unity3D, которая использует иерархическую машину состояний с деревьями смешивания (blend tree) для анимаций. Это относится не совсем к коду, но является хорошим примером комбинации подходов.
К смешанным подходам я отнес React компоненты с хуками, т.к. там довольно специфичный случай. С точки зрения разработчика, для повторного использования кода в компоненте используется дерево функций (хуков). С точки зрения организации данных в компоненте – компонент хранит список с данными для хуков. К тому же связь между хуками и компонентом устанавливается во время выполнения. Т.к. я разрабатываю на React, то решил включить частичное описание внутреннего устройство компонента с хуками в статью.
### React hooks
**Эта часть статьи для разработчиков, знакомых c React. Остальным многое в ней будет не понятно.**
Особенность функциональных компонентов в React-е в том, что разработчик не указывает сам связь между компонентом и его хуками. Отсюда возникает вопрос, как React определяет к какому компоненту применить такой-то хук?
Как я понял, хуки при вызове добавляют к текущему обрабатываемому компоненту (точнее к fiber-ноде) свое состояние – объект, в котором могут быть указаны переданные сallback-и (в случае useEffect, useCallback), массив зависимостей, значения (в случае useState) и прочие данные (в случае useMemo, useRef, …).
А вызываются хуки при обходе дерева компонентов, т.е. когда вызывается функция-компонент. React-у известно, какой компонент он обходит в данный момент, поэтому при вызове функции-хука в компоненте, состояние хука добавляется (или обновляется при повторных вызовах) в очередь состояний хуков fiber-ноды. **Fiber-нода** – это внутреннее представление компонента.
*Стоит отметить, что дерево fiber элементов не совсем соответствует структуре дерева компонентов. У Fiber-ноды только одна дочерняя нода, на которую указывает ссылка* ***child****. Вместо ссылки на вторую ноду, первая нода ссылается на вторую (соседнюю) с помощью ссылки* ***sibling****. К тому же, все дочерние ноды ссылаются на родительскую ноду с помощью ссылки* ***return****.*
*Также для оптимизации вызова эффектов (обновление DOM, другие сайд-эффекты) в fiber-нодах используются 2 ссылки (****firstEffect, nextEffect****), указывающие на первую fiber-ноду с эффектом и следующую ноду, у которой есть эффект. Таким образом, получается список нод с эффектами. Ноды без эффектов в нем отсутствуют. Подробнее об этом можно почитать по ссылкам в конце главы.*
Вернемся к хукам. Структура сложного функционального компонента с несколькими вложенными custom hooks для разработчика выглядит как дерево функций. Но React хранит в памяти хуки компонента не как дерево, а как очередь. На схеме ниже изображен компонент с вложенными хукам, а под ним fiber-нода с очередью состояний этих же хуков.
На схеме в fiber-ноде отображены также поля, которые участвует в создании различных структур для оптимизации рендеринга. Они не будут рассмотрены в рамках статьи.
Чтобы просмотреть содержимое fiber-ноды, достаточно воспользоваться console.log и вставить туда JSX код, который возвращает компонент:
```
function MyComponent() {
const jsxContent = ();
console.log(jsxContent);
return jsxContent;
}
```
Корневую fiber-ноду можно просмотреть следующим образом:
```
const rootElement = document.getElementById('root');
ReactDOM.render(, rootElement);
console.log(rootElement._reactRootContainer._internalRoot);
```
Пример компонента с хуками и отображение его fiber-ноды
```
import { useState, useContext, useEffect,useMemo, useCallback,
useRef, createContext } from 'react';
import ReactDOM from 'react-dom';
const ContextExample = createContext('');
function ChildComponent() {
useState('childComponentValue');
return ;
}
function useMyHook() {
return useState('valueB');
}
function ParentComponent() {
const [valueA, setValueA] = useState('valueA');
useEffect(function myEffect() {}, [valueA]);
useMemo(() => 'memoized ' + valueA, [valueA]);
useCallback(function myCallback() {}, [valueA]);
useRef('refValue');
useContext(ContextExample);
useMyHook();
const jsxContent = (
setValueA('valueA new')}>Update valueA
);
console.log('component under the hood: ', jsxContent);
return jsxContent;
}
const rootElement = document.getElementById('root');
ReactDOM.render(
,
rootElement,
);
```
Также есть интересная наработка: [react-fiber-traverse](https://github.com/bendtherules/react-fiber-traverse)
**С более подробным описанием работы внутренних механизмов React на русском языке можно ознакомиться по ссылкам:**
* [Как Fiber в React использует связанный список для обхода дерева компонентов](https://medium.com/@kutuzovmm/kak-fiber-ispolzuet-svyazannyi-spisok-c5784bf88afa)
* [Fiber изнутри: подробный обзор нового алгоритма согласования в React](https://medium.com/@kutuzovmm/fiber-iznutri-podrobnyi-mehanizm-soglasovaniya-v-react-e55190921e14)
* [Как происходит обновление свойств и состояния в React — подробное объяснение](https://medium.com/@kutuzovmm/obnovlenie-props-i-state-v-react-85ffe36e6f7a)
* [За кулисами системы React hooks](http://falbar.ru/article/za-kulisami-sistemy-react-hooks)
* [Видео: Под капотом React hooks](https://www.youtube.com/watch?v=3Ku62Nh1mhk)
У подхода с хуками на данный момент есть недостаток - фиксированное дерево функций (хуков) в компонентах. При стандартном использовании хуков, нельзя изменить логику уже написанного компонента или хуков, состоящих из других хуков. К тому же это мешает тестированию хуков по отдельности. В какой-то степени можно улучшить ситуацию композицией (compose) хуков. Например, [существует такое решение](https://github.com/helloitsjoe/react-hooks-compose). Или можно сделать, чтобы хуки задавались через props, по аналогии с директивами в Angular и Vue. [Пример](https://github.com/sergeysibara/unusual-hooks#usehookslikedirectives---using-hooks-like-directives). Возможно существуют еще какие-нибудь решения.
Линейность кода и составляющих сложного объекта
-----------------------------------------------
Известно, что множество вложенные условий, callback-ов затрудняют читаемость кода:
[Замена вложенных условных операторов граничным оператором](https://refactoring.guru/ru/replace-nested-conditional-with-guard-clauses)
[Качество кода](https://habr.com/ru/company/oleg-bunin/blog/433326/) (в статье упоминается линейный код)
[Как писать чистый код](https://www.azoft.ru/blog/clean-code/) (в статье упоминается линейность кода).
Я думаю, что наследование, большие цепочки и иерархии вложенных объектов могут привести к аналогичной ситуации, но для составляющих сложного объекта. Даже если объект расположен линейно в коде, внутри он может быть устроен так, что необходимо пройтись по множеству родительских классов или вложенных объектов, чтобы разобраться в его функционале. Я уже писал ранее про деревья поведения, что в них следует избегать большой вложенности. Так и в других случаях. | https://habr.com/ru/post/545368/ | null | ru | null |
# Загрузка модов из Steam Workshop без регистрации и SMS
Как скачать моды из Мастерской Стим, не имея на аккаунте нужной игры? И Яндекс, и Гугл с радостью предложат вам десятки различных рецептов, кроме единственно правильного. На самом деле вам не нужно пользоваться услугами сторонних сайтов или устанавливать сомнительные браузерные расширения, ведь получить любой мод из Steam Workshop можно при помощи консольной утилиты SteamCMD от самих Valve. Этот способ не просто является самым надежным, но и позволяет автоматизировать загрузку с помощью скриптов. Если данная проблема актуальна и для вас (например, вы, как и автор этой статьи, предпочитаете покупать игры в GoG или увлекаетесь созданием собственных сборок модификаций), добро пожаловать под кат.
Необязательное (и довольно длинное) предисловие, которое можно пропустить
-------------------------------------------------------------------------
С [RimWorld](https://rimworldgame.com/) я познакомился спустя примерно год после релиза, и был совершенно очарован проектом. Еще больше, чем сама игра, меня поразила активность сложившегося вокруг нее комьюнити: энтузиасты генерировали какое-то невероятное количество контента, притом на удивление качественного. Помимо традиционных для любого проекта с поддержкой модификаций текстур-паков и разного рода фан-сервиса, для RimWorld стали появляться масштабные аддоны, добавляющие новые отрасли и биомы, полностью меняющие боевую систему, улучшающие местную медицину, систему болезней и травм, добавляющие новые сценарии и случайно генерируемые события, или вносящие существенные правки в игровой баланс. И это — не считая небольших, но крайне полезных дополнений, вроде возможности утешать колонистов, находящихся в состоянии нервного срыва или погреться у костра на открытом воздухе (да, звучит странно, но в оригинальной игре греться у огня можно лишь внутри помещений).
Несмотря на примитивную графику, по геймплею эта игра даст фору любому другому проектуВпечатлившись таким многообразием, я захотел создать собственную сборку, превратив RimWorld в этакую «игру мечты», симулятор жизни на другой планете, вобравший в себя все лучшее, что породил коллективный разум сообщества. Для себя я обозначил лишь два основных критерия отбора модификаций:
**1. Модификации должны улучшать, дополнять и расширять существующий игровой процесс, а также привносить новые геймплейные возможности**
Это значит, что любые моды, призванные искусственно усложнить или, напротив, оказуалить игру, сразу отбрасываются, однако если изменения баланса обусловлены здравым смыслом, такой мод включается в сборку. Приведу пример.
Мод [Invisible Conduit](https://steamcommunity.com/sharedfiles/filedetails/?id=2013416365) скрывает крупные силовые кабели и провода от подключаемого электрооборудования, что улучшает внешний вид помещений и окружения, положительно отражаясь на настроении колонистов.
Невидимые провода — это что-то из разряда читовЭто — упрощение ради упрощения: после установки модификации вам больше не придется задумываться о том, чтобы прокладывать кабели под стенами, где они не видны, или продумывать расположение светильников и разнообразной аппаратуры, однако никаких новых геймплейных аспектов такая модификация не добавляет, поэтому и в мою сборку она не вошла.
В то же время в нее включен мод [Subsurface Conduit](https://steamcommunity.com/sharedfiles/filedetails/?id=1609226728), который позволяет прокладывать подземные кабели. Такие коммуникации также не видны и не портят обстановку, кроме того, они хорошо защищены от атак и их нельзя просто так разрушить. На лицо упрощение, однако на монтаж подземных кабелей колонисты тратят больше времени и больше ресурсов (эти параметры легко настроить), поэтому прокладывать их выгодно только между зданиями, иначе вы потеряете в темпе развития колонии, что окажется фатальным на высокой сложности игры.
Прокладка подземных кабелей требует больше стали и очков работыТо есть, мод сбалансирован (выгоды от него компенсируются затратами ресурсов и времени), добавляет новый геймплейный аспект (пусть совсем незначительный, но все же), к тому же, не противоречит логике мира, да и житейской логике в целом, ведь объективно, нельзя придумать ни одной причины, по которой бы колонисты, способные построить геотермальную турбину, не додумались бы укладывать критически важные силовые магистрали в траншеи и снабжать такие кабели дополнительной защитой. Именно поэтому данная модификация заняла достойное место в моей сборке.
**2. Никаких кроссоверов**
Кошкодевочки, азари, терминаторы, хаоситы — это существа из иных вселенных, и в RimWorld им определенно нечего делать: их появление на планете фронтира нельзя обосновать лором (разве что притянуть за уши гипотетического безумного ученого из утопического мира, который настолько фанател от реликтовой по меркам его планеты игрушки «Mass Effect», что вывел азари с помощью генной инженерии), поэтому и в сборку подобные модификации не попали.
Ктулху, конечно, фхтагн, но в сеттинг RimWorld как-то не вписываетсяОпределившись с тем, какой результат желаю получить в конечном итоге, я приступил к работе. И здесь я столкнулся с одной фундаментальной проблемой. Точнее, проблем нарисовалась целая куча, но такие досадные «мелочи», как баги, несовместимость модификаций между собой, сломанный баланс и откровенно любительский перевод, авторы которого явно не удосужились вникнуть в контекст, были вполне ожидаемы. А вот тот факт, что множество годных модов доступно исключительно в Steam, меня неприятно удивил.
Как оказалось, сегодня авторы модификаций вообще не задумываются о том, чтобы выкладывать свои творения на GitHub или Nexus Mods, а многие их тех, кто все же этим занимается, крайне редко обновляют моды на сторонних ресурсах. В подавляющем большинстве случаев самую актуальную версию мода можно получить только в Steam Workshop, а зачастую Мастерская и вовсе является единственным местом, где модификация доступна.
Почему это оказалось проблемой? Во-первых, если игра есть в GoG, я покупаю ее именно там, так как мне куда приятнее скачать установщик без встроенной DRM и держать его копию на собственном винчестере в полной уверенности, что если завтра с сервисом что-то случится, то моя коллекция никуда не денется. Во-вторых, при создании сборки чрезвычайно удобно иметь под рукой несколько версий игры (например, одну стабильную, в которую можно спокойно играть, вторую — для отладки сборки, третью — для тестирования новых модификаций, четвертую — наиболее актуальную версию дистрибутива, вышедшую неделю назад, с которой большинство модов из готовой сборки работают криво, и т.д.). И удобство GoG-версии RimWorld как раз и заключается в том, что вы можете установить сколько угодно копий игры на один компьютер и вдоволь экспериментировать.
Разумеется, в такой ситуации можно было бы приобрести игру еще раз, уже в Steam, подписаться на нужные модификации, а затем раскидывать их копии между версиями сборок вручную или скриптом. Но зачем, если все необходимое можно забирать напрямую из Мастерской с помощью утилиты для командной строки от самих Valve? Разберемся, как это сделать.
Скачиваем любые моды из Steam Workshop с помощью официальной утилиты Valve
--------------------------------------------------------------------------
Консольная утилита SteamCMD изначально предназначалась для установки и обновления дистрибутивов выделенных серверов из командной строки, однако ее можно использовать, в том числе, для загрузки модификаций из Steam Workshop, причем для этого вам даже не понадобиться действующий аккаунт в Steam.
SteamCMD доступна для операционных систем Windows, macOS и Linux. Все версии утилиты используют идентичный синтаксис. Чтобы приступить к работе с версией программы для Windows, достаточно загрузить ее последнюю версию [по ссылке](https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip) и распаковать полученный архив в корень системного диска. О том, как установить SteamCMD на Linux и macOS, вы можете узнать в [официальном руководстве](https://developer.valvesoftware.com/wiki/SteamCMD) от Valve.
Рассмотрим основные команды, поддерживаемые утилитой, которые необходимо знать для прямой загрузки модификаций из Steam Workshop.
* **Запуск SteamCMD**
```
cd C:\SteamCMD
steamcmd
```
После запуска утилита автоматически проверит обновления и загрузит все необходимые для работы файлы. Чтобы каждый раз не переходить в каталог, steamcmd.exe можно добавить в переменную среды PATH.
* **Авторизация на сервере**
```
login anonymous
```
В большинстве случаев для загрузки модификаций достаточно авторизоваться под гостевым (анонимным) аккаунтом, однако для работы с некоторыми продуктами, представленными в сервисе цифровой дистрибуции, может потребоваться войти в учетную запись Steam (так, например, вам не удастся загрузить под гостевым аккаунтом модификации для игр от самой Valve).
Чтобы войти под действующим аккаунтом Steam, необходимо указать свое имя пользователя, после чего утилита запросит пароль.
```
login
```
Обратите внимание, что если вы уже авторизованы в десктопном клиенте Steam, вам необходимо предварительно выйти из своего аккаунта. В случае, если ваш профиль защищает Steam Guard, вам также придется ввести код подтверждения для авторизации, который придет на связанный e-mail.
* **Выбор директории**
```
force_install_dir
```
Данная команда позволяет принудительно указать каталог, в который будут загружены модификации. Эта информация не сохраняется, то есть, каждый раз после запуска SteamCMD вам придется заново выбирать нужную директорию.
Еще один важный нюанс: при загрузке модификаций SteamCMD сохраняет исходную структуру каталогов. То есть, если вы укажете, что моды необходимо загружать в папку , на самом деле они будут сохранены в каталог:
```
\steamapps\workshop\content\
```
* **Загрузка модификаций из Steam Workshop**
```
workshop_download_item validate
```
Необходимые переменные получаем из ссылок на сайте Steam. Разберемся на примере RimWorld.
Официальная страница игры расположена по адресу:
<https://store.steampowered.com/app/294100/RimWorld/>
Здесь `294100` — это и есть нужный нам *.*
А вот, как выглядит ссылка на небольшую модификацию «Proxy Hit»:
<https://steamcommunity.com/sharedfiles/filedetails/?id=2365526329>
Здесь является `2365526329`, на что красноречиво указывает имя передаваемого параметра.
Опция `validate` отвечает за проверку целостности скачанных файлов. Кроме того, если ранее вы уже загружали мод, а к нему вышло обновление, при наличии опции `validate` SteamCMD лишь сравнит файлы на ПК и на сервере, загрузив только те, которые подверглись изменениям.
* **Завершение работы**
```
quit
```
Данная команда завершает сессию работы с сервером и останавливает процессы SteamCMD.
SteamCMD поддерживает два способа автоматизации.
**1. Последовательный ввод команд с префиксом «+»**
```
steamcmd +login anonymous +force_install_dir C:\Mods +workshop_download_item 294100 2009463077 validate +quit
```
Данный способ удобно использовать только для скачивания отдельных модификаций. Если вам надо загрузить несколько сотен модов, куда удобнее написать для SteamCMD сценарий.
**2. Создание сценариев**
Сценарий представляет собой простой текстовый файл, в котором последовательно перечислены все команды, которые должна выполнить SteamCMD. Ниже приведен пример сценария для загрузки базовых библиотек, необходимых для работы ряда модификаций Rimworld.
```
//
// Добавлять комментарии можно через двойной слэш
//
@ShutdownOnFailedCommand 0 // завершение работы при возникновении ошибок, при множественной загрузке рекомендуется отключить
@NoPromptForPassword 1 // отключение запроса пароля при загрузке файлов
login anonymous
force_install_dir C:\Mods
//
// Библиотеки
//
workshop_download_item 294100 2009463077 validate // Harmony
workshop_download_item 294100 818773962 validate // HugsLib
workshop_download_item 294100 839005762 validate // Humanoid Alien Races
//
quit
```
Для запуска сценариев предусмотрена команда `runscript`:
```
steamcmd +runscript DownloadingMods.txt > Log.txt
```
Рекомендую перенаправлять результаты выполнения скрипта в лог. Дело в том, что при массовой загрузке модификаций иногда (довольно редко, но все же) могут возникать ошибки доступа к серверу. В этом случае соответствующий мод не будет загружен вообще, а SteamCMD сообщит о возникшей проблеме, однако продолжит свою работу и приступит к загрузке следующей по списку модификации. Вы же, просмотрев лог, сможете отдельно докачать недостающие моды.
Бонус: параметры запуска для установщиков GoG
---------------------------------------------
Зная о том, как работает SteamCMD, вы сможете без труда написать скрипт для автоматизации загрузки модификаций к интересующей вас игре. Если при этом вы, как и я, предпочитаете покупать игры в GoG, то вам пригодятся знания дополнительных параметров установщиков.
Инсталляторы GoG создаются с использованием [Inno Setup](https://jrsoftware.org/isinfo.php), однако поддерживают лишь ограниченное количество параметров: ряд опций не работает вовсе, а некоторые вызывают критические ошибки, делая установку игры невозможной. В своих скриптах я использую следующие параметры:
* `/silent`
Позволяет пропустить окно с принятием лицензионного соглашения и выбором каталога, однако прогресс-бар установки все равно будет отображаться на экране. Хотя Inno Setup поддерживает параметр `/verysilent`, который позволяет сделать установку полностью «бесшумной», с инсталляторами GoG он работает некорректно, вызывая ошибку и зависание установщика.
* `/nocancel`
Блокирует кнопку «Cancel». Очень удобно, если вы устанавливаете несколько игр подряд, при этом продолжая работать на компьютере: так вы исключите вероятность случайного прерывания процедуры установки.
* `/norestart`
Запрещает автоматическую перезагрузку компьютера после установки игры. Опять же, очень удобно, если вы устанавливаете сразу несколько игр, параллельно работая за компьютером.
* `/closeapplications`
Инсталлятор будет автоматически закрывать программы, использующие файлы, которые должны быть обновлены во время установки. Данная опция помогает избежать ситуаций, когда установка игры останавливается из-за того, что у инсталлятора нет доступа к тому или иному файлу.
* `/dir=""`
Поскольку установка проходит в silent-режиме, выбрать директорию для файлов игры через мастер мы не сможем. Но это не является проблемой: нужный каталог можно заранее указать с помощью опции `dir`.
* `/log=""`
Лог установки можно вывести в текстовый файл. Это очень удобно при работе с «проблемными» играми, а также может помочь при создании собственной сборки модов: проанализировав сохраненные данные, вы сможете узнать, например, где игра хранит файлы настроек или профили игроков.
Порядок параметров значения не имеет. В своих скриптах я использую следующую конструкцию:
```
rimworld.exe /silent /nocancel /norestart /closeapplications /dir="C:\RimWorld" /log="InstallationLog.txt"
```
Надеюсь, этот небольшой материал будет полезен всем, кто увлекается разработкой модификаций для игр или созданием собственных сборок.
---
**P.S.** Поскольку эта статья — мой дебют на портале, я хотел бы узнать, насколько завсегдатаям Хабра интересен RimWorld вообще и моддинг этой игры в частности. На данный момент у меня есть несколько идей для будущих публикаций:
1. «RimWorldоведение» — рассказываю о том, как устроена сама игра и модификации к ней. Какова структура модов, где и что искать, если вы хотите отбалансировать мод, добавить перевод или изменить существующий и т.д.
2. «Все равно его не брошу, потому что он хороший» — о кривых, дисбалансных, но очень оригинальных и остроумных модификациях, удалить которые не поднимается рука. Описание модификаций и их проблем с подробной инструкцией по исправлению багов и доведению до ума.
3. «Стройка века» — что-то вроде дневника, в котором я буду рассказывать о прогрессе сборки и модификациях, в нее вошедших. Каждый материал будет представлять собой нечто среднее между обзором на мод и гайдом по возможным проблемам и способам их устранения. | https://habr.com/ru/post/552978/ | null | ru | null |
# Гайд по поиску и устранению утечек памяти в Go сервисах
Как обнаружить утечку?
----------------------
Все просто, посмотреть на график изменения потребления памяти вашим сервисом в системе мониторинга.
Серверу плохаОдин и тот же сервис запущенный с разными настройкамиНа всех этих картинках видно, что график потребления памяти только растет со временем, но никогда не убывает. Интервал может быть любым, посмотрите график за день, неделю или месяц.
Как настроить мониторинг?
-------------------------
Тестировать наш сервис мы будем локально без помощи DevOps-инженеров. Для работы нам понадобится git, Docker и терминал, а разворачивать мы будем связку Grafana и Prometheus.
**Grafana** это интерфейс для построения красивых графиков, диаграмм и dashboard-ов из них. **Prometheus** это система, которая включает в себя базу данных временных рядов и специального агента, который занимается сбором метрик с ваших сервисов.
Для того что бы быстро развернуть это всё на локальной машине воспользуемся готовым решением <https://github.com/vegasbrianc/prometheus>:
```
$ git clone git@github.com:vegasbrianc/prometheus.git
$ cd prometheus
$ HOSTNAME=$(hostname) docker stack deploy -c docker-stack.yml prom
```
После запуска по ссылке `http://:3000` у нас должна открыться Grafana. Читайте README в репозитории, там всё подробно расписано.
### Prometheus client
Теперь нам нужно научить наш сервис отдавать метрики, для этого нам понадобится [Prometheus client](https://prometheus.io/docs/instrumenting/clientlibs/).
[Код примера из официального репозитория](https://github.com/prometheus/client_golang/blob/main/examples/simple/main.go)
```
package main
import (
"flag"
"log"
"net/http"
"github.com/prometheus/client_golang/prometheus/promhttp"
)
var addr = flag.String("listen-address", ":8080", "The address to listen on for HTTP requests.")
func main() {
flag.Parse()
http.Handle("/metrics", promhttp.Handler())
log.Fatal(http.ListenAndServe(*addr, nil))
}
```
Самые важные строчки это 8 и 15 в 90% случаев их будет достаточно.
```
"github.com/prometheus/client_golang/prometheus/promhttp"
...
http.Handle("/metrics", promhttp.Handler())
...
```
После запуска проверьте, что на endpoint-е `/metrics` появились данные.
### Добавляем job в Prometheus agent
В папке репозитория prometheus найдите файлик prometheus.yml, там есть секция scrape\_configs, добавьте туда свою job-у
```
scrape_configs:
- job_name: 'my-service'
scrape_interval: 5s
static_configs:
- targets: ['192.168.1.4:8080']
```
`194.168.1.4` это IP адрес вашей локальной машины. Узнать его можно командой ipconfig, ifconfig обычно интерфейс называется en0
```
$ ifconfig
en0: flags=8863 mtu 1500
options=6463
ether f4:d4:88:7a:99:ce
inet6 fe80::1413:b61f:c073:6a8e%en0 prefixlen 64 secured scopeid 0xe
inet 192.168.1.4 netmask 0xffffff00 broadcast 192.168.1.255
nd6 options=201
media: autoselect
status: active
```
Так же не забудьте поменять в своём сервисе IP адрес запуска, сейчас там прописано `":8080"` что по факту означает IP адрес текущей машины `127.0.0.1`, для верности напишите `"192.168.1.4:8080"`
```
var addr = flag.String("listen-address", "192.168.1.4:8080", "The address to listen on for HTTP requests.")
```
#### Зачем прописывать IP?
Дело в том что docker stack в данной конфигурации запускает Grafana и Prometheus в своем изолированном network-е, они не видят ваш localhost, он у них свой. Конечно можно запустить ваш сервис в контексте сети docker-а, но прописать прямой IP локального интерфейса это самый простой путь подружить контейнеры запущенные внутри сети докера с вашими сервисами запущенными локально.
#### Применяем настройки
В папке с репозиторием выполняем команды
```
$ docker stack rm prom
$ HOSTNAME=$(hostname) docker stack deploy -c docker-stack.yml prom
```
Убедиться, что все заработало после перезапуска, можно посмотрев на панель targets prometheus-а по адресу http://localhost:9090/
### Настраиваем Grafana
Тут всё просто, надо поискать красивый dashboard для Go на [официальном сайте](https://grafana.com/grafana/dashboards/) и импортировать его себе.
Лично мне понравился этот: [ссылка на dashboard](https://grafana.com/grafana/dashboards/14061).
Нагрузочное тестирование
------------------------
Что бы выявить утечку сервис нужно нагрузить реальной работой. В веб разработке основные транспортные протоколы между беком и фронтом это HTTP и Web Socket. Для них существует масса утилит нагрузочного тестирования, например
```
$ ab -n 10000 -kc 100 http://192.168.1.4:8080/endpoint
$ wrk -c 100 -d 10 -t 2 http://192.168.1.4:8080/endpoint
```
или тот же Jmeter, но мы будем использовать [artillery.io](https://www.artillery.io/) так как у нас web socket-ы и мне было необходимо воспроизвести определенный сценарий, что бы словить memory leak.
Для artillery понадобится node и npm, а так как я когда-то я программировал на node.js мне нравится проект [volta.sh](https://volta.sh/), это что-то вроде виртуального окружения в python, позволяет для каждого проекта иметь свою версию node.js и его утилит, но выбор за вами.
Ставим артиллерию:
```
$ npm install -g artillery@latest
$ artillery -v
```
Пишем сценарий нагрузочного тестирования test.yml:
```
config:
target: "ws://192.168.1.4:8080/v1/ws"
phases:
# - duration: 60
# arrivalRate: 5
# - duration: 120
# arrivalRate: 5
# rampTo: 50
- duration: 600
arrivalRate: 50
scenarios:
- engine: "ws"
name: "Get current state"
flow:
- think: 0.5
```
Последняя фаза добавляет 50 виртуальных пользователей каждую секунду в течение десяти минут. Каждый из которых сидит и думает 0.5 секунд, а можно сделать какие-нибудь запросы по сокетам или даже несколько.
Запускаем и смотрим графики в Grafana:
```
artillery run test.yml
```
Графики здорового человека### На что стоит обратить внимание
Кроме памяти стоит посмотреть, как ведут себя ваши goroutine. Часто проблемы бывают из-за того что рутина остается "висеть" и вся память выделенная ей и все переменные указатели на которые попали в нее остаются "висеть" мертвым грузом в памяти и не удаляются garbage collector-ом. Вы так же увидите это на графике. Банальный пример обработчик запроса в котором запускается рутина для "тяжелых" вычислений:
```
func (s *Service) Debug(w http.ResponseWriter, r *http.Request) {
go func() { ... }()
w.WriteHeader(http.StatusOK)
...
}
```
Эту проблему можно решить например через context, waitGroup, errGroup:
```
func (s *Service) Debug(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithCancel(r.Context())
go func() {
for {
select {
case <-ctx.Done():
return
default:
}
...
}
}()
w.WriteHeader(http.StatusOK)
...
}
```
Либо при регистрации клиента вы выделяете под него память, например данные его сессии, но не освобождаете её, когда клиент отключился от вас аварийно. Что-то типа
```
type clientID string
type session struct {
role string
refreshToken string
...
}
var clients map[clientID]*clientSession
```
Следите за тем как вы передаете аргументы в функцию, по указателю или по значению. Используете ли вы глобальные переменные внутри пакетов? Не зависают ли в каналах и рутинах указатели на структуры данных? Graceful shutdown это про вас?
Дать конкретные советы невозможно, каждый проект индивидуален, но знать как самостоятельно настроить мониторинг и отследить утечку, это большой шаг на пути к стабильности 99.9%. | https://habr.com/ru/post/658085/ | null | ru | null |
# Мигаем светодиодом из модуля ядра Linux
Всем привет. В этой статье хочу поделиться опытом создания простого модуля ядра Linux. Статья будет полезна тем, кто хотел бы понять как писать модули ядра, но не знает с чего начать.
Мне давно хотелось разобраться в этой теме, но до недавнего времени не знал как к ней подойти. Хотелось, чтобы модуль был достаточно простым, но сложнее чем сообщение «Hello world!» выведенное в log файле. В итоге я решил попробовать помигать светодиодом. Дополнительная цель была вывести параметр отвечающий за частоту мигания в sysfs.
Для проведения эксперимента я использовал плату Orange Pi One с Ubuntu Linux на борту (версия ядра 3.4.113). Для того чтобы собрать модуль ядра вам понадобиться компилятор gcc, утилита make и заголовочные файлы ядра. Чтобы установить заголовочные файлы запустите следующую команду:
```
sudo apt-get install linux-headers-$(uname -r)
```
Далее я разберу на мой взгляд самые интересные части модуля. В целях экономии места весь код тут приводить не буду, он вместе с make файлом доступен на [github](https://github.com/mks-a/blink_from_linux_kernel_module).
В модуле я использовал заголовочные файлы:
```
#include
#include
#include
#include
#include
```
kernel.h и module.h нужно включать всегда при написании модуля ядра, gpio.h собственно отвечает за работу с GPIO, hrtimer.h (high resolution timer) – заголовочный файл таймера, moduleparam.h – нужен для вывода параметров в sysfs.
Чтобы не светить свои переменные и функции в ядро системы, все они должны быть описаны как static. На всякий случай отмечу, что ядро написано на C и static, в отличие от С++ означает то, что объект доступен только внутри исполняемого файла.
Точкой входа является:
```
static int blink_module_init(void)
```
Здесь я инициализирую переменные которые в дальнейшем буду использовать в том числе:
```
gpio_timer_interval = ktime_set(gpio_blink_interval_s, 0);
```
ktime\_set инициализирует тип данных ktime\_t задавая ему нужное количество секунд (gpio\_blink\_interval\_s) и наносекунд (0). В дальнейшем эту переменную будет использовать таймер.
Далее идет запрос на использование GPIO:
```
err = gpio_request(BLINK_PIN_NR, "blink_led");
```
Эта функция в случае успеха возвращает 0, так что в дальнейшем я проверяю что она вернула. Далее выбранный пин нужно установить на вывод сигнала и указать значение по умолчанию.
```
err = gpio_direction_output(BLINK_PIN_NR, GPIOF_INIT_LOW);
```
Если никаких ошибок не было, то инициализирую и запускаю таймер
```
hrtimer_init(&gpio_blink_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
gpio_blink_timer.function = &gpio_blink_timer_callback;
hrtimer_start(&gpio_blink_timer, gpio_timer_interval, HRTIMER_MODE_REL);
```
Функция обратного вызова таймера будет gpio\_blink\_timer\_callback. В этой функции я меняю значение пина на противоположное
```
gpio_value ^= 0x01;
gpio_set_value(BLINK_PIN_NR, gpio_value);
```
задаю когда таймер должен сработать в следующий раз
```
hrtimer_forward_now(&gpio_blink_timer, gpio_timer_interval);
```
и возвращаю HRTIMER\_RESTART.
Теперь разберем как показать какую нибудь переменную в sysfs. Для этого я использую макрос
```
module_param_cb(gpio_blink_interval_s, &kp_ops, &gpio_blink_interval_s, 0660);
```
Первый параметр этого макроса — имя файла в sysfs. Второй — структура данных содержащая функции обратного вызова. Третий параметр — указатель на реальную переменную и четвертый права доступа к файлу в sysfs.
Функции из kp\_ops вызываются когда пользователь меняет значения sysfs файла или читает его значение. Вот как я их инициализировал:
```
static const struct kernel_param_ops kp_ops =
{
.set = &set_blink_interval,
.get = &get_blink_interval
};
```
В данном случае интерес представляет set, так как в нем устанавливается новое значение gpio\_timer\_interval.
```
gpio_timer_interval = ktime_set(gpio_blink_interval_s, 0);
```
В точке выхода я очищаю все используемые ресурсы
```
static void blink_module_exit(void)
{
hrtimer_cancel(&gpio_blink_timer);
gpio_set_value(BLINK_PIN_NR, 0);
gpio_free(BLINK_PIN_NR);
printk(KERN_ALERT "Blink module unloaded\n");
}
```
Точку входа и выхода обязательно нужно указать в соответствующих макросах
```
module_init(blink_module_init);
module_exit(blink_module_exit);
```
Вроде описал все важные моменты. Если у читателей возникнут какие-то вопросы с удовольствием отвечу на них в комментариях. | https://habr.com/ru/post/411721/ | null | ru | null |
# Организация простой архитектуры в андроид-приложении со связкой ViewModel+LiveData, Retrofit+Coroutines
Без долгих вступлений расскажу, как можно быстро и просто организовать удобную архитекруту вашего приложения. Материал будет полезен тем, кто не очень хорошо знаком с mvvm-паттерном и котлиновскими корутинами.
Итак, у нас стоит простая задача: получить и обработать сетевой запрос, вывести результат во вью.
Наши действия: из активити (фрагмента) вызываем нужный метод ViewModel -> ViewModel обращается к ретрофитовской ручке, выполняя запрос через корутины -> ответ сетится в лайвдату в виде ивента -> в активити получая ивент передаём данные во вью.
### Настройка проекта
#### Зависимости
```
//Retrofit
implementation 'com.squareup.retrofit2:retrofit:2.6.2'
implementation 'com.squareup.retrofit2:converter-gson:2.6.2'
implementation 'com.squareup.okhttp3:logging-interceptor:4.2.1'
//Coroutines
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0'
//ViewModel lifecycle
implementation 'androidx.lifecycle:lifecycle-extensions:2.1.0'
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0-rc01"
```
#### Манифест
```
```
### Настройка ретрофита
Создаем котлиновский объект **NetworkService**. Это будет наш сетевой клиент — синглтон
UPD синглтон используем для простоты понимания. В комментариях указали, что правильнее использовать инверсию контроля, но это отдельная тема
```
object NetworkService {
private const val BASE_URL = " http://www.mocky.io/v2/"
// HttpLoggingInterceptor выводит подробности сетевого запроса в логи
private val loggingInterceptor = run {
val httpLoggingInterceptor = HttpLoggingInterceptor()
httpLoggingInterceptor.apply {
httpLoggingInterceptor.level = HttpLoggingInterceptor.Level.BODY
}
}
private val baseInterceptor: Interceptor = invoke { chain ->
val newUrl = chain
.request()
.url
.newBuilder()
.build()
val request = chain
.request()
.newBuilder()
.url(newUrl)
.build()
return@invoke chain.proceed(request)
}
private val client: OkHttpClient = OkHttpClient
.Builder()
.addInterceptor(loggingInterceptor)
.addInterceptor(baseInterceptor)
.build()
fun retrofitService(): Api {
return Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.client(client)
.build()
.create(Api::class.java)
}
}
```
### Api интерфейс
Используем замоканные запросы к фэйковому сервису.
Приостановим веселье, здесь начинается магия корутин.
Помечаем наши функции ключевым словом **suspend fun ...**.
Ретрофит научился работать с котлиновскими suspend функциями с версии 2.6.0, теперь он напрямую выполняет сетевой запрос и возвращает объект с данными:
```
interface Api {
@GET("5dcc12d554000064009c20fc")
suspend fun getUsers(
@Query("page") page: Int
): ResponseWrapper
@GET("5dcc147154000059009c2104")
suspend fun getUsersError(
@Query("page") page: Int
): ResponseWrapper
}
```
**ResponseWrapper** — это простой класс-обертка для наших сетевых запросов:
```
class ResponseWrapper : Serializable {
@SerializedName("response")
val data: T? = null
@SerializedName("error")
val error: Error? = null
}
```
Дата класс **Users**
```
data class Users(
@SerializedName("count")
var count: Int?,
@SerializedName("items")
var items: List?
) {
data class Item(
@SerializedName("first\_name")
var firstName: String?,
@SerializedName("last\_name")
var lastName: String?
)
}
```
### ViewModel
Создаем абстрактный класс **BaseViewModel**, от которого будут наследоваться все наши ViewModel. Здесь остановимся подробнее:
```
abstract class BaseViewModel : ViewModel() {
var api: Api = NetworkService.retrofitService()
// У нас будут две базовые функции requestWithLiveData и
// requestWithCallback, в зависимости от ситуации мы будем
// передавать в них лайвдату или колбек вместе с параметрами сетевого
// запроса. Функция принимает в виде параметра ретрофитовский suspend запрос,
// проверяет на наличие ошибок и сетит данные в виде ивента либо в
// лайвдату либо в колбек. Про ивент будет написано ниже
fun requestWithLiveData(
liveData: MutableLiveData>,
request: suspend () -> ResponseWrapper) {
// В начале запроса сразу отправляем ивент загрузки
liveData.postValue(Event.loading())
// Привязываемся к жизненному циклу ViewModel, используя viewModelScope.
// После ее уничтожения все выполняющиеся длинные запросы
// будут остановлены за ненадобностью.
// Переходим в IO поток и стартуем запрос
this.viewModelScope.launch(Dispatchers.IO) {
try {
val response = request.invoke()
if (response.data != null) {
// Сетим в лайвдату командой postValue в IO потоке
liveData.postValue(Event.success(response.data))
} else if (response.error != null) {
liveData.postValue(Event.error(response.error))
}
} catch (e: Exception) {
e.printStackTrace()
liveData.postValue(Event.error(null))
}
}
}
fun requestWithCallback(
request: suspend () -> ResponseWrapper,
response: (Event) -> Unit) {
response(Event.loading())
this.viewModelScope.launch(Dispatchers.IO) {
try {
val res = request.invoke()
// здесь все аналогично, но полученные данные
// сетим в колбек уже в главном потоке, чтобы
// избежать конфликтов с
// последующим использованием данных
// в context классах
launch(Dispatchers.Main) {
if (res.data != null) {
response(Event.success(res.data))
} else if (res.error != null) {
response(Event.error(res.error))
}
}
} catch (e: Exception) {
e.printStackTrace()
// UPD (подсказали в комментариях) В блоке catch ивент передаем тоже в Main потоке
launch(Dispatchers.Main) {
response(Event.error(null))
}
}
}
}
}
```
### Ивенты
Крутое решение от Гугла — оборачивать дата классы в класс-обертку Event, в котором у нас может быть несколько состояний, как правило это LOADING, SUCCESS и ERROR.
```
data class Event(val status: Status, val data: T?, val error: Error?) {
companion object {
fun loading(): Event {
return Event(Status.LOADING, null, null)
}
fun success(data: T?): Event {
return Event(Status.SUCCESS, data, null)
}
fun error(error: Error?): Event {
return Event(Status.ERROR, null, error)
}
}
}
enum class Status {
SUCCESS,
ERROR,
LOADING
}
```
Вот как это работает. Во время сетевого запроса мы создаем ивент со статусом LOADING. Ждем ответа от сервера и потом оборачиваем данные ивентом и отправляем его с заданным статусом дальше. Во вью проверяем тип ивента и в зависимости от состояния устанавливаем разные состояния для вью. Примерно на такой-же философии строится архитектурный паттерн MVI
### ActivityViewModel
```
class ActivityViewModel : BaseViewModel() {
// Создаем лайвдату для нашего списка юзеров
val simpleLiveData = MutableLiveData>()
// Получение юзеров. Обращаемся к функции requestWithLiveData
// из BaseViewModel передаем нашу лайвдату и говорим,
// какой сетевой запрос нужно выполнить и с какими параметрами
// В данном случае это api.getUsers
// Теперь функция сама выполнит запрос и засетит нужные
// данные в лайвдату
fun getUsers(page: Int) {
requestWithLiveData(simpleLiveData) {
api.getUsers(
page = page
)
}
}
// Здесь аналогично, но вместо лайвдаты используем котлиновский колбек
// UPD Полученный результат мы можем обработать здесь перед отправкой во вью
fun getUsersError(page: Int, callback: (data: Event) -> Unit) {
requestWithCallback({
api.getUsersError(
page = page
)
}) {
callback(it)
}
}
}
```
И, наконец
### MainActivity
```
class MainActivity : AppCompatActivity() {
private lateinit var activityViewModel: ActivityViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
activityViewModel = ViewModelProviders.of(this).get(ActivityViewModel::class.java)
observeGetPosts()
buttonOneClickListener()
buttonTwoClickListener()
}
// Наблюдаем за нашей лайвдатой
// В зависимости от Ивента устанавливаем нужное состояние вью
private fun observeGetPosts() {
activityViewModel.simpleLiveData.observe(this, Observer {
when (it.status) {
Status.LOADING -> viewOneLoading()
Status.SUCCESS -> viewOneSuccess(it.data)
Status.ERROR -> viewOneError(it.error)
}
})
}
private fun buttonOneClickListener() {
btn_test_one.setOnClickListener {
activityViewModel.getUsers(page = 1)
}
}
// Здесь так же наблюдаем за Ивентом, используя колбек
private fun buttonTwoClickListener() {
btn_test_two.setOnClickListener {
activityViewModel.getUsersError(page = 2) {
when (it.status) {
Status.LOADING -> viewTwoLoading()
Status.SUCCESS -> viewTwoSuccess(it.data)
Status.ERROR -> viewTwoError(it.error)
}
}
}
}
private fun viewOneLoading() {
// Пошла загрузка, меняем состояние вьюх
}
private fun viewOneSuccess(data: Users?) {
val usersList: MutableList? = data?.items as MutableList?
usersList?.shuffle()
usersList?.let {
Toast.makeText(applicationContext, "${it}", Toast.LENGTH\_SHORT).show()
}
}
private fun viewOneError(error: Error?) {
// Показываем ошибку
}
private fun viewTwoLoading() {}
private fun viewTwoSuccess(data: Users?) {}
private fun viewTwoError(error: Error?) {
error?.let {
Toast.makeText(applicationContext, error.errorMsg, Toast.LENGTH\_SHORT).show()
}
}
}
```
[Исходный код](https://github.com/shikleyev/CleanCoroutines) | https://habr.com/ru/post/475598/ | null | ru | null |
# Универсальные подсказки на jQuery
Доброго времени суток уважаемые читатели. Хочу представить вашему взору свой маленький плагин реализованный на jQuery. Плагин призван универсализировать создание всплывающих подсказок (tooltips).
Ранее я находил множество кодов для решения проблем с подсказками и ошибками при валидации, но все они были тяжеловесными и не очень универсальными. Это привело к тому, что я занялся разработкой своего плагина в обход существующим.
Главной задачей, было сделать так, чтобы выводом подсказок можно было управлять, но при этом не лезть в сам JS код.
Второй задачей было впихнуть в код столько функционала, чтобы подсказки могли выводится как слева/справа/снизу/сверху, так и была прилеплена к курсору мыши.
Третей задачей (зачем вообще было реализовывать на JS) было центрирования подсказки, относительно наведенного объекта.
Верстка получилась придельный простой:
```
Текст подсказки
```
Как видно из кода, у нас есть блок обвертка tooltip-wrapper, который объединяет подсказку с элементом на которого будет вызываться подсказка.
Стили его также предельно просты:
```
.tooltip-wrapper{
position: relative;
display: inline-block;
}
```
Далее у нас есть объект (в нашем примере input.field) и само сообщение valid-massege. Я стараюсь разграничивать классы которые использую в стилях и в сценариях, из-за этого у нас их два valid-massege и valid-massege-js.
С обязательных стилей у самого тултипа только position: absolute.
Теперь давайте посмотрим на сам сценарий, который должен удовлетворять наши требования:
```
(function($){
tooltip = function() {
this._init = function(element, options) {
var defaults = {
tooltipElement: $(element),
tooltipSide: "right",
fix: false
},
settings = $.extend(defaults, options);
settings.tooltipElement.each(function(i){
if (settings.fix == false) {
var tooltipElementHeight = $(this).actual( "outerHeight", { absolute : true } ),
tooltipWrapperHeight = $(this).parent(".tooltip-wrapper").actual( "outerHeight", { absolute : true } ),
tooltipElementWidth = $(this).actual( "outerWidth", { absolute : true } ),
tooltipWrapperWidth = $(this).parent(".tooltip-wrapper").actual( "outerWidth", { absolute : true } );
if (settings.tooltipSide == "left") {
$(this).addClass('tooltip-left').css({top:-(tooltipElementHeight/2 - tooltipWrapperHeight/2)});
}
else if (settings.tooltipSide == "right"){
$(this).addClass('tooltip-right').css({top:-(tooltipElementHeight/2 - tooltipWrapperHeight/2)});
}
else if (settings.tooltipSide == "top"){
$(this).addClass('tooltip-top').css({left: -((tooltipElementWidth - tooltipWrapperWidth)/2)});
}
else if (settings.tooltipSide == "bottom"){
$(this).addClass('tooltip-bottom').css({left: -((tooltipElementWidth - tooltipWrapperWidth)/2)});
}
}
else{
$(document).mousemove(function (pos) {
settings.tooltipElement.css({top: pos.clientY+10, left: pos.clientX+10});
});
}
});
};
};
// Launch plugin
$.fn.tooltip = function( options ){
return this.each(function(){
$( this ).data( "tooltip", new tooltip()._init( this, options ) );
});
};
})(jQuery);
```
Теперь давайте я попробую объяснить, что тут к чему.
Плагин будет вызываться по названию (tooltip) и в него будет передаваться всего один параметр — это блочек с подсказкой.
```
$('.valid-massege-js').tooltip(); // именно тот класс с приставкой -js
```
По умолчанию плагин будет выводить подсказку с правого края от текста, так как у него указано в параметрах — tooltipSide: «right»
Это значение можно менять на любое из четырех возможных (top/right/bottom/left) и передавать его вместе с вызовом плагина:
```
$('.valid-massege-js').tooltip({
tooltipSide: "bottom"
});
```
В самом HTML-коде при замене стороны будет меняться класс обозначивающий сторону (tooltip-top/tooltip-right/tooltip-bottom/tooltip-left).
```
.valid-message.tooltip-left{
right: 100%;
margin-right: 10px;
}
.valid-message.tooltip-right{
left: 100%;
margin-left: 10px;
}
.valid-message.tooltip-top{
bottom: 100%;
margin-bottom: 10px;
}
.valid-message.tooltip-bottom{
top: 100%;
margin-top: 10px;
}
```
Также в плагине присутствует возможность прикрепления подсказки к курсору, пока он находится над областью. По умолчанию данная возможность отключена, но ее можно легко включить:
```
$('.valid-message-js').tooltip({
fix: true
});
```
И последнее, для работы плагина вам понадобится сама библиотека jQuery и библиотека jquery.actual. Но не пугайтесь, jquery.actual в сжатом виде занимает 1 кб. И на большом проекте она вам может пригодится и для других сценариев, так как она закрывает главный баг с .width() и .height() у скрытых элементов. Ее мы можем найти [здесь](https://github.com/dreamerslab/jquery.actual).
Посмотреть [демо](http://viking-r.pp.ua/tooltip-messages/) | https://habr.com/ru/post/203694/ | null | ru | null |
# Распределенное логирование и трассировка для микросервисов
Логирование — важная часть любого приложения. Любая система логирования проходит три основных шага эволюции. Первый — вывод на консоль, второй — запись логов в файл и появление фреймворка для структурированного логирования, и третий — распределенное логирование или сбор логов различных сервисов в единый центр.
Если логирование хорошо организовано, то позволяет понимать, что, когда и как идет не так, как задумано, и передавать нужную информацию людям, которым предстоит эти ошибки исправлять. Для системы, в которой каждую секунду отправляется 100 тысяч сообщений в 10 дата-центрах на 190 стран, а 350 инженеров каждый день что-то деплоят, система логирования особенно важна.
**Иван Летенко** — тимлид и разработчик в Infobip. Чтобы решить проблему централизованной обработки и трассировки логов в микросервисной архитектуре при таких огромных нагрузках, в компании пробовали различные комбинации стека ELK, Graylog, Neo4j и MongoDB. В итоге, спустя много грабель, написали свой лог-сервис на Elasticsearch, а как БД для дополнительной информации взяли PostgreSQL.
Под катом подробно, с примерами и графиками: архитектура и эволюция системы, грабли, логирование и трассировка, метрики и мониторинг, практика работы с кластерами Elasticsearch и их администрирования в условиях ограниченных ресурсов.
Чтобы ввести вас в контекст, расскажу немного о компании. Мы помогаем клиентам-организациям доставлять сообщения их клиентам: сообщения от службы такси, СМС от банка о списании или одноразовый пароль при входе в ВК. В день через нас проходит **350 млн сообщений** для клиентов в 190 странах. Каждое из них мы принимаем, обрабатываем, биллим, роутим, адаптируем, отсылаем операторам, а в обратном направлении обрабатываем отчеты о доставке и формируем аналитику.
Чтобы всё это работало в таких объемах, у нас есть:
* 36 дата-центров по всему миру;
* 5000+ виртуальных машин;
* 350+ инженеров;
* 730+ различных микросервисов.
Это сложнейшая система, и ни один гуру не сможет в одиночку понять весь масштаб. Одна из основных целей нашей компании — это высокая скорость доставки новых фич и релизов для бизнеса. При этом всё должно работать и не падать. Мы над этим работаем: 40 000 деплоев в 2017 году, 80 000 в 2018, 300 деплоев в день.
У нас 350 инженеров — получается, что **каждый инженер ежедневно что-то деплоит**. Еще несколько лет назад такая производительность была только у одного человека в компании — у Крешимира, нашего principal-инженера. Но мы добились того, что каждый инженер чувствует себя так же уверенно, как Крешимир, когда нажимает кнопку «Deploy» или запускает скрипт.
Что для этого нужно? Прежде всего **уверенность в том, что мы понимаем, что происходит в системе** и в каком состоянии она находится. Уверенности придает возможность задать системе вопрос и выяснить причину проблемы во время инцидента и при разработке кода.
Чтобы добиться этой уверенности, мы инвестируем в **наблюдаемость (observability)**. Традиционно этот термин объединяет три компоненты:
* логирование;
* метрики;
* трассировка.
Об этом и поговорим. Прежде всего, посмотрим на наше решение для логирования, но метрик и трассировки также обязательно коснемся.
Эволюция
--------
Практически любое приложение или система логирования, в том числе и у нас, проходит несколько этапов эволюции.
Первый шаг — это **вывод на консоль**.
Второй — мы начинаем **писать логи в файл**, появляется **фреймворк** для структурированного вывода в файл. Обычно мы используем Logback, потому что живем в JVM. На этом этапе появляется структурированное логирование в файл, понимание, что разные логи должны иметь разный уровень, warnings, errors.
Как только **экземпляров нашего сервиса** или разных сервисов **становится уже несколько**, появляется задача **централизованного доступа** к логам для разработчиков и поддержки. Мы переходим к распределенному логированию — объединяем различные сервисы в единый сервис логирования.
Распределенное логирование
--------------------------
Самый известный вариант — стек ELK: Elasticsearch, Logstash и Kibana, но мы выбрали **Graylog**. У него классный интерфейс, который заточен на логирование. Из коробки идут алерты уже в бесплатной версии, чего нет в Kibana, например. Для нас это отличный выбор с точки зрения логов, а под капотом тот же Elasticsearch.
*В Graylog можно строить алерты, графики аналогично Kibana и даже метрики по логам.*
### Проблемы
Наша компания росла, и в определенный момент стало понятно, что с Graylog что-то не так.
**Чрезмерная нагрузка**. Появились проблемы с производительностью. Многие разработчики стали использовать классные возможности Graylog: строили метрики и дашборды, которые выполняют агрегацию по данным. Не лучший выбор строить сложную аналитику на кластере Elasticsearch, на который идет мощная нагрузка на запись.
**Коллизии**. Команд много, единой схемы нет. Традиционно, когда один ID первый раз попал в Graylog в качестве long, автоматически произошел маппинг. Если другая команда решит, что туда надо записать UUID в виде строки — это сломает систему.
Первое решение
--------------
**Разделили логи приложений и коммуникационные логи**. У разных логов разные сценарии и способы применения. Есть, например, логи приложений, к которым у разных команд разные требования по разным параметрам: по времени хранения в системе, по скорости поиска.
Поэтому первое, что мы сделали, — разделили логи приложений и коммуникационные логи. Второй тип — важные логи, которые хранят информацию о взаимодействии нашей платформы с внешним миром и о взаимодействии внутри платформы. Мы еще поговорим об этом.
**Заменили существенную часть логов на метрики**. В нашей компании стандартный выбор — это Prometheus и Grafana. Какие-то команды используют и другие решения. Но важно, что мы избавились от большого количества дашбордов с агрегациями внутри Graylog, перевели все на Prometheus и Grafana. Это значительно облегчило нагрузку на серверы.
Посмотрим на сценарии применения логов, метрик и трейсов.
### Логи
**Высокая размерность, отладка и исследование**. Чем хороши логи?
> Логи — это события, которые мы логируем.
У них может быть большая размерность: можно логировать Request ID, User ID, атрибуты запроса и другие данные, размерность которых не ограничена. Они также хороши для отладки и исследования, чтобы задавать вопросы системе о том, что происходило, и искать причины и следствия.
### Метрики
**Низкая размерность, агрегация, мониторинг и алерты**. Под капотом всех систем сбора метрик находятся time series базы данных. Эти БД отлично справляются с агрегацией, поэтому метрики подходят для агрегации, мониторинга и построения алертов.
> Метрики очень чувствительны к размерности данных.
Для метрик размерность данных не должна превышать тысячи. Если мы будем добавлять какие-то Request ID, у которых размер значений не ограничен, то быстро столкнемся с серьезными проблемами. Мы уже наступали на эти грабли.
### Корреляция и трассировка
> Логи должны быть коррелированы.
Структурированных логов недостаточно, чтобы мы могли удобно искать по данным. Должны быть поля с определенными значениями: Request ID, User ID, другие данные с сервисов, с которых логи пришли.
Традиционное решение — присваивать транзакции (логу) на входе в систему уникальный ID. Затем этот ID (контекст) пробрасывается через всю систему по цепочке вызовов внутри сервиса или между сервисами.
*Корреляция и трассировка.*
Есть устоявшиеся термины. Трассировка разбивается на spans и демонстрирует стек вызовов одного сервиса относительно другого, одного метода относительно другого относительно временной шкалы. Наглядно прослеживается путь сообщения, все тайминги.
Сначала мы использовали Zipkin. Уже в 2015 году у нас был Proof of Concept (пилотный проект) этих решений.
*Распределенная трассировка.*
Чтобы получить такую картину, **код нужно инструментировать**. Если вы уже работаете с кодовой базой, которая существует, нужно по ней пройтись — она требует изменений.
Для полной картины и чтобы получать выгоду от трейсов, необходимо **инструментировать все сервисы в цепочке**, а не один сервис, на котором вы сейчас работаете.
Это мощный инструмент, но он требует значительных затрат на администрирование и железо, поэтому мы перешли от Zipkin на другое решение, которое предоставляется «as a service».
Отчеты о доставке
-----------------
Логи должны быть коррелированы. Трейсы тоже должны быть коррелированы. Нам нужен единый ID — общий контекст, который можно пробрасывать по всей цепочке вызовов. Но зачастую это невозможно — **корреляция происходит внутри системы в результате ее работы**. Когда мы начинаем одну или несколько транзакций, мы еще не знаем, что они часть единого большого целого.
Рассмотрим первый пример.
*Отчеты о доставке.*
* Клиент отправил запрос на сообщение, и наша внутренняя платформа его обработала.
* Сервис, который занимается взаимодействием с оператором, отправил это сообщение оператору — появилась запись в системе логов.
* Позже оператор присылает нам отчет о доставке.
* Сервис, который занимается процессингом, не знает, к какому конкретно сообщению относится этот отчет о доставке. Эта взаимосвязь создается внутри нашей платформы позже.
Две связанные транзакции — части единой целой транзакции. Эта информация очень важна для инженеров поддержки и разработчиков интеграций. Но это совершенно невозможно видеть, исходя из единой трассировки или единого ID.
Второй случай похож — клиент присылает нам сообщение в большой пачке, потом мы их разбираем, они возвращаются тоже пачками. Количество пачек даже может меняться, но все они потом объединяются.
С точки зрения клиента, он отправил сообщение и получил ответ. Но мы получили несколько независимых транзакций, которые необходимо объединять. Получается связь один ко многим, а с отчетом о доставке — один к одному. По сути, это граф.
*Строим граф.*
Раз мы видим граф, то адекватный выбор — графовые БД, например, Neo4j. Выбор был очевиден, потому что Neo4j дарит на конференциях классные футболки и бесплатные книжки.
### Neo4j
Мы реализовали Proof of Concept: хост на 16 ядер, который мог обрабатывать граф 100 млн нод и 150 млн связей. Граф занимал всего 15 ГБ диска — тогда нам это подходило.
*Наше решение. Архитектура логов.*
Кроме Neo4j у нас появился несложный интерфейс для просмотра связанных логов. С ним инженеры видят картину целиком.
Но довольно быстро мы разочаровались в этой БД.
### Проблемы с Neo4j
**Ротация данных**. У нас мощные объемы и данные необходимо ротировать. Но при удалении ноды из Neo4j данные на диске не очищаются. Пришлось строить сложное решение и полностью перестраивать графы.
**Производительность**. Все графовые БД заточены на чтение. На запись производительность заметно меньше. Наш случай абсолютно противоположный: мы много пишем и относительно редко читаем — это единицы запросов в секунду или даже в минуту.
**High availability и кластерный анализ платно**. В наших масштабах это выливается в приличные затраты.
Поэтому мы пошли другим путем.
### Решение с PostgreSQL
Мы решили, что раз читаем редко, то граф можно строить на лету при чтении. Так мы в реляционной базе PostgreSQL храним список смежности наших ID в виде простой таблички с двумя столбцами и индекс по обоим. Когда приходит запрос, мы обходим граф связанности по знакомому алгоритму DFS (обход в глубину), и получаем все связанные ID. Но это по необходимости.
Ротация данных тоже решается легко. На каждый день заводим новую табличку и через несколько дней, когда приходит время — удаляем её и освобождаем данные. Простое решение.
Сейчас в PostgreSQL у нас 850 млн связей, они занимают 100 ГБ диска. Мы пишем туда со скоростью 30 тыс в секунду, и для этого в БД всего две VM по 2 CPU и 6 GB RAM. Что и требовалось доказать — PostgreSQL умеет быстро писать longs.
Еще есть небольшие машины для самого сервиса, которые ротируют и управляют.
*Как изменилась наша архитектура.*
Сложности с Graylog
-------------------
Компания росла, появлялись новые дата-центры, нагрузка заметно увеличивалась, даже с решением с коммуникационными логами. Мы задумались о том, что Graylog подходит уже не идеально.
**Единая схема и централизация**. Хочется иметь единый инструмент управления кластерами в 10 дата-центрах. Также встал вопрос единой схемы маппинга данных, чтобы не было коллизий.
**API**. Мы используем собственный интерфейс для отображения связей между логами и стандартное API Graylog не всегда было удобно использовать, например когда нужно отобразить данные с разных дата-центров, правильно их рассортировать и пометить. Поэтому нам хотелось иметь возможность менять API как нам нравится.
**Производительность, трудно оценить потери**. Наш трафик — 3 ТБ логов в день, что прилично. Поэтому Graylog не всегда стабильно работал, нужно было залезать в его внутренности, чтобы понять причины сбоев. Получалось, что мы используем его уже не как инструмент — с этим надо было что-то делать.
**Задержки обработки (очереди)**. Нам не нравилась стандартная реализация очереди в Graylog.
**Необходимость поддерживать MongoDB**. Graylog тащит за собой MongoDB, приходилось администрировать еще и эту систему.
Мы поняли, что на данном этапе хотим собственное решение. Возможно, там меньше классных функций по алертингу, которые уже не использовались, по дашбордам, но свое лучше.
### Наше решение
Мы разработали собственный Logs service.
*Сервис логов.*
В тот момент у нас уже была экспертиза по обслуживанию и поддержанию крупных кластеров Elasticsearch, поэтому за основу взяли Elasticsearch. Стандартный стек в компании — это JVM, но для бэкенда мы классно используем и Kotlin, поэтому для сервиса взяли этот язык.
Первый вопрос — как ротировать данные и что делать с маппингом. Мы используем фиксированный маппинг. В Elasticsearch лучше иметь индексы одинакового размера. Но с такими индексами нам нужно как-то маппить данные, особенно для нескольких дата-центров, распределенной системы и распределенного состояния. Были идеи прикрутить ZooKeeper, но это опять усложнение обслуживания и кода.
> Поэтому мы решили просто — пишем по времени.
Один индекс на один час, в других дата-центрах 2 индекса на час, в третьих один индекс на 3 часа, но все по времени. Индексы получаются разного размера, поскольку ночью трафик меньше, чем днем, но в целом работает. Опыт показал, что усложнения не нужны.
Для простоты миграции и учитывая большой объем данных мы выбрали протокол GELF — простой протокол Graylog на основе TCP. Так у нас появился GELF-сервер на Netty и GELF-декодер.
Потом JSON кодируется для записи в Elasticsearch. Мы используем официальное Java API от Elasticsearch и пишем Bulk’ами.
> Для высокой скорости записи нужно писать Bulk’ами.
Это важная оптимизация. API предоставляет Bulk-процессор, который автоматически накапливает запросы и потом отправляет на запись их пачкой или по времени.
### Проблема с Bulk-процессор
Вроде бы все хорошо. Но мы запустили и поняли, что упираемся в Bulk-процессор — это было неожиданно. Мы не можем добиться тех значений, на которые рассчитывали — проблема пришла из ниоткуда.
В стандартной реализации Bulk-процессор однопоточный, синхронный, несмотря на то, что там есть настройка параллелизма. В этом и была проблема.
Покопались и оказалось, что это известная, но не решенная бага. Мы немного изменили Bulk-процессор — сделали явную блокировку через ReentrantLock. Только в мае похожие изменения были внесены в официальный репозиторий Elasticsearch и будут доступны только с версии 7.3. Текущая — 7.1, а мы пользуемся версией 6.3.
Если вы также работаете с Bulk-процессором и хотите разогнать запись в Elasticsearch — посмотрите эти [изменения на GitHub](https://github.com/elastic/elasticsearch/blob/master/server/src/main/java/org/elasticsearch/action/bulk/BulkProcessor.java) и обратно портируйте под вашу версию. Изменения затрагивают только Bulk-процессор. Сложностей не возникнет, если нужно портировать на версию ниже.
Все отлично, Bulk-процессор пошел, скорость разогналась.
Производительность Elasticsearch на запись нестабильна во времени, поскольку там происходят различные операции: мёрджинг индексов, flush. Также производительность на некоторое время замедляется во время обслуживания, когда выбывает часть нод из кластера, например.
В связи с этим мы поняли, что нам нужна реализация не только буфера в памяти, но и очереди. Мы решили, что будем отправлять в очередь только отклоненные сообщения — только те, что Bulk-процессор не смог записать в Elasticsearch.
### Retry fallback
Это простая реализация.
* Сохраняем в файл отклоненные сообщения — `RejectedExecutionHandler`.
* Повторно отправляем с заданным интервалом в отдельном executor.
* При этом мы не задерживаем новый трафик.
Для инженеров поддержки и разработчиков новый трафик в системе заметно важнее, чем тот, который почему-то задержался во время спайка или замедления Elasticsearch. Он задержался, но прибудет потом — ничего страшного. Новый трафик приоритетнее.
*Наша схема стала выглядеть так.*
Теперь поговорим как мы готовим Elasticsearch, какие параметры использовали и как настраивали.
Конфигурация Elasticsearch
--------------------------
Проблема, с которой мы столкнулись — необходимость разгонять Elasticsearch, оптимизировать его на запись, поскольку количество чтений заметно меньше.
Мы использовали несколько параметров.
`"ignore_malformed": true` — **отбрасываем поля с неверным типом, а не весь документ**. Нам все-таки хочется хранить данные, даже если почему-то туда просочились поля с неправильным маппингом. Этот параметр не совсем связан с производительностью.
Для железа у Elasticsearch есть нюанс. Когда мы начали просить большие кластеры, то нам сказали, что RAID-массивы из SSD-дисков под ваши объемы это жутко дорого. Но массивы не нужны, потому что отказоустойчивость и партиционирование уже встроено в Elasticsearch. Даже на официальном сайте есть рекомендация брать больше дешевого железа, чем меньше дорогого и хорошего. Это касается и дисков, и количества ядер процессоров, потому что весь Elasticsearch очень хорошо параллелится.
`"index.merge.scheduler.max_thread_count": 1` — **рекомендовано для HDD**.
Если вам достались не SSD, а обычные диски HDD, то в этот параметр выставляйте единицу. Индексы пишутся кусочками, потом эти кусочки мёржатся. Это чуть-чуть экономит диск, но, прежде всего, ускоряет поиск. Также, когда вы перестали записывать в индекс, можно сделать `force merge`. Когда нагрузка на кластер поменьше, оно автоматически мёржится.
`"index.unassigned.node_left.delayed_timeout": "5m"` — **задержка реаллокации при пропадании ноды**. Это время через которое Elasticsearch начнет реаллоцировать индексы и данные, если какая-то нода перезагрузилась, деплоится или выведена для обслуживания. Но если у вас мощная нагрузка на диск и сеть, то реаллокация это тяжелая операция. Чтобы их не перегрузить, этот таймаут лучше контролировать и понимать, какие задержки необходимы.
`"index.refresh_interval": -1` — **не обновлять индексы, если нет поисковых запросов**. Тогда индекс будет обновляться при появлении поискового запроса. Этот индекс может быть выставлен в секундах и минутах.
`"index.translogDurability": "async"` — как часто выполнять fsync: при каждом запросе или по времени. Дает прирост производительности для медленных дисков.
Еще у нас появился интересный способ применения. Поддержка и разработчики хотят иметь возможность полнотекстового поиска и применения regexp’ов по всему телу сообщения. Но в Elasticsearch это невозможно — он может искать только по токенам, которые уже есть в его системе. RegExp и wildcard можно использовать, но токен не может начинаться с какого-то RegExp. Поэтому мы добавили `word_delimiter` в фильтр:
```
"tokenizer": "standard"
"filter" : [ "word_delimiter" ]
```
Он автоматически разбивает слова на токены:
* «Wi-Fi» → «Wi», «Fi»;
* «PowerShot» → «Power», «Shot»;
* «SD500» → «SD», «500».
Подобным образом пишется название класса, разная отладочная информация. С ним мы закрыли часть проблем с полнотекстовым поиском. Советую добавлять такие настройки, когда работаете с логином.
### О кластере
**Количество шард должно равняться количеству дата-нод для распределения нагрузки**. Минимальное количество реплик — 1, тогда каждая нода будет иметь один основной шард и одну реплику. Но если у вас ценные данные, например, финансовые транзакции, — лучше 2 и более.
**Размер шарда от нескольких ГБ до нескольких десятков ГБ**. Количество шардов на ноде не больше 20 на 1 ГБ хипа Elasticsearch, естественно. Дальше Elasticsearch замедляется — мы на это тоже наступали. В тех дата-центрах где трафика немного, данные не ротировались по объему, появлялись тысячи индексов и система падала.
**Используйте** `allocation awareness`, например, по имени гипервизора на случай обслуживания. Помогает разбрасывать индексы и шарды по разным гипервизорам, чтобы они не пересекались, когда выбывает какой-то гипервизор.
**Создавайте индексы предварительно**. Хорошая практика, особенно когда пишем по времени. Индекс сразу горячий, готовый и нет задержек.
**Ограничьте число шард одного индекса на ноде**. `"index.routing.allocation.total_shards_per_node": 4` — это максимальное количество шард одного индекса на ноде. В идеальном случае их 2, мы ставим 4 на всякий случай, если всё-таки у нас окажется меньше машин.
В чем здесь проблема? Мы используем `allocation awareness` — Elasticsearch знает, как правильно разбросать индексы по гипервизорам. Но мы выяснили, что после того, как нода была долго выключена, а потом обратно приходит в кластер, Elasticsearch видит, что на ней формально меньше индексов и они восстанавливаются. Пока данные не синхронизируются, формально на ноде мало индексов. При необходимости аллоцировать новый индекс Elasticsearch старается как можно плотнее забить эту машину свежими индексами. Так нода получает нагрузку не только от того, что на нее реплицируются данные, но еще и свежим трафиком, индексами и новыми данными, которые попадают на эту ноду. Контролируйте и ограничивайте это.
### Рекомендации по обслуживанию Elasticsearch
Тем, кто работает с Elasticsearch, эти рекомендации уже знакомы.
> Во время планового обслуживания применяйте рекомендации для rolling upgrade: disable shard allocation, synced flush.
**Disable shard allocation**. Отключите аллокацию реплик шард, оставьте возможность аллоцировать только primary. Это заметно помогает Elasticsearch — он не будет переаллоцировать данные, которые вам не нужны. Например, вы знаете, что через полчаса нода поднимется — зачем перебрасывать все шарды с одной ноды на другую? Ничего страшного не случится, если полчаса пожить с желтым кластером, когда доступны только primary-шарды.
**Synced flush**. В этом случае нода при возвращении в кластер синхронизируется намного быстрее.
> При сильной нагрузке на запись в индекс или восстановлении можно уменьшить количество реплик.
Если вы загружаете большой объем данных, например, пик нагрузки, можно отключить шарды и позже дать команду, чтобы Elasticsearch их создал, когда нагрузка будет уже меньше.
Приведу несколько команд, которыми я люблю пользоваться:
* `GET _cat/thread_pool?v` — позволяет посмотреть `thread_pool` на каждой ноде: что сейчас горячо, какие очереди на запись и чтение.
* `GET _cat/recovery/?active_only=true` — какие индексы куда реаллоцируются, где происходит восстановление.
* `GET _cluster/allocation/explain` — в удобном человеческом виде почему и какие индексы или реплики не аллоцировались.
Для мониторинга мы используем Grafana.
Есть прекрасный [экспортер](https://github.com/vvanholl/elasticsearch-prometheus-exporter) и Grafana teamplay от **Vincent van Hollebeke**, который позволяет наглядно смотреть состояние кластера и все его основные параметры. Мы добавили его в наш Docker-образ и все метрики при деплое у нас из коробки.
Выводы по логированию
---------------------
Логи должны быть:
* **централизованы** — единая точка входа для разработчиков;
* **доступны** — возможность быстрого поиска;
* **структурированы** — для быстрого и удобного извлечения ценной информации;
* **коррелированы** — не только между собой, но и с другими метриками и системами, которые вы используете.
Недавно проходил шведский конкурс **Melodifestivalen**. Это отбор представителей от Швеции на Евровидение. Перед конкурсом к нам обратилась наша служба поддержки: «Сейчас в Швеции будет большая нагрузка. Трафик достаточно чувствительный и мы хотим коррелировать некоторые данные. У вас в логах есть данные, которых не хватает на дашборде Grafana. У нас есть метрики, которые можно взять из Prometheus, но нам нужны данные по конкретным ID-запросам».
Они добавили Elasticsearch как источник Grafana и смогли коррелировать эти данные, закрыть проблему и получить достаточно быстро хороший результат.
> Эксплуатация собственных решений заметно проще.
Сейчас вместо 10 кластеров Graylog, которые работали для этого решения, у нас несколько сервисов. Это 10 дата-центров, но у нас нет даже специально выделенной команды и людей, которые их обслуживают. Есть несколько человек, которые работали над ними и что-то меняют по необходимости. Эта маленькая команда прекрасно вписана в нашу инфраструктуру — деплоить и обслуживать легче и дешевле.
> Разделяйте кейсы и используйте соответствующие инструменты.
Это отдельные инструменты для логирования, трассировки и мониторинга. Нет «золотого инструмента», который закроет все ваши потребности.
Чтобы понять, какой именно инструмент нужен, что именно мониторить, какие где использовать логи, какие требования логам, нужно обязательно обратиться к **SLI/SLO** — Service Level Indicator/Service Level Objective. Нужно знать, что важно для ваших клиентов и вашего бизнеса, на какие индикаторы они смотрят.
> Уже через неделю в СКОЛКОВО состоится [HighLoad++ 2019](https://www.highload.ru/moscow/2019). Вечером 7 ноября Иван Летенко [расскажет](https://www.highload.ru/moscow/2019/abstracts/5486), как живется с Redis на проде, а всего в [программе](https://www.highload.ru/moscow/2019/schedule) 150 докладов на самые разные темы.
>
>
>
> Если у вас не получается посетить HighLoad++ 2019 вживую, у нас хорошие новости. В этом году конференция пройдет сразу в трех городах — в Москве, Новосибирске и Санкт-Петербурге. Одновременно. Как это будет и как попасть — узнайте на отдельной [промостранице](https://www.highload.ru/moscow/2019/telemost) события. | https://habr.com/ru/post/473946/ | null | ru | null |
# In-app purchasing или внутренние платежи в приложениях для Android
#### О чем это вообще?
С версией приложения Android Market 2.3.0 для разработчиков приложений для платформы Android открылась возможность предоставлять пользователям платежи внутри самих приложений. Теперь можно продавать уровни и артефакты, видео, музыку, плагины и прочее, пользуясь лишь встроенными средствами платформы. Давайте увидим, как это можно сделать.
#### Что нам понадобится?
Как обычно, любимая IDE, Android SDK и [пример приложения](http://developer.android.com/guide/market/billing/billing_integrate.html#billing-download).
Так же будет полезным представлять себе, что такое Service, BroadcastReceiver и, конечно, Activity.
Так же нам понадобится разрешение в файле манифеста —
, без него ничего не заработает.
#### Как это в принципе работает?
Работает все через сервис в приложении Android Market. Он умеет посылать запросы на получение деталей определенной вещи, которую хочет купить пользователь, на покупку, получать ответы о успехе или неудачи покупки, и прочее. Вся информация о вещах, которые вы продаете, должна быть заведена через [Консоль Разработчика](https://market.android.com/publish/Home) для конкретного приложения. Как только мы получили сигнал об успешной покупке, мы можем начать грузить с нашего сервера контент.
#### Как все это устроено?
На сервере в маркете хранится информация о вещах, которые можно купить. С сервером взаимодействует клиентское приложение маркета. С ним взаимодействует наше приложение.
Наше приложение будет состоять как минимум из:
1. BillingService. Это сервис, который связан с приложением маркета, и отправляет ему всю информацию об операциях и получает на них ответы, в случае, если они синхронные.
2. BillingReceiver. Получает асинхронные ответы от приложения маркета.
3. PurchaseObserver. Сущность, которая будет оповещать UI об изменениях состояния покупок.
#### Какие сообщения мы отсылаем маркету?
Вначале нам нужно соединить наш BillingService с приложением маркета для того, чтобы вызывать метод sendBillingRequest сервиса MarketBillingService. Интерфейс сервиса описан в файле IMarketBillingService.aidl, его можно скачать отсюда, а положить надо в com.android.vending.billing пакет вашего приложения. IDE должна сразу же сгенерить IMarketBillingService.java файл, который нам понадобиться для вызова вышеупомянутого метода.
Сам метод принимает параметр Bundle, в котором и хранится вся информация. Самой важной является параметр с ключом «BILLING\_REQUEST». Он определяет тип запроса. Они бывают:
• `CHECK_BILLING_SUPPORTED` – проверка доступности in-app billing.
• `REQUEST_PURCHASE` – запрос покупки.
• `GET_PURCHASE_INFORMATION` – получение информации об изменении состояния покупки.
• `CONFIRM_NOTIFICATIONS` – подтверждение факта получение уведомления от приложения маркета.
• `RESTORE_TRANSACTIONS` – восстановление транзакций по уже купленным вещам.
#### Какие получаем ответы?
Метод синхронно возвращает ответ, который тоже представляет из себя Bundle. В нем лежит:
• `RESPONSE_CODE` — код ответа
• `PURCHASE_INTENT` — `PendingIntent`, для того, чтобы запустить активти покупки.
• `REQUEST_ID` – идентификатор посланного запроса
В случае асинхронных ответов(получаемых через BillingReceiver), в них лежит следующее:
• `com.android.vending.billing.RESPONSE_CODE`
Код ответа. Маркет подтверждает успех или неудачу посылки запроса.
• `com.android.vending.billing.IN_APP_NOTIFY`
Оповещение о том, что статус покупки изменился. После этого сообщения нужно отправлять запрос с типом `GET_PURCHASE_INFORMATION`, чтобы получить инфу.
• `com.android.vending.billing.PURCHASE_STATE_CHANGED`
А тут приходит детальная информация о покупке. Она включает в себя nonce, список заказов, с указанием идентификаторов продуктов, их состояний и проч.
Последовательность при покупке будет такая:
1. Посылаем `REQUEST_PURCHASE`
2. Получаем синхронный ответ
3. Запускаем Activity покупки(также встроенную в приложение маркета)
4. Получаем асинхронное сообщение `IN_APP_NOTIFY`
5. Посылаем `GET_PURCHASE_INFORMATION`
6. Получаем синхронный ответ
7. Получаем асинхронный ответ `PURCHASE_STATE_CHANGED`
8. Отправляем `CONFIRM_NOTIFICATIONS`
9. Получаем синхронный ответ
#### А может, посмотрим лучше на код?
Итак, основные моменты в коде:
##### 1. Коннект к маркету.
В onCreate() в BillingService пишем:
> `try {
>
> boolean bindResult = getApplicationContext().bindService(
>
> new Intent("com.android.vending.billing.MarketBillingService.BIND"),
>
> this,
>
> Context.BIND\_AUTO\_CREATE);
>
> if (bindResult) {
>
> Log.i(TAG, "Service bind successful.");
>
> } else {
>
> Log.e(TAG, "Could not bind to the MarketBillingService.");
>
> }
>
> } catch (SecurityException e) {
>
> Log.e(TAG, "Security exception: " + e);
>
> }
>
>
>
> //И чуть ниже:
>
> @Override
>
> public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
>
> Log.i(TAG, "MarketBillingService connected.");
>
> marketService = IMarketBillingService.Stub.asInterface(iBinder);
>
> runPendingRequests();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### 2. Отправка запросов.
В примере приложения создана иерархия классов для запросов и это правильно. Самая главная вещь в них – это отложенная отправка. Дело в том, что bindService происходит асинхронно, а значит ссылку на MarketBillingService мы получаем гораздо позже, чем кончается onCreate(), и даже позже, чем пытаемся в первый раз выполнить запросы. Поэтому делаем так:
> `/\*\*
>
> \* Run the request, starting the connection if necessary.
>
> \*
>
> \* @return this request if the request was not executed in order to queue it.
>
> \*/
>
> public final AbstractRequest runRequest() {
>
> if (runIfConnected()) {
>
> return null;
>
> }
>
> return this;
>
> }
>
>
>
> /\*\*
>
> \* Try running the request directly if the service is already connected.
>
> \*
>
> \* @return true if the request ran successfully; false if the service
>
> \* is not connected or there was an error when trying to use it
>
> \*/
>
> public boolean runIfConnected() {
>
> if (service.isConnected()) {
>
> try {
>
> requestId = run();
>
> if (requestId >= 0) {
>
> service.addRequest(requestId, this);
>
> }
>
> return true;
>
> } catch (MyException e) {
>
> onException(e);
>
> }
>
> }
>
> return false;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Возвращение запроса нужно, чтобы запомнить его в списке ожидающих отправки запросов в сервисе. Потом, когда мы получим ссылку на MarketBillingService в onServiceConnected(), мы все запросы попробуем отправить еще раз.
##### 3. Оповещение UI
В BillingService будем хранить ссылку на некую сущность, которая хранит в себе Handler от нашего UI. Тогда по получении ответов можно будет делать следующее:
> `private void notifyGui(int messageId, PurchasedItem item) {
>
> if (observer != null) {
>
> observer.notifyGui(messageId, item);
>
> } else {
>
> // пошлем здесь оповещение в NotificationBar
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Важно: не забывать обнулять observer сервиса из своей Activity при выходе из нее и восстанавливать эту ссылку. Делается это так:
> `@Override
>
> protected void onUserLeaveHint() {
>
> if (billingService != null) {
>
> unbindService(this);
>
> billingService.resetEventDispatcher();
>
> billingService = null;
>
> }
>
> super.onUserLeaveHint();
>
> }
>
>
>
> @Override
>
> public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
>
> //Connected to BillingService
>
> if (componentName.getShortClassName().equals(serviceClassName)) {
>
> billingService = ((BillingService.LocalBinder) iBinder).getService();
>
> billingService.setObserver(new PurchaseObserver());
>
> try {
>
> billingService.checkBillingAvailability();
>
> } catch (MyException e) {
>
> Log.e(TAG, "Billing unavailable", e);
>
> Toast.makeText(this, "Billing unavailable", Toast.LENGTH\_LONG).show();
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### 4. Запуск Activity покупки.
Загляните в PurchaseObserver класс примера. Там есть метод public void startBuyPageActivity(PendingIntent pendingIntent, Intent intent). PendingIntent – это то, что мы получили ответом от маркета. А Intent – просто new Intent().
Что же этот метод делает?
На самом деле в этот класс передается инстанс вашей Activity. Дальше от нее через reflection происходит попытка получить метод startInstentSender. Этот метод появился только в Android 2.0. Если он есть, то метод вызывается, и Activity запускается в стеке Activity нашего приложения. Если же метод не найден, то происходит старт Activity в отдельном стеке.
#### А как же безопасность?
Вопрос безопасности – тема отдельной статьи, и так уже много. В примере приложения за безопасность отвечает класс Security. Скажу только, что верифицировать покупки нужно не в приложении(как это сделано в примере), а на собственном сервере, дабы не давать логику проверки в руки потенциальных обладателей apk.
P.S. На основе [developer.android.com/guide/market/billing/billing\_overview.html](http://developer.android.com/guide/market/billing/billing_overview.html) | https://habr.com/ru/post/117944/ | null | ru | null |
# Внешние данные конфигурации в Spring
### Введение
#### Ситуация
Большинство наших приложений зависят от внешних сервисов, например серверов баз данных, SMS-шлюзов и систем наподобие PayPal. Эти сервисы могут существовать более чем в одной среде, то есть в средах разработки и эксплуатации. Если мы хотим подключиться к эксплуатационной среде, мы должны сначала пройти через среду разработки. Таким образом, во время создания приложений нам приходится переключаться между средами. Это связано с тем, что у каждой среды своя уникальная конфигурация со своими параметрами подключения и прочими значениями.
#### Проблема
Предположим, что мы разрабатываем платежный сервис, который подключается к внешнему платежному провайдеру. Значения коммерческого счета в эксплуатационной среде и среде разработки не совпадают. То есть при каждом переключении среды нам приходится изменять значения и компилировать код заново, а это неэффективно.
#### Решение
Лучшее решение этой проблемы — вывод данных конфигурации приложения во внешний источник. Нам не нужно будет каждый раз заново компилировать код при переключении среды. Мы сможем переопределить значения параметров конфигурации, затратив меньше усилий. Наше приложение Spring сможет считывать значения коммерческого счета из внешних источников, например переменных среды, аргументов командной строки и файлов свойств.
### Вывод данных конфигурации во внешний источник
#### Источники свойств
Существуют различные способы вывода данных конфигурации приложения Spring во внешний источник. Для задания свойств приложения мы можем использовать переменные среды, файлы свойств (например, в формате YAML или с расширением \*.properties) и аргументы командной строки. Мы также можем хранить файлы свойств в произвольных местах и сообщать приложению Spring, где их искать.
### Файлы свойств
По умолчанию приложение Spring загружает свойства из файлов application.properties или application.yml из перечисленных ниже источников в порядке приоритета (то есть вышестоящий файл свойств переопределяет файлы из источников нижнего уровня) и добавляет их в среду:
1. подкаталог конфигурации текущего каталога;
2. текущий каталог;
3. пакет конфигураций в параметре classpath;
4. корневой каталог classpath.
По умолчанию имя файла конфигурации — application. При желании мы можем указать другое имя, используя ключ свойств среды `spring.config.name`. В примере ниже мы переопределили имя конфигурации Spring, заданное по умолчанию, на `new_name`.
```
spring.config.name=new_name
```
**Пользовательское место хранения**
Мы можем задать внешний источник свойств приложения или файлов YAML с помощью свойства среды `spring.config.location`. Это свойство может указывать на любое пользовательское место хранения и таким образом переопределять местоположение по умолчанию. См. пример ниже:
```
spring.config.location={path_to_configuration_file/directory}
```
**Примечание**. При указании расположения каталога необходимо убедиться, что после значения `spring.config.location` стоит символ / (например, `spring.config.location=classpath:/config/`) и что задано имя файла конфигурации по умолчанию. Также с помощью ключа свойств `spring.config.additional-location` можно указать дополнительные каталоги, поиск в которых будет проводиться перед поиском в местоположениях по умолчанию.
```
spring.config.additional-location={path_to_configuration_file/directory}
```
Spring Boot также поддерживает обобщенное указание местоположения с помощью подстановочных символов. Эта функция полезна в средах с несколькими источниками свойств конфигурации, таких как среды Kubernetes. Например, у вас есть конфигурации Redis и MySQL. Они могут храниться в разных местах, но при этом они обе должны быть указаны в файле `application.properties`, чтобы их видело приложение. Это может привести к тому, что два отдельных файла `application.properties` будут смонтированы в разных местах, например `/config/redis/application.properties` и `/config/mysql/application.properties`. В таком случае использование обобщенного указания каталога `config/*/` позволит обрабатывать оба файла.
**Форматы файлов**
Файл свойств приложения может быть в формате YAML или иметь расширение .properties. Если эти два файла свойств будут храниться в одной и той же папке конфигурации, файл `application.properties` будет иметь приоритет над файлом `application.yml`. В следующем фрагменте кода показаны настройки коммерческого счета, определенные в файле свойств каждого типа.
**application.properties**
```
merchantaccount.name=Maureen Sindiso Mpofu
merchantaccount.username=momoe
merchantaccount.code=771222279
merchantaccount.number=100
merchantaccount.currency=ZWL
server.port: 9092
```
**application.yml**
```
merchantaccount:
name: Maureen Sindiso Mpofu
username: momoe
code: MCA1230
number: 771222279
currency: ZWL
```
**Файлы форматов YAML и .properties**
YAML — это легкочитаемый стандарт сериализации данных, часто применяемый в файлах конфигурации. Он является надмножеством формата JSON и очень удобен при составлении иерархической конфигурации. Файлы формата YAML предпочтительны, поскольку они более понятны и удобочитаемы, особенно по сравнению с файлами .properties. Помимо этого, у них есть другие очень полезные функции, например безопасность типов и т. д.
Для загрузки файла YAML приложению Spring требуется библиотека [SnakeYAML](https://bitbucket.org/asomov/snakeyaml) в параметре `classpath`. В приведенном примере кода использованы стартеры Spring Boot, поэтому необходимости включать данную библиотеку в параметр `classpath` нет.
**Множество профилей**
YAML позволяет указать несколько профилей в одном файле конфигурации, тогда как при использовании файла .property нам может потребоваться файл конфигурации для каждого профиля. Рассмотрим следующий пример.
1. **Файл YAML**
**application.yml**
```
spring:
profiles:
active: development
---
spring:
profiles: development
merchantaccount:
name: Maureen Sindiso Mpofu
username: momoe
code: MCA1230
number: 771222279
currency: ZWL
server:
port: 9090
---
spring:
profiles: production
server:
port: 9093
merchantaccount:
name: Maureen Sindiso Mpofu
username: momoe
code: MCA1234
number: 771222279
currency: ZWD
```
2. **Файл .properties**
В случае с файлом `.properties`, при определении двух профилей нужно создать отдельный файл конфигурации для каждого из них. К имени каждого файла конфигурации добавляется `-{имя_профиля}.properties`. В примере ниже показаны профили приложения для разработки и эксплуатации.
**application-development.properties**
```
merchantaccount.name=Maureen Sindiso Mpofu
merchantaccount.username=momoe
merchantaccount.code=771222279
merchantaccount.number=100
merchantaccount.currency=ZWL
server.port: 9092
```
**application-production.properties**
```
merchantaccount.name=Maureen Sindiso Mpofu
merchantaccount.username=momoe
merchantaccount.code=MCA1234
merchantaccount.number=771222279
merchantaccount.currency=ZWD
server.port: 9093
```
При наличии свойств, общих для профилей разработки и эксплуатации, нам может потребоваться файл application.properties, заданный по умолчанию.
**application.properties**
```
spring.profiles.active=development
#default port number
server.port=9091
```
Образец данных конфигурации в приведенных выше фрагментах кода устанавливает профиль разработки в качестве активного профиля. Поэтому при запуске приложения значения свойств, определенные в этом профиле, будут иметь приоритет над эксплуатационным профилем. Но не стоит забывать, что настройки профиля можно также переопределить с помощью аргументов командной строки.
Вы можете узнать больше о профилях Spring в [этой статье](https://springframework.guru/spring-profiles/).
**Читаемость**
YAML поддерживает списки и карты в виде иерархических свойств, и по сравнению с файлом расширения .properties версия YAML более удобочитаемая. Допустим, мы хотим настроить параметры подключения для реальной и тестовой сред. Сначала зададим имена подключений в виде списка, а затем сопоставим их с соответствующими URL-адресами с помощью карты, как показано ниже. Рассмотрим, как реализация в YAML может упростить эту конфигурацию в сравнении с файлом .properties.
**application.yml**
```
connection:
names:
- test
- live
addresses:
test: http://host/test
live: http://host/live
```
**application.properties**
```
#list
connection.names[0]=test
connection.names[1]=live
#map
connection.addresses.test=http://host/test
connection.addresses.live= http://host/live
```
Тестовые примеры для проверки сопоставлений можно найти в тестовых пакетах с [примером кода](https://github.com/spring-framework-guru/sfg-blog-posts/tree/master/external-configuration) из данной статьи.
### Аргументы командной строки
Когда мы вводим аргумент командной строки, приложение Spring преобразует его в свойство и добавляет в Spring Environment. С помощью этих аргументов можно сконфигурировать параметры приложения. К примеру, следующие аргументы командной строки переопределят порт сервера приложения, заданный любым другим источником свойств. При запуске приложения командой Maven или Java мы все равно получим тот же результат.
**Команда Maven:**
```
$mvn spring-boot:run -Dspring-boot.run.arguments="--spring.profiles.active=production"
```
**Команда JVM:**
```
$java -jar target/app.jar – spring.profiles.active=production
```
Также можно вводить несколько аргументов одновременно. Дополним приведенный выше пример еще одним свойством — портом сервера, как показано ниже.
**Команда Maven (через пробел):**
```
$mvn spring-boot:run -Dspring-boot.run.arguments="--spring.profiles.active=production – server.port=8089"
```
**Команда JVM:**
```
$java -jar target/app.jar – spring.profiles.active=production – server.port=8089
```
### Переменные среды
Если у нас нет возможности изменять значения свойств через командную строку, на выручку приходят переменные среды. Приложение Spring может считывать свойства из них. При запуске оно ищет переменную среды под именем `SPRING_APPLICATION_JSON`, которая может содержать набор свойств JSON в одностроковом формате. Мы можем поэкспериментировать и переопределить адреса подключения, указанные в нашем файле свойств, как описано ниже.
Откроем терминал и выполним следующую команду. Она устанавливает переменные среды приложения, переопределяя настройки подключения.
```
$export SPRING_APPLICATION_JSON='{"connection":{"addresses":{"test":"http://localhost/payments/pre-prod1","live":"http://192.168.123.23/payments/prod1"}}}'
```
После этого запустим наше приложение:
```
$java -jar -Dspring.profiles.active=development target/app.jar
```
**Результат**
Проверив журнал, мы заметим, что адреса подключения в профиле разработки были переопределены, а значения в файле JSON, который мы передали через переменную среды, были в приоритете.
#### Передача свойств
Существуют различные способы передачи значений свойств в приложение из соответствующих источников. Мы можем использовать аннотацию `@Value` абстракции Spring Environment или привязать эти значения к структурированному объекту с аннотацией `@ConfigurationProperties`.
`@Value`
Этот метод актуален при наличии небольшого количества свойств, но он не рекомендуется, если свойств много. Представьте, если в коммерческом счете более двадцати свойств, нам придется указывать аннотацию @Value двадцать раз. Приведенный ниже фрагмент кода показывает, как можно использовать эту аннотацию для внедрения значения свойства в приложение.
`@Value(“${propertyName}”)`
Важно убедиться, что имя свойства `@Value` совпадает с именем, указанным в источниках свойств.
`@ConfigurationProperties`
При наличии нескольких свойств мы можем сгруппировать их и сопоставить с классом POJO. Таким образом, мы получим структурированный и типобезопасный объект, который сможем внедрить в любое место в нашем приложении. Поэтому вместо использования аннотации `@Value` значения свойств можно получить с помощью метода чтения значения класса POJO.
```
@Data
@Component
@ConfigurationProperties(prefix = "merchantaccount")
public class MerchantAccount {
private String name;
private String username;
private String code;
private int number;
private String currency;
}
```
Класс POJO должен иметь аннотации `@ConfigurationProperties` и `@Component`, как описано выше. Значение префикса, указанное в аннотации, должно совпадать с префиксом свойства, определенного в файле `application.yml`.
**application.yml**
```
merchantaccount:
name: Maureen Sindiso Mpofu
username: momoe
code: MCA1230
number: 771222279
currency: ZWL
```
Важно отметить, что аннотация `@ConfigurationProperties` также позволяет нам сопоставлять списки и карты, как показано ниже:
```
@ConfigurationProperties(prefix = "connection")
@Component
@Data
public class ConnectionSettings {
List names;
Map addresses;
}
```
### Порядок приоритета данных конфигурации
В приложении Spring Boot может быть несколько источников свойств. Поэтому важно знать, какой источник свойства имеет наивысший приоритет. Например, если конфигурация нашего приложения находится в файле `application.yml` и во время выполнения приложения мы решаем передать аргументы командной строки, тогда значения свойств в файле `application.yml` будут переопределены значениями аргументов командной строки.
В Spring Boot 2.2.x используется приведенный ниже порядок источников свойств. Источник свойств, расположенный выше в списке, имеет приоритет над источниками под ним.
1. Свойства глобальных настроек в папке `$HOME/.config/spring-boot`, когда средства разработки активны.
2. Аннотации `@TestPropertySource` в ваших тестах.
3. Атрибут свойств в ваших тестах. Он доступен в `@SpringBootTest` и тестовых аннотациях для проверки работы определенного фрагмента вашего приложения.
4. Аргументы командной строки.
5. Свойства из `SPRING_APPLICATION_JSON` (строковый JSON в переменной среды или системном свойстве).
6. Начальные параметры `ServletConfig`.
7. Начальные параметры `ServletContext`.
8. Атрибуты JNDI из `java:comp/env`.
9. Свойства Java System, то есть `System.getProperties()`.
10. Переменные среды ОС.
11. `RandomValuePropertySource`, свойства которого хранятся только в `random.*`.
12. Свойства приложения для конкретного профиля, за пределами упакованного файла `.jar (application- {profile}.properties` и варианты YAML).
13. Свойства приложения для конкретного профиля внутри файла .jar (`application- {profile}.properties` и варианты YAML).
14. Свойства приложения за пределами упакованного файла .jar (`application.properties` и варианты YAML).
15. Свойства приложения в файле .jar (`application.properties` и варианты YAML).
16. Аннотации `@PropertySource` в классах `@Configuration`. Необходимо учесть, что такие источники свойств не добавляются в Environment, пока контекст приложения не будет обновлен. В этот момент уже поздно настраивать некоторые свойства, например logging.\* и spring.main.\*, которые считываются перед началом обновления.
17. Свойства по умолчанию (заданные настройкой `SpringApplication.setDefaultProperties`).
### Заключение
Рекомендуется выносить данные конфигурации во внешний источник. Если свойств много, мы можем сгруппировать их в простой класс Java и использовать аннотацию `@ConfigurationProperties`, чтобы структурировать конфигурацию и сделать ее типобезопасной. Однако самая большая проблема при использовании внешних источников свойств заключается в правильном выборе конфигурации для разворачиваемого приложения. Поэтому важно соблюдать осторожность при настройке приложения, в котором для разных сред используются разные источники свойств. Пример кода для этой статьи [доступен на GitHub](https://github.com/spring-framework-guru/sfg-blog-posts/tree/master/external-configuration).
---
> Материал подготовлен в рамках специализации [«Java Developer».](https://otus.pw/8Bsx/)
>
> | https://habr.com/ru/post/576910/ | null | ru | null |
# Основы оптимизации кода игр
Многие начинающие инди-разработчики слишком поздно задумываются над оптимизацией кода. Она отдаётся на откуп движкам или фреймворкам или рассматривается как «сложная» техника, недоступная их пониманию. Однако существуют способы оптимизации, которые можно реализовать более простым способом, позволяющие коду работать эффективнее и на большем количестве систем. Давайте для начала рассмотрим самые основы оптимизации кода.
Оптимизация ради игроков и собственного психического здоровья
-------------------------------------------------------------
Довольно часто инди-разработчики имитируют методы оптимизации крупных компаний. Это не всегда плохо, но стремление к оптимизации игры уже после прохождения точки невозврата — хороший способ свести себя с ума. Умной тактикой отслеживания эффективности оптимизации будет сегментирование целевой аудитории и изучение характеристик её машин. Бенчмаркинг игры с учётом компьютеров и консолей потенциальных игроков поможет сохранить баланс между оптимизацией и собственным психическим здоровьем.
Основы оптимизации кода
-----------------------
На самом деле есть довольно малое количество оптимизаций, которые почти всегда можно использовать для повышения скорости игры. Большинство из них не привязано к конкретной платформе (некоторые движки и фреймворки учитывают их), поэтому ниже я покажу примеры на псевдокоде, чтобы вы знали, с чего начинать.
### Минимизация влияния объектов за пределами экрана
Часто этим занимаются движки, а иногда даже сами GPU. Минимизация объёма вычислений для объектов за пределами экрана чрезвычайно важна. В собственной архитектуре лучше разделять объекты на два «слоя» — первый будет графическим представлением объекта, второй — данными и функциями (например, его местоположением). Когда объект находится за пределами экрана, нам больше не нужно тратить ресурсы на его рендеринг и достаточно заниматься его отслеживанием. Отслеживание с помощью переменных таких параметров, как позиция и состояние, значительно снижает потребности в ресурсах.
В играх с большим количеством объектов или объектов с большими объёмами данных может оказаться полезным сделать ещё один шаг и создать отдельные процедуры обновления. Одна процедура будет выполнять обновление, когда объект находится на экране, другая — когда он за его пределами. Настроив такое разделение, мы сможем уберечь систему от необходимости выполнения множества анимаций, алгоритмов и других обновлений, которые необязательны, когда объект скрыт.
Вот пример псевдокода класса объекта, использующего флаги и ограничения местоположения:
```
Object NPC {
Int locationX, locationY; //текущая позиция объекта на 2d-плоскости
Function drawObject() {
//функция отрисовки объекта, вызываемая в цикле обновления экрана
}
//функция, проверяющая, находится ли объект в текущем вьюпорте
Function pollObjectDraw(
array currentViewport[minX,minY,maxX,maxY]
) {
//если он находится внутри вьюпорта, сообщаем, что его нужно отрисовывать
If (this.within(currentViewport)) {
Return true;
}
Else {
Return false;
}
}
}
```
Хотя этот пример очень упрощён, он позволяет нам опрашивать объекты и определять их видимость перед отрисовкой, благодаря чему можно выполнять упрощённую функцию вместо выполнения полного вызова отрисовки. Чтобы отделить функции, не являющиеся графическими вызовами, может потребоваться создание дополнительного буфера — например, функция, в которую включено всё, что вскоре может увидеть игрок, а не только то, что он может видеть в текущий момент.
### Независимость от обновления кадров
В движках и фреймворках обычно есть объекты, обновляемые в каждом кадре или «цикле» (tick). Это сильно нагружает процессор, и чтобы снизить нагрузку, мы должны по возможности избавиться от обновления в каждом кадре.
Первое, что нужно отделить — это функции рендеринга. Такие вызовы обычно очень активно используют ресурсы, поэтому интеграция вызова, сообщающего нам, изменились ли визуальные свойства игрока, сильно снизить объём рендеринга.
Можно сделать ещё один шаг и использовать для наших объектов временный экран. Отрисовывая объекты непосредственно во временный контейнер, мы можем гарантировать, что они будут отрисовываться только при необходимости.
Аналогично упомянутой выше оптимизации, в начальной итерации нашего кода используется простой опрос:
```
Object NPC {
boolean hasChanged; //флаг имеет значение true, когда в объект внесены изменения
//функция, возвращающая флаг
Function pollObjectChanged(
return hasChanged();
}
}
```
Теперь в каждом кадре вместо выполнения множества функций мы сначала убеждаемся, что это необходимо. Хотя эта реализация тоже очень проста, она может значительно повысить эффективность игры, особенно когда дело доходит до статичных предметов и медленно обновляемых объектов наподобие HUD.
В своей игре вы можете зайти ещё дальше и разбить флаг на несколько более мелких компонентов для сегментирования функционала. Например, можно добавить отдельные флаги для изменения данных и графических изменений.
### Непосредственные вычисления и поиск значений
Эта оптимизация применялась с самых первых дней игровой индустрии. Выбрав компромисс между вычислениями и поиском значений, можно значительно снизить время обработки. В истории гейминга хорошо известным примером такой оптимизации является хранение значений тригонометрических функций в таблицах, потому что в большинстве случаев эффективнее хранить большую таблицу и получать данные из неё, а не выполнять расчёты на лету, что увеличивает нагрузку на процессор.
Сегодня нам редко приходится делать выбор между хранением результатов и выполнением алгоритма. Однако всё ещё встречаются ситуации, в которых такой выбор может снизить объём используемых ресурсов, что позволяет добавить в игру новые возможности, не перегружая при этом систему.
Реализацию такой оптимизации можно начать с определения часто выполняемых в игре вычислений или частей вычислений: чем больше вычисления, тем лучше. Однократное выполнение повторяющихся частей алгоритма и сохранение их значений часто может сэкономить значительную долю вычислительных ресурсов. Даже выделение этих частей в отдельные игровые циклы помогает оптимизировать производительность.
Например, во многих шутерах с видом сверху часто есть большие группы врагов, выполняющих одинаковые действия. Если в игре есть 20 врагов, каждый из которых движется по дуге, то вместо вычисления каждого движения отдельно, более эффективно будет сохранять результаты работы алгоритма. Благодаря этому их можно изменять на основании начальной позиции врага.
Чтобы понять, будет ли этот метод полезен в вашей игре, попробуйте использовать бенчмарки для сравнения разницы ресурсов, используемых при вычислениях и хранении данных.
### Использование времени простоя процессора
Это больше относится к использованию бездействующих ресурсов, но при правильной реализации для объектов и алгоритмов вы можете располагать задачи таким образом, чтобы повысить эффективность кода.
Чтобы начать применять чувствительность к простою в собственном ПО, вам для начала нужно выделить те внутриигровые задачи, которые не критичны ко времени и могут вычисляться до того, как они станут нужны. В первую очередь стоит искать код с подобным функционалом в том, что относится к атмосфере игры. Погодные системы, не взаимодействующие с географией, фоновыми визуальными эффектами и фоновым звуком обычно можно отнести к вычислениям во время простоя.
Кроме атмосферных вычислений, к области вычислений во время простоя относятся обязательные вычисления. Можно сделать более эффективными происходящие независимо от игрока вычисления искусственного интеллекта (потому что они или не учитывают игрока, или пока не взаимодействуют с игроком), а также вычисляемые движения, например скриптовые события.
Создание системы, использующей режим простоя, не просто обеспечивает повышенную эффективность — её можно применять для масштабирования визуального качества. Например, на слабой машине игроку может быть доступен только базовый («ванильный») игровой процесс. Однако если система обнаруживает кадры, в которых почти не выполняется вычислений, то мы можем использовать их для добавления частиц, графических событий и других атмосферных штрихов, придающих игре больше пафоса.
Для реализации такой возможности нужно использовать функционал, имеющийся в выбранном движке, фреймворке или языке, позволяющий определять, насколько сильно используется процессор. Задавайте в своём коде флаги, позволяющие с лёгкостью определить объём «лишних» вычислительных ресурсов и настраивайте подсистемы таким образом, чтобы они проверяли эти флаги и вели себя соответственно.
Сочетание оптимизаций
---------------------
Объединив эти методы, можно сделать код гораздо более эффективным. Благодаря эффективности появляется возможность добавления новых функций, совместимости с бОльшим количеством систем и обеспечения качественного игрового процесса. | https://habr.com/ru/post/358176/ | null | ru | null |
# Консольные помощники для работы с Kubernetes через kubectl
Kubectl — основной консольный интерфейс для взаимодействия с Kubernetes и, безусловно, важный инструмент в руках любого администратора/DevOps-инженера, причастного к эксплуатации таких кластеров. Если вы пользуетесь им каждый день и делаете это по-настоящему активно, то, как это свойственно ИТ-специалистам, наверняка задумывались о способах упрощения/автоматизации своих манипуляций. Благо, это мир сисадминов, Open Source и консоли, так что в нём, конечно, уже нашлись и те, кто не только задумывался об этом, но и воплотил свои потребности в жизнь — в виде утилит, доступных теперь и всем «коллегам по цеху». О них и пойдёт речь в этом небольшом обзоре.
kube-shell
----------
* [GitHub](https://github.com/cloudnativelabs/kube-shell)
* Язык: Python\*
* Лицензия: Apache 2.0
Интерактивная оболочка для kubectl, в основе которой — библиотека [prompt-toolkit](https://github.com/jonathanslenders/python-prompt-toolkit) для Python, служащая «заменой для GNU readline и гораздо большим». Эта библиотека реализует автоматическое дополнение вводимых команд с выпадающими пояснениями, подсветку синтаксиса и ряд других возможностей, которые по сути и делают всю «интерактивность» в kube-shell. Тот случай, когда проще один раз увидеть:
Среди других возможностей этой оболочки:
* автоматические подсказки, появляющиеся по мере ввода команд в стиле [fish shell](http://fishshell.com/);
* история введённых команд с поиском по частичным совпадениям;
* расширенные фичи автодополнения: fuzzy-поиск, подстановка значений из полученных с сервера данных;
* удобное переключение между кластерами и пространствами имён *(висит [тикет](https://github.com/cloudnativelabs/kube-shell/issues/22) на добавление аналогичного переключения между пользователям)*;
* режим редактирования vi.
В непонятном будущем [ожидается](https://github.com/cloudnativelabs/kube-shell/wiki/Proposal:-SQL-like-query-language) также появление поддержки SQL-подобного языка для выполнения через kubectl команд такого вида:
```
ls select (property1, property2, property3) where (propery1=value1 and property2=value2) order by property3
```
Вдохновением для kube-shell послужили похожие оболочки для работы с API в AWS: [aws-shell](https://github.com/awslabs/aws-shell) и [saws](https://github.com/donnemartin/saws).
*\* В проекте также используется вспомогательная программа на Go (она забавно называется — [python\_eats\_cobra.go](https://github.com/cloudnativelabs/kube-shell/blob/master/misc/python_eats_cobra.go)) для генерации JSON-файла с доступными в kubectl командами, аргументами и т.п. В дальнейшем с этим файлом работает основное приложение на Python.*
kube-prompt
-----------
* [GitHub](https://github.com/c-bata/kube-prompt)
* Язык: Go
* Лицензия: MIT License
Ещё одна интерактивная оболочка, очень похожая по своей сути на описанную ранее kube-shell и появившаяся на месяц позже (согласно первому коммиту в GitHub, который случился в июле против июня 2017 года). Её главное отличие — использование «родного» для Kubernetes-сообщества языка программирования Go вместо Python. Однако своего prompt-toolkit у Go не было, поэтому… автор (Masashi Shibata из Японии) взял и написал [go-prompt](https://github.com/c-bata/go-prompt), а уже на её основе реализовал новую оболочку. И результатам получился весьма схожим:
*(Набор символов справа снизу — последовательность нажатий на клавиатуре для достижения такого результата. Более наглядно — в [этой GIF-анимации](https://github.com/c-bata/assets/raw/master/kube-prompt/kube-prompt.gif) на 16 Мб.)*
Если сравнивать kube-prompt с его Python-собратом глазами конечного пользователя, то дополнительных фишек у него меньше (например, отсутствует постоянный вывод текущего кластера/пространства имён и быстрое переключение между ними). Зато в нём нет необходимости вводить «kubectl» в начале всех команд и этом сохранена возможность добавления других shell-команд через pipe («|») — например, grep при получении списка подов.
Тем не менее, несмотря на то, что kube-prompt разрабатывается единственным человеком и чуть меньше по времени, по количеству звёздочек на GitHub он уже немного впереди, так что перспективы дальнейшего развития у этих конкурентных решений не столь очевидны.
kubectl-repl
------------
* [GitHub](https://github.com/Mikulas/kubectl-repl)
* Язык: Go
* Лицензия: Apache 2.0
«REPL» в названии этого приложения — тот самый цикл [Read–Eval–Print Loop](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop), реализующий простую интерактивную среду внутри shell. По сути же kubectl-repl представляет собой оригинальную «обёртку», которая после своего запуска предлагает вводить дальнейшие команды без упоминания kubectl и упрощает взаимодействие с этой утилитой благодаря двум возможностям:
1. Переключение пространств имён (одной командой выбирается текущее, которое затем показывается как актуальное в приглашении и добавляется ко всем последующим вызовам kubectl);
2. «Номерной» выбор элементов из списков, возвращаемых `kubectl get`.
Вторая фича реализована таким образом, что всем элементам списков — например, для списка подов, вернувшихся по команде `kubectl get pods | grep foobar`, — добавляется столбец с переменными вида `$1`, `$2`, `$3`… Эти переменные доступны для использования в дальнейших командах kubectl или shell. Пример из документации:
```
# kube-system get pods
+ kubectl -n kube-system get pods
NAME READY STATUS RESTARTS AGE
$1 kube-dns-3945342221-mwdh6 3/3 Running 0 9d
$2 kube-dns-3945342221-x3fhn 3/3 Running 0 9d
# kube-system ; echo $(whoami) $2
+ echo $(whoami) kube-dns-3945342221-x3fhn
mikulas kube-dns-3945342221-x3fhn
```
Утилита kubectl-repl — совсем молодая, разрабатывается одним энтузиастом меньше месяца.
k8sh
----
* [GitHub](https://github.com/Comcast/k8sh)
* Язык: Bash
* Лицензия: Apache 2.0
Ещё одна попытка сделать простую обёртку вокруг kubectl — на сей раз на обычном Bash. После запуска отображает в своём приглашении текущий контекст (`kubectl config current-context`) и пространство имён, предлагая короткие команды для их смены (`ct` и `ns` соответственно), а также набор из других алиасов. Например:
* `kubectl describe` → `k describe`
* `kubectl get pods` → `pods`
* `kubectl get persistentvolumeclaims` → `pvc`
Подгружаемые с запуском k8sh алиасы можно расширять, создав файл `~/.k8sh_extensions` со своим Bash-кодом (в репозитории есть [пример](https://github.com/Comcast/k8sh/blob/master/examples/k8sh_extensions), как этим воспользоваться).
kubectl-aliases
---------------
* [GitHub](https://github.com/ahmetb/kubectl-aliases)
* Язык: Python, Bash
* Лицензия: Apache 2.0
Более «хардкорный» вариант Bash/zsh-алиасов для kubectl. Его автор написал скрипт на Python, который автоматически генерирует файл `.kubectl_aliases`, содержащий сотни(!) строчек следующего вида:
```
alias k='kubectl'
…
alias ka='kubectl apply -f'
…
alias ksyslo='kubectl --namespace=kube-system logs -f'
…
alias ksysgdep='kubectl --namespace=kube-system get deployment'
…
alias kgno='kubectl get nodes'
…
alias ksysgdepojson='kubectl --namespace=kube-system get deployment -o=json'
…
```
Как отмечает сам автор, [анонсировавший](https://ahmet.im/blog/kubectl-aliases/) своё детище менее 2 недель назад, «это может выглядеть по-настоящему глупо, однако ОЧЕНЬ ПОЛЕЗНО для меня; [благодаря этим алиасам] я действительно существенно экономлю время в своём ежедневном рабочем процессе».
Другие
------
* О [**kubectx**](https://github.com/ahmetb/kubectx) для удобного переключения между кластерами мы уже писали в [этом обзоре](https://habrahabr.ru/company/flant/blog/330198/), а с тех пор утилита была дополнена kubens (см. [тот же репозиторий](https://github.com/ahmetb/kubectx)) для аналогичного переключения между пространствами имён.
* [**kubeplay**](https://github.com/errordeveloper/kubeplay) — ещё одна реализация REPL, но предлагающая использовать синтаксис Ruby.
* [**zsh-kubectl-prompt**](https://github.com/superbrothers/zsh-kubectl-prompt) — простой скрипт для отображения в приглашении zsh текущего контекста и пространства имён Kubernetes.
P.S.
----
Читайте также в нашем блоге:
* «[kubebox и другие консольные оболочки для Kubernetes](https://habr.com/company/flant/blog/426985/)»;
* «[Полезные утилиты при работе с Kubernetes](https://habrahabr.ru/company/flant/blog/330198/)»;
* «[Полезные команды и советы при работе с Kubernetes через консольную утилиту kubectl](https://habrahabr.ru/company/flant/blog/333956/)»;
* «[Знакомство с kube-spawn — утилитой для создания локальных Kubernetes-кластеров](https://habrahabr.ru/company/flant/blog/338132/)»;
* «[Обзор GUI-интерфейсов для управления Docker-контейнерами](https://habrahabr.ru/company/flant/blog/338332/)». | https://habr.com/ru/post/341606/ | null | ru | null |
# Управление картинками и другим бинарным содержимым вашего веб-проекта
Мы, в компании XIAG, в разных проектах постоянно решаем одну и ту же задачу: как хранить и показывать бинарные пользовательские данные. Это могут быть логотипы компаний, PDF файлы с описанием вакансий или приветственное видео. Причем это содержание нужно показывать на страницах сайта самым разнообразным способом: лого должно быть нужного размера, PDF — в виде маленькой превью-картинки, а из видео нужно показать пару стоп-кадров.
Уверен, такая задача знакома всем веб-разработчикам. В этой статье мы хотим поделиться нашим решением проблемы, опубликованным под открытой лицензией на ГитХабе.
Познакомьтесь с веб-сервисом Barberry (<https://github.com/Magomogo/Barberry>), который мы успешно используем уже около года. Суть сервиса в том, что он хранит оригиналы загруженных документов и способен по-разному отдавать их, конвертируя на лету.
#### Веб-сервис с REST интерфейсом
Первая и очевидная мысль — решение стандартной задачи не должно быть частью конкретного приложения. Нам нужен изолированный сервис, на который можно возложить эту простую ответственность.
Barberry размещается на сервере отдельно и взаимодействует с миром по HTTP. Чтобы попробовать сервис в работе, необходимо инсталлировать <https://github.com/Magomogo/barberry-service> на ваш сервер. Мы уже сделали это у себя, демонстрацию работы сервиса можно увидеть по адресу [http://barberry.xiag.ch](http://barberry.xiag.ch/demo.html)
##### Загрузка
Для того, чтобы загрузить данные в Barberry, необходимо сделать POST запрос. Сервис определит Content-Type и сообщит уникальный идентификатор сохраненного документа.
Пример загрузки фотографии DSC01823.JPG, например в консоли командой curl:
```
$ curl -X POST -F file=@/tmp/DSC01823.JPG barberry.xiag.ch
```
```
Запрос:
POST / HTTP/1.1
-- данные --
Ответ:
HTTP/1.1 201 Created
{"id":"yPkjPk","contentType":"image/jpeg","ext":"jpg","length":218038,"filename":"DSC01823.JPG"}
```
JSON ответ сервера описывает полученный документ. Дальнейшее обращение к нему будет происходить по уникальному “id”:”yPkjPk”.
##### Выгрузка
Идентификатор загруженного документа необходимо сохранить на стороне вашего приложения. Он используется для выгрузки:
```
Запрос:
GET /yPkjPk.jpg HTTP/1.1
Ответ:
HTTP/1.1 200 OK
Content-Type: image/jpeg
```
В окне браузера появится изображение. Ничего особенного. Вся мощь Barberry раскрывается далее.
#### Конвертация на лету и кеширование
Что будет, если попросить документ в другом формате? Для этого к идентификатору документа необходимо дописать другое расширение.
```
Запрос:
GET /yPkjPk.gif HTTP/1.1
Ответ:
HTTP/1.1 200 OK
Content-Type: image/gif
```
Изображение изменится, сервис сконвертировал JPG -> GIF, и передал нам. Для конвертации был использован barberry-plugin-imagemagick, который берет на себя конвертацию изображений.
Запрос может быть еще более сложным:
```
Запрос:
GET /yPkjPk_200x200.gif HTTP/1.1
```
Изменится не только формат исходного изображения, но и размер. В общем случае после идентификатора документа идет произвольная команда, которая будет передана плагину, который будет производить конвертацию в нужный формат.
Если попросить странного, сервис ответит правильно:
```
Запрос:
GET /yPkjPk.pdf HTTP/1.1
Ответ:
HTTP/1.1 404 Not Found
```
Это значит, что сервис не нашел возможности конвертировать изображение в PDF документ. Конечно, никто не запрещает написать плагин для этого, и подключить к вашей установке Barberry.
О кешировании. Конвертация не происходит при каждом GET запросе. Веб-сервер сконфигурирован так, что запускает конвертер только если в кеше не нашлось необходимого файла. В примере используется apache с его rewrite модулем.
#### Гибкость
Несмотря на то, что задача стандартна, для разных проектов есть свои ньюансы. Архитектура Barberry позволяет создавать специфичные плагины, расширяя возможности по конвертации данных. Например, вместо плагина для работы с картинками [github.com/Magomogo/barberry-plugin-imagemagick](https://github.com/Magomogo/barberry-plugin-imagemagick) можно реализовать свой, добавляющий на изображение водяной знак вашего сайта.
Так у Barberry появились довольно экзотические способности:
* [github.com/kevich/barberry-plugin-pdf](https://github.com/kevich/barberry-plugin-pdf) — преобразование PDF в простой текст и изображения
* [github.com/ykovaleva/barberry-plugin-webcapture](https://github.com/ykovaleva/barberry-plugin-webcapture) — снимки веб-сайтов в интернете в виде изображений или PDF (используется webkit)
* [github.com/jamayka/barberry-plugin-openoffice](https://github.com/jamayka/barberry-plugin-openoffice) — конвертирование таблиц и документов XSL, DOC, PDF и всего остального, что умеет Open Office headless.
* [github.com/ykovaleva/barberry-plugin-ffmpeg](https://github.com/ykovaleva/barberry-plugin-ffmpeg) — работа с видео, получение стоп-кадров
Управление зависимостями отдано менеджеру пакетов composer. Чтобы создать barberry сервис для своего приложения, мы рекомендуем сделать форк <https://github.com/Magomogo/barberry-service> и добавлять свою специфику.
Например, заглянуть в composer.json и подключить необходимые вам плагины. Изначально подключен только плагин для работы с картинками:
```
"require": {
"barberry/barberry": "1.1.*",
"barberry/plugin-imagemagick": "1.0.*"
}
```
Чтобы расширить функциональность, можно подключить плагины, которые будут работать с документами других Content-Type.
#### Мониторинг
Как и любое веб-приложение, Barberry в продуктивном режиме должен быть подключен к системе мониторинга. По адресу [barberry.xiag.ch/monitoring.php](http://barberry.xiag.ch/monitoring.php) находится скрипт, который опрашивает все подключенные плагины и рапортует, всё ли в порядке.
#### Заключение
Описание деталей реализации находится за рамками этого поста. Заинтересованных приглашаем к сотрудничеству на страницах ГитХаба. | https://habr.com/ru/post/175053/ | null | ru | null |
# Подводные камни при работе с enum в C#
C# имеет низкий порог вхождения и прощает многое. Серьёзно, на этом языке преспокойно можно писать, не особо понимая, как всё работает под капотом, и не забивать голову. Однако со временем приходится сталкиваться с разными нюансами. Сегодня рассмотрим один из них — работу с перечислениями.
Вообще маловероятно, что найдётся такой разработчик, который бы не сталкивался с перечислениями. Тем не менее допустить ошибку при их использовании можно. Особенно если:
* это и не ошибка как таковая, а просто не совсем оптимальная работа приложения (например, из-за доп. нагрузки на GC);
* приходится писать много кода и нет времени вникать во все нюансы языка.
Более того, на практике описанные ниже проблемы могут и не быть проблемами для вашего приложения. Однако, если подобный код будет многократно исполняться (например, десятки миллионов раз) и начнёт доставлять неудобства, вы уже будете знать, с чем имеете дело.
**Примечание**. Все исследования, которые мы будем проводить ниже, выполнялись для .NET Framework. Это важно. Про .NET поговорим немного позже.
Неожиданная нагрузка на GC
--------------------------
С описываемой проблемой я столкнулся не так давно, когда занимался различными оптимизациями C# анализатора PVS-Studio. Да, у нас уже была одна [статья на эту тему](https://pvs-studio.com/ru/blog/posts/csharp/0836/), но, думаю, будет ещё.
В процессе работы я исправлял различные места в коде. Как показала практика, даже маленькие правки могут дать неплохие результаты, если сделаны они в 'узких' местах приложения.
В какой-то момент по результатам профилирования я вышел на класс *VariableAnnotation*. Его упрощённый вариант и рассмотрим.
```
enum OriginType
{
Field,
Parameter,
Property,
....
}
class VariableAnnotation where T : Enum
{
public T Type { get; }
public SyntaxNode OriginatingNode { get; }
public VariableAnnotation(SyntaxNode originatingNode, T type)
{
OriginatingNode = originatingNode;
Type = type;
}
public override bool Equals(object obj)
{
if (obj is null)
return false;
if (obj is not VariableAnnotation other)
return false;
return Enum.Equals(this.Type, other.Type)
&& this.OriginatingNode == other.OriginatingNode;
}
public override int GetHashCode()
{
return this.OriginatingNode.GetHashCode()
^ this.Type.GetHashCode();
}
}
```
А теперь напишем два простых метода, в которых:
* в цикле сравниваются экземпляры типа *VariableAnnotation*;
* создаётся экземпляр типа *VariableAnnotation* и у него в цикле вычисляется хеш-код.
Соответствующие методы:
```
static void EqualsTest()
{
var ann1 = new VariableAnnotation(new SyntaxNode(),
OriginType.Parameter);
var ann2 = new VariableAnnotation(new SyntaxNode(),
OriginType.Parameter);
while (true)
{
var eq = Enum.Equals(ann1, ann2);
}
}
static void GetHashCodeTest()
{
var ann = new VariableAnnotation(new SyntaxNode(),
OriginType.Parameter);
while (true)
{
var hashCode = ann.GetHashCode();
}
}
```
Если запустить любой из этих методов и понаблюдать за приложением в динамике, можно отметить неприятную особенность: оно даёт нагрузку на GC.
Например, это можно увидеть в окне "Diagnostic tools" Visual Studio.
Или в Process Hacker на вкладке ".NET performance" информации о процессе.
По этим примерам несложно вычислить, что виновника два:
* *Enum.Equals(ann1, ann2)*;
* *ann.GetHashCode()*.
Разберёмся с ними поочерёдно.
Enum.Equals
-----------
Будем исследовать следующий код:
```
static void EnumEqTest(OriginType originLhs, OriginType originRhs)
{
while (true)
{
var eq = Enum.Equals(originLhs, originRhs);
}
}
```
Первое, на что обратят внимание знатоки (IDE в этом поможет, кстати) — никакого *Enum.Equals* нет. В данном случае происходит вызов метода *Object.Equals(object objA, object objB)*.
На это намекает сама IDE:
Так как мы работаем с экземплярами значимого типа, а для вызова метода нам нужны ссылочные, перед вызовом будет произведена упаковка. Кстати, если заглянуть в IL код, можно найти эти самые команды упаковки:
```
.method private hidebysig static void
EnumEqTest(valuetype EnumArticle.Program/OriginType originLhs,
valuetype EnumArticle.Program/OriginType originRhs) cil managed
{
// Code size 20 (0x14)
.maxstack 8
IL_0000: ldarg.0
IL_0001: box EnumArticle.Program/OriginType
IL_0006: ldarg.1
IL_0007: box EnumArticle.Program/OriginType
IL_000c: call bool [mscorlib]System.Object::Equals(object,
object)
IL_0011: pop
IL_0012: br.s IL_0000
}
```
Здесь мы чётко видим вызов метода *System.Object::Equals(object, object)*, а также команды предварительной упаковки аргументов — *box* (IL\_0001, IL\_0007).
Так как мы упаковываем объекты только для вызова метода, соответствующие ссылки никуда не сохраняются, следовательно, упакованные объекты будут очищены при сборке мусора.
**Примечание**. Кто-то может сказать — всем очевидно, что *Enum.Equals* == *Object.Equals*. Вон, даже IDE подсветку делает. Ответ — нет, нет и ещё раз нет. Самое простое этому доказательство состоит в том, что такой код был написан. И я уверен, что некоторые разработчики используют подобный способ сравнения. По поводу "очевидности" — очень часто люди попадают в ловушку, думая, что если что-то очевидно им, то это очевидно всем. На самом деле это не так.
Если мы поменяем вызов *Enum.Equals* (по факту — *Object.Equals*) на сравнение через '==', то избавимся от ненужной упаковки:
```
var eq = originLhs == originRhs;
```
Однако следует помнить, что обобщённый вариант кода (тип *VariableAnnotation* был обобщённым) не скомпилируется:
```
static void EnumEq(T originLhs, T originRhs) where T : Enum
{
while (true)
{
// error CS0019: Operator '==' cannot be applied
// to operands of type 'T' and 'T'
var eq = originLhs == originRhs;
}
}
```
Вызовы экземплярных методов *Enum.Equals* и *Enum.CompareTo* нам не подойдут, так как влекут за собой упаковку.
Выходом может стать использование обобщённого типа *EqualityComparer*. Например, можно вполне спокойно воспользоваться дефолтным компаратором. Код примет примерно следующий вид:
```
static void EnumEq(T originLhs, T originRhs) where T : Enum
{
while (true)
{
var eq = EqualityComparer.Default.Equals(originLhs, originRhs);
}
}
```
Метод *EqualityComparer.Equals(T x, T y)* принимает аргументы обобщённого типа, а следовательно, не требует упаковки (по крайней мере, перед своим вызовом). Внутри вызова методов всё тоже нормально.
Из кода IL команды упаковки пропали:
```
.method private hidebysig static void
EnumEq<([mscorlib]System.Enum) T>(!!T originLhs,
!!T originRhs) cil managed
{
// Code size 15 (0xf)
.maxstack 8
IL_0000: call
class [mscorlib]System.Collections.Generic.EqualityComparer`1
class [mscorlib]System.Collections.Generic.EqualityComparer`1
::get_Default()
IL_0005: ldarg.0
IL_0006: ldarg.1
IL_0007: callvirt
instance bool class
[mscorlib]System.Collections.Generic.EqualityComparer`1::Equals(!0,
!0)
IL_000c: pop
IL_000d: br.s IL_0000
}
```
Профилировщик Visual Studio не фиксирует на таком коде событий сборки мусора.
Process Hacker говорит о том же.
Вам может стать интересно, а как же устроен внутри *EqualityComparer* (мне, например, стало). Исходный код этого типа можно посмотреть, например, на [referencesource.microsoft.com](https://bit.ly/2SSW4qh).
Enum.GetHashCode
----------------
Теперь же рассмотрим, что у нас с методом *Enum.GetHashCode*. Начнём со следующего кода:
```
static void EnumGetHashCode(OriginType origin)
{
while (true)
{
var hashCode = origin.GetHashCode();
}
}
```
Возможно, вы будете удивлены, но здесь происходит упаковка и, как следствие, нагрузка на GC, о чём опять же наглядно свидетельствуют профилировщик и Process Hacker.
А давайте-ка поддадимся ностальгии? Скомпилируем этот код через Visual Studio 2010 и посмотрим, какой IL код получится. Примерно такой:
```
.method private hidebysig static void EnumGetHashCode(valuetype
EnumArticleVS2010.Program/OriginType origin) cil managed
{
// Code size 14 (0xe)
.maxstack 8
IL_0000: ldarg.0
IL_0001: box EnumArticleVS2010.Program/OriginType
IL_0006: callvirt instance int32 [mscorlib]System.Object::GetHashCode()
IL_000b: pop
IL_000c: br.s IL_0000
}
```
Кажется, всё ожидаемо: команда *box* на месте (IL\_0001). Это отвечает на вопрос, откуда упаковка и нагрузка на GC.
Вернёмся в современный мир и теперь скомпилируем код через Visual Studio 2019. Получился такой IL код:
```
.method private hidebysig static void
EnumGetHashCode(valuetype EnumArticle.Program/OriginType origin) cil managed
{
// Code size 16 (0x10)
.maxstack 8
IL_0000: ldarga.s origin
IL_0002: constrained. EnumArticle.Program/OriginType
IL_0008: callvirt instance int32 [mscorlib]System.Object::GetHashCode()
IL_000d: pop
IL_000e: br.s IL_0000
}
```
Неожиданно команда *box* испарилась (прямо как карандаш в "Тёмном рыцаре"), а вот упаковка и нагрузка на GC остались. Здесь я решил посмотреть реализацию *Enum.GetHashCode()* на [referencesource.microsoft.com](https://bit.ly/2Uvlafc).
```
[System.Security.SecuritySafeCritical]
public override unsafe int GetHashCode()
{
// Avoid boxing by inlining GetValue()
// return GetValue().GetHashCode();
fixed (void* pValue = &JitHelpers.GetPinningHelper(this).m_data)
{
switch (InternalGetCorElementType())
{
case CorElementType.I1:
return (*(sbyte*)pValue).GetHashCode();
case CorElementType.U1:
return (*(byte*)pValue).GetHashCode();
case CorElementType.Boolean:
return (*(bool*)pValue).GetHashCode();
....
default:
Contract.Assert(false, "Invalid primitive type");
return 0;
}
}
}
```
Самая интересная часть здесь — комментарий "*Avoid boxing ...*". Как будто что-то не сходится...
Итак, вроде бы упаковки не должно быть, команды *box* в IL коде также нет, но выделение памяти в управляемой куче и события сборки мусора на месте.
Давайте что ли посмотрим в [спецификацию CIL](https://www.ecma-international.org/publications-and-standards/standards/ecma-335/), чтобы получше разобраться с IL кодом. Ниже ещё раз приведу вызов метода, чтобы он был перед глазами:
```
ldarga.s origin
constrained. EnumArticle.Program/OriginType
callvirt instance int32 [mscorlib]System.Object::GetHashCode()
```
С инструкцией *ldarga.s* всё просто — адрес аргумента метода загружается на evaluation stack.
Далее идёт префикс *constrained*. Формат префикса:
```
constrained. thisType
```
Stack transition:
```
..., ptr, arg1, ... argN -> ..., ptr, arg1, ... arg
```
В зависимости от того, чем является *thisType*, отличается способ обработки управляемого указателя *ptr*:
* если *thisType* — ссылочный тип, *ptr* разыменовывается и используется как *this*-указатель для вызова метода;
* если *thisType* — значимый тип, который имплементирует вызываемый метод, *ptr* передаётся в этот метод в качестве *this*-указателя как есть;
* если *thisType* — значимый тип, который не имплементирует вызываемый метод, тогда указатель *ptr* разыменовывается, производится упаковка объекта, после чего полученный указатель используется как *this*-указатель при вызове метода.
Как отмечено в спецификации, последний случай возможен только тогда, когда метод объявлен в *System.Object*, *System.ValueType* и *System.Enum* и не переопределяется в дочернем типе.
Второй кейс из списка выше позволяет исключить упаковку объекта при вызове метода, если это возможно. Но мы с вами столкнулись с третьим случаем. *GetHashCode* переопределён в *System.Enum*. *System.Enum* является базовым типом для *OriginType*. Однако само перечисление не переопределяет методы из *System.Enum*, отсюда упаковка при их вызове.
Подчеркну, что это актуально для любых значимых типов. Если вы не переопределяете метод базового типа, для его вызова будет выполнена упаковка объекта.
```
struct MyStructBoxing
{
private int _field;
}
struct MyStructNoBoxing
{
private int _field;
public override int GetHashCode()
{
return _field;
}
}
static void TestStructs(MyStructBoxing myStructBoxing,
MyStructNoBoxing myStructNoBoxing)
{
while (true)
{
var hashCode1 = myStructBoxing.GetHashCode(); // boxing
var hashCode2 = myStructNoBoxing.GetHashCode(); // no boxing
}
}
```
Но вернёмся к перечислениям. Как же быть с ними, ведь мы не можем переопределить метод в перечислении?
На выручку может прийти уже упоминавшийся ранее тип *System.Collections.Generic.EqualityComparer*, который содержит обобщённый метод *GetHashCode* — *public abstract int GetHashCode(T obj)*:
```
var hashCode = EqualityComparer.Default.GetHashCode(\_origin);
```
Разница в рассмотренных примерах между .NET и .NET Framework
------------------------------------------------------------
Как я упоминал ранее, всё сказанное выше было актуально для .NET Framework. Посмотрим, как обстоят дела в .NET?
### Equals
Упаковка, ожидаемо, никуда не делась. Неудивительно, ведь нам всё так же нужно вызывать метод *Object.Equals(object, object)*. Так что сравнивать элементы перечисления таким образом в любом случае не стоит.
Если же говорить про экземплярный метод *Enum.Equals*, то здесь также остаётся необходимость в упаковке аргумента.
### GetHashCode
А вот здесь меня ждал приятный сюрприз!
Вспомним пример кода:
```
static void GetHashCodeTest(OriginType origin)
{
while (true)
{
var hashCode = origin.GetHashCode();
}
}
```
Напоминаю, что при исполнении данного кода в .NET Framework из-за упаковки создаются временные объекты, как следствие — дополнительная нагрузка на GC.
Однако при использовании .NET (и .NET Core) ничего подобного не происходит! Никаких временных объектов, никакой нагрузки GC.
Производительность
------------------
Ладно, с упаковкой вроде разобрались. Давайте посмотрим, что у нас по быстродействию. Заодно сравним скорость работы одного и того же кода для .NET Framework и .NET.
Весь код для сравниваемых методов одинаков, отличаться будут только способы сравнения элементов перечисления и получения хеш-кодов.
### Equals
Описание способов сравнения, используемых в методах:
* *ObjectEquals: Object.Equals(lhs, rhs)*;
* *Enum.Equals: lhs.Equals(rhs)*;
* *Enum.CompareTo: lhs.CompareTo(rhs) == 0*;
* *EqualityComparerEquals: EqualityComparer.Default.Equals(lhs, rhs)*;
* *DirectComparison: lhs == rhs*.
Ниже приводится сравнение времени исполнения.
**.NET Framework 4.8**
**.NET 5**
Меня очень порадовали результаты работы *EqualityComparer* на .NET 5, где по скорости получилось примерно такое же время, как при прямом сравнении элементов перечисления. Стоит отдать должное Microsoft — не изменяя C# кода, вы из коробки получаете оптимизацию при обновлении целевого фреймворка / рантайма.
### GetHashCode
Описание способов получения хеш-кодов, используемых в методах:
* *EnumGetHashCode*: *\_origin.GetHashCode()*;
* *UnderlyingValue*: *(int)\_origin*;
* *UnderlyingValueGetHashCode*: *((int)\_origin).GetHashCode()*;
* *EqualityComparerGetHashCode*: *EqualityComparer.Default.GetHashCode(\_origin)*.
С первым и последним пунктом всё понятно. Второй и третий — 'хаки' для получения хеш-кода, навеянные реализацией [Enum.GetHashCode](https://bit.ly/3xBoK6x) и [Int32.GetHashCode](https://bit.ly/2TKDdht). Да, неустойчивые к изменениям underlying типа и не очень очевидные. Не призываю так писать, но ради интереса добавил в тесты.
Ниже приводится сравнение времени исполнения.
**.NET Framework 4.8**
**.NET 5**
Сразу 2 хорошие новости:
* в .NET убрали упаковку при прямом вызове *GetHashCode*;
* *EqualityComparer*, как и в случае с *Equals*, опять стал работать лучше.
Заключение
----------
C# — классный. Можно много лет писать на нём и не знать о нюансах, связанных с какими-то базовыми вещами: почему *out*-параметры [можно не инициализировать](https://pvs-studio.com/ru/blog/posts/csharp/0800/), почему [результатом упаковки nullable-значения может быть *null*](https://pvs-studio.com/ru/blog/posts/csharp/0772/), почему при вызове *GetHashCode* для перечислений может происходить упаковка. А когда всё же приходится сталкиваться с чем-то подобным, бывает интересно вникнуть в суть. Я от этого кайфую. Надеюсь, вы тоже.
Как обычно, приглашаю подписываться на [мой Twitter](https://twitter.com/_SergVasiliev_), чтобы не пропустить ничего интересного.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Vasiliev. [Enums in C#: Hidden Pitfalls](https://habr.com/en/company/pvs-studio/blog/568926/). | https://habr.com/ru/post/568928/ | null | ru | null |
# Решение алгоритмических задач: возможность бронирования отеля
***Перевод статьи подготовлен специально для студентов курса [«Алгоритмы для разработчиков»](https://otus.pw/haoR/).***
*Эта статья является частью серии о том, как решать алгоритмические задачи. Исходя из своего личного опыта, я обнаружил, что большинство ресурсов просто подробно описывают решение. Объяснение основной линии рассуждений, позволяющей найти эффективное решение, к сожалению, не очень распространено. Поэтому, цель этой серии — описание возможного хода рассуждений для решения задач с нуля.*
---
### Задача
> * Задача: [InterviewBit](https://www.interviewbit.com/problems/hotel-bookings-possible/)
>
>
>
> Менеджер отеля должен обработать N заказов на бронирование номеров на следующий сезон. В его отеле есть K номеров. Информация о бронировании содержит дату заезда и дату выезда. Менеджер хочет выяснить, достаточно ли номеров в отеле, чтобы удовлетворить спрос.
>
>
>
> Входные данные:
>
>
>
> — Первым на вход подается список с информацией о времени заезда
>
> — Вторым — список с информацией о времени выезда
>
> — Третьим — К, обозначающее количество номеров
>
>
>
> Выходные данные:
>
> — Логическое значение, которое обозначает возможность забронировать номера
>
> false означает, что в отеле не достаточно номеров для N бронирований
>
> true означает, что в отеле достаточно номеров для N бронирований
>
>
>
> **Пример:**
>
>
>
> Входные данные:
>
> — заезд = [1, 3, 5]
>
> — выезд = [2, 6, 10]
>
> — К = 1
>
>
>
> Выходные данные: false. В день = 5 в отеле 2 гостя. Но у нас есть только один номер.
>
>
>
> * Категория: [Массивы](https://medium.com/solvingalgo/tagged/arrays)
>
>
>
>
### Процесс решения
Эта задача интересна, на мой взгляд, тем, что есть много разных способов ее решения. Давайте же рассмотрим возможные варианты.
Структура, хранящая счетчики для каждого дня
Первая идея может заключаться в том, что нам нужна структура для хранения количества заказов на каждый день. Эта структура может быть массивом с фиксированным размером (определяется максимальным днем отъезда).
> Входные данные:
>
> — въезды = [1, 3, 5]
>
> — выезды = [2, 6, 10]
>
> — k = 1
>
>
Для этого примера размер массива будет равен 10 (потому что последний выезд в день 10). Чтобы заполнить этот массив, мы проходимся по спискам въездов и выездов и увеличиваем или уменьшаем счетчик соответствующего дня. Пример на псевдокоде:
```
int[] counts = new int[maxDepartures(departures)]
for each arr in arrivals {
counts[arr]++
}
for each dep in departures {
counts[dep]--
}
```
В итоге мы получим следующий массив:
`значение: 1 0 1 1 2 1 1 1 1 0
индекс: 1 2 3 4 5 6 7 8 9 10`
После того, как массив заполнен, нужно просто пройтись по нему и проверить, все ли элементы не превышают `k` (количество комнат).
В предыдущем примере максимальное количество номеров было 1. Поскольку в день 5 у нас есть 2 бронирования, мы возвращаем `false`.
Временная сложность этого решения — O(n), где n — количество бронирований, а пространственная — O(m), где m — максимальный день отъезда. Неплохо в теории, но есть вероятность выделить очень много памяти под большой массив, хотя большая ее часть не будет использована.
Например:
> Входные данные:
>
> — въезды = [1, 3, 5]
>
> — выезды = [2, 10000, 10]
>
> — k = 1
В данном случае будет выделен массив из 10 тысяч целых чисел.
Давайте посмотрим на другие варианты решения.
### Хранение коллекции событий
Какие есть другие варианты? Давайте еще раз посмотрим, что у нас получалось с предыдущей структурой:
`значение: 1 0 1 1 2 1 1 1 1 0
индекс: 1 2 3 4 5 6 7 8 9 10`
Мы видим, что некоторая информация дублируется. Например, между 6 и 9 днями количество бронирований не меняется, так как мы знаем, что за этот период времени ничего не произойдет.
Может станет лучше, если вместо этого хранить события? Давайте снова возьмем тот же пример:
> Входные данные:
>
> — въезды = [1, 3, 5]
>
> — выезды = [2, 6, 10]
>
> День 1: +1 бронирование
>
> День 2: -1 бронирование
>
> День 3: +1 бронирование
>
> День 6: -1 бронирование
>
> День 5: +1 бронирование
>
> День 10: -1 бронирование
Решение заключается в том, чтобы, перебирая эти события, увеличивать или уменьшать счетчик. Если в какой-то момент счетчик больше `k`, мы возвращаем `false`. Однако, чтобы выполнить перебор, эту коллекцию событий нужно отсортировать.
Какую структуру здесь лучше использовать? Давайте обобщим наши требования:
* Поиск, чтобы проверять, существует ли уже такой день,
* Добавление нового дня,
* Просмотр структуры, чтобы перебирать каждый отсортированный день.
Как насчет использования двоичного дерева поиска (Binary Search Tree, BST)?
Каждый узел может быть представлен следующим образом:
```
class Node {
int day
int count
Node left
Node right
}
```
Сортировка будет производиться по полю `day`.
Давайте посмотрим на последствия с точки зрения временной сложности:
* Поиск, чтобы проверять, существует ли уже такой день: O(log(n)) в среднем случае, O(n) в худшем случае,
* Добавление нового дня: O(log(n)) в среднем случае, O(n) в худшем случае,
* Просмотр структуры для перебора каждого отсортированного дня: O(n), используя поиск в глубину.
Поскольку нам приходится перебирать каждый элемент и вставлять его в дерево, сложность алгоритма составляет O(n log(n)) в среднем случае, O(n²) в худшем случае.
Другой вариант — использование хеш-таблицы и сортировка ключей после добавления всех событий:
* Поиск, чтобы проверять, существует ли уже такой день: O(1) в среднем случае, O(n) в худшем случае (вероятность зависит от емкости ассоциативного массива),
* Добавление нового дня: O(1) в среднем случае, O(n) в худшем случае,
* Просмотр структуры для перебора каждого отсортированного дня: O(n log(n)) для сортировки ключей и O(n) для перебора.
В конце концов, решение имеет O(n log(n)) в среднем случае (из-за операции сортировки), O(n²) в худшем случае. Похоже, это решение имеет ту же сложность, что и решение, использующее дерево.
Давайте посмотрим на возможную реализацию на Java, используя отсортированный ассоциативный массив:
```
public boolean hotel(ArrayList arrivals, ArrayList departures, int k) {
// Коллекция событий
Map events = new HashMap<>();
// Количество номеров
int n = arrivals.size();
for (int i = 0; i < n; i++) {
int arrival = arrivals.get(i);
int departure = departures.get(i);
// Прибавляем один для каждого въезда
Integer current = events.get(arrival);
events.put(arrival, current == null ? 1 : current + 1);
// Отнимаем один для каждого выезда
current = events.get(departure);
events.put(departure, current == null ? -1 : current - 1);
}
// Сортируем ассоциативный массив
Map sortedEvents = new TreeMap<>(events);
int count = 0;
for (Map.Entry entry : sortedEvents.entrySet()) {
count += entry.getValue();
// Если count превышает максимальное количество номеров
if (count > k) {
return false;
}
}
return true;
}
```
### Постоянная пространственная сложность
Если мы хотим оптимизировать наш алгоритм, нам нужно подумать, действительно ли необходимо хранить все эти события? Разве мы не можем просто перебирать данные коллекции (въезды и выезды) и проверять ограничение на бронирования в процессе?
Решение возможно, но для этого потребовалось бы упростить входные данные, сортируя их заранее.
Если обе коллекции отсортированы, мы можем просто выполнить итерацию по каждому элементу, используя два указателя (один для въездов и другой для выездов), и выполнять проверку ограничений на лету.
Как вы можете видеть, во время каждой итерации нам все еще нужно проверять минимум между `arrivals.get(indexArrival) и departures.get(indexDeparture)`, чтобы узнать, какой указатель нужно обновить.
В целом, алгоритм имеет постоянную временную и пространственную сложность O(n log(n)) из-за операций сортировки. | https://habr.com/ru/post/470676/ | null | ru | null |
# Один алгоритм комбинаторной генерации
Комбинаторика в старших классах школы, как правило, ограничивается текстовыми задачами, в которых нужно применить одну из трёх известных формул — для числа сочетаний, перестановок или размещений. В институтских курсах по дискретной математике рассказывают и о более сложных комбинаторных объектах — скобочных последовательностях, деревьях, графах… При этом, как правило, ставят задачу вычислить количество объектов данного типа для некоторого параметра n, например количество деревьев на n вершинах. Узнав количество объектов для фиксированного n, можно задаться и более сложным вопросом: как все эти объекты за разумное время предъявить? Алгоритмы, решающие подобного рода задачи, называются алгоритмами комбинаторной генерации. Таким алгоритмам, например, посвящена первая глава четвёртого тома «Искусства программирования» Дональда Кнута. Кнут очень подробно рассматривает алгоритмы генерации всех кортежей, разбиений числа, деревьев и других структур. Придумать какой-нибудь алгоритм, работающий умеренно быстро, для каждой из этих задач несложно, но с дальнейшей оптимизацией могут возникнуть серьёзные проблемы.
В процессе написания магистерской диссертации, защищённой в [Академическом университете](http://mit.spbau.ru), мне потребовалось изучить и применить один из алгоритмов комбинаторной генерации, подходящий для особого класса задач. Это генерация структур, на которых дополнительно введено некоторое отношение эквивалентности. Чтобы было понятно, о чём идёт речь, я приведу простой пример. Давайте попробуем сгенерировать все триангуляции шестиугольника. Получится что-нибудь такое:
Написать алгоритм, который вернёт все такие триангуляции, довольно несложно. Например, сгодится такая процедура: фиксируем какое-нибудь ребро (пусть это будет ребро 1-6), после чего в цикле перебираем вершины, не являющиеся его концами. На текущей вершине и фиксированном ребре строим треугольник, а оставшиеся после этого две области триангулируем рекурсивно. Если присмотреться к получающимся в результате работы этого алгоритма триангуляциям, то можно заметить, что многие из них почти одинаковы и отличаются лишь тем, как расставлены пометки (номера) вершин. Поэтому, полезно было бы придумать алгоритм, который будет генерировать так называемые непомеченные триангуляции — те, что изображены на следующем рисунке:
Более формально, пусть на нашем множестве объектов действует некоторое [отношение эквивалентности](http://ru.wikipedia.org/wiki/%CE%F2%ED%EE%F8%E5%ED%E8%E5_%FD%EA%E2%E8%E2%E0%EB%E5%ED%F2%ED%EE%F1%F2%E8) , разбивающее всё множество на классы *изоморфных* друг другу объектов. Требуется сгенерировать по одному представителю из каждого класса. Вы, наверное, заметили, что две правых триангуляции на втором рисунке тоже очень друг на друга похожи и из них можно оставить только одну. В действительности, всё зависит от того, какое отношение эквивалентности мы выбрали. Если считать изоморфными только те триангуляции, которые можно наложить друг на друга после поворота, то их останется четыре, а если разрешить ещё возможность переворачивать шестиугольник, то три.
Казалось бы, сгенерировать по одному представителю из каждого класса несложно: генерируем все объекты, после чего попарно тестируем на изоморфизм и выкидываем дубликаты. К сожалению, для некоторых типов объектов это будет работать ужасающе долго даже для небольших n. Задачу проверки изоморфизма, например, двух графов, за полиномиальное время решать не умеют, а значит, подпрограмму, решающую эту задачу, желательно вызывать как можно реже. Ещё один минус предложенного наивного подхода состоит в том, что все объекты придётся держать в памяти одновременно. При этом, если подождать медленную программу, выдающую верный ответ, ещё теоретически можно, то получить переполнение памяти вместо ответа уже совсем неприемлемо. Так что, для генерации попарно неизоморфных объектов нужно воспользоваться каким-то более хитрым методом. Такой метод неоднократно переоткрывался для многих конкретных комбинаторных объектов (графов, деревьев, разбиений), а в общем виде был описан в статье [Isomorph-Free Exhaustive Generation](http://cs.anu.edu.au/~bdm/papers/orderly.pdf).
Я расскажу об этом методе на примере задачи, несколько более общей по сравнению с задачей о триангуляциях: мы будем генерировать все «рассечения», то есть способы разбить многоугольник не обязательно на треугольники, а на многоугольники с числом сторон из списка, который подаётся на вход программе.
Для того, чтобы этот метод описать потребуется несколько формальных определений.
Пусть X — некоторое множество «структур». Элементы множества X мы будет называть *помеченными объектами*. В нашей задаче помеченными объектами являются рассечения, вершины которых пронумерованы против часовой стрелки. Структура данных для помеченных рассечений простая — это списки смежности:
```
public class Dissection {
private int[][] adjacent;
...
}
```
Пусть G — некоторая [группа](http://ru.wikipedia.org/wiki/Группа_(математика)) перестановок, действующая на множестве X. Это значит, что каждому помеченному объекту x из X и каждому элементу g группы G поставлен в соответствие другой помеченный объект y = g\*x, причём выполнены следующие свойства:
1. Умножению любых элементов группы h и g соответствует последовательное применение действий к объекту x: h\*(g\*x)=(hg)\*x.
2. Единица группы e переводит каждый помеченный объект x сам в себя: e\*x=x.
Можно показать, что всё множество X разбивается на классы эквивалентности относительного такого отношения: x и y эквивалентны, если x=g\*y. В нашем первом примере с триангуляциями, элементы группы — повороты на 0, 60, 120, 180, 240 и 300 градусов — делят всё множество на четыре класса эквивалентности, элементы которых отличаются именно своей структурой, а не пометками вершин. Эти классы эквивалентности и были изображены на втором рисунке. Мы будем называть эти классы *непомеченными объектами*.
Каждому элементу X мы сопоставим натуральное число, которое будем называть порядком. Порядок у всех эквивалентных объектов должен быть одинаков. Это свойство позволяет доопределить порядок для классов эквивалентности (непомеченных объектов): он будет равен порядку любого представителя соответствующего класса. Для нашего примера на рисунке, порядок — это количество вершин в многоугольнике. У всех непомеченных объектов на рисунке он равен шести.
Это были достаточно общие определения. Теперь перейдём к определениям, специфичным для будущего алгоритма. Каждому помеченному объекту x сопоставим два множества — множество *нижних объектов* L(x) и множество *верхних объектов* U(x). Порядки элементов в этих множествах по определению равны порядку x. Прежде чем дать формальные требования к нижним и верхним объектам, я попробую дать интуитивное описание. Каждый нижний объект должен содержать в себе информацию о том, как однозначно перейти от текущего объекта к объекту меньшего порядка. Например, нижний объект-рассечение — это рассечение, в котором дополнительно выделен (например, покрашен в красный цвет) один из «крайних» многоугольников, который можно от этого рассечения отрезать. Верхний объект — это, наоборот, помеченный объект плюс информация, позволяющяя его однозначным образом «нарастить», увеличив порядок. Верхнее рассечение, например, — это рассечение, в котором одна из сторон многоугольника дополнительно выделена (например, покрашена в красный цвет) и на ней написано число. Посмотрев на такое рассечение, мы можем понять, к какой стороне приклеить новый многоугольник, чтобы увеличить порядок. Число сторон приклеиваемого многоугольника будет определяться тем, какое число написано на ребре. Эту идею можно проиллюстрировать следующим рисунком, изображающим два объекта — нижний и верхний, отвечающих одному и тому же рассечению.
В программе нижние и верхние рассечения представлены так:
```
public class LowerDissection {
private Dissection dissection;
private int after;
...
}
```
```
public class UpperDissection {
private Dissection dissection;
private int after, size;
...
}
```
Для нижнего рассечения мы храним лишь номер вершины, с которой начинается многоугольник, который мы собираемся удалять. Для верхнего рассечения хранится номер вершины, после которой нужно будет приклеивать новый многоугольник, а так же число его сторон.
Можно заметить, что некоторые нижние и верхние объекты находятся в отношении «соответствия»: нижнему объекту соответствует верхний, получающийся после того, как мы уменьшили порядок способом, закодированным в нижнем объекте.
Здесь нижнему объекту сопоставляется верхний, результат удаления выделенного четырёхугольника. На следующем рисунке — наоборот: к верхнему объекту, а точнее, к его выделенному ребру с написанной на нём пятёркой, приклеивается пятиугольник. При этом получается нижний объект, хранящий информацию о том, как откатить проделанную операцию.
Теперь формально, что же нужно потребовать от упомянутых конструкций:
1. Группа G действует на трёх типах объектов: помеченных, верхних и нижних. Каждое из этих трёх множеств замкнуто относительно действия группы (это значит, что, например, подействовав элементом группы на нижний объект, нельзя получить верхний — довольно формальное требование).
2. Для каждого помеченного объекта x и элемента группы g: L(g\*x)=g\*L(x); U(g\*x)=g\*U(x) (запись g\*L(x) значит, что мы применяем g к каждому элементу множества L(x), аналогично для g\*U(x)).
3. Для каждого нижнего объекта y, соответствующее ему множество верхних объектов не пусто.
4. Если два нижних объекта y и x эквиваленты (то есть, y=g\*x), то любые два соответствующих им верхних объекта тоже эквивалентны.
5. Если два верхних объекта y и x эквиваленты, то любые два соответствующих им нижних объекта тоже эквивалентны.
6. Порядок нижнего объекта больше, чем порядок любого соответствующего ему верхнего.
Чтобы лучше понять эту концепцию, предлагаю вам на минуту отвлечься от чтения и подумать, как будут выглядеть нижние и верхние объекты, если в качестве множества X взять графы без треугольников (то есть, такие графы, в которых никакие три вершины не соединены рёбрами все одновременно).
**Ответ**Конечно, это не единственный способ, но довольно естественно в качестве нижних объектов взять графы без треугольников, в которых одна из вершин покрашена в красный цвет (это будет означать, что мы собираемся её удалять), а в качестве верхних — графы без треугольников, в которых в красный цвет покрашены несколько вершин (это будет означать, что мы собираемся добавить вершину и соединить её со всеми красными вершинами). При этом нужно потребовать, чтобы красные вершины было попарно не соединены. В этом случае после добавления новой вершины треугольники не образуются.
Продолжим. Пусть от некоторого непомеченного объекта нельзя ничего «откусить». Таким образом, нижних объектов, соответствующих ему (а точнее, соответствующих его помеченным объектам), нет. Такой объект называется *неприводимым*. В нашем случае, неприводимыми являются рассечения, состоящие из единственного многоугольника. Все остальные являются *приводимыми*.
Наш алгоритм будет генерировать все неизоморфные рассечения последовательно, начиная с неприводимых, постепенно наращивая их порядок. Для этого мы будем приклеивать к текущему рассечению все возможные многоугольники со всех возможных сторон. Проблема, однако, состоит в том, что к одному и тому же рассечению можно прийти несколькими способами. Например, к рассечению восьмиугольника, которому соответствовал нижний объект на двух предыдущих картинках, можно прийти, приклеив к треугольнику четырехугольник, а потом пятиугольник, а можно — приклеив, наоборот, к пятиугольнику треугольник и четырёхугольник. Таким образом, возникает возможность сгенерировать одно и то же рассечение несколько раз, и даже не заметить этого. Это то, чего как раз хочется избежать.
Чтобы обойти эту проблему, сгенерировав новое рассечение, мы будем проверять, правда ли, что последнее добавление многоугольника отвечает какому-то единственному каноническому способу построения этого рассечения. Для этого нам понадобится функция P, сопоставляющая каждому помеченному объекту множество нижних объектов, для которых он является «потомком». Функция P должна удовлетворять таким требованиям:
1. Если L(x) пусто, то и P(x) тоже пусто.
2. Если L(x) не пусто, то P(x) состоит из таких и только таких соответствующих объекту х нижних объектов, что любые два из них переходят друг в друга под действием какого-то элемента g, для которого g\*x=x.
3. Для любого непомеченного объекта x и элемента группы g: g\*P(x)=P(g\*x).
Стоит обратить особое внимание на второе требование: оно, фактически, означает, что множество P(x) должно состоять из нескольких объектов, являющихся эквивалентными относительно симметрий объекта x. Пусть, например, вышло так, что рассечение x симметрично относительно лишь поворотов на 0 и 180 градусов. Тогда P(x) должно состоять из ровно двух нижних объектов, получающихся друг из друга с помощью таких поворотов.
Попробуем удовлетворить общему требованию в нашем примере. Для этого возьмём какое-то рассечение x и прокрутим на нём пометки всеми n способами (n — количество вершин). Каждый раз, когда с вершин 1 и 2 будет начинаться «крайний» многоугольник (такой, что его можно отрезать), будем такую нумерацию запоминать. После этого из всего выделенного подможества нумераций вершин выберем те, которые дают лексикографически минимальную (подойдёт и любой другой разумный порядок) запись списков смежности. Эти нумерации выделяют нам некоторые многоугольники на исходном объекте х — те, которые при соответствующих нумерациях начинаются с 1 и 2. P(x) как раз и состоит из нижних объектов для x, в которых эти многоугольники покрашены в красный цвет. Без рисунка тут не обойтись:
Итак, мы выбрали рассечение x, изображённое слева, и восемью различными способами переставили пометки. Способы a, c, e и g нам сразу не подходят: на вершинах 1,2,...,i не построен многоугольник, который можно отрезать. Видно, что способы b и f, в сущности, одинаковы, равно как и способы d и h. Из этих четырёх способов выбираем те, которые в некотором смысле «минимальны». Как мы уже заметили, можно определить минимум как угодно, но однозначно. Например, подойдёт минимальная лексикографически запись списков смежности. В этом случае способы b и f выигрывают. Эти способ выделяют нам треугольники 2,3,4 и 6,7,8 на исходном помеченном объекте х. В результате мы получаем два нижних объекта, показанных на рисунке справа.
Функция P — самая важная для быстрой генерации. Удовлетворить указанным требованиям и сохранить высокую скорость работы, в действительности, весьма сложно. Как видно, функция P, в некотором смысле, позволяет указать, какой из способов «откусить» крайний многоугольник является каноническим, с точностью до изоморфизма. Если концепция ясна, предлагаю вам придумать, как должна работать функция P(x) для уже упомянутых графов без треугольников.
**Ответ**Ответ, конечно, не однозначен. Один из простых (но не очень эффективных) способов такой: для графа без треугольников x переберём все способы перенумеровать вершины, после чего оставим те, которые дают лексикографически минимальную запись списков смежности. Для каждого из таких способов выберем вершину v, имеющую номер 1, и составим нижний объект — граф x с покрашенной в красный цвет вершиной v. Все такие различные нижние объекты и образуют результат работы P(x).
Код, добавляющий к описанным выше классам методы, реализующие все перечисленные функции, лучше посмотреть в [репозитории](https://code.google.com/p/dissection-generator/): в нём слишком много технических подробностей, чтобы обсуждать его в деталях.
Теперь всё готово для того, чтобы описать непосредственно алгоритм генерации. Он будет запускаться для каждого неприводимого рассечения. Для текущего рассечения мы рассматриваем все неизоморфные способы создать верхний объект, а затем каждый полученный верхний объект наращиваем до нижнего с увеличением порядка. Далее, с помощью функции P каждый нижний объект проверяем на то, что он действительно является родителем соответствующего ему помеченного объекта. Если эта проверка проходит, то считаем, что данный помеченный объект является представителем нового класса эквивалентности; запускаем алгоритм для него рекурсивно. Можно, конечно, доказать корректность этого алгоритма, но, чувствую, я и так немного переусердствовал с формализмом, да и для того, чтобы разобраться с доказательством, проще обратиться к [исходной статье](http://cs.anu.edu.au/~bdm/papers/orderly.pdf).
Лучше давайте вначале посмотрим на код, отвечающий за генерацию:
```
public static void generateSubtreeFrom(Dissection root, int maxOrder) {
for (UpperDissection upper : root.createAllUpper()) {
LowerDissection lower = upper.createArbitraryLower();
if (lower != null) {
Dissection probableChild = lower.getUnderlyingDissection();
if (probableChild.getOrder() <= maxOrder && lower.isParentFor(probableChild)) {
root.addChild(probableChild);
generateSubtreeFrom(probableChild, maxOrder);
}
}
}
}
```
А теперь — на результат генерации всех неизоморфных рассечений на 3,4 и 5-угольники, вплоть до порядка, равного восьми. Стрелки направлены от родителей к потомкам. Видно, что все рассечения образовали деревья, корнями которых являются неприводимые объекты.
[](http://habrastorage.org/getpro/habr/post_images/09a/837/17b/09a83717b55216090b7b2609c1754969.png)
Исходный код программы, которая сгенерировала этот рисунок, доступен на [гуглокоде](https://code.google.com/p/dissection-generator/). Результатом её работы является описание в формате graphviz.
В заключение добавлю, что для рассмотренной задачи можно, в принципе, придумать более простой и при этом более быстрый алгоритм. Однако, описанная процедура применима практически ко всем типам комбинаторных объектов, которые можно построить индуктивным способом, «наращивая» структуру. Более того, для некоторых видов графов, по крайней мере, по утверждению автора алгоритма, такой подход даёт одни из лучших, если не лучшие на сегодняшний день скорости генерации. | https://habr.com/ru/post/225255/ | null | ru | null |
# Новости из мира OpenStreetMap № 489 (26.11.2019-02.12.2019)
Babykarte — проект Sören Reinecke aka ValorNaram [1](#wn489_21428) | Map data OpenStreetMap contributors
Работа над ошибками
-------------------
* Пытаетесь понять, кто такой пользователь [@anonymaps](https://twitter.com/Anonymaps)? Можете исключить из списка подозреваемых редакторов проекта WeeklyOSM. Как верно [отметил](https://twitter.com/Anonymaps/status/1201484324320808960) этот загадочный пользователь, разработка сервиса OpenRailWayMap не обсуждается в списке рассылки rails\_dev. Rails — это веб-фреймворк, который находится в основе, между прочим, сайта OpenStreetMap.org. Если вы хотите помочь создать всемирную, открытую, актуальную и подробную карту железнодорожной сети, основанную на OpenStreetMap, то обсуждение этого проекта вы можете найди в списке рассылки [OpenRailWayMap](https://lists.openrailwaymap.org/mailman/listinfo/openrailwaymap).
Картографирование
-----------------
* Грэм Фитцпатрик в списке рассылки «Тегирование» [сообщил](https://lists.openstreetmap.org/pipermail/tagging/2019-November/049404.html), что он создал
[вики-страницу](https://wiki.openstreetmap.org/wiki/Tag:barrier%3Dberm) для обсуждения необходимости принятия еще одного уточняющего значения для тега barrier — `berm` (песчаная насыпь).
* Началось голосование за тег [`mimics=*`](https://wiki.openstreetmap.org/wiki/Proposed_features/Mimics), которым предлагается отмечать телекоммуникационные мачты и башни, замаскированные под что-то другое.
* Южноафриканская некоммерческая организация "[Code for Africa](https://www.businesslive.co.za/bd/world/africa/2019-11-29-drones-to-put-lagos-waterway-on-the-map/)" начала проект по картированию плавучих трущоб в Макато — столице Нигерии, в ходе которого данные будут собираться с помощью беспилотников. Вся полученная информация будет загружена в OpenStreetMap.
* Ник Джонс [опубликовал](https://towardsdatascience.com/identifying-gaps-in-openstreetmap-coverage-through-machine-learning-257545c04330) статью, в которой объясняется методология выявления «белых пятен» в OpenStreetMap при помощи машинного обучения.
* Третий год подряд в декабре итальянская добровольческая студенческая ассоциация PoliMappers проводит месячную карто-акцию. Узнать больше об этой инициативе можно в Facebook, Twitter, [WikiOSM](https://wiki.openstreetmap.org/wiki/PoliMappers/Adventures2019), а также в [Telegram-канале](https://t.me/PoliMappersAdventures).
* В онлайн-редакторе [RapiD](https://mapwith.ai/rapid) появились новые данные — распознанные по спутниковым снимкам дороги [всех стран](https://github.com/facebookmicrosites/Open-Mapping-At-Facebook/wiki/Available-Countries) Южной Америки и Африки, которые отсутствуют в OSM. Также в новую версию в полном объеме импортированы распознанные Microsoft периметры зданий (>150 млн объектов в США, Танзании и Уганде).
* Активные действия одного пользователя, который хочет, чтобы весь мир научился говорить на эсперанто, [вызвали](https://forum.openstreetmap.org/viewtopic.php?id=68105) дискуссию на форуме. Обсуждение того, какой стоит использовать язык для указания имени у международных объектов, продолжился в списке рассылки [OSM-talk](https://lists.openstreetmap.org/pipermail/talk/2019-December/083609.html).
* Российское сообщество OSM [решило](https://forum.openstreetmap.org/viewtopic.php?id=68084) завершить [импорт](http://audit.osmz.ru/project/mrkf_theaters/) театров, который был начат еще в 2017 году. Кстати, 2019 год в России объявлен «Годом театров».
* В своем Твиттере Дабо Хамда [сообщил](https://twitter.com/i/moments/1200397226239037440), что Гвинейское сообщество провело двухдневные курсы по картографированию и ГИС в «Цифровом кампусе Франкофонии» в Конакри для студентов-геоматиков и всех желающих. Слушатели узнали о том, что такое OSM и какие есть инструменты для работы с ним, как создать и работать с местным сообществом, а также как собирать данные с помощью приложений Kobo и OSMTracker. Помимо этого, было уделено внимание использованию данных из OSM в QGIS и OSMAnd.
Сообщество
----------
* На [четыре](https://wiki.openstreetmap.org/wiki/Foundation/AGM19/Election_to_Board/Answers_and_manifestos) вакантные должности в Совете директоров ФОО баллотируются 12 кандидатов: Нуно Кальдейра, Стив Кост, Джинал Фофлия, Грегори Марлер, Микель Марон, Рори МакКэнн, Михаил Мигурский, Аллан Мастард, Гийом Ришар, Дитмар Сейфер, Клиффорд Сноу, Юджин Альвин Виллар. Прочитайте их [ответы](https://wiki.openstreetmap.org/wiki/Foundation/AGM19/Election_to_Board/Answers_and_manifestos#Answers_to_the_official_questions) на следующие вопросы: деятельность в OSM, зачем вступаете в Совет и хотите быть его членом, разносторонний Совет, ваше время, конфликт интересов, казначей, очная встреча, заседания Совета и рабочих группа, коммуникации, чтобы вы сделали и каким видите OSM в 2020 году. [Манифесты](https://wiki.openstreetmap.org/wiki/Foundation/AGM19/Election_to_Board/Answers_and_manifestos#Manifestos) кандидатов можно прочитать в WikiOSM.
* Мартин Борсье [высказал](https://forum.openstreetmap.org/viewtopic.php?pid=770399#p770399) несколько интересных мыслей относительно массовых импортов в OSM: «OSM никогда не состоял и не будет в дальнейшем на 100% только из данных, предоставленных государством; OSM не является резервной базой данных для органов власти. Если они используют OSM, то только на свой страх и риск, а потому не должны забывать об этом и о том, что в любой момент какие-либо данные в OSM обновятся». Именно поэтому он и говорит: «Выйди на улицу, сядь на велосипед, смотри по сторонам и картографирую!» Его высказывания пришлись по душе многим на форуме.
* Джессика Сена [написала](https://medium.com/geochicas/state-of-the-map-latam-2019-37d14ee6b7be) отчет о международной конференции «State of the Map Latam», которая проходила с 14 по 16 ноября в городе Энкарнасьон (Парагвай). Главной темой мероприятия был вопрос — «Какой мир показывают ваши карты?»
* The Survey of India — государственное агентство Индии, отвечающее за картографирование и топографическую съемку — в настоящее время обновляет карту Индии в масштабе 1:500. В [статье](https://www.livemint.com/news/india/the-21st-century-race-to-map-india-11574789386680.html) Шришти Чоудхари дается не только описание нынешнего состояния картографии в Индии, а также приводится печальный рассказ Навина П. Френсиса о трудностях, с которыми сталкиваются картографы OSM в Индии из-за отсутствия открытых ГИС-данных.
Импорты
-------
* Генри Буш [интересуется](https://lists.openstreetmap.org/pipermail/talk-gb/2019-November/023817.html), можно ли выполнить импорт [участков](https://en.wikipedia.org/wiki/Site_of_Special_Scientific_Interest) особого научного значения (охраняемый законом памятник природы в Великобритании) с помощью инструмента похожего на API Natural Englans. Он стал постепенно собирать данные об импорте на странице [SSSIBot](https://wiki.openstreetmap.org/wiki/User:Spookypeanut/SSSIBot).
Фонд OpenStreetMap
------------------
* Доротея Казаци [в деталях](https://lists.openstreetmap.org/pipermail/osmf-talk/2019-December/006445.html) описала процесс голосования на предстоящих выборах в Совет Фонда OSM (например, в том числе убедиться, что у вас работает Javascript).
* Стив Фридл [дал](https://www.openstreetmap.org/user/SJFriedl/diary/391453) свои рекомендации по предстоящим выборам в Совет Фонда OSM. Помимо него также были комментарии и от других людей, включая Микеля Марона, являющегося одним из кандидатов.
* Кристоф Хорманн [подробно](http://blog.imagico.de/2019-osmf-board-candidates-analysis-and-recommendations/) проанализировал кандидатов и представил свои рекомендации по выборам.
* Разбор кандидатов также выполнил пользователь wastnordost, который свел всю информацию о них в одной [таблице](https://wiki.openstreetmap.org/wiki/User:Westnordost/AGM19_Cheatsheet), что позволяет наглядно их сравнить между собой.
События
-------
* 6 марта 2020 года в в Риге (Латвия) пройдет [Балтийская ГИС-конференция](https://www.balticgitconf.eu/). Одна из секций конференции будет посвящена OSM. Организаторы ждут наших с вами докладов, а также ищут партнеров.
* Организаторы мини-конференции «15 лет OSM», которая состоялась 16 ноября 2019 года в Санкт-Петербурге, выложили в сеть [презентации](https://drive.google.com/drive/folders/1AByhamae1kv2WcNiN9hcFwvXjA8p2M6J) и [видеозаписи](https://www.youtube.com/playlist?list=PLbVYnlbAqwxKY148Yfxs3SjaN19ObOmj8) докладов.
Гуманитарный OSM
----------------
* Некоммерческой организации «Missing Maps» исполнилось пять лет. Во многих блогах упоминается это событие. «Missing Maps» [подвели](https://www.missingmaps.org/blog/2019/11/27/happy-birthday/) итоги своей работы за это время и пообещали в будущем году делать публикации в своем блоге каждый месяц. Их также [поздравил](http://k1z.blog.uni-heidelberg.de/2019/12/02/5-years-missing-maps-achievements-and-furture-work-and-how-to-vizualize-the-missing-maps-impact-using-ohsome/) Мелани Экл.
* Рейчал ВанНайс в списке рассылки HOT [сообщила](https://lists.openstreetmap.org/pipermail/hot/2019-November/015054.html), что уже началась подготовка к ежегодной конференции HOT Summit 2020.
* Томми Чарльз, координатор OSM в [Сьерра-Леоне](https://ru.wikipedia.org/wiki/%D0%A1%D1%8C%D0%B5%D1%80%D1%80%D0%B0-%D0%9B%D0%B5%D0%BE%D0%BD%D0%B5), начал [сбор](https://lists.openstreetmap.org/pipermail/hot/2019-November/015059.html) пожертвований для возрождения картографического сообщества в этой западноафриканской стране.
* 15 ноября общество Красного Креста в Уганде, которая пострадала от сильного наводнения, [провело](https://www.redcrossug.org/publications/478-mapping-plays-a-vital-role-in-disaster-response-and-preparedness) обучающий семинар по картографированию. В нем приняло участие порядка 60 волонтеров.
Переходим на OSM
----------------
* Сайт [switch2osm.org](https://switch2osm.org) существенно обновил свой дизайн. Теперь он стал намного [красивее](https://github.com/switch2osm/switch2osm.github.io/pull/60), чем был до этого, а также перешел с WordPress на Github, что значительно [упростило](https://github.com/switch2osm/switch2osm.github.io/issues) его разработку.
Лицензии
--------
* Не так [давно](http://weeklyosm.eu/archives/12554) мы сообщали, что Strava снова дала согласие на использование своих данных в OSM. Однако Илья Зверев [считает](http://shtosm.ru/all/strava-is-back/), что сообщество не верно поняло ответ разработчиков Strava и по факту данные все также «закрыты» лицензией.
Программное обеспечение
-----------------------
* Леонардо Гутьеррес разработал мобильное приложение [“BusBoy”](https://play.google.com/store/apps/details?id=app.busboy.navigator), которое показывает маршруты общественного транспорта в городе Бояка (Колумбия). В основе приложения — данные из OSM, которые до этого были [собраны](https://boyaca7dias.com.co/2019/12/03/busboy-app/) членами местного OSM-сообщества.
* Тиани Рен и Моника Брандейс [рассказали](https://medium.com/critigenopensource/openstreetmap-quality-measurement-7b208ed868b8) о разработанном ими валидаторе — [Map Quality Measurement (MQM)](https://github.com/spatialdev/osmquality), который позволяет анализировать данные OSM на предмет наличия ошибок. Они подробно описали, как с помощью этого инструмента изучали качество данных в OSM 51 города в США и составляли соответствующий [рейтинг](https://osmquality.io/).
* На сайте Linuxinsider [сообщается](https://www.linuxinsider.com/story/86387.html), что вышла новая версия (13.0) OSGeoLive GIS — дистрибутива Linux на базе Lubuntu, в котором собраны различные ГИС-программы с открытым исходным кодом.
Программирование
----------------
* Фабиан Ковач [рассказал](http://k1z.blog.uni-heidelberg.de/2019/11/28/becoming-ohsome-is-simple-adding-support-of-simple-feature-types-to-the-ohsome-api) о ряде новых возможностях платформы "[ohsome](https://heigit.org/big-spatial-data-analytics-en/ohsome/)".
* Свен Геггус [ищет](https://github.com/giggls/mapnik-german-l10n/issues/35) библиотеку транскрипций для кантонского диалекта (желательно на C++ или python) для использования ее в Гонконге и Макао.
* Портал mappinggis.com [опубликовал](https://mappinggis.com/2019/11/como-crear-un-geopdf-con-qgis/) учебное пособие о том, как с помощью QGIS создать GeoPDF. Эта новая функция QGIS, которая появилась в версии 3.10.
* Российский программист Кирилл Рубинштейн [написал](https://habr.com/ru/company/okdesk/blog/473568/) статью о том, как выбирал картографический сервис для своего программного продукта. Он детально сравнил разные картографические сервисы и в итоге стал работать с OSM.
Релизы
------
* Интересно, что обновилось в новой версии JOSM? Список изменений [здесь](https://josm.openstreetmap.de/wiki/Changelog#stable-release-19.11).
Знаете ли вы …
--------------
* … о сервисе [Babykarte](https://babykarte.openstreetmap.de/)? Не так давно вышла новая версия (3.0), в которой изменился дизайн, повышена производительность, а также благодаря FOSSGIS сайт переехал на сервер немецкого сообщества OSM.
* … о проекте [FactsMap](http://factsmaps.com/)? Это обширная коллекция аналитических карт, диаграмм, фактов, статистики и графиков, которые заставляют задуматься о многом.
* … о сервисе [OpenTripMap](https://opentripmap.com/), который показывает достопримечательности и туристические объекты?
Другие «гео» события
--------------------
* BBC сообщает, что Apple [выполнила](https://www.bbc.com/news/technology-50573069) требования России — отображать Крым как часть России, если заходить на сервис из России. В [интервью](https://news.ycombinator.com/item?id=21648633) Hacker News Ричард Фэйрхерст отметил, что подобные локальные изменения широко распространены во всем мире на любой крупной карте, кроме OpenStreetMap.В 2018 г. Рабочая группа по данным Фонда OSM отвечая картографам на этот вопрос сообщила, что в OSM есть правило — как на земле — а потому [Крым](https://wiki.osmfoundation.org/wiki/Working_Group_Minutes/DWG_2018-11-14_Crimea) — это часть России. Но уже после, за несколько дней до выборов в Совет Фонда ОСМ, это решение было отклонено Советом Фонда ОСМ. Более того, многие кандидаты на выборах в Совет Фонда OSM в 2019 году используют тему [Крыма](https://wiki.openstreetmap.org/wiki/Foundation/AGM19/Election_to_Board/Answers_and_manifestos) в своих предвыборных обещаниях. С одной стороны, Аллан, Юджин, Гийом и Рори выступают за четкие правила и соблюдение принципа «на местах». С другой стороны, Микель, который «участвовал в принятии решения об отмене решения Рабочей группу по данным по Крыму», обосновывает свое решение сделать исключение в целях достижения «общественной гармонии».
* В Великобритании приближаются национальные выборы, и британское общество по проведению избирательной реформы (которое выступает за то, чтобы люди в парламенте справедливо представляли отданные голоса) подготовило [анимацию](https://twitter.com/electoralreform/status/1025290216473616385), которая показывает, как “размывание” политических границ (изменение их в пользу одной партии) может резко повлиять на результаты выборов. Доктор Боб Барр [объясняет](https://twitter.com/DrBobBarr/status/1196358815748370432), как именно это работает.
* Командой, состоящей из представителей Германского аэрокосмического центра, Google и MindEarth, была [создана](https://www.esa.int/Applications/Observing_the_Earth/Mapping_our_global_human_footprint) карта населенных пунктов планеты World Settlement Footprint 2015 с разрешением в 10 м. Для разработки карты использовались радиолокационные данные спутников Sentinel-1 и оптических данных Landsat-8. Перед публикацией карта была проверена с помощью снимков большого разрешения Google Earth (более 900 тыс объектов) путем краундсорсинга. Детали проекта можно узнать в [статье](https://arxiv.org/pdf/1910.12707.pdf). (pdf) на сайте arXiv.
* Mapillary [представил](https://gisuser.com/2019/10/mapillary-launches-a-mapping-dashcam-solution-to-help-logistics-companies-cut-delivery-delays-by-improving-maps-en-route/) видеорегистратор, который был специально разработан для картографических целей. Он автоматически снимает и загружает снимки на сервер. Планируется, что регистратор будет устанавливаться на транспортные средства, занимающиеся доставкой товаров, что позволит генерировать картографические данные в режиме реального времени.
* Студентка-медик из Стэнфорда Ханна Уайлд совершила поездку в долину реки Омо в Эфиопии для изучения состояния здоровья проживающего там кочевого народа ньянгатомов. Джоди Бергер [рассказал](https://news.stanford.edu/2019/11/27/hard-to-count-matter/), как Ханне помогали в составлении карт Стейси Мейплс, гуманитарная команда OpenStreetMap (HOT), DigitalGlobe и прожорливые козы.
* The New York Times [подготовила](https://www.nytimes.com/interactive/2019/12/02/nyregion/nyc-subway-map.html) замечательную интерактивную статью о карте метрополитена Нью-Йорка. В ней рассказывается об истории создания карты, а также раскрываются некоторые детали и особенности, которые, возможно, люди не заметили.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [488](https://habr.com/ru/post/479234/) [487](https://habr.com/ru/post/478196/), [486](https://habr.com/ru/post/477166/), [485](https://habr.com/ru/post/476060/), [484](https://habr.com/ru/post/475200/) | https://habr.com/ru/post/480206/ | null | ru | null |
# godebug — кроссплатформенный дебаггер для Go
Ребята из компании Mailgun презентовали новый [кроссплатформенный дебаггер для Go](https://github.com/mailgun/godebug), который использует оригинальную технологию, в корне отличающуюся от стандартных подходов. Забегая наперед — с помощью Gopherjs этот дебаггер работает даже в браузере.
#### Интро
> All that stands in the way [of a good Go debugger] is the writing of a lot of non-portable low-level code talking to buggy undocumented interfaces.
>
>
>
> — Rob Pike
Поддержка Go была в дебаггере gdb давно, но оставалось много [мелких, но неприятных проблем](https://golang.org/doc/gdb#Known_Issues), которые не давали возможности полноценно им пользоваться. Также есть проект [delve](https://github.com/derekparker/delve), но о его популярности пока сложно сделать выводы. В любом случае, «классические» подходы к написанию дебаггера для Go неизменно сталкивались со сложностью реализации, особенно когда речь заходит о спецефичных для Go вещах вроде дебага горутин.
Абсолютно другой подход выбрал Jeremy Schlatter из компании Mailgun, которая использует Go достаточно активно — он взял за основу ту же идею, которая лежит в основе go coverage tool, встроенной системы тестов и некоторых других: изменение кода на лету перед компиляцией. Такой подход вообще стал возможен благодаря двум основным моментам — огромной скорости компиляции и простой грамматике языка. Встроенные в stdlib инструменты для разбора Go-грамматики (go/ast и go/parser) позволяют достаточно просто на лету модифицировать код компилируемой программы, а это открывает целый новый пласт возможностей.
#### Пример
К примеру, возьмем простую программу на Go:
```
package main
import "fmt"
func hello(text string) {
fmt.Println(text)
}
func main() {
fmt.Printf("Hello,")
hello("world")
}
```
И запустим godebug с командой output, чтобы посмотреть сгенерированный код:
```
package main
import (
"fmt"
"github.com/mailgun/godebug/lib"
)
var main_go_scope = godebug.EnteringNewScope(main_go_contents)
func hello(text string) {
ctx, ok := godebug.EnterFunc(func() {
hello(text)
})
if !ok {
return
}
defer godebug.ExitFunc(ctx)
scope := main_go_scope.EnteringNewChildScope()
scope.Declare("text", &text)
godebug.Line(ctx, scope, 6)
fmt.Println(text)
}
func main() {
ctx, ok := godebug.EnterFunc(main)
if !ok {
return
}
godebug.Line(ctx, main_go_scope, 10)
fmt.Printf("Hello,")
godebug.Line(ctx, main_go_scope, 11)
hello("world")
}
var main_go_contents = `package main
import "fmt"
func hello(text string) {
fmt.Println(text)
}
func main() {
fmt.Printf("Hello,")
hello("world")
}
`
```
Не вдаваясь пока в подробности каждой функции, видно, что на каждой строчке расставлены функции-идентификаторы строк, входа и выхода из функций, декларации переменных и так далее. Рантайм дебаггера уже работает с этими, добавленными функциями, имея полную информацию о программе.
#### Демо
Этот подход, конечно же, не универсален и имеет свои ограничения и недостатки, но его относительная простота и преимущества очевидны. Одной из демонстраций сильных сторон такого подхода является возможность делать отладку прямо в браузере, с помощью gopherjs: [focused-sprite-91100.appspot.com/playground/blog-post](https://focused-sprite-91100.appspot.com/playground/blog-post) — попробуйте сами.
[](https://focused-sprite-91100.appspot.com/playground/blog-post)
Есть некоторые нюансы с тем, что нарушается нативная нумерация строк — это может повлиять на, скажем, логгеры/трейсеры, которые репортят номер строки. Но в целом для большинства случаев этот подход работает на ура.
#### Установка
Установка дебаггера не отличается от установки любой другой Go-программы:
```
go install github.com/mailgun/godebug
```
#### Использование
Пользоваться дебаггером очень просто:
```
$ godebug
godebug is a tool for debugging Go programs.
Usage:
godebug command [arguments]
The commands are:
run compile, run, and debug a Go program
test compile, run, and debug Go package tests
output generate debug source code, but do not build or run it
Use "godebug help [command]" for more information about a command.
```
godebug run \*.go — компилирует с поддержкой дебага все исходники в текущей директории. Все дополнительные пакеты, используемые в коде, как свои, так и внешние — компилируются нативно, без дебага — это сделано специально, чтобы не замедлять код там, где это не нужно. Если нужно отлаживать и код в каких-то включенных пакетах, то они должны быть указаны с помощью флага -instrument:
```
godebug run -instrument github.com/go-sql-driver/mysql main.go
```
Брекпоинты в программе ставятся следующей конструкцией:
```
_ = "breakpoint"
```
При обычной сборке этот код ничего не делает, а godebug его распознает перед компиляцией и вставит инструкцию для остановки.
#### Статус
Проект уже готов для практического использования, хотя поддерживаются пока только самые базовые функции:
* list
* step
* next
* continue
* print
В планах поддержка остановки/инспекции горутин и другие вещи, которые коммьюнити сочтет нужными/полезными.
#### Ссылки:
* Подробная статья — анонс дебаггера: [blog.mailgun.com/introducing-a-new-cross-platform-debugger-for-go](http://blog.mailgun.com/introducing-a-new-cross-platform-debugger-for-go/)
* Слайды с доклада Jeremy на GoSF'15: [go-talks.appspot.com/github.com/jeremyschlatter/godebug-talk/godebug.slide](https://go-talks.appspot.com/github.com/jeremyschlatter/godebug-talk/godebug.slide)
* Видео доклада: [www.youtube.com/watch?v=qo4RAPxCTa0](https://www.youtube.com/watch?v=qo4RAPxCTa0)
* Github: [github.com/mailgun/godebug](https://github.com/mailgun/godebug) | https://habr.com/ru/post/256355/ | null | ru | null |
# Елочка, зажгись! Часть 3: веб-интерфейс и приложение для Android
*Этим текстом мастер Гамбс завершает описание своей новой ёлочной гирлянды. 2015 г. Москва*
Привет, Хабр!
Итак, мы добрались до финального этапа: раз у нас есть гирлянда, которой управляет нанокомпьютер Black Swift со встроенным Wi-Fi, то логично сделать для неё веб-интерфейс и смартфонное приложение, чтобы *помигать светодиодом*, если вы понимаете, о чём я.
1. [Гирлянда, подключение Black Swift и среда сборки под OpenWRT на C/C++](http://habrahabr.ru/company/blackswift/blog/247817/)
2. [Софт на C, работа с GPIO и программная ШИМ](http://habrahabr.ru/company/blackswift/blog/247925/)
3. Веб-интерфейс и приложение для Android
Но сначала — по просьбам читателей публикуем видео работающей ёлочной гирлянды. Не думаю, что кто-то не видел ёлочных гирлянд, думаю, что просто не все верят, что я правда 28-29 декабря пошёл за светодиодами, чтобы украсить ёлку…
За кадром сижу я и одной рукой держу фотоаппарат, а другой переключаю режимы её работы, тыкая мышкой в браузер.
Теперь же, когда последние следы недоверия испарились, продолжим. В предыдущих сериях мы получили работающий контроллер гирлянды, умеющий принимать команды через UNIX-сокет — в них задаётся режим работы, а также скорость и яркость гирлянды. Проще всего прослойку между вебом и сокетом сделать на банальном PHP — это буквально несколько строчек.
Веб-сервер и PHP5 на нанокомпьютере
-----------------------------------
У нас в Black Swift уже стоит стандартный веб-сервер uhttpd, обслуживающий штатный веб-интерфейс LuCI. Чтобы работать с PHP, мы поставим второй веб-сервер — lighttpd (я вот думаю, в финальную прошивку его и php5 надо просто по умолчанию включить), а также удобный текстовый редактор nano:
```
opkg update
opkg install nano
opkg install lighttpd lighttpd-mod-cgi
opkg install php5 php5-cgi
/etc/init.d/lighttpd enable
```
Веб-сервер и PHP подтянут с собой свои зависимости сами. Средние три команды, я думаю, очевидны, первая же подтянет из репозитория обновлённый список пакетов, а последняя включит для lighttpd автозапуск при старте системы.
Теперь чуть-чуть подправим конфиги:
```
nano /etc/config/uhttpd
```
В первых строчках ищем директивы «list listen\_http», которых там две штуки, и меняем в них порт :80 на :8080 (или ещё какой-нибудь). Потом перезапускаем uhttpd командой /etc/init.d/uhttpd restart.
Аналогичным образом правим /etc/lighttpd/lighttpd.conf (он длинный, для поиска нужного текста в nano используется комбинация Ctrl-W):
```
server.modules = (
"mod_cgi"
)
```
В конфиге есть длинный закомментированный список подключаемых модулей, нам нужен только mod\_cgi, который будет работать с php\_cgi.
```
server.document-root = "/www/tree"
index-file.names = ( "index.html", "default.html", "index.htm", "default.htm", "index.php" )
cgi.assign = ( ".php" => "/usr/bin/php-cgi" )
```
Здесь всё достаточно очевидно для всех, кто хоть раз видел веб-сервер на линуксе: корневая папка, корневые файлы (добавляем в список index.php) и привязка к файлам \*.php конкретного обработчика.
Теперь открываем /etc/php.ini и правим одну строчку:
```
doc_root = "/www/tree"
```
И финальный штрих — /etc/init.d/lighttpd start
Теперь мы имеем на порту 80 веб-сервер с работающим PHP, так что остаётся только создать каталог /www/tree и положить в него файл index.php. Который, конечно, сначала надо написать.
index.php
---------
Задача также предельно банальная, скажем прямо.
Писать в файловый сокет из PHP не просто, а очень просто:
```
$sockf = fsockopen("unix:///tmp/treelights.sock", 0, $errno, $errstr);
if ($sockf)
{
$command = $cmd . " " . $val;
fwrite($sockf, $command);
fclose($sockf);
}
```
Где $cmd — команда, которую мы хотим передать, например, brightness, а $val — соответствующее значение, например, 2.
Далее всё очевидно: пользователь двигает ползунок (в HTML5 появились ползунки, ура-ура), javascript выдёргивает его положение и передаёт в PHP-файл:
```
Brightness
php echo (11 - $values[1]); ?
```
и
```
function displayBrightness(brightness) {
document.querySelector('#bLevel').value = brightness;
}
function setBrightness(brightness) {
url = 'index.php?cmd=brightness&val=';
location.href = url.concat(brightness);
}
```
Первая функция при перемещении ползунка сразу же меняет численное значение рядом с ним, вторая передаёт команду и это значение в PHP-файл сразу, как только пользователь ползунок отпустит. NB: первые реализации HTML5 страдали тем, что onchange и oninput в range работали одинаково, выскакивая при каждом сдвиге ползунка, но сейчас нам это уже не очень важно.
Вы уже наверняка обратили внимание на два момента: JS вызывает тот же index.php, в котором он написан, только с параметрами, а в HTML есть вставки на PHP, подставляющие при генерации кода некое определённое ранее положение ползунка.
Первое сделано потому, что для простоты демонстрации я не использовал AJAX, а второе — чтобы при открытии странички она показала текущее состояние гирлянды, если таковое ранее устанавливалось.
Обработка переданных с файлом параметров проста:
```
$cmd=($_GET['cmd']);
$val=($_GET['val']);
if (!empty($cmd))
{
$sockf = fsockopen("unix:///tmp/treelights.sock", 0, $errno, $errstr);
/* дальше вы уже знаете */
}
```
Здесь всё столь же банально: если параметры передали, то мы сначала запихнём их в сокет, а потом покажем веб-интерфейс, если не передали — просто покажем веб-интерфейс.
Настроек гирлянды у нас негусто, поэтому хранить их логично в обычном файле. Однако тут стоит вспомнить, что программу на C мы писали без учёта сохранения параметров, поэтому и PHP после перезапуска системы должен показывать параметры по умолчанию, а не сохранённые ранее. Сделать это в OpenWRT очень просто — сохраняйте всё ненужное в /tmp, он живёт в ОЗУ и при перезагрузке исчезает навсегда.
```
if (file_exists("/tmp/tree.set"))
{
$settings = file_get_contents("/tmp/tree.set");
// Mode, Brightness, Speed
$values = explode(",", $settings);
}
else
{
$values[0] = "0";
$values[1] = "1";
$values[2] = "1";
}
```
Ну и после установки новых параметров гирлянды, конечно, их надо записать:
```
$settings = $values[0] . "," . $values[1] . "," . $values[2];
file_put_contents("/tmp/tree.set", $settings);
```
В общем, на этом со строительством веб-интерфейса фактически всё — добавляем аналогичным образом прочие кнопки и полузнки и получаем результат: <https://github.com/olegart/treelights/blob/master/php/index.php>
Теперь на нашу ёлочку можно зайти из браузера.
Приложение для Android и Network Service Discovery
--------------------------------------------------
Disclaimer: вообще я сам под Android умею писать примерно никак, так что не судите строго. С другой стороны, тот факт, что у меня получилось и оно работает, многое говорит о простоте реализации подобных применений Black Swift, когда прототипы всех основных частей системы можно сделать в прямом смысле слова на коленке.
Итак, у нас есть веб-интерфейс по некоему IP-адресу. Банальным способом было бы показать на смартфоне его содержимое в компоненте WebView, но мы пойдём чуть дальше и сделаем автоопределение этого адреса (ну право слово, не будете же вы жене диктовать «Дорогая, выключи гирлянду, она на 192.168.1.158, если DHCP ей что-то новое не дал») с помощью сервиса Network Service Discovery. NSD нормально работает в Android начиная с чего-то типа 4.1 или 4.2, но вряд ли нас это сейчас остановит.
В свете дисклеймера не буду рассказывать, как писать под Android, а сразу дам ссылку: [приложение, которое я делал для своего интерфейса «умного дома»](https://github.com/olegart/hmlight-android). Его надо скачать, положить куда-нибудь аккуратно, потом поставить [Android Studio](http://developer.android.com/sdk/index.html), открыть в нём проект и немного поправить.
Открываем Gradle Scripts → build.gradle (Module: app) и меняем в applicationId «lightcontrol» на что-нибудь более адекватное новогодней ёлке. Хотя вообще можете и «lightcontrol» оставить, у вас-то наверняка путаницы с софтом «умного дома» с таким же названием не будет.
Такая же косметика: в Manifests → AndroidManifest.xml меняем android:label на что-нибудь про ёлку (NB: com.example.lightcontrol.app здесь и во всех остальных местах, кроме build.gradle, мы не трогаем!). Аналогично идём в res → values → strings.xml и меняем значение app\_name на что-нибудь про Рождество.
Наконец, открываем основной код приложения и в его начале меняем значение переменной TAG на что-нибудь своё. Это слово надо запомнить, оно нам пригодится на следующем шагу — дело в том, что по этому имени приложение будет искать нужный сервис в локальной сети. Пусть будет «Treelights», например.
Всё поменяли? Можно ещё пройтись по выводимым приложением сообщениям (я не заморачивался с локализацией, всё забито прямо в код) и поменять для красоты фразы в духе «управление светом в доме» на «управление гирляндой на ёлке».
Теперь финал: Build → Generate signed APK, создаём свой ключ для подписи приложения и собственно компилируем всё. С точки зрения отзывчивости пользовательского интерфейса Android Studio абсолютно кошмарен, но сборка проекта занимает секунд десять, не больше, после чего вам либо вываливается ошибка в логе, либо предложение открыть в explorer.exe папку с готовым APK. Открываем, копируем app-release.apk на смартфон и устанавливаем (в настройках Android надо включить установку из всех подряд источников).
Теперь возвращаемся к ёлочке и настраиваем там сервис avahi, который и будет рассылать уведомления, получаемые компонентом NSD:
```
opkg update
opkg install avahi-daemon
nano /etc/avahi/services/http.service
```
Меняем ровно один пункт: в теге name проставляем имя, содержащее слово, ранее вписанное нами в переменную TAG в мобильном приложении (это было слово «Treelights»):
Сохраняем, открываем /etc/avahi/avahi-daemon.conf и вписываем в первую секцию строку enable-dbus=no (у нас нет DBUS, поэтому без неё avahi при старте будет ругаться матом).
Финальный шаг:
```
/etc/init.d/avahi-daemon enable
/etc/init.d/avahi-daemon start
```
Снова берём в руки смартфон, запускаем наше приложение и радуемся, видя, как через долю секунды поисков оно открывает веб-интерфейс ёлочной гирлянды.
Оставшееся до Нового года время можно потратить на рисование красивого веб-интерфейса с крупными кнопочками.
Вместо заключения
-----------------
Я сразу предвижу два вопроса из серии «зачем ты это сделал»: 1) зачем вообще нужна гирлянда с Wi-Fi и 2) зачем её делать на Black Swift, а не на том же Raspberry, так как габариты тут роли не играют.
На самом деле, конечно, гирлянде не очень нужен Wi-Fi, а замена BSB на RPi ничего в данном не изменит. Но знаете такую работу Акерлофа «Market for Lemons», он в ней показывал, как рынок при свободной конкуренции может самостоятельно скатиться в продажу дешёвой дряни, вот прямо как те новогодние гирлянды, лежащие в магазинах? Акерлоф получил за неё Нобелевку по экономике, а сама работа стала наиболее известна по иллюстрации процесса на примере автомобильного рынка — хотя в предисловии и сказано, что пример не является ни важным, ни реалистичным, а выбран просто из-за простоты и наглядности объяснения.
Так вот, в моём случае ситуация ровно такая же, разве что из Нобелевского комитета мне пока не звонили (Акерлоф, впрочем, тоже 31 год звонка ждал). Я хотел показать, насколько просто использовать Black Swift и с точки зрения подключения, и с точки зрения программирования в довольно-таки комплексном проекте, имеющем и специализированную аппаратную часть, и веб-интерфейс, и мобильное приложение. Фактически, это — нормальный, годный пример автоматизации устройства в рамках популярнейшей ныне концепции «Интернета вещей».
При этом, хотя я написал три статьи и много букв в них, если посмотреть на объём итоговой работы — фактически это «проект выходного дня», один вечер в котором уйдёт на пайку гирлянды, а второй — на написание всего ПО.
В следующий же раз я покажу пример разработки, в которой Black Swift критичен и труднозаменим — потому что габариты того же Raspberry Pi будут сравнимы с внешними размерами корпуса всего финального устройства. | https://habr.com/ru/post/248037/ | null | ru | null |
# Основы работы с Neo4j в браузере
В статье рассматривается как начать работать с графовой СУБД [Neo4j](https://neo4j.com/), используя *Neo4j Browser*. Это руководство может быть полезным как дополнение к книге Редмонда и Уилсона "Семь баз данных за семь недель", так как рассматриваемый веб-интерфейс был полностью переработан, а также к книге "Графовые базы данных" (Робинсон, Вебер, Эифрем), так как в ней этот вопрос вообще не рассматривается. Статья рассчитана на приступающих к изучению Neo4j. Те, кто уже знаком с этой СУБД, могут смело её пропустить.
*Примечание*. В статье не рассматривается как установить и настроить Neo4j. Рассматриваемые версии Neo4j 3.3.2 и 3.4.0, Neo4j Browser 3.1.4 и 3.1.12, соответственно.
Начало работы
-------------
Для начала убедимся, что Neo4j запущена (пример для Linux):
```
service --status-all | grep neo4j
```
```
[ + ] neo4j
```
Знак "плюс" означает, что СУБД уже запущена, "минус" — ещё нет. Для запуска Neo4j выполните команду:
```
sudo service neo4j start
```
После запуска перейдите по ссылке <http://localhost:7474/browser/>. Вы должны увидеть интерфейс Neo4j Browser представленный на изображении выше.
Сейчас нас будут интересовать два элементы интерфейса, изображённые ниже: редактор и учебник.
Учебник
-------
Neo4j предоставляет великолепный интерактивный учебник для начинающих. Очень рекомендую его пройти. Для этого просто щёлкните на **Start Learning** и сначала ознакомьтесь с основными понятиями Neo4j:
По достижению последнего шага щёлкните на **Intro** и ознакомьтесь с возможностями Neo4j Browser:
Редактор
--------
В верхней части окна Neo4j Browser располагается строка так называемого редактора:
Начиная набор команд с двоеточия, увидим список всех доступных команд с кратким описанием:
Вызовем команду `:help`:
Чтобы ознакомиться с примерами работы с графами можно выбрать `:play movie graph` или `:play northwind graph`.
Мы не будем здесь рассматривать эти примеры, а рассмотрим как создать свой граф с помощью языка *Cypher*.
Создаём граф
------------
Для начала можно ознакомиться с языком Cypher, вызвав команду:
```
:play cypher
```
Итак, начнём. Создадим небольшой социальный граф. Перейдём в редактор и наберём первую команду на языке Cypher:
```
CREATE (u1:Person {name: "Evgeny", from: "Krasnodar"})
```
После выполнения команды Browser сообщит нам результат:
Добавим ещё один узел:
```
CREATE (u2:Person {name: "Dmitry", from: "Tula"})
```
Теперь запросим все узлы типа `Person` и извлечём значения свойства `name`:
```
MATCH (ee:Person) RETURN ee.name
```
*Примечание.* Как и в SQL есть возможность упорядочить извлекаемые данные по какому-либо полю:
```
MATCH (ee:Person) RETURN ee.name ORDER BY ee.name
```
Далее можем запросить все узлы данного типа:
```
MATCH (ee:Person) RETURN ee
```
Обратите внимание на появившуюся кнопку **Graph**. Щёлкним на ней и увидим наши узлы в графическом виде:
*Примечание.* В версии 3.4 по-умолчанию как-раз открывается графическое представление. Для получения табличного представления нужно щёлкнуть на кнопку с надписью "Table". Хотя, бывает и наоборот.
Добавим связь между узлами:
```
MATCH (e:Person) WHERE e.name = "Evgeny"
MATCH (d:Person) WHERE d.name = "Dmitry"
CREATE (e)-[:KNOWS]->(d),
(d)-[:KNOWS]->(e)
```
И вновь запросим наш граф:
С помощью Cypher можно также выполнять различные операции над графами, например, запрашивать смежные вершины, друзей друзей в социальном графе, удалять рёбра и вершины и многое другое, но это тема для отдельного разговора.
Также можно настраивать Neo4j Browser на различный стиль отображения узлов и связей в зависимости от заданных им меток.
Ссылки
------
* [Neo4j Browser User Interface Guide](https://neo4j.com/developer/neo4j-browser/)
* [The Neo4j Developer Manual v3.4](https://neo4j.com/docs/developer-manual/3.4/)
* [The Neo4j Developer Manual v3.3](https://neo4j.com/docs/developer-manual/3.3/)
* [Neo4j Graph Database Sandbox](https://neo4j.com/sandbox-v2/)
* [Neo4j GraphGists](https://neo4j.com/graphgists/) | https://habr.com/ru/post/470541/ | null | ru | null |
# Делаем рейтинг городов России по качеству дорог
В очередной раз проезжая на машине по родному городу и объезжая очередную яму я подумал: а везде ли в нашей стране такие «хорошие» дороги и решил — надо объективно оценить ситуацию с качеством дорог в нашей стране.
Формализация задачи
-------------------
В России требования к качеству дорог описываются в ГОСТ Р 50597-2017 «Дороги автомобильные и улицы. Требования к эксплуатационному состоянию, допустимому по условиям обеспечения безопасности дорожного движения. Методы контроля». Этот документ определяет требования к покрытию проезжей части, обочинам, разделительным полосам, тротуарам, пешеходным дорожкам и т.п., а так же устанавливает типы повреждений.
Поскольку задача определения всех параметров дорог достаточно обширна, а решил для себя ее сузить и остановиться только на задаче определения дефектов покрытия проезжей части. В ГОСТ Р 50597-2017 выделяются следующие дефекты покрытия проезжей части:
* выбоины
* проломы
* просадки
* сдвиги
* гребенки
* колея
* выпотевание вяжущего
Выявлением этих дефектов я и решил заняться.
Сбор датасета
-------------
Где взять фотографии на которых изображены достаточно большие участки дорожного полотна, да еще с привязкой к геолокации? Ответ пришел стразу — панорамы на картах Яндекса (или Гугла), однако, немного поискав, нашел еще несколько альтернативных вариантов:
* выдача поисковиков по картинкам для соответствующих запросов;
* фотографии на сайтах для приема жалоб (Росяма, Сердитый гражданин, Добродел и пр.)
* на Opendatascience подсказали проект по детектированию дефектов дорог с размеченным датасетом — [github.com/sekilab/RoadDamageDetector](https://github.com/sekilab/RoadDamageDetector)
К сожалению, анализ этих вариантов показал, что они не очень-то мне подходят: выдача поисковиков обладает большим шумом (много фотографий, не являющихся дорогами, различных рендеров и тп), фотографии с сайтов для приема жалоб содержат только фотографии с большими нарушениями асфальтового покрытия, фотографий с небольшими нарушения покрытия и без нарушений на этих сайтах довольно мало, датасет из проекта RoadDamageDetector собран в Японии и не содержит образцов с большими нарушения покрытия, а также дорог без покрытия вообще.
Раз альтернативные варианты не подходят будем использовать панорамы Яндекса (вариант панорам Гугла я исключил, т. к. сервис представлен в меньшем количестве городов России и обновляется реже). Данные решил собирать в городах с населением более 100 тыс. человек, а также в федеральных центрах. Составил список названий городов — их оказалось 176, позже выяснится, что панорамы есть только в 149 из них. Не буду углубятся в особенности парсинга тайлов, скажу что в итоге у меня получилось 149 папок (по одной для каждого города) в которых суммарно находилось 1.7 млн фотографий. К примеру для Новокузнецка папка выглядела вот так:
По количеству скачанных фотографий города распределились следующим образом:
**Таблица**
| Город | Количество фотографий, шт |
| --- | --- |
| Москва
| 86048
|
| Санкт-Петербург
| 41376
|
| Саранск
| 18880
|
| Подольск
| 18560
|
| Красногорск
| 18208
|
| Люберцы
| 17760
|
| Калининград
| 16928
|
| Коломна
| 16832
|
| Мытищи
| 16192
|
| Владивосток
| 16096
|
| Балашиха
| 15968
|
| Петрозаводск
| 15968
|
| Екатеринбург
| 15808
|
| Великий Новгород
| 15744
|
| Набережные Челны
| 15680
|
| Краснодар
| 15520
|
| Нижний Новгород
| 15488
|
| Химки
| 15296
|
| Тула
| 15296
|
| Новосибирск
| 15264
|
| Тверь
| 15200
|
| Миасс
| 15104
|
| Иваново
| 15072
|
| Вологда
| 15008
|
| Жуковский
| 14976
|
| Кострома
| 14912
|
| Самара
| 14880
|
| Королёв
| 14784
|
| Калуга
| 14720
|
| Череповец
| 14720
|
| Севастополь
| 14688
|
| Пушкино
| 14528
|
| Ярославль
| 14464
|
| Ульяновск
| 14400
|
| Ростов-на-Дону
| 14368
|
| Домодедово
| 14304
|
| Каменск-Уральский
| 14208
|
| Псков
| 14144
|
| Йошкар-Ола
| 14080
|
| Керчь
| 14080
|
| Мурманск
| 13920
|
| Тольятти
| 13920
|
| Владимир
| 13792
|
| Орёл
| 13792
|
| Сыктывкар
| 13728
|
| Долгопрудный
| 13696
|
| Ханты-Мансийск
| 13664
|
| Казань
| 13600
|
| Энгельс
| 13440
|
| Архангельск
| 13280
|
| Брянск
| 13216
|
| Омск
| 13120
|
| Сызрань
| 13088
|
| Красноярск
| 13056
|
| Щёлково
| 12928
|
| Пенза
| 12864
|
| Челябинск
| 12768
|
| Чебоксары
| 12768
|
| Нижний Тагил
| 12672
|
| Ставрополь
| 12672
|
| Раменское
| 12640
|
| Иркутск
| 12608
|
| Ангарск
| 12608
|
| Тюмень
| 12512
|
| Одинцово
| 12512
|
| Уфа
| 12512
|
| Магадан
| 12512
|
| Пермь
| 12448
|
| Киров
| 12256
|
| Нижнекамск
| 12224
|
| Махачкала
| 12096
|
| Нижневартовск
| 11936
|
| Курск
| 11904
|
| Сочи
| 11872
|
| Тамбов
| 11840
|
| Пятигорск
| 11808
|
| Волгодонск
| 11712
|
| Рязань
| 11680
|
| Саратов
| 11616
|
| Дзержинск
| 11456
|
| Оренбург
| 11456
|
| Курган
| 11424
|
| Волгоград
| 11264
|
| Ижевск
| 11168
|
| Златоуст
| 11136
|
| Липецк
| 11072
|
| Кисловодск
| 11072
|
| Сургут
| 11040
|
| Магнитогорск
| 10912
|
| Смоленск
| 10784
|
| Хабаровск
| 10752
|
| Копейск
| 10688
|
| Майкоп
| 10656
|
| Петропавловск-Камчатский
| 10624
|
| Таганрог
| 10560
|
| Барнаул
| 10528
|
| Сергиев Посад
| 10368
|
| Элиста
| 10304
|
| Стерлитамак
| 9920
|
| Симферополь
| 9824
|
| Томск
| 9760
|
| Орехово-Зуево
| 9728
|
| Астрахань
| 9664
|
| Евпатория
| 9568
|
| Ногинск
| 9344
|
| Чита
| 9216
|
| Белгород
| 9120
|
| Бийск
| 8928
|
| Рыбинск
| 8896
|
| Северодвинск
| 8832
|
| Воронеж
| 8768
|
| Благовещенск
| 8672
|
| Новороссийск
| 8608
|
| Улан-Удэ
| 8576
|
| Серпухов
| 8320
|
| Комсомольск-на-Амуре
| 8192
|
| Абакан
| 8128
|
| Норильск
| 8096
|
| Южно-Сахалинск
| 8032
|
| Обнинск
| 7904
|
| Ессентуки
| 7712
|
| Батайск
| 7648
|
| Волжский
| 7584
|
| Новочеркасск
| 7488
|
| Бердск
| 7456
|
| Арзамас
| 7424
|
| Первоуральск
| 7392
|
| Кемерово
| 7104
|
| Электросталь
| 6720
|
| Дербент
| 6592
|
| Якутск
| 6528
|
| Муром
| 6240
|
| Нефтеюганск
| 5792
|
| Реутов
| 5696
|
| Биробиджан
| 5440
|
| Новокуйбышевск
| 5248
|
| Салехард
| 5184
|
| Новокузнецк
| 5152
|
| Новый Уренгой
| 4736
|
| Ноябрьск
| 4416
|
| Новочебоксарск
| 4352
|
| Елец
| 3968
|
| Каспийск
| 3936
|
| Старый Оскол
| 3840
|
| Артём
| 3744
|
| Железногорск
| 3584
|
| Салават
| 3584
|
| Прокопьевск
| 2816
|
| Горно-Алтайск
| 2464
|
Подготовка датасета для обучения
--------------------------------
И так, датасет собран, как теперь имея фотографию участка дороги и прилагающих объектов узнать качество асфальта, изображенного на ней? Я решил вырезать кусок фотографии размером 350\*244 пикселя по центру исходной фотографии чуть ниже середины. Затем уменьшить вырезанный кусок по горизонтали до размера 244 пикселя. Получившееся изображение (размером 244\*244) и будет входным для сверточного энкодера:
Что бы лучше понять с какими данными я имею дело первых 2000 картинок я разметил сам, остальные картинки размечали работники Яндекс.Толоки. Перед ними я поставил вопрос в следующей формулировке.
Укажите, какое дорожное покрытие Вы видите на фотографии:
1. Грунт/Щебень
2. Брусчатка, плитка, мостовая
3. Рельсы, ж/д пути
4. Вода, большие лужи
5. Асфальт
6. На фотографии нет дороги/ Посторонние предметы/ Покрытие не видно из-за машин
Если исполнитель выбирал «Асфальт», то появлялось меню, предлагающее оценить его качество:
1. Отличное покрытие
2. Незначительные одиночные трещины/неглубокие одиночные выбоины
3. Большие трещины/Сетка трещин/одиночные не значительные выбоины
4. Большое количество выбоин/ Глубокие выбоины/ Разрушенное покрытие
Как показали тестовые запуски заданий, исполнители Я.Толоки добросовестностью работы не отличаются – случайно кликают мышкой по полям и считают задание выполненным. Пришлось добавлять контрольные вопросы (в задании было 46 фотографий, 12 из которых были контрольными) и включить отложенную приемку. В качестве контрольных вопросов я использовал те картинки, которые разметил сам. Отложенную приемку я автоматизировал – Я.Толока позволяет выгружать результаты работы в CSV-файл, и загружать результаты проверки ответов. Проверка ответов работала следующим образом – если в задании более 5% неверных ответов на контрольные вопросы, то оно считается невыполненным. При этом, если исполнитель указал ответ, логически близкий к верному, то его ответ считается верным.
В результате я получил около 30 тысяч размеченных фотографий, которые я решил распределить в три класса для обучения:
* «Good» – фотографии с метками «Асфальт: Отличное покрытие» и «Асфальт: Незначительные одиночные трещины»
* «Middle» — фотографии с метками «Брусчатка, плитка, мостовая», «Рельсы, ж/д пути» и «Асфальт: Большие трещины/Сетка трещин/одиночные не значительные выбоины»
* «Large» — фотографии с метками «Грунт/Щебень», «Вода, большие лужи» и «Асфальт: Большое количество выбоин/ Глубокие выбоины/ Разрушенное покрытие»
* Фотографии с метками «На фотографии нет дороги/ Посторонние предметы/ Покрытие не видно из-за машин» оказалось очень мало (22 шт.) и я их исключил из дальнейшей работы
Разработка и обучение классификатора
------------------------------------
Итак, данные собраны и размечены, переходим к разработке классификатора. Обычно для задач классификации изображений, особенно при обучении на небольших датасетах, используют готовый сверточный энкодер, к выходу которого подключают новый классификатор. Я решил использовать простой классификатор без скрытого слоя, входной слой размером 128 и выходной слой размером 3. В качестве энкодеров решил сразу использовать несколько готовых вариантов, обученных на ImageNet:
* Xception
* Resnet
* Inception
* Vgg16
* Densenet121
* Mobilenet
Вот так выглядит функция, создающая Keras-модель с заданным энкодером:
```
def createModel(typeModel):
conv_base = None
if(typeModel == "nasnet"):
conv_base = keras.applications.nasnet.NASNetMobile(include_top=False,
input_shape=(224,224,3),
weights='imagenet')
if(typeModel == "xception"):
conv_base = keras.applications.xception.Xception(include_top=False,
input_shape=(224,224,3),
weights='imagenet')
if(typeModel == "resnet"):
conv_base = keras.applications.resnet50.ResNet50(include_top=False,
input_shape=(224,224,3),
weights='imagenet')
if(typeModel == "inception"):
conv_base = keras.applications.inception_v3.InceptionV3(include_top=False,
input_shape=(224,224,3),
weights='imagenet')
if(typeModel == "densenet121"):
conv_base = keras.applications.densenet.DenseNet121(include_top=False,
input_shape=(224,224,3),
weights='imagenet')
if(typeModel == "mobilenet"):
conv_base = keras.applications.mobilenet_v2.MobileNetV2(include_top=False,
input_shape=(224,224,3),
weights='imagenet')
if(typeModel == "vgg16"):
conv_base = keras.applications.vgg16.VGG16(include_top=False,
input_shape=(224,224,3),
weights='imagenet')
conv_base.trainable = False
model = Sequential()
model.add(conv_base)
model.add(Flatten())
model.add(Dense(128,
activation='relu',
kernel_regularizer=regularizers.l2(0.0002)))
model.add(Dropout(0.3))
model.add(Dense(3, activation='softmax'))
model.compile(optimizer=keras.optimizers.Adam(lr=1e-4),
loss='binary_crossentropy',
metrics=['accuracy'])
return model
```
Для обучения использовал генератор с аугментацией (т.к. возможностей встроенной в Keras аугментации мне показались недостаточными, то я воспользовался библиотекой [Augmentor](https://github.com/mdbloice/Augmentor)):
* Наклоны
* Случайные искажения
* Повороты
* Замена цвета
* Сдвиги
* Изменение контраста и яркости
* Добавление случайного шума
* Кропы
После аугментации фотографии выгладили так:
Код генератора:
```
def get_datagen():
train_dir='~/data/train_img'
test_dir='~/data/test_img'
testDataGen = ImageDataGenerator(rescale=1. / 255)
train_generator = datagen.flow_from_directory(
train_dir,
target_size=img_size,
batch_size=16,
class_mode='categorical')
p = Augmentor.Pipeline(train_dir)
p.skew(probability=0.9)
p.random_distortion(probability=0.9,grid_width=3,grid_height=3,magnitude=8)
p.rotate(probability=0.9, max_left_rotation=5, max_right_rotation=5)
p.random_color(probability=0.7, min_factor=0.8, max_factor=1)
p.flip_left_right(probability=0.7)
p.random_brightness(probability=0.7, min_factor=0.8, max_factor=1.2)
p.random_contrast(probability=0.5, min_factor=0.9, max_factor=1)
p.random_erasing(probability=1,rectangle_area=0.2)
p.crop_by_size(probability=1, width=244, height=244, centre=True)
train_generator = keras_generator(p,batch_size=16)
test_generator = testDataGen.flow_from_directory(
test_dir,
target_size=img_size,
batch_size=32,
class_mode='categorical')
return (train_generator, test_generator)
```
В коде видно, что для тестовых данных аугментация не используется.
Имея настроенный генератор можно заняться обучением модели, его будем проводить в два этапа: сначала обучать только наш классификатор, затем полностью всю модель.
```
def evalModelstep1(typeModel):
K.clear_session()
gc.collect()
model=createModel(typeModel)
traiGen,testGen=getDatagen()
model.fit_generator(generator=traiGen,
epochs=4,
steps_per_epoch=30000/16,
validation_steps=len(testGen),
validation_data=testGen,
)
return model
def evalModelstep2(model):
early_stopping_callback = EarlyStopping(monitor='val_loss', patience=3)
model.layers[0].trainable=True
model.trainable=True
model.compile(optimizer=keras.optimizers.Adam(lr=1e-5),
loss='binary_crossentropy',
metrics=['accuracy'])
traiGen,testGen=getDatagen()
model.fit_generator(generator=traiGen,
epochs=25,
steps_per_epoch=30000/16,
validation_steps=len(testGen),
validation_data=testGen,
callbacks=[early_stopping_callback]
)
return model
def full_fit():
model_names=[
"xception",
"resnet",
"inception",
"vgg16",
"densenet121",
"mobilenet"
]
for model_name in model_names:
print("#########################################")
print("#########################################")
print("#########################################")
print(model_name)
print("#########################################")
print("#########################################")
print("#########################################")
model = evalModelstep1(model_name)
model = evalModelstep2(model)
model.save("~/data/models/model_new_"+str(model_name)+".h5")
```
Вызываем full\_fit() и ждем. Долго ждем.
По результату будем иметь шесть обученных моделей, точность этих моделей проверять будем на отдельной порции размеченных даны я получил следующие:
| | |
| --- | --- |
| Название модели | Точность, % |
| Xception | 87.3 |
| Resnet | 90.8 |
| Inception | 90.2 |
| Vgg16 | 89.2 |
| Densenet121 | 90.6 |
| Mobilenet | 86.5 |
В общем-то, не густо, но при такой маленькой обучающей выборке ожидать большего не приходится. Чтобы еще немного поднять точность я объединил выходы моделей за счет усреднения:
```
def create_meta_model():
model_names=[
"xception",
"resnet",
"inception",
"vgg16",
"densenet121",
"mobilenet"
]
model_input = Input(shape=(244,244,3))
submodels=[]
i=0;
for model_name in model_names:
filename= "~/data/models/model_new_"+str(model_name)+".h5"
submodel = keras.models.load_model(filename)
submodel.name = model_name+"_"+str(i)
i+=1
submodels.append(submodel(model_input))
out=average(submodels)
model = Model(inputs = model_input,outputs=out)
model.compile(optimizer=keras.optimizers.Adam(lr=1e-4),
loss='binary_crossentropy',
metrics=['accuracy'])
return model
```
Итоговая точность получилась 91,3 %. На таком результате я решил остановиться.
Использование классификатора
----------------------------
Наконец-то готов классификатор и его можно запустить в дело! Подготавливаю входные данные и запускаю классификатор — чуть больше суток и 1,7 млн. фотографий обработаны. Теперь самое интересное – результаты. Сразу привожу первую и последнюю десятку городов по относительному количеству дорог с хорошим покрытием:
**Полная таблица (картинка кликабельна)**[](https://i.ibb.co/bQSSpHB/10.png)
А вот рейтинг качества дорог по субъектам федерации:
**Полная таблица**
Рейтинг по федеральным округам:
Распределение качества дорог по России в целом:
Ну, вот и все, выводы каждый может сделать сам.
Напоследок приведу лучшие фотографии в каждой категории (которые получили максимальное значение в своем классе):
**Картинка**
P.S. В комментариях совершенно справедливо указали на отсутствие статистики по годам получения фотографий. Исправляюсь и привожу таблицу:
| | |
| --- | --- |
| Год | Количество фотографий, шт |
| 2008 | 37 |
| 2009 | 13 |
| 2010 | 157030 |
| 2011 | 60724 |
| 2012 | 42387 |
| 2013 | 12148
|
| 2014 | 141021
|
| 2015 | 46143
|
| 2016 | 410385
|
| 2017 | 324279
|
| 2018 | 581961
| | https://habr.com/ru/post/437542/ | null | ru | null |
# Добавляем фуригану к кандзи Python макросом для LibreOffice
Дамы и господа, план такой:
* всё, что вы хотели знать о японской письменности, но боялись спросить
* что такое ruby text
* как писать аддоны для LibreOffice на Python
* как сгенирировать чтение для канзи
* собираем всё это вместе в фуриганайзер!
В современном японском языке используются, в основном, три письменных системы.
Во-первых, это две слоговые азбуки: хирагана и катакана. Хирагана более округлая, выглядит примерно вот так: これはひらがなです и является как-бы основной азбукой.。 Катакана более угловатая (カタカナデス) и используется в основном для заимствованных слов, в целом же набор знаков хираганы и катаканы практически аналогичный. Дальше будем называть всё это просто “кана”. “Слоговая азбука” значит, что вместо наших гласных и согласных “а”, “б” и “в” — только целые слоги типа “ка”, “са” и “то”. Гласные, правда тоже есть, пять штук (“а”, “и”, “у”, “э“, “о” + «я», «ю» и «ё») и только один согласный знак “н” в порядке исключения.
Именно поэтому японцам очень трудно выговаривать слова с подряд идущими согласными — они к такому просто не привыкли, но это нам сейчас не важно. Одной каной, в принципе, можно написать любую фразу на японском.
Еще одна система — это заимствованные из Китая иероглифы, которые мы будем дальше называть **кандзи**, потом что они так называются. После заимствования японские, да собсно и китайские тоже, кандзи существенно поменялись, и сейчас довольно таки различаются, хотя конечно, с другой стороны, во многом остались схожи. Скажем так, глядя на китайский текст японец может более-менее понять о чём там идёт речь. Кандзи выглядят примерно так: 友達、日本酒、世界。 Да, в японском — круглая точка.
Тут ключевой для понимания момент: японский и китайский языки на уровне грамматики вообще никак не родственные. Так что вот так вот просто взять китайские знаки и начать ими писать было не можно. Собственно с помощью кандзи можно писать отдельные слова, скорее даже основы слов, а для указания грамматических форм и связи слов между собой по-прежнему используется кана. Выглядит это примерно так: 送りがなはとっても便利です. Если присмотреться — видно что первый символ — кандзи, за ним идут несколько знаков каны и т.д. Таким трюком легко визуально отличить японский текст от китайского, которые выглядит графически более “плотным” т.к. там исключительно кандзи. Эта кана, которая прицепляется в кандзи для указания грамматической формы, называется “окуригана”.
Вот, ну и наконец… Число кандзи довольно велико, и, если вы не робот — то запомнить все сложно. Если слово написано кандзи — то часто не очевидно как собс-но его читать, при том, что что в устной речи слово вполне могла встречаться и человек его знает. Чтобы помочь в такой ситуации, особенно для редких кандзи или когда текст предназначен для детей, иностранцев, или других умственно ограниченных категорий граждан — чтение кандзи подписывают сверху с помощью каны. Это и называется “**фуригана**”. Выглядит как на картинке в начале поста.
Фух, переходим к следующему пункту.
Для добавления аннотации поверх текста используется так называемый ruby. К языку программирования отношения не имеет. Как я только что узнал из Википедии — по-русски называется [“агат”](https://ru.wikipedia.org/wiki/%D0%90%D0%B3%D0%B0%D1%82_(%D0%BA%D0%B5%D0%B3%D0%BB%D1%8C))
Поддержка руби есть в html с помощью тэга ruby:
```
текст
аннотация
```
Но сейчас нас интересует LibreOffice. В ручном режиме добавить руби аннотацию к тексту можно через меню Format -> Asian Phonetic Guide. Это несколько странно, ведь можно поле руби же не только для фонетики использовать, ну да фиг с ними. Если такого нет в меню — то можно попробовать добавить поддержку азиатских языков в Tools -> Options -> Language Settings.
Дальше, мы хотим это делать автоматически для выделенного текста. LibreOffice прекрасен тем, что в нём можно писать макросы на Python. Для этого должен стоять модуль libreoffice-script-provider-python (ставиться через apt-get), который по-умлочанию не стоит. Ах да, я всё делаю под Ubuntu, если у вас другая операционная система — то вы можете поделиться в комментариях рецептом для неё :)
Собственно макрос пишется как обычная функция на пайтоне. Документ виден через глобальную переменную с инстансом соответствующего класса и, собственно, в нём все нужные методы.
Вот простой пример:
```
def HelloWorldPython():
desktop = XSCRIPTCONTEXT.getDesktop()
model = desktop.getCurrentComponent()
if not hasattr(model, "Text"):
model = desktop.loadComponentFromURL("private:factory/swriter","_blank", 0, () )
text = model.Text
tRange = text.End
tRange.String = "Hello World (in Python)"
return None
g_exportedScripts = HelloWorldPython,
```
Сохраняем в файл, кладём его или делаем символьную ссылку в папку, в которой LibreOffice держит скрипты. В моём случае это “~/.config/libreoffice/4/user/Scripts/python”.
Открываем LibreOffice Writer (OpenOffice тоже должен работать), идём в Tools -> Macros -> Run Macro и видим там наш скрипт, если всё получилось.
Осталось написать такой скрипт, который бы брал кандзи из документа и добавлял их чтения в руби соответствующих символов. Тут всё просто: для генерации чтения есть специальные программы, мы просто запустим их из нашего скрипта-макроса, через стандартный ввод-вывод прогоним японский текст и вставим аутпут в документ.
Программа под названием kakasi берёт японский текст и выдаёт чтение целым куском, но это не совсем то, что надо, т.к. хочется фрагменты фонетической подсказки распределить между ruby полями соответствующих симоволов. Для этого с помощью mecab можно токенизировать японский текст, а потому уже кормить его kakasi по частям. На самом деле точность генерации чтения от этого чуть-чуть ухудшается, но улучшается вёрстка документа. Какие-то огрехи можно потом поправить вручную.
Вот собсно и всё, ставим apt-get install kakasi, mecab,
идём в [github.com/undertherain/furiganize](https://github.com/undertherain/furiganize), качаем оттуда корявый скрипт который я написал и который собс-но вот это всё проделывает. Кладём его в нужную папку и enjoy. Если кто-то поделиться опытом с другими операционными сиcтемами — будет вообще замечательно. | https://habr.com/ru/post/395153/ | null | ru | null |
# Ещё раз о задержках в исходном коде проекта FPGA или простой вопрос для собеседования на вакансию разработчика FPGA
Некоторое время назад при обсуждении в компании профессиональных разработчиков FPGA возникла дискуссия о прохождении собеседования. Какие вопросы там задают, и что можно было бы задать. Я предложил два вопроса:
1. Приведите пример синхронного кода без использования задержек, который даст разные результаты при моделировании и при работе в реальной аппаратуре
2. Исправьте этот код при помощи задержек.
После этого вопроса завязалась оживлённая дискуссия, в результате которой я решил более подробно рассмотреть этот вопрос.
Я уже немного касался этого вопроса в [предыдущей статье](https://habr.com/post/309162/). Сейчас более подробно. Вот текст примера:
```
library IEEE;
use IEEE.STD_LOGIC_1164.all;
entity delta_delay is
end delta_delay;
architecture delta_delay of delta_delay is
signal clk1 : std_logic:='0';
signal clk2 : std_logic;
alias clk3 : std_logic is clk1; -- назначение другого имени clk1
signal a : std_logic;
signal b : std_logic;
signal c : std_logic;
signal d : std_logic;
begin
--- Формирование тестовых сигналов ---
clk1 <= not clk1 after 5 ns;
pr_a: process begin
a <= '0' after 1 ns;
wait until rising_edge( clk1 );
wait until rising_edge( clk1 );
a <= '1' after 1 ns;
wait until rising_edge( clk1 );
wait until rising_edge( clk1 );
wait until rising_edge( clk1 );
wait until rising_edge( clk1 );
end process;
--- Синтезируемая часть - переназначение тактового сигнала ---
clk2 <= clk1; -- вот в этом проблема, не надо так делать без крайней необходимости
--- Вариант 1 - Синтезируемая часть без задержек ---
b <= a when rising_edge( clk1 );
c <= b when rising_edge( clk1 );
d <= b when rising_edge( clk2 );
--- Вариант 2 - Синтезируемая часть с задержками ---
--
--clk2 <= clk1;
--b <= a after 1 ns when rising_edge( clk1 );
--c <= b after 1 ns when rising_edge( clk1 );
--d <= b after 1 ns when rising_edge( clk2 );
--- Вариант 3 - Синтезируемая часть без задержек но с переназначением сигнала через alias ---
--b <= a when rising_edge( clk1 );
--c <= b when rising_edge( clk1 );
--d <= b when rising_edge( clk3 );
end delta_delay;
```
Для упрощения весь код размещён в одном компоненте.
Сигналы **clk1** и **a** это сигналы тестового воздействия. **clk1** это тактовая частота 100 MHz, Сигнал **а** держится два такта в 0 и четыре такта в 1. Сигнал **a** формируется с задержкой 1 nc относительно нарастающего фронта **clk1**. Этих двух сигналов достаточно для описания проблемы.
Различные варианты синтезируемого кода можно раскомментировать и промоделировать.
Рассмотрим первый вариант, это синтезируемый код без задержек и с использованием переназначения тактовой частоты.
Вот результаты моделирования для варианта 1:
На диаграмме визуально видно, что сигналы тактовой частоты **clk1** и **clk2** совпадают, но на самом деле **clk2** задержан относительно **clk1** на величину дельта задержки. Сигнал **c** отстаёт от сигнала **b** на один такт. Это правильно. Но вот сигнал **d** должен совпадать с сигналом **c**, а этого не происходит. Он срабатывает раньше.
Давайте вспомним что такое дельта задержка. Это принципиальное понятие, на нём основана работа событийных симуляторов, которыми мы пользуемся при моделировании логических схем.
Симулятор имеет понятие модельного времени. К этому модельному времени привязаны все события в системе. Давайте посмотрим на формирование тактовой частоты:
```
clk1 <= not clk1 after 5 ns;
```
Предположим что сейчас мы моделируем только **clk1**, других сигналов нет.
В начальный момент времени **clk1** равен 0, это задано при объявлении сигнала. Симулятор видит требование инвертировать сигнал. Ключевое слово after даёт инструкцию провести назначение нового значение через 5 ns относительно текущего модельного времени. Симулятор это видит и делает отметку, что в момент времени 5 ns значение **clk1** будет равно 1. Пока это модельное будущее, оно кстати ещё может измениться. Далее симулятор просматривает остальные сигналы. Симулятор увидит что для данного момента модельного времени всё выполнено и он может рассчитывать следующий момент. Возникает вопрос – а какой момент следующий? В принципе возможны разные варианты. Например Simulink имеет режим с фиксированным шагом. В этом случае произойдёт приращении модельного времени на какую то величину и вычисления продолжаться.
Системы моделирования цифровых схем делают по другому. Они переходят к ближайшему событию, которые они уже разместили в будущем на своей оси модельного времени. В данном случае это будет момент 5 нс. Симулятор увидит что **clk1** изменился и просчитает для него новое значение, это будет 0 который также будет размещён с задержкой в 5 нс на временной оси. Т.е. это будет момент 10 нс. И так процесс будет продолжаться пока не закончиться заданное время моделирования.
Теперь давайте добавим сигналы **a** и **b**.
Сигнал **a** назначается в процессе. Для сигнала **b** используется условная конструкция when; Функция rising\_edge(**clk1**) анализирует **clk1** и возвращает **true** когда зафиксирован фронт, т.е. предыдущее значение равно 0 а текущее равно 1.
В момент модельного времени 5 ns произойдёт изменение **clk1**. Он станет равным 1 и для момента 10 ns будет создано событие установки его в 0. Но это потом. Пока мы ещё в моменте 5 ns и продолжаем вычисления. Симулятор переходит к строчке
```
b<=a when rising_edge(clk1);
```
Поскольку есть функция которая зависит от **clk1** то симулятор вычислит значение функции, увидит что она вернула true и произведёт присваивание
```
b<=a;
```
Вот здесь начинается самое интересное — когда надо изменить значение **b**. Казалось бы надо изменить его сейчас, в этот момент времени. Но у нас параллельные процессы. Может быть, нам ещё понадобиться значение **b** для расчёта других сигналов. И вот здесь появляется понятие дельта задержки. Это минимальная величина, на которую смещается модельное время. Эта величина даже не имеет размерности времени. Это просто дельта. Но их может быть много. Причём настолько много что симулятор просто останавливается по ошибке или зависает.
Итак, новое значение **b** будет установлено для момента 5 ns + 1 (1 – это первая дельта задержка). Симулятор увидит, что рассчитывать для момента 5 ns уже нечего и перейдёт к следующему моменту, а это будет 5 ns + 1; В этот момент rising\_edge(ckl1) не срабатывает. А значение b будет установлено в 1. После этого симулятор перейдёт к моменту 10 nc.
А вот теперь давайте добавим сигналы **c**, **d** и разберёмся почему они разные.
Лучше всего это рассмотреть момент модельного времени 25 ns с учётом дельта задержек
| delta | clk1 | clk2 | re(clk1) | re(clk2) | b | c | d |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 1 | 0 | true | false | 0 | 0 | 0 |
| 1 | 1 | 1 | false | true | 1 | 0 | 0 |
| 2 | 1 | 0 | false | false | 1 | 0 | 1 |
Примечание: re — rising\_edge
Из таблицы видно что в момент срабатывания функции rising\_edge(**clk2**) значение **b** уже равно 1. И поэтому оно будет присвоено сигналу **d**.
Исходя из здравого смысла это не то поведение, которое мы ожидали от кода. Ведь мы просто переназначили сигнал **clk1** на **clk2** и ожидали, что сигналы **c** и **d** будут одинаковыми. Но следуя логике работы симулятора это не так. Это **ПРИНЦИПИАЛЬНАЯ** особенность. Эту особенность конечно надо знать разработчикам FPGA проектов и поэтому это хороший и нужный вопрос для собеседования.
Что же произойдет при синтезе? А вот синтезатор проследует здравому смыслу, он сделает сигналы **clk2** и **clk1** одним сигналом и поэтому **c** и **d** тоже будут одинаковыми. А при определённых настройках синтезатора они тоже будут объединены в один сигнал.
Это как раз случай, когда моделирование и работа в реальной аппаратуре приведут к разным результатам. Хочу обратить внимание, что причина разных результатов – это разная логика симулятора и синтезатора. Это ПРИНЦИПИАЛЬНАЯ разница. Это не имеет ничего общего с временными ограничениями. И если ваш проект в модели и в железе показывает разные результаты то проверьте, может быть там закралась конструкция подобная
```
clk2 <= clk1
```
Теперь второй вопрос – исправьте этот код при помощи задержек.
Это вариант 2. Его можно раскомментировать и промоделировать.
Вот результат.
Результат правильный. Что же произошло? Давайте ещё раз составим таблицу для интервала 25 – 36 нс
| time | delta | clk1 | clk2 | re(clk1) | re(clk2) | b | c | d |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 25 | 0 | 1 | 0 | true | false | 0 | 0 | 0 |
| 25 | 1 | 1 | 1 | false | true | 0 | 0 | 0 |
| 26 | 0 | 1 | 1 | false | false | 1 | 0 | 0 |
| 35 | 0 | 1 | 0 | true | false | 1 | 0 | 0 |
| 35 | 1 | 1 | 1 | false | true | 1 | 0 | 0 |
| 36 | 0 | 1 | 1 | false | false | 1 | 1 | 1 |
Видно, что значение **b** не меняется в моменты фронтов **clk1**, **clk2**. Задержка в 1 нс уводит момент изменения сигналов за зону срабатывания фронтов. Этот код становиться ближе к реальности. В реальной схеме существует какое то время на срабатывание триггера и на распространение сигнала. Это время должно быть меньше периода тактовой частоты, собственного говоря, именно этого добивается трассировщик и именно это проверяет временной анализ.
Причина возникновения ошибки это переназначение тактового сигнала обычным присваиванием при котором появляется дельта задержка. Однако язык VHDL имеет конструкцию alias. Это позволяет получить другое имя для сигнала. Вот объявление:
```
alias clk3 : std_logic is clk1;
```
В тексте примера можно раскомментировать вариант 3 – он будет работать правильно.
Данный пример написан на языке VHDL. Может быть это проблемы только этого языка? Но вот те же варианты на языке Verilog.
**Скрытый текст**
```
`timescale 1 ns / 1 ps
module delta_delay_2 ();
reg clk1 = 1'b0;
reg clk2;
wire clk3;
reg a = 1'b0;
reg b;
reg c;
reg d;
initial begin
forever clk1 = #5 ~clk1;
end
initial begin
repeat(10)
begin
#20 a = 1'b1;
#60 a = 1'b0;
end
end
// Синтезируемая часть - переназначение тактового сигнала ---
always @(clk1) clk2 <= clk1;
// Вариант 1 - Синтезируемая часть без задержек
always @(posedge clk2) d <= b;
always @(posedge clk1)
begin
c <= b;
b <= a;
end
// Вариант 2 - Синтезируемая часть с задержеками
//always @(posedge clk1) b = #1 a;
//
//always @(posedge clk1) c = #1 b;
//
//always @(posedge clk2) d = #1 b;
// Вариант 3 - Синтезируемая часть без задержек
// но с переназначением сигнала через assign
//assign clk3 = clk1;
//
//always @(posedge clk3) d <= b;
//
//always @(posedge clk1)
//begin
// c <= b;
// b <= a;
//end
endmodule
```
* Вариант 1 – без задержек. Работает неправильно.
* Вариант 2 – с задержками. Работает правильно.
* Вариант 3 – переназначение через wire. Работает правильно.
В языке Verilog есть понятие reg и wire. В данном случае переназначение тактового сигнала через wire выглядит более естественным. Это является аналогом присвоения через alias в языке VHDL. Это несколько снимает напряжённость проблемы, но всё равно это надо знать.
Также в языке Verilog есть понятие блокирующего и неблокирующего присваивания. Назначение сигналов **b** и **c** можно написать и по другому:
```
always @(posedge clk1)
begin
c = b;
b = a;
end
```
А можно так:
```
always @(posedge clk1)
begin
b = a;
c = b;
end
```
В зависимости от порядка строк результат будет разный.
Возвращаясь к теме собеседования хочу ещё раз подчеркнуть что эти вопросы на понимание сути проблемы. А уже из понимания проблемы можно делать разные выводы, например какой использовать стиль кода. Лично я всегда использую назначение задержек.
[Файлы примеров доступны здесь](https://github.com/dsmv/fpga_components) | https://habr.com/ru/post/419875/ | null | ru | null |
# Пробуем Orchard CMS для корпоративного сайта
Привет!
У нас есть [корпоративный сайт](http://eastbanctech.ru) на Liferay, и он требует довольно кропотливой работы на этапе создания layout. Мы решили посмотреть, чем отличается создание кастомного раздела в Liferay от того же процесса в Orchard CMS в рамках такой небольшой задачки как создание корпоративных новостей.
Что у нас из этого вышло:
#### Настройка Orchard:
Реализация раздела «Новости» состоит из следующих частей:
1. Тип содержимого.
2. Настройки типа содержимого.
3. Само содержимое.
4. Запрос.
5. Проекция – то, как всё будет выглядеть на сайте. Кастомизация внешних элементов.
##### Создание типа «News» и запроса (для показа на главной странице):
1. Создаём ContentType:
2. Добавляем в Новости картинку:
3. Создаём запрос
3.1.
3.2. Теперь надо настроить фильтры для запроса:
3.3. Определим порядок сортировки:
3.4. Т.к. результат запроса надо где-то показывать, создаём Projection:
Теперь на главной странице будет проекция. В dashboard можно создать несколько новостей.
#### Кастомизация внешнего вида
##### Создаём тему
Необходимо скачать и включить модуль Code generation: <http://docs.orchardproject.net/Documentation/Command-line-scaffolding>
Далее открываем папку с установленным Orchard -> bin -> orchard.exe, ждём, пока она инициализируется, пишем: codegen theme /BasedOn:TheThemeMachine /CreateProject:true
Открываем проект с темой:
И не можем создать Razor template… Для того, чтобы мы могли создавать .cshtml файлы из интерфейса студии, необходимо выгрузить проект, открыть файл проекта каким-либо текстовым редактором и изменить ProjectTypeGuids, добавив в него {E53F8FEA-EAE0-44A6-8774-FFD645390401}. У нас результат получился таким: {E53F8FEA-EAE0-44A6-8774-FFD645390401};{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}. Теперь можно сохранить файл проекта и загрузить его в студии.
Все файлы темы, не найденные в текущей, берутся из базовой, если она определена, или из темы «SafeMode». Нам необходимо изменить фавиконку и подключить скрипты, фавиконка подключается только в темплейте «Document.cshtml», скрипты, связанные с темой, принято подключать здесь же.
Теперь мы можем создать Document.cshtml в папке Views.
Внутри этого файла мы добавляем ссылки на скрипты, регистрируем фавиконку, а остальной код взят из аналогичного файла в теме SafeMode
Views\Document.cshtml:
```
@using Orchard.Mvc.Html;
@using Orchard.UI.Resources;
@{
RegisterLink(new LinkEntry { Type = "image/x-icon", Rel = "shortcut icon", Href = Url.Content("~/Themes/ETRTheme/Content/images/favicon-201209261628.ico") });
Script.Include("html5.js").UseCondition("lt IE 9").AtHead();
Script.Include("jquery.min.js").AtHead();
Script.Include("jquery-ui.min.js").AtHead();
Script.Include("knockout-2.2.1.js").AtHead();
Script.Include("jquery.lightbox.js").AtHead();
Script.Include("jquery.cycle.all.js").AtHead();
Script.Include("date.format.js").AtHead();
Script.Include("script.js").AtHead();
string title = Convert.ToString(Model.Title);
string siteName = Convert.ToString(WorkContext.CurrentSite.SiteName);
}
@Html.Title(title, siteName)
@Display(Model.Head)
(function (d) { d.className = "dyn" + d.className.substring(6, d.className.length); })(document.documentElement);
@Display(Model.Body)
@Display(Model.Tail)
```
Этот файл отвечает за отрисовку страницы, в строке «@Display(Model.Body)» он вызывает Layout.cshtml.
Layout содержит в себе разметку страницы, подключает css и «показывает» разные зоны.
##### Изменение шейпов для кастомизации UI
Для того чтобы кастомизировать внешний вид элементов, необходимо создать несколько темплейтов с определёнными названиями (по одному на каждую кастомизацию, Orchard сам подберёт, каким темплейтом какой элемент ему рэндерить).
<http://docs.orchardproject.net/Documentation/Accessing-and-rendering-shapes#NamingShapesandTemplates>
В нашем случае будут, например, такие темплейты:
* Content-News.Summary.cshtml – отвечает за отображение сокращённого варианта новости.
* SliderGrid-ProjectionPage.cshtml – отвечает за отображение projection.
Темплейт для отображения сокращённой новости:
Views\Content-News.Summary.cshtml:
```
@using Orchard.Utility.Extensions;
@using Orchard.Fields.Fields;
@using Orchard.Core.Common.Models;
@using Orchard.ContentManagement;
@using System.Text.RegularExpressions;
@using Orchard.Tags.Models;
@using System.Text;
@using Orchard.MediaLibrary.Fields;
@using Orchard.ContentManagement
@{
ContentItem contentItem = Model.ContentItem;
var contentTypeClassName = ((string)contentItem.ContentType).HtmlClassify();
var news = ((dynamic)contentItem).News;
IEnumerable fields = news.Fields;
var common = contentItem.As();
var publishedDate = "";
if (common.PublishedUtc.HasValue)
{
var date = common.PublishedUtc.Value;
publishedDate = date.ToString("d MMMM yyyy");
}
MediaLibraryPickerField newsMainImage = null;
bool newsHasImage = false;
string imageUrl = null;
string imageAlternateText = null;
try
{
newsMainImage = (MediaLibraryPickerField)fields.First(f => f.Name == "NewsMainImage");
imageUrl = newsMainImage.MediaParts.First().MediaUrl;
imageAlternateText = newsMainImage.MediaParts.First().AlternateText;
newsHasImage = true;
}
catch (InvalidOperationException e)
{
newsHasImage = false;
}
var body = contentItem.As();
var summaryBodyText = body.Text.RemoveTags().Trim().Replace(Environment.NewLine, " ");
summaryBodyText = Regex.Replace(summaryBodyText, @"\s+", " ");
var textLength = newsHasImage ? 400 : 500;
textLength = textLength > summaryBodyText.Length ? summaryBodyText.Length : textLength;
summaryBodyText = summaryBodyText.Substring(0, textLength);
var tags = contentItem.As().CurrentTags;
var tagsHtml = new List();
foreach (var t in tags)
{
if (tagsHtml.Any())
{
tagsHtml.Add(new HtmlString(", "));
}
tagsHtml.Add(Html.ActionLink((string)t.TagName, "Search", "Home", new { area = "Orchard.Tags", tagName = (string)t.TagName }, new { }));
}
class="b-newsroll-item-inner"
}
else
{
class="b-newsroll-item-inner-no-image"
}>
@if (common.PublishedUtc.HasValue)
{
@publishedDate
}
@if (newsHasImage)
{
)alt="@imageAlternateText"
}/>
}
@Html.Raw(summaryBodyText)
@Html.ItemDisplayLink(T("Read more").ToString(), contentItem)
@if (tagsHtml.Any())
{
@T("Tags:")
@foreach (var htmlString in tagsHtml)
{
@htmlString
}
}
}
```
##### Создание грида для расположения новостей
Теперь надо сделать нормальный грид для новостей, для этого создаём модуль «SliderGrid»: codegen module SliderGrid и описываем в нём шейпы:
Layouts\SliderGridLayoutForms.cs:
```
using System;
using Orchard.DisplayManagement;
using Orchard.Forms.Services;
using Orchard.Localization;
namespace SliderGrid.Layouts
{
public class SliderGridLayoutForms : IFormProvider
{
protected dynamic Shape { get; set; }
public Localizer T { get; set; }
public SliderGridLayoutForms(
IShapeFactory shapeFactory)
{
Shape = shapeFactory;
T = NullLocalizer.Instance;
}
public void Describe(DescribeContext context)
{
Func form =
shape =>
{
var f = Shape.Form(
Id: "SliderGridLayout",
\_HtmlProperties: Shape.Fieldset()
);
return f;
};
context.Form("SliderGridLayout", form);
}
}
}
Layouts\SliderGridLayout.cs:
using System.Collections.Generic;
using System.Linq;
using Orchard.ContentManagement;
using Orchard.DisplayManagement;
using Orchard.Localization;
using Orchard.Projections.Descriptors.Layout;
using Orchard.Projections.Models;
using Orchard.Projections.Services;
namespace SliderGrid.Layouts
{
public class SliderGridLayout : ILayoutProvider
{
public Localizer T { get; set; }
private readonly IContentManager \_contentManager;
protected dynamic Shape { get; set; }
public SliderGridLayout(IShapeFactory shapeFactory, IContentManager contentManager)
{
\_contentManager = contentManager;
Shape = shapeFactory;
T = NullLocalizer.Instance;
}
public void Describe(DescribeLayoutContext describe)
{
describe.For("Html", T("Html"), T("Html Layouts"))
.Element("SliderGrid", T("SliderGrid"), T("Renders multiPageGrid of elements + slider."),
DisplayLayout,
RenderLayout,
"SliderGridLayout"
);
}
public LocalizedString DisplayLayout(LayoutContext context)
{
return T("Renders multiPageGrid + slider.");
}
public dynamic RenderLayout(LayoutContext context, IEnumerable layoutComponentResults)
{
IEnumerable shapes =
context.LayoutRecord.Display == (int)LayoutRecord.Displays.Content
? layoutComponentResults.Select(x => \_contentManager.BuildDisplay(x.ContentItem, context.LayoutRecord.DisplayType))
: layoutComponentResults.Select(x => x.Properties);
return Shape.SliderGrid(Items: shapes);
}
}
}
```
##### Включаем грид
Подключаем в «модулях» фичу SliderGrid, изменяем layout запроса LastNews на SliderGrid:
 | https://habr.com/ru/post/189314/ | null | ru | null |
# Пишем собственный хитрый thread_pool-диспетчер для SObjectizer-а
О чем эта статья?
=================
Одной из основных отличительных черт [C++ного фреймворка SObjectizer](https://habrahabr.ru/post/304386/) является наличие диспетчеров. Диспетчеры определяют где и как акторы (агенты в терминологии SObjectizer-а) будут обрабатывать свои события: на отдельной нити, на пуле рабочих нитей, на одной общей для группы акторов нити и т.д.
В состав SObjectizer-а уже входит [восемь штатных диспетчеров](https://www.slideshare.net/YauheniAkhotnikau/dive-into-sobjectizer-55-eighth-part-dispatchers) (плюс еще один в [наборе расширений для SObjectizer-а](https://stiffstream.com/ru/products/so_5_extra.html)). Но даже при всем этом многообразии встречаются ситуации, когда под конкретную специфическую задачу имеет смысл сделать собственного диспетчера. В статье как раз и рассматривается одна из таких ситуаций и показывается как можно сделать собственный диспетчер, если штатные диспетчеры по каким-то причинам нас не устраивают. А заодно будет показано как просто поменять поведение приложения всего лишь привязав одного и того же актора к разным диспетчерам. Ну и еще несколько интересных мелочей и не очень мелочей.
В общем, если кому-то интересно прикоснуться к деталям реализации одного из немногих живых и развивающихся акторных фреймворков для C++, то можно смело читать дальше.
Преамбула
=========
Недавно один из пользователей SObjectizer-а рассказал про специфическую проблему, с которой ему довелось столкнуться в процессе использования SObjectizer-а. Смысл в том, что на базе SObjectizer-овских агентов разрабатывается приложение для управления подключенными к компьютеру устройствами. Часть операций (а именно операция инициализации и переинициализации устройства) выполняется синхронно, что приводит к блокировке рабочей нити на некоторое время. Операции же ввода-вывода осуществляются асинхронно, поэтому иницирование чтения/записи и обработка результата чтения-записи выполняются значительно быстрее и не блокируют рабочую нить надолго.
Устройств много, от нескольких сотен до нескольких тысяч, поэтому использовать схему «одно устройство — одна рабочая нить» не выгодно. Из-за чего используется небольшой пул рабочих нитей, на котором выполняются все операции с устройствами.
Но такой простой подход имеет неприятную особенность. Когда возникает большое количество заявок на инициализацию и переинициализацию устройств, то эти заявки начинают распределяться по всем нитям из пула. И регулярно случаются ситуации, когда все рабочие нити пула заняты выполнением длительных операций, тогда как короткие операции, вроде чтения-записи, скапливаются в очередях и долго не обрабатываются. Данная ситуация стабильно наблюдается, например, при старте приложения, когда сразу формируется большая «пачка» заявок на инициализацию устройств. И пока эта «пачка» не будет разобрана, операции ввода-вывода на уже проинициализированных устройствах не выполняются.
Для устранения этой неприятности можно использовать несколько подходов. В данной статье разберем один из них, а именно — написание собственного хитрого thread\_pool-диспетчера, анализирующего типы заявок.
Что мы хотим достичь?
=====================
Проблема состоит в том, что долго работающие обработчики (т.е. обработчики операций инициализации и переинициализации устройств) блокируют все имеющиеся в пуле рабочие нити и из-за этого заявки для коротких операций (т.е. операций ввода-вывода) могут ждать в очереди очень долго. Мы же хотим получить такую схему диспетчеризации, чтобы при появлении заявки для короткой операции, ее ожидание в очередях было сведено к минимуму.
Имитационный «стенд»
====================
В статье мы будем использовать [имитацию описанной выше проблемы](https://github.com/Stiffstream/so5_tricky_thread_pool_disp_ru). Почему имитацию? Потому, что, во-первых, мы имеем представление только о сути проблемы пользователя, но не знаем деталей и никогда не видели его кода. И, во-вторых, имитация позволяет сконцентироваться на наиболее значимых аспектах решаемой проблемы, не распыляя внимания на мелкие детали, коих в реальном продакшен-коде великое множество.
Однако, есть одна важная деталь, которая нам стала известна от нашего пользователя и которая самым серьезным образом сказывается на описываемом ниже решении. Дело в том, что в SObjectizer есть понятие thread-safety для обработчиков сообщений. Т.е. если обработчик сообщения помечен как thread-safe, то SObjectizer имеет право запустить этот обработчик в параллель с другими thread-safe обработчиками. И есть adv\_thread\_pool-диспетчер, который именно это и делает.
Так вот, наш пользователь для управления устройствами использовал stateless-агента, привязанного к adv\_thread\_pool-диспетчеру. Это сильно упрощает всю кухню.
Итак, что же мы будем рассматривать?
Мы сделали имитацию, состоящую из одних и тех же агентов. Один агент — это вспомогательный агент типа a\_dashboard\_t. Его задача — собирать и фиксировать статистику, по которой мы будем судить о результатах имитационных экспериментов. [Реализацию](https://github.com/Stiffstream/so5_tricky_thread_pool_disp_ru/blob/201909051500/dev/common/a_dashboard.hpp) данного агента мы рассматривать не будем.
Второй агент, [реализованный классом a\_device\_manager\_t](https://github.com/Stiffstream/so5_tricky_thread_pool_disp_ru/blob/201909051500/dev/common/a_device_manager.hpp#L8-L206), имитирует работу с устройствами. О том, как работает этот агент мы немного поговорим ниже, т.к. это может быть интересным примером того, как в SObjectizer-е могут быть реализованы агенты, не нуждающиеся в изменении своего состояния.
В имитацию входят два приложения, которые делают практически одно и то же: разбирают аргументы командной строки и запускают имитацию с агентами a\_dashboard\_t и a\_device\_manager\_t внутри. Но первое приложение привязывает a\_device\_manager\_t к диспетчеру adv\_thread\_pool. А вот второе приложение реализует собственный тип диспетчера и привязывает a\_device\_manager\_t к этому собственному диспетчеру.
На основании результатов работы каждого из приложений можно будет увидеть, как разные типы диспетчеров влияют на характер обслуживания заявок.
Агент a\_device\_manager\_t
===========================
В этом разделе мы попробуем осветить основные моменты в реализации агента a\_device\_manager\_t. Все остальные детали можно увидеть [в полном коде агента](https://github.com/Stiffstream/so5_tricky_thread_pool_disp_ru/blob/201909051500/dev/common/a_device_manager.hpp#L8-L206). Или уточнить в комментариях.
Агент a\_device\_manager\_t должен имитировать работу с множеством однотипных устройств, но при этом он должен быть «stateless-агентом», т.е. он не должен менять своего состояния в процессе работы. Именно то, что агент не изменяет своего состояния и позволяет ему иметь thread-safe обработчики событий.
Однако, если агент a\_device\_manager\_t не меняет своего состояния, то как же он определяет, какое устройство должно быть инициализировано, какое устройство должно быть переинициализировано, а с каким устройством нужно выполнять операции ввода-вывода? Все просто: вся эта информация пересылается внутри сообщений, которые агент a\_device\_manager\_t отсылает сам себе.
При старте агент a\_device\_manager\_t отсылает себе N сообщений init\_device\_t. Получив такое сообщение агент a\_device\_manager\_t создает экземпляр «устройства» — объект типа device\_t и выполняет его инициализацию. Затем указать на этот экземпляр отсылается в сообщении perform\_io\_t. Выглядит это так:
```
void on_init_device(mhood_t cmd) const {
// Обновим статистику по этой операции.
handle\_msg\_delay(a\_dashboard\_t::op\_type\_t::init, \*cmd);
// Нужно создать новое устройство и проимитировать паузу,
// связанную с его инициализацией.
auto dev = std::make\_unique(cmd->id\_,
calculate\_io\_period(),
calculate\_io\_ops\_before\_reinit(),
calculate\_reinits\_before\_recreate());
std::this\_thread::sleep\_for(args\_.device\_init\_time\_);
// Отсылаем первое сообщение о необходимости выполнить IO-операцию
// на этом устройстве.
send\_perform\_io\_msg(std::move(dev));
}
```
Получив сообщение perform\_io\_t агент a\_device\_manager\_t имитирует операцию ввода-вывода для устройства, указатель на которое находится внутри сообщения perform\_io\_t. При этом для device\_t декрементируется счетчик IO-операций. Если этот счетчик достигает нуля, то a\_device\_manager\_t либо отсылает сам себе сообщение reinit\_device\_t (если счетчик переинициализаций еще не обнулен), либо сообщение init\_device\_t для пересоздания устройства. Эта нехитрая логика имитирует поведение реальных устройств, которые имеют свойство «залипать» (т.е. переставать нормально выполнять IO-операции) и тогда их нужно переинициализировать. А также тот печальный факт, что у каждого устройства есть ограниченный ресурс, исчерпав который устройство должно быть заменено.
Если же счетчик IO-операций еще не обнулился, то агент a\_device\_manager\_t еще раз отсылает сам себе сообщение perform\_io\_t.
В коде все это выглядит следующим образом:
```
void on_perform_io(mutable_mhood_t cmd) const {
// Обновим статистику по этой операции.
handle\_msg\_delay(a\_dashboard\_t::op\_type\_t::io\_op, \*cmd);
// Выполняем задержку имитируя реальную IO-операцию.
std::this\_thread::sleep\_for(args\_.io\_op\_time\_);
// Количество оставшихся IO-операций должно уменьшиться.
cmd->device\_->remaining\_io\_ops\_ -= 1;
// Возможно, пришло время переинициализировать устройство.
// Или даже пересоздавать, если исчерпан лимит попыток переинициализации.
if(0 == cmd->device\_->remaining\_io\_ops\_) {
if(0 == cmd->device\_->remaining\_reinits\_)
// Устройство нужно пересоздать. Под тем же самым идентификатором.
so\_5::send(\*this, cmd->device\_->id\_);
else
// Попытки переинициализации еще не исчерпаны.
so\_5::send>(\*this, std::move(cmd->device\_));
}
else
// Время переинициализации еще не пришло, продолжаем IO-операции.
send\_perform\_io\_msg(std::move(cmd->device\_));
}
```
Вот такая нехитрая логика, касательно которой может иметь смысл уточнение некоторых деталей.
Отсылка информации агенту a\_dashboard\_t
-----------------------------------------
В обработчиках сообщений init\_device\_t, reinit\_device\_t и perform\_io\_t первой строкой идет подобная конструкция:
```
handle_msg_delay(a_dashboard_t::op_type_t::init, *cmd);
```
Это передача агенту a\_dashboard\_t информации о том, сколько конкретное сообщение провело в очереди заявок. На основании этой информации как раз и строится статистика.
В принципе, точную информацию о том, сколько времени сообщение провело в очереди заявок можно было бы получить разве что внедрившись в потроха SObjectizer-а: тогда мы бы могли зафиксировать время постановки заявки в очередь и время ее извлечения оттуда. Но для столь простого эксперимента мы таким экстримом заниматься не будем. Поступим проще: при отсылке очередного сообщения будем сохранять в нем ожидаемое время прибытия сообщения. Например, если мы отсылаем отложенное на 250ms сообщение, то мы ждем его прибытия в момент (Tc+250ms), где Tc — это текущее время. Если сообщение пришло через (Tc+350ms), значит 100ms оно провело в очереди.
Это, конечно же, не точный способ, но для нашей имитации он вполне подходит.
Блокирование текущей рабочей нити на некоторое время
----------------------------------------------------
Также в коде обработчиков сообщений init\_device\_t, reinit\_device\_t и perform\_io\_t можно увидеть обращение к std::this\_thread::sleep\_for. Это не что иное, как имитация синхронных операций с устройством, которые должны блокировать текущую нить.
Времена задержек можно задать через командную строку, а по умолчанию используются следующие значения: для init\_device\_t — 1250ms, для perform\_io\_t — 50ms. Длительность для reinit\_device\_t вычисляется как 2/3 от длительности init\_device (т.е. 833ms по умолчанию).
Использование мутабельных сообщений
-----------------------------------
Пожалуй, самой интересной особенностью агента a\_device\_manager\_t является то, как обеспечивается время жизни динамически созданных объектов device\_t. Ведь экземпляр device\_t создается динамически при обработке init\_device\_t и затем он должен оставаться живым до тех пор, пока не будут исчерпаны попытки переинициализации этого устройства. А когда попытки переинициализации исчерпаны, то экземпляр device\_t должен быть уничтожен.
При этом a\_device\_manager\_t не должен менять своего состояния. Т.е. мы не можем завести в a\_device\_manager\_t какой-то std::map или std::unordered\_map, который был бы словарем живых device\_t.
Для решения этой задачки используется следующий трюк. В сообщениях reinit\_device\_t и perform\_io\_t передается unique\_ptr, содержащий указатель на экземпляр device\_t. Соответственно, когда мы обрабатываем reinit\_device\_t или perform\_io\_t и хотим отправить следующее сообщение для этого устройства, то мы просто перекладываем unique\_ptr из старого экземпляра сообщения в новый экземпляр. А если экземпляр нам больше не нужен, т.е. мы для него больше не отсылаем ни reinit\_device\_t, ни perform\_io\_t, то экземпляр device\_t уничтожается автоматически, т.к. уничтожается экземпляр unique\_ptr в уже обработанном сообщении.
Но тут есть небольшой фокус. Обычно сообщения в SObjectizer отсылаются как иммутабельные объекты, которые не должны модифицироваться. Это потому, что SObjectizer реализует модель Pub/Sub и отсылая сообщение в mbox в общем случае нельзя с уверенностью сказать, сколько именно подписчиков получат сообщение. Может быть их будет десять. Может быть сто. Может быть тысяча. Соответственно, какие-то подписчики будут обрабатывать сообщение одновременно. И поэтому нельзя разрешать, чтобы один подписчик модифицировал экземпляр сообщения в то время, как другой подписчик пытается с этим экземпляром работать. Именно из-за этого обычные сообщения передаются в обработчик по константной ссылке.
Однако, бывают ситуации, когда сообщение гарантированно отсылается одному-единственному получателю. И этот получатель хочет модифицировать полученный экземпляр сообщения. Вот как в нашем примере, когда мы хотим забрать из полученного perform\_io\_t значение unique\_ptr и отдать это значение в новый экземпляр reinit\_device\_t.
Для таких случаев в SObjectizer-5.5.19 была добавлена поддержка [мутабельных сообщений](https://www.slideshare.net/YauheniAkhotnikau/dive-into-sobjectizer-55-tenth-part-mutable-messages). Эти сообщения специальным образом помечаются. И SObjectizer в run-time проверяет, отсылаются ли мутабельные сообщения в multi-producer/multi-consumer mbox-ы. Т.е. мутабельное сообщение может быть доставлено не более чем одному получателю. Поэтому оно передается получателю по обычной, не константной ссылке, что и позволяет модифицировать содержимое сообщения.
Следы этого обнаруживаются в коде a\_device\_manager\_t. Например, вот такая сигнатура обработчика говорит о том, что обработчик ожидает мутабельное сообщение:
```
void on_perform_io(mutable_mhood_t cmd) const
```
А вот этот код говорит о том, что отыслается экземпляр мутабельного сообщения:
```
so_5::send>(\*this, std::move(cmd->device\_));
```
Имитация с использованием adv\_thread\_pool-диспетчера
======================================================
Для того, чтобы посмотреть, как будет вести себя наш a\_device\_manager\_t со штатным adv\_thread\_pool-диспетчером нужно создать кооперацию из агентов a\_dashboard\_t и a\_device\_manager\_t, привязав a\_device\_manager\_t к adv\_thread\_pool-диспетчеру. Что выглядит [следующим образом](https://github.com/Stiffstream/so5_tricky_thread_pool_disp_ru/blob/201909051500/dev/adv_thread_pool_case/main.cpp):
```
void run_example(const args_t & args ) {
print_args(args);
so_5::launch([&](so_5::environment_t & env) {
env.introduce_coop([&](so_5::coop_t & coop) {
const auto dashboard_mbox =
coop.make_agent()->so\_direct\_mbox();
// Агента для управления устройствами запускаем на отдельном
// adv\_thread\_pool-диспетчере.
namespace disp = so\_5::disp::adv\_thread\_pool;
coop.make\_agent\_with\_binder(
disp::create\_private\_disp(env, args.thread\_pool\_size\_)->
binder(disp::bind\_params\_t{}),
args,
dashboard\_mbox);
});
});
}
```
В результате тестового запуска с 20-ю рабочими нитями в пуле и остальными значениями по умолчанию получаем следующую картинку:
Можно увидеть большой «синий» пик в самом начале (это массовое создание устройств при старте), а также большие «серые» пики вскоре после начала работы. Сперва мы получаем большое количество сообщений init\_device\_t, часть из которых долго ждут своей очереди на обработку. Затем очень быстро обрабатываются perform\_io\_t и генерируется большое количество reinit\_device\_t. Часть из этих reinit\_device\_t ждут в очередях, отсюда и заметные серые пики. Также можно видеть заметные провалы в линиях зеленого цвета. Это падение количества обработанных perform\_io\_t сообщений в те моменты, когда идет массовая обработка reinit\_device\_t и init\_device\_t.
Наша задача как раз состоит в том, чтобы уменьшить количество «серых» всплесков и сделать «зеленые» провалы не такими глубокими.
Идея собственного хитрого thread\_pool-диспетчера
=================================================
Проблема с adv\_thread\_pool-диспетчером в том, что для него все заявки равноценны. Поэтому, как только у него освобождается рабочая нить, он отдает ей первую заявку из очереди. Совершенно не разбираясь с тем, какой у этой заявки тип. Это и приводит к ситуациям, когда все рабочие нити заняты обработкой заявок init\_device\_t или reinit\_device\_t, в то время как в очереди скапливаются заявки типа perform\_io\_t.
Чтобы избавится от этой проблемы сделаем свой хитрый thread\_pool-диспетчер, который будет иметь два подпула из рабочих нитей двух типов.
Рабочие нити первого типа могут обрабатывать заявки любых типов. Приоритет отдается заявкам типа init\_device\_t и reinit\_device\_t, но если их в данный момент нет, то можно обрабатывать и заявки типа perform\_io\_t.
Рабочие нити второго типа не могут обрабатывать заявки типа init\_device\_t и reinit\_device\_t. Заявку типа perform\_io\_t обрабатывать могут, а вот заявку типа init\_device\_t не могут.
Тем самым, если у нас образуется 50 заявок типа reinit\_device\_t и 150 заявок типа perform\_io\_t, то первый подпул будет разгребать заявки reinit\_device\_t, а второй подпул в это же время будет разгребать заявки perform\_io\_t. Когда все заявки типа reinit\_device\_t будут обработаны, то рабочие нити из первого подпула освободятся и смогут помочь обработать оставшиеся заявки типа perform\_io\_t.
Получается, что наш хитрый thread\_pool-диспетчер держит отдельное множество нитей для обработки коротких заявок и это позволяет не притормаживать короткие заявки даже когда имеется большое количество долгих заявок (как, скажем, в самом начале работы, при единовременной отсылке большого количества init\_device\_t).
Имитация с использованием хитрого thread\_pool-диспетчера
=========================================================
Для того, чтобы проделать ту же самую имитацию, но уже с другим диспетчером нам нужно лишь [немного переделать](https://github.com/Stiffstream/so5_tricky_thread_pool_disp_ru/blob/201909051500/dev/tricky_disp_case/main.cpp) уже показанную выше функцию run\_example:
```
void run_example(const args_t & args ) {
print_args(args);
so_5::launch([&](so_5::environment_t & env) {
env.introduce_coop([&](so_5::coop_t & coop) {
const auto dashboard_mbox =
coop.make_agent()->so\_direct\_mbox();
// Агента для управления устройствами запускаем на отдельном
// хитром диспетчере.
coop.make\_agent\_with\_binder(
tricky\_dispatcher\_t::make(env, args.thread\_pool\_size\_)->binder(),
args,
dashboard\_mbox);
});
});
}
```
Т.е. мы создаем все тех же агентов, только в этот раз мы привязываем a\_device\_manager\_t к другому диспетчеру.
В результате запуска с теми же самыми параметрами мы увидим уже другую картинку:
Присутствует все тот же «синий» пик. Теперь он стал даже повыше, что не удивительно, т.к. для обработки init\_device\_t теперь выделено меньше рабочих нитей. Зато мы не видим «серых» пиков и «зеленые» провалы стали менее глубокими.
Т.е. мы получили тот результат, который хотели. И теперь мы можем посмотреть на код этого самого хитрого диспетчера.
Реализация хитрого thread\_pool-диспетчера
==========================================
Диспетчеры в SObjectizer делятся на два типа:
Во-первых, публичные диспетчеры. У каждого публичного диспетчера должно быть свое уникальное имя. Обычно экземпляры диспетчера создаются еще до запуска SObjectizer-а, во время запуска SObjectizer-а публичные диспетчеры стартуют, а при завершении работы SObjectizer-а — останавливаются. У этих диспетчеров должен быть [определенный интерфейс](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5/5.5.22/dev/so_5/rt/h/disp.hpp#l40). Но это уже устаревший тип диспетчеров. Существует далеко не нулевая вероятность, что в следующей мажорной версии SObjectizer-а публичных диспетчеров уже не будет.
Во-вторых, приватные диспетчеры. Пользователь создает такие диспетчеры в любой момент после запуска SObjectizer-а. Приватный диспетчер должен стартовать сразу после создания и завершает он свою работу после того, как им перестают пользоваться. Как раз для своей имитации мы будем создавать диспетчера, который может использоваться только как приватный диспетчер.
Давайте рассмотрим основные моменты, связанные с нашим диспетчером.
disp\_binder для нашего диспетчера
----------------------------------
Приватные диспетчеры не имеют жестко определенного интерфейса, т.к. все основные операции осуществляются в конструкторе и деструкторе. Но у приватного диспетчера должен быть публичный метод, который обычно называется binder(), возвращающий специальный объект-binder. Этот объект-binder будет привязывать агента к конкретному диспетчеру. И вот у binder-а уже должен быть вполне себе определенный интерфейс — [disp\_binder\_t](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5/5.5.22/dev/so_5/rt/h/disp_binder.hpp#l44).
Поэтому для [своего диспетчера](https://github.com/Stiffstream/so5_tricky_thread_pool_disp_ru/blob/201909051500/dev/tricky_disp_case/main.cpp#L14) мы делаем собственный тип binder-а, реализующий интерфейс disp\_binder\_t:
```
class tricky_dispatcher_t
: public std::enable_shared_from_this {
friend class tricky\_event\_queue\_t;
friend class tricky\_disp\_binder\_t;
class tricky\_event\_queue\_t : public so\_5::event\_queue\_t {...};
class tricky\_disp\_binder\_t : public so\_5::disp\_binder\_t {
std::shared\_ptr disp\_;
public:
tricky\_disp\_binder\_t(std::shared\_ptr disp)
: disp\_{std::move(disp)} {}
virtual so\_5::disp\_binding\_activator\_t bind\_agent(
so\_5::environment\_t &,
so\_5::agent\_ref\_t agent) override {
return [d = disp\_, agent] {
agent->so\_bind\_to\_dispatcher(d->event\_queue\_);
};
}
virtual void unbind\_agent(
so\_5::environment\_t &,
so\_5::agent\_ref\_t) override {
// Ничего не нужно делать.
}
};
...
// Объект, реализующий интерфейс so\_5::event\_queue\_t для того,
// чтобы выполнять привязку агентов к диспетчеру.
tricky\_event\_queue\_t event\_queue\_;
...
public:
...
// Создать биндера, который сможет привязать агента к этому диспетчеру.
so\_5::disp\_binder\_unique\_ptr\_t binder() {
return so\_5::disp\_binder\_unique\_ptr\_t{
new tricky\_disp\_binder\_t{shared\_from\_this()}};
}
};
```
Наш класс tricky\_dispatcher\_t наследуется от std::enable\_shared\_from\_this для того, чтобы мы могли использовать счетчик ссылок для контроля за временем жизни диспетчера. Как только диспетчер перестанет использоваться, счетчик ссылок обнуляется и диспетчер автоматически уничтожается.
В классе ticky\_dispatcher\_t есть публичный метод binder(), возвращающий новый экземпляр tricky\_disp\_binder\_t. В этот экземпляр передается умный указатель на сам диспетчер. Это позволяет затем связать конкретного агента с конкретным диспетчером, что мы и видели ранее в коде run\_example:
```
// Агента для управления устройствами запускаем на отдельном
// хитром диспетчере.
coop.make_agent_with_binder(
tricky\_dispatcher\_t::make(env, args.thread\_pool\_size\_)->binder(),
args,
dashboard\_mbox);
});
});
```
Объект-binder должен выполнять два действия. Первое — это привязывание агента к диспетчеру. Что выполняется в методе bind\_agent(). Хотя, на самом деле, связывание агента с диспетчером выполняется в два этапа. Сперва в процессе регистрации кооперации вызывается метод bind\_agent() и этот метод должен создать все необходимые для агента ресурсы. Например, если агент привязывается к диспетчеру active\_obj, то для агента должна быть выделена новая рабочая нить. Это как раз должно происходить в bind\_agent(). Метод bind\_agent() возвращает функтор, который уже завершит процедуру привязки агента с использованием выделенных ранее ресурсов. Т.е. получается, что при регистрации кооперации сперва вызывается bind\_agent(), а чуть позже — возвращенный bind\_agent()-ом функтор.
В нашем случае bind\_agent() очень простой. Никаких ресурсов не нужно выделять, достаточно просто вернуть функтор, который и свяжет агента с диспетчером (подробнее об этом ниже).
Второе действие — это отвязывание агента от диспетчера. Это отвязывание происходит когда агент изымается из SObjectizer-а (дерегистрируется). При этом может потребоваться очистить какие-то ресурсы, которые агенту были выделены. Например, диспетчер active\_obj останавливает выделенную агенту рабочую нить.
За выполнение второго действия отвечает метод unbind\_agent(). Но в нашем случае он пустой, поскольку для tricky\_dispatcher\_t очистка ресурсов при отвязывании агента не требуется.
tricky\_event\_queue\_t
-----------------------
Выше мы говорили о «привязывании агента к диспетчеру», но в чем смысл этого привязывания? Смысл в двух простых вещах.
Во-первых, какие-то диспетчеры, вроде упоминавшегося выше active\_obj, должны выделять те или иные ресурсы для агента в момент привязки.
Во-вторых, в SObjectizer агенты не имеют собственных очередей сообщений/заявок. В этом состоит принципиальное отличие SObjectizer от реализаций «классической Actor Model», в которой у каждого актора есть собственный mailbox (и, следовательно, собственная очередь сообщений).
В SObjectizer же очередями заявок владеют диспетчеры. Именно диспетчеры определяют, где и как хранятся заявки (т.е. адресованные агенту сообщения), где, когда и как заявки извлекаются и обрабатываются.
Соответственно, когда агент начинает работать внутри SObjectizer-а нужно установить связь между агентом и той очередью заявок, в которую должны складываться адресованные агенту сообщения. Для этого нужно вызвать у агента специальный метод so\_bind\_to\_dispatcher() и передать в этот метод ссылку на объект, реализующий интерфейс [event\_queue\_t](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5/5.5.22/dev/so_5/rt/h/event_queue.hpp#l26). Что, собственно, мы и видим в реализации tricky\_disp\_binder\_t::bind\_agent().
Но вопрос в том, что именно tricky\_disp\_binder\_t отдает в so\_bind\_to\_dispatcher(). В нашем случае это специальная реализация интерфейса event\_queue\_t, которая служит всего лишь тоненьким прокси для вызова tricky\_dispatcher\_t::push\_demand():
```
class tricky_event_queue_t : public so_5::event_queue_t {
tricky_dispatcher_t & disp_;
public:
tricky_event_queue_t(tricky_dispatcher_t & disp) : disp_{disp} {}
virtual void push(so_5::execution_demand_t demand) override {
disp_.push_demand(std::move(demand));
}
};
```
Что скрывает за собой tricky\_dispatcher\_t::push\_demand?
----------------------------------------------------------
Итак, в нашем tricky\_dispatcher\_t есть один-единственный экземпляр tricky\_event\_queue\_t, ссылка на который передается всем привязанным к диспетчеру агентам. А сам этот экземпляр просто делегирует всю работу методу tricky\_dispatcher\_t::push\_demand(). Пришло время заглянуть внутрь push\_demand-а:
```
void push_demand(so_5::execution_demand_t demand) {
if(init_device_type == demand.m_msg_type ||
reinit_device_type == demand.m_msg_type) {
// Эти заявки должны идти в свою собственную очередь.
so_5::send(init\_reinit\_ch\_, std::move(demand));
}
else {
// Это заявка, которая должна попасть в общую очередь.
so\_5::send(other\_demands\_ch\_, std::move(demand));
}
}
```
Здесь все просто. Для каждой новой заявки проверяется ее тип. Если заявка относится к сообщениям init\_device\_t или reinit\_device\_t, то ее кладут в одно место. Если же это заявка любого другого типа, то ее кладут в другое место.
Самое интересное — это что из себя представляют init\_reinit\_ch\_ и other\_demands\_ch\_? А представляют они ни что иное, как CSP-шные каналы, которые в SObjectizer называются [mchain-ы](https://www.slideshare.net/YauheniAkhotnikau/dive-into-sobjectizer-55-ninth-part-message-chains):
```
// Каналы, которые будут использоваться в качестве очередей сообщений.
so_5::mchain_t init_reinit_ch_;
so_5::mchain_t other_demands_ch_;
```
Получается, что когда для агента сформирована новая заявка и эта заявка дошла до push\_demand, то ее тип анализируется и заявка отсылается либо в один канал, либо в другой. А уже извлекают и обрабатывают заявки рабочие нити, которые входят в пул диспетчера.
Реализация рабочих нитей диспетчера
-----------------------------------
Как говорилось выше, наш хитрый диспетчер использует рабочие нити двух типов. Теперь уже понятно, что рабочие нити первого типа должны читать заявки из init\_reinit\_ch\_ и исполнять их. А если init\_reinit\_ch\_ пуст, то нужно читать и исполнять заявки из other\_demands\_ch\_. Если же оба канала пусты, то нужно спать пока в какой-то из каналов не поступит заявка. Либо пока оба канала не закроют.
С рабочими нитями второго типа еще проще: нужно читать заявки только из other\_demands\_ch\_.
Собственно, именно это мы и видим в коде tricky\_dispatcher\_t:
```
// Обработчик объектов so_5::execution_demand_t.
static void exec_demand_handler(so_5::execution_demand_t d) {
d.call_handler(so_5::null_current_thread_id());
}
// Тело рабочей нити первого типа.
void first_type_thread_body() {
// Выполняем работу до тех пор, пока не будут закрыты все каналы.
so_5::select(so_5::from_all(),
case_(init_reinit_ch_, exec_demand_handler),
case_(other_demands_ch_, exec_demand_handler));
}
// Тело рабочей нити второго типа.
void second_type_thread_body() {
// Выполняем работу до тех пор, пока не будут закрыты все каналы.
so_5::select(so_5::from_all(),
case_(other_demands_ch_, exec_demand_handler));
}
```
Т.е. нить первого типа висит на select-е из двух каналов. Тогда как нить второго типа — на select-е только из одного канала (в принципе, внутри second\_type\_thread\_body() можно было бы использовать so\_5::receive() вместо so\_5::select()).
Собственно, это и все, что нам потребовалось сделать, чтобы организовать две thread-safe очереди заявок и чтение этих очередей на разных рабочих нитях.
Запуск-останов нашего хитрого диспетчера
----------------------------------------
Для полноты картины имеет смысл привести в статье еще и код, относящийся к запуску и останову tricky\_dispatcher\_t. Запуск выполняется в конструкторе, а останов, соответственно, в деструкторе:
```
// Конструктор сразу же запускает все рабочие нити.
tricky_dispatcher_t(
// SObjectizer Environment, на котором нужно будет работать.
so_5::environment_t & env,
// Количество рабочих потоков, которые должны быть созаны диспетчером.
unsigned pool_size)
: event_queue_{*this}
, init_reinit_ch_{so_5::create_mchain(env)}
, other_demands_ch_{so_5::create_mchain(env)} {
const auto [first_type_count, second_type_count] =
calculate_pools_sizes(pool_size);
launch_work_threads(first_type_count, second_type_count);
}
~tricky_dispatcher_t() noexcept {
// Все работающие нити должны быть остановлены.
shutdown_work_threads();
}
```
В конструкторе также можно увидеть и создание каналов init\_reinit\_ch\_ и other\_demands\_ch\_.
Вспомогательные методы launch\_work\_threads() и shutdown\_work\_threads() выглядят следующим образом:
```
// Запуск всех рабочих нитей.
// Если в процессе запуска произойдет сбой, то ранее запущенные нити
// должны быть остановлены.
void launch_work_threads(
unsigned first_type_threads_count,
unsigned second_type_threads_count) {
work_threads_.reserve(first_type_threads_count + second_type_threads_count);
try {
for(auto i = 0u; i < first_type_threads_count; ++i)
work_threads_.emplace_back([this]{ first_type_thread_body(); });
for(auto i = 0u; i < second_type_threads_count; ++i)
work_threads_.emplace_back([this]{ second_type_thread_body(); });
}
catch(...) {
shutdown_work_threads();
throw; // Пусть с исключениями разбираются выше.
}
}
// Вспомогательный метод для того, чтобы завершить работу всех нитей.
void shutdown_work_threads() noexcept {
// Сначала закроем оба канала.
so_5::close_drop_content(init_reinit_ch_);
so_5::close_drop_content(other_demands_ch_);
// Теперь можно дождаться момента, когда все рабочие нити закончат
// свою работу.
for(auto & t : work_threads_)
t.join();
// Пул рабочих нитей должен быть очищен.
work_threads_.clear();
}
```
Здесь, пожалуй, единственный хитрый момент — это необходимость ловить исключения в launch\_work\_threads, вызывать shutdown\_work\_threads, а затем пробрасывать исключение дальше. Все остальное вроде как тривиально и не должно вызывать затруднений.
Заключение
==========
Вообще говоря, разработка диспетчеров для SObjectizer-а — это непростая тема. И входящие в состав SO-5.5 и [so\_5\_extra](https://stiffstream.com/ru/products/so_5_extra.html) штатные диспетчеры имеют гораздо более навороченную реализацию, чем показанный в этой статье tricky\_dispatcher\_t. Тем не менее, в каких-то специфических ситуациях, когда ни один штатный диспетчер не подходит на 100%, можно реализовать собственный диспетчер, специально заточенный под вашу задачу. Если не пытаться затрагивать такую сложную тему, как run-time-мониторинг и статистика, то написание собственного диспетчера не выглядит такой уж запредельно сложной темой.
Следует также отметить, что показанный выше tricky\_dispatcher\_t оказался простым из-за очень важного допущения о том, что события всех привязанных к нему агентов будут thread-safe и их можно будет вызывать параллельно ни о чем не задумываясь. Однако, обычно это не так. В большинстве случаев у агентов есть только thread-unsafe обработчики. Но даже когда встречаются thread-safe обработчики, то они существуют одновременно со thread-unsafe обработчиками. И при диспетчеризации заявок приходится проверять тип очередного обработчика. Например, если обработчик для очередной заявки thread-safe, а сейчас работает thread-unsafe, то нужно дождаться пока завершится ранее запущенный thread-unsafe обработчик. Как раз всем этим занимается штатный adv\_thread\_pool-диспетчер. Но применяется на практике он редко. Гораздо чаще используются другие диспетчеры, которые не анализируют флаг thread-safety для обработчиков, а считают, что все обработчики являются thread-unsafe.
Напоследок хочется сказать, что упоминавшаяся в статье возможность работы с мутабельными сообщениями была добавлена в SObjectizer после общения в кулуарах после [доклада про SObjectizer на C++Russia 2017](https://www.youtube.com/watch?v=9fWDTbXnWaw). Если кто-то хочет пообщаться с разработчиками SObjectizer вживую и высказать им все, что вы думаете по этому поводу, то это можно будет сделать [на C++Russia 2018](http://cppconf.ru/talks/evgeniy-okhotnikov). | https://habr.com/ru/post/353712/ | null | ru | null |
# Документирование API — документация из тестов
Пост в продолжение [темы экспериментальных решений](https://habrahabr.ru/post/350382/), откуда будет переиспользован код для примера. В прошлом посте я затронул тему, как можно написать тесты на простой сервис, когда он выступает в роли черного ящика и из кода теста у нас нет прямого доступа к коду тестируемой программы. Ещё раз остановлюсь на том, что тестируемый сервис был реализован на языке Go, а тесты к сервису на языке Ruby и фрэймворке для тестирования RSpec. Стэк был выбран из собственных предпочтений и не имеет ключевого значения к рассматриваемой теме. В этой статье хочу рассмотреть вопрос документирования API, вновь используя не совсем стандартное решение.
Существует несколько основных подходов к написанию документации:
* Просто пишем документацию вручную.
* Автоматическая генерация документация по комментариями в коде.
* Автоматическая генерация документации по коду.
В первом случае минусы очевидны, необходимо вручную поддерживать документацию, к тому же текст документации отделён от кода. Во втором случае документация чаще всего генерируется из комментариев к классам, методам, функциями. В данном случае гораздо проще поддерживать актуальное описание, к тому же могут быть дополнительные проверки, вроде того, что сигнатура функции совпадает с описанием параметров в комментарии. Автоматическая генерация по коду должна исключить проблему поддержки актуального описания методов API. Данные способы широко применяются для документирования библиотек. Однако автоматическая генерация крайне редко встречается для WEB API, одна из возможных причин — все такие генераторы являются фрэймворко зависимые и требуют определённой поддержки рефлексии от веб фрэймворка и языка программирования.
Теперь кратко рассмотрим несколько менее распространенных способов составления (и использования) документации:
* Пишем машиночитаемую документацию, генерируем по ней код шаблон кода сервера и клиента.
* Имея машиночитаемую документацию, проверяем в тестах соответствие поведения API на описание в документации, например, что ответ метода соответствует тому, что написано в документации.
Сразу поясню, зачем может понадобится документация к API (машиночитаемая в том числе) до того, как написана сама реализация API. Чаще всего такая ситуация возникает, когда ведётся одновременная разработка как сервера API, так и клиентского кода. Имея машиночитаемую документацию на этапе разработки клиента, появляется возможность сгенерировать как сам API клиент, так и сервер, эмулирующий реальные ответы.
Ещё хочу отметить, что такие протоколы как GRPC, Apache Thrift и подобные фактически заставляют сначала написать (а потом и поддерживать) машиночитаемое описание API и только потом писать реализацию, что несомненно может нести некоторый раздражающий эффект от необходимости постоянной правки файлов с описанием протокола, но с другой стороны мы всегда уверены, что как минимум описание сигнатур соответствует реальности.
И последний (в данном тексте) способ получения документации:
* Генерируем документацию к методам API по реальному ответу от сервера. Запросы к серверу кодируются к тестах.
И вот это уже тема вынесенная в заголовок. Так как код тестов является неотъемлемой частью тестируемой системы, можно достаточно дёшево возложить на тесты дополнительный функционал. Выделю плюсы этого метода:
* Внутри документации получаем 100% актуальные примеры ответов от методов API, и все возможные сценарии использования, если они отдельно покрыты тестами.
* Мы можем автоматически сгенерировать документацию не внося изменений в исходный код сервиса. Таким образом мы больше не зависим от поддержки авто документации конкретным фрэймворком или технологии,
* Мы вообще можем не иметь доступ к исходному коду сервиса, но можем получить в том числе машиночитаемую документацию и использовать все её преимущества.
В данном примере для документирования API будет использована спецификация [Swagger](http://swagger.io/), пропущу общее описание данного инструмента, так как таких обзоров достаточно. Но отмечу, что это машиночитаемая документация, позволяющая генерировать как уже человеческую документацию, так и шаблоны серверного и клиентского кода для работы с описанным API.
На просторах сети были найдены руби гемы [rspec-rails-swagger](https://github.com/drewish/rspec-rails-swagger) и [rswag](https://github.com/domaindrivendev/rswag). Оба к сожалению имеют хоть и минимальную, но привязку к rails. Гемы имеют вполне подробную документацию с примерами и достаточно простой код. В качестве эксперимента я отвязал [гем rspec-rails-swagger от Rails](https://github.com/ZurgInq/rspec-rails-swagger/commit/9051854340780d9b9a60811f2f8d230cc99ef570) и подключил к существующим функциональным тестам.
Описание теста для генерации документации к методу выглядит следующим образом:
```
describe 'swagger_docs' do
let(:movies_resp_body) { File.read('spec/fixtures/movies.json') }
path '/movies' do
operation "GET", summary: "respond 200 OK" do
parameter :rating, in: :query, type: :string, required: false, description: "filter by rating"
response 200, description: "successful" do
schema(
type: :array,
items: {
type: :string,
}
)
end
end
end
end
```
Данный код запускает тесты на исполнение и используют расширение синтаксиса Rspec для указания мета информации которая будет использована при генерации swagger файла.
Запускаем rspec через длинную команду:
```
bundle exec rspec -f RSpec::Rails::Swagger::Formatter --order defined -t swagger_object
```
Флаг -t фильтрует запускаемые тесты только теми, которые используют специальный синтаксис гема. Флаг -f подключает «форматтер» для вывода результат в виде swagger json файла.
Выхлоп команды выдаст валидный swagger файл который можно загрузить в swagger-ui или попробовать использовать для генерации клиента к API.
В конечном итоге мы имеем функциональные тесты на фрэймворке Rspec, попутно сгенерировав swagger документацию, из которой можно быстро получить болванку API клиента для любого другого языка программирования. [Полный листинг примера](https://github.com/ZurgInq/rspec-tutorial).
Резюмируя:
* Автоматическая документация гарантирует некоторое минимальное совпадение ваших ожиданий от API и суровой изменчивой реальности.
* В некоторых случаях разработчик физически вынужден вначале описать методы API и только потом их реализацию (протоколы GRPC, Apache Thrift).
* Автоматически сгенерированная машиночитаемая документация может упростить жизнь как на этапе разработки, так и на этапе поддержки и работы с API.
* Используя специальные инструменты можно генерировать машиночитаемую документацию не внося изменения в исходный код. | https://habr.com/ru/post/351660/ | null | ru | null |
# Тонкости реализации кода библиотеки. Часть вторая
 В [предыдущей части](http://habrahabr.ru/blogs/cpp/138085/) был приведен способ, с помощью которого, можно сократить количество кода при использовании классов-помощников и классов из других пространств имен.
В данной статье речь пойдет о том, как можно реализовать размещение элементов библиотеки по файлам. Также будут затронуты вопросы подключения элементов библиотеки в пользовательском коде, и, конечно же, как «рабочие» пространства имен могут помочь в реализации библиотеки.
#### Подходы, применяемые при организации файлов библиотеки
Для начала определимся, что речь пойдет о библиотеках, весь код которых поставляется в виде заголовочных файлов. При создании структуры файлов в таких библиотеках придерживаются ряда правил. Не все из них можно назвать «стандартными», но применение представленных правил в существующих библиотеках не такое и редкое явление.
1) *Заголовочные файлы библиотеки обычно размещают в отдельной папке*.
Название папки содержит имя библиотеки или пространства имен, используемого в библиотеке. Это позволяет в пользовательском коде «документировать» использование библиотеки:
```
#include
#include
```
2) *Файлы, содержащие «пользовательские» типы, и файлы, предоставляющие детали реализации, желательно размещать в разных папках*.
Под «пользовательскими» типами понимаются типы, определяемые библиотекой и предоставляемые пользователю для использования в своем коде.
Применение данного правила со стороны разработчика библиотеки позволяет пользователю библиотеки легко определить файлы, которые ему необходимы для включения в своем проекте без чтения сопутствующей документации.
Для примера, некоторые библиотеки *boost* размещают файлы реализации во вложенной папке *detail*.
3) *Для каждого класса библиотеки нередко создается отдельный файл с одноименным названием*.
Такой подход позволяет пользователю библиотеки легко разобраться в ее структуре, а разработчику предоставляет простоту навигации по классам в своей библиотеке.
4) *Файлы библиотеки должны быть самодостаточными*.
В основном, это касается тех файлов, в которых определяются «пользовательские» типы и которые пользователь библиотеки подключает в своей программе или другой библиотеке посредством *#include*.
Подробней об этом правиле можно почитать в книге «Стандарты программирования на C++» Г.Саттера и А.Александреску (правило 23).
#### Описание тестовой библиотеки
Далее предположим, что нам необходимо реализовать некоторую библиотеку *SomeLib*. Эта библиотека должна предоставлять пользователю классы *A\_1*, *A\_2* и *A\_3*, реализующие некоторый функционал. Зеленой областью на рисунке представлена сама библиотека, красной — пространство имен, а синими — классы, предоставляемые пользователю.
Пусть библиотека *SomeLib* имеет зависимость от библиотеки *STL* и содержит «невидимые» пользователю вспомогательные классы *I\_1* и *I\_2*, которые на рисунке представлены оранжевым цветом. Стрелками указаны зависимости классов от других. Например, класс *A\_1* зависит от классов *list*, *vector* и *I\_1*. Под зависимостями класса в данном случае понимается использование им других классов при описании своих данных, функций-членов или реализации этих функций.
Предположим, что библиотека поставляется в виде заголовочных файлов и в качестве одного из файлов содержит *config.hpp*, описывающий некоторые «управляющие» структуры.
И так начнем…
#### Реализация тестовой библиотеки с использованием представленных правил
При реализации библиотеки воспользуемся стандартным подходом, описанным в предыдущей части. Пользовательские классы будем размещать в пространстве имен библиотеки *some\_lib*, а служебные классы во вложенном пространстве имен *impl*.
Библиотека будет размещаться в папке *some\_lib*. В этой папке будут файлы *A\_\*.hpp*, описывающие «пользовательские» типы. Файлы *I\_\*.hpp*, содержащие служебные классы, будем размещать во вложенной папке *impl*.
Теперь можно приступить к реализации. Пропустим описание процесса кодирования и сразу перейдем к результатам.
Файл *some\_lib/impl/config.hpp*
```
#ifndef SOME_LIB__IMPL__CONFIG_HPP
#define SOME_LIB__IMPL__CONFIG_HPP
#if defined(_MSC_VER)
//...
#elif defined(__GNUC__)
//...
#else
//...
#endif
#endif
```
Файл *some\_lib/impl/I\_1.hpp*
```
#ifndef SOME_LIB__IMPL__I_1_HPP
#define SOME_LIB__IMPL__I_1_HPP
#include
#include
namespace some\_lib {
namespace impl
{
class I\_1
{
public:
void func( std::vector const& );
private:
// члены-данные
};
}}
#endif
```
Файл *some\_lib/impl/I\_2.hpp*
```
#ifndef SOME_LIB__IMPL__I_2_HPP
#define SOME_LIB__IMPL__I_2_HPP
#include
#include
namespace some\_lib {
namespace impl
{
class I\_2
{
public:
// интерфейс
private:
std::vector data\_;
};
}}
#endif
```
Файл *some\_lib/A\_1.hpp*
```
#ifndef SOME_LIB__A_1_HPP
#define SOME_LIB__A_1_HPP
#include
#include
#include
#include
namespace some\_lib
{
class A\_1
{
public:
// интерфейс
private:
impl::I\_1 a\_;
std::list data\_;
std::vector another\_data\_;
};
}
#endif
```
Файл *some\_lib/A\_2.hpp*
```
#ifndef SOME_LIB__A_2_HPP
#define SOME_LIB__A_2_HPP
#include
#include
#include
namespace some\_lib
{
class A\_2
{
public:
A\_2( std::string const& );
private:
impl::I\_2 a\_;
};
}
#endif
```
Файл *some\_lib/A\_3.hpp*
```
#ifndef SOME_LIB__A_3_HPP
#define SOME_LIB__A_3_HPP
#include
#include
#include
#include
namespace some\_lib
{
class A\_3
{
public:
A\_3( std::string const& );
void func( A\_2& );
private:
impl::I\_2 a\_;
std::string name\_;
};
}
#endif
```
Пользователь теперь может использовать нашу библиотеку, подключив один или несколько заголовочных файлов.
```
#include
#include
#include
```
#### Замечания по реализации тестовой библиотеки
Для незначительного сокращения кода вместо стандартно применяемых «стражей» включения и реализующихся через *#ifndef*, *#define*, *#endif*, в заголовочных файлах можно использовать *#pragma once*. Но данный способ работает не на всех компиляторах и, поэтому, не всегда применим.
Наша библиотека содержит относительно простую схему связей между элементами. Во что выливается разработчику библиотеки реализация более сложных зависимостей представить нетрудно.
Стоит отметить еще один интересный момент. При включении только одного заголовочного файла *some\_lib/A\_3.hpp* пользователь фактически подключает больше половины библиотеки (если быть более точным, то 4/6 исходных файлов).
А если теперь задаться вопросом: действительно ли, так необходимо реализовывать для пользователя библиотеки возможность подключения отдельных ее элементов?
Основным аргументом в пользу ответа «Да» будет то, что данный подход позволит сократить время компиляции при подключении отдельных элементов по сравнению с временем компиляции при полном включении всех элементов библиотеки. Если связей между элементами библиотеки почти нет (не наш случай), то это действительно так. А если связей немало — ответ неоднозначный. При обдумывании ответа стоит вспомнить о том, что «стражи» включения и директивы *#include* на этапе обработки исходных файлов препроцессором в ходе компиляции имеют ненулевые временные издержки.
Предположим, что ответ на этот вопрос «Нет». Вот здесь-то и начинается самое интересное…
#### Реализация тестовой библиотеки, использующей единственную точку подключения
Пользователю для подключения библиотеки теперь необходима всего одна строчка кода:
```
#include
```
Теперь остановимся на моментах реализации, которые может применить разработчик библиотеки:
1) Поскольку имеется только одна точка подключения библиотеки (файл *some\_lib/include.hpp*), разработчик библиотеки может избавиться от всех «стражей» включения, кроме одного — в файле подключения всей библиотеки.
2) Каждый файл «пользовательского» класса или класса-элемента реализации теперь не обязан содержать включения файлов, содержащих зависимые элементы.
3) Применение «рабочих» пространств имен позволяет избавиться от задания пространств имен в каждом файле.
Поскольку файл для подключения библиотеки пользователем только один, то можно пересмотреть структуру файлов библиотеки.
Реализация библиотеки теперь может выглядеть следующим образом:
Файл *some\_lib/include.hpp*
```
#ifndef SOME_LIB__INCLUDE_HPP
#define SOME_LIB__INCLUDE_HPP
#include
#include
#include
#include
namespace z\_some\_lib
{
using namespace std;
// или
// using std::list;
// using std::vector;
// using std::string;
#include
#include
#include
#include
#include
}
namespace some\_lib
{
using z\_some\_lib::A\_1;
using z\_some\_lib::A\_2;
using z\_some\_lib::A\_3;
}
#endif
```
Файл *some\_lib/private/config.hpp*
```
#if defined(_MSC_VER)
//...
#elif defined(__GNUC__)
//...
#else
//...
#endif
```
Файл *some\_lib/private/I\_1.hpp*
```
class I_1
{
public:
void func( vector const& );
private:
// члены-данные
};
```
Файл *some\_lib/private/I\_2.hpp*
```
class I_2
{
public:
// интерфейс
private:
vector data\_;
};
```
Файл *some\_lib/public/A\_1.hpp*
```
class A_1
{
public:
// интерфейс
private:
I_1 a_;
list data\_;
vector another\_data\_;
};
```
Файл *some\_lib/public/A\_2.hpp*
```
class A_2
{
public:
A_2( string const& );
private:
I_2 a_;
};
```
Файл *some\_lib/public/A\_3.hpp*
```
class A_3
{
public:
A_3( string const& );
void func( A_2& );
private:
I_2 a_;
string name_;
};
```
#### Заключение
Описывать достоинства и недостатки представленного подхода к реализации, думаю, нет смысла — код сам говорит за себя. Каждый разработчик самостоятельно решит какую схему при реализации кода библиотеки он для себя выберет, взвесив при этом все «за» и «против».
А если внимательно присмотреться к представленной схеме, то есть ощущение чего-то знакомого. Но об этом не сейчас… | https://habr.com/ru/post/138438/ | null | ru | null |
# Поиск на Drupal 7 с помощью Apache Solr ч.7 — полнотекстовый поиск на русском языке
Наконец-то собрался и написал очередную статью из этого цикла. Теперь я расскажу о том, как сделать хороший полнотекстовый поиск на русском языке для Drupal на Apache Solr.
* [Поиск на Drupal 7 с помощью Apache Solr ч.1 — базовая настройка](http://habrahabr.ru/post/175527/)
* [Поиск на Drupal 7 с помощью Apache Solr ч.2 — учимся настраивать индекс](http://habrahabr.ru/post/177509/)
* [Поиск на Drupal 7 с помощью Apache Solr ч.3 — учимся добавлять собственные поля и опции в индекс](http://habrahabr.ru/post/178285/)
* [Поиск на Drupal 7 с помощью Apache Solr ч.4 — фасетные фильтры](http://habrahabr.ru/post/180083/)
* [Поиск на Drupal 7 с помощью Apache Solr ч.5 — виджеты для фасетных фильтров](http://habrahabr.ru/post/182820/)
* [Поиск на Drupal 7 с помощью Apache Solr ч.6 — настраиваем apache solr + tomcat](http://habrahabr.ru/post/189840/)
* Поиск на Drupal 7 с помощью Apache Solr ч.7 — полнотекстовый поиск на русском языке
В принципе этот материал применим к любому языку, но по понятным причинам я выбрал русский. В конце первой статьи из этого цикла, я писал о том, как улучшить поиск на русском языке. Этот способ простой, но не очень действенный. Максимум на что он способен по умолчанию, это работать с окончанием слова. Рассмотрим простой пример. Слово «климатических» находится по слову климатический.
Но уже для слова климат результатов не будет.
Для того, чтобы сделать поиск более гибким, подключим дополнительный словарь. Я использовал класс HunspellStemFilterFactory для стемминга.
Скачиваем словари для русского языка отсюда — [download.services.openoffice.org/files/contrib/dictionaries/ru\_RU-pack.zip](http://download.services.openoffice.org/files/contrib/dictionaries/ru_RU-pack.zip)
Нам нужны два файла — ru\_RU.aff и ru\_RU.dic. Их необходимо сконвертировать в utf-8, иначе apache solr не будет с ними работать.
Изначально я пытался поменять им кодировку через iconv, но solr с ними так и не заработал.
В итоге я пересохранил файлы в UTF-8 через Krusader — после этого все работало отлично.
После того как вы сконвертируете файлы, их нужно положить в ту же папку солра, где лежит schema.xml
Теперь в схеме (schema.xml) указываем, что мы собираемся использовать HunspellStemFilterFactory и наши словари:
```
```
```
...
...
...
...
```
Помимо этого после определения HunspellStemFilterFactory в анализаторе для индекса добавим настройки для того, чтобы разбивать слова на части (граммы). Это сделает поиск более гибким
```
```
Если у вас был включен фильтр Портера
```
```
не забудьте его закоментировать.
Теперь перезагружаем солр и переиндексируем контент. Можно увидеть, что поиск работает намного лучше! Вот пара примеров:
Тоже самое можно делать и со словарями других языков. Полный список словарей — [download.services.openoffice.org/files/contrib/dictionaries](http://download.services.openoffice.org/files/contrib/dictionaries/)
Помимо того, чтобы просто использовать готовые словари, вы можете также создать свое правило.
Я заметил, что в русском словаре для солра, нет слова «вомбат» и решил его добавить. Для этого сперва заходим в файл ru\_RU.aff и ищем подходящее окончание. Слово «вомбат» имеет нулевое окончание и ему подходит следующее правило:
SFX K 0 а [^ейоь]
SFX K 0 у [^ейоь]
SFX K 0 ом [^ежйоцчшщь]
SFX K 0 е [^ейоь]
SFX K 0 ы [^гежйкохчшщь]
SFX K 0 и [гжкхчшщ]
SFX K 0 ей [жчшщ]
SFX K 0 ов [^ежйоцчшщь]
SFX K 0 ам [^ейоь]
SFX K 0 ами [^ейоь]
SFX K 0 ах [^ейоь]
вомбатА, вомбатУ… вомбатАХ.
Код этого окончания — K.
Теперь открываем файл ru\_RU.dic и добавляем новое слово с соответствующим кодом
Код будет описывать каким образом изменяется слово. Разумеется на скриншоте лишь пример и следовало бы вставлять новое слово в алфавитном порядке.
Перезагружаем солр, переиндексируем контент и смотрим результаты
Напоминаю что я использую apachesolr 3.6.1 (это не принципиально, но я сталкивался с тем, что на некоторых версиях иногда не работает то или иное, зачастую проблема кроется в особенностях построения запросов к солру через search api либо в описании schema.xml и config.xml).
На всякий случай прикрепляю свою [схему](http://www.badscript.net/storage/schema.xml), если у вас что то не получается, попробуйте использовать ее. | https://habr.com/ru/post/213085/ | null | ru | null |
# Высокоуровневый С или пару слов о Cello
[Cello](http://libcello.org/) — это библиотека, которая сделала высокоуровневый C возможным! Обобщения (generics), параметрический полиморфизм, интерфейсы, конструкторы/деструкторы, сборщик мусора (по желанию), исключения и рефлекция. Да-да, ты не ослышался, все эти плюхи в одном флаконе. Так как Cello построен в пределах стандарта С, в сухом остатке ты получишь все, что нужно живому человеку на земле: высокую производительность, мощный инструментарий и гибкие библиотеки.
Talk is cheap, show me the code!
```
#include "Cello.h"
int main(int argc, char** argv) {
/* Stack objects are created using "$" */
var i0 = $(Int, 5);
var i2 = $(Int, 3);
var i2 = $(Int, 4);
/* Heap objects are created using "new" */
var items = new(Array, Int, i0, i1, i2);
/* Collections can be looped over */
foreach (item in items) {
print("Object %$ is of type %$\n",
item, type_of(item));
}
/* Heap objects destructed via Garbage Collection */
return 0;
}
```
ШОК! Зачем же мне теперь все эти ваши Go/D/Nim/<впиши>, если С на стероидах решает все проблемы рода человеческого?! Хочешь узнать о готовности Cello к продакшну и увидеть **еще больше кода**? Добро пожаловать подкат.
#### Вводная
Cello добавляет поверх С дополнительный слой рантайма. Это абсолютная необходимость, потому что иначе расширить язык было бы возможно только меняя компилятор, а такую роскошь мы себе позволить не можем. Пользователь определяет *типопеременные* (runtime type variables), которые содержат всю необходимую информацию для нового функционала, связывая их с обычными легитимными типами.
Оверхед у GC в Cello конечно же, есть. Указатели в Cello сопровождаются дополнительной мета-информацией, которая хранится прямо перед данными. Это говорит о том, что указатели в Cello полностью совместимы с рабоче-крестьянскими указателями из Стандарта и могут без труда кооперироваться.
Вся информация о типах в большей мере является всего лишь списком экземпляров *типоклассов* и *интерфейсов*. Эти ребята себя очень хорошо зарекомендовали, поэтому они используются везде: начиная от GC, заканчивая документацией. Они позволяют использовать объекты в контексте их *поведения*. Это прикольно, потому что можно писать алгоритмы в обобщенной манере, опираясь только на вводные данные, но не на реальную реализацию той или иной структуры.
Cello, в принципе, довольно умен и может автоматически выводить поведения (behaviours) в большинстве случаев. Объекты в Cello можно печатать, сравнивать, хэшировать, сериализировать, сортировать копировать и вот это все. Короче говоря, райское наслаждение.
#### Объекты
Объекты в Cello начинаются с обыкновенных рабоче-крестьянских структур, которые ты так хорошо знаешь из С. Чуть позже Cello добавит в них немного мета-информации. Тут есть одно требование: определять структуры нужно **без** `typedef`. Например, давайте напишем структуру для хранения какой-то картинки, да на стероидах! Для этого нужно определить обыкновенную сишную структуру и зарегистрировать новополученный тип при помощи макроса `Cello`:
```
struct Image {
uint64_t width;
uint64_t height;
unsigned char *data;
};
var Image = Cello(Image);
```
Обрати внимание, у нас появились две штуки. Оригинальный сишный тип `Image` и переменная, которая представляет тип в рантайме. По воле случая, мы тоже ее назвали `Image`. Ты скорее всего обратил внимание на этого подозрительного товарища по имени `var`. На самом деле `var` это всего лишь `void*`, тоесть *обобщенный указатель*, но стоит использовать первый вариант, для удобства.
В контексте базовых типов, это все. Больше ничего не нужно писать, за тебя все сделает компилятор. Теперь можно создавать переменные типа `Image`: что на стэке, что на куче. Помимо всего прочего, их можно напечатать, сравнить, закинуть в коллекцию и вот это все:
```
/* Allocate on Stack or Heap */
struct Image* x = $(Image, 0, 0, NULL);
struct Image* y = new(Image);
/* Print */
print("This is an image: %$\n", x);
/* Compare */
print("Images %$ and %$ are equal? %s\n",
x, y, eq(x, y) ? $S("Yes") : $S("No"));
/* Put in an Array */
struct Array* a = new(Array, Image, x, y);
print("Array of Images: %$\n", a);
```
В действительности, почти все основные типоклассы в Cello, по умолчанию, с реализацией. Но настоящая сила Cello проявляется тогда, когда мы начинаем расширять реализацию этих типоклассов.
#### Конструкторы и деструкторы
Наша сишная структура, `Image`, содержит указатель на какой-то участок памяти, который может быть выделен какой-то другой функцией. Если ты хочешь избежать утечек, надо убедиться, что мы вовремя эту память освобождаем. Теперь воспользуемся Cello, чтобы определить деструктор для `Image`:
```
void Image_Del(var self) {
struct Image* i = self;
free(i->data);
}
```
Ты можешь с легкостью привести аргумент `self` к сишному типу `Image*`. Это возможно, потому что указатели Cello (те, которые мы создаем с `var`) полностью совместимы с рабоче-крестьянскими указателями в С. Так как у тебя есть `var`-указатель из Cello, ты знаешь, что на нем висит опредленный сишный тип (прямо как здесь, в деструкторе), а значит, что можно абсолютно безопасно привести его к этому типу и разумеется, получить доступ к полям этого типа. В конкретно этом случае, мы вызываем `free` для указателя на данные из `Image`.
Чтобы зарегистрировать деструктор в Cello, ты захочешь передать его в макрос `Cello`, как экземпляр `Instance` нового типокласса `New`. Так как мы пока не хотим определять конструктор, то стоит просто передать `NULL` в соотв. поле:
```
var Image = Cello(Image, Instance(New, NULL, Image_Del));
```
Теперь, когда GC в Cello придет, чтобы разобраться с объектом `Image`, он вызовет наш деструктор. А чего, по-моему, круто!
#### Cахар, сахар, сахар
Daniel Holden написал Cello, чтобы местами упростить свою работу, так что тут хватает разнообразного сахара. Например, сокращенный синтаксис создания переменных или даже таблицы (sic!):
```
#include "Cello.h"
int main(int argc, char** argv) {
/* Shorthand $ can be used for basic types */
var prices = new(Table, String, Int);
set(prices, $S("Apple"), $I(12));
set(prices, $S("Banana"), $I( 6));
set(prices, $S("Pear"), $I(55));
/* Tables also support iteration */
foreach (key in prices) {
var val = get(prices, key);
print("Price of %$ is %$\n", key, val);
}
return 0;
}
```
Или замысловатые range-циклы и прочие слайсы:
```
#include "Cello.h"
int main(int argc, char** argv) {
var items = new(Array, Int,
$I( 8), $I( 5), $I(20),
$I(15), $I(16), $I(98));
/* Iterate over indices using "range" */
foreach (i in range($I(len(items)))) {
print("Item Range %i is %i\n", i, get(items, i));
}
/* Iterate over every other item with "slice" */
foreach (item in slice(items, _, _, $I(2))) {
print("Item Slice %i\n", item);
}
return 0;
}
```
#### И это еще далеко не все...
На самом деле, возможности Cello не заканчиваются на приведенном мною в этой статье функционале, но это не беда, ведь с остальными штуками вы сможете ознакомиться с помощью [документации](http://libcello.org/learn). Кстати говоря, у Cello есть классный [Quickstart](http://libcello.org/learn/quickstart), в котором автор покажет, как написать програму, которая интересным образом глитчует .tga-изображения. Настоятельно рекомендую ознакомиться!
Отвечая на вопрос, готов ли Cello к продакшну… тут нет однозначного ответа. Си, в основном, используется там, где нужна прямо таки maxxxимальная производительность — например, во встраиваемых системах. Захотят ли разработчики подобного софта тянуть за собой GC — это очень спорный вопрос и я склонен к отрицательному ответу. С другой стороны, над Cello довольно долгое время экспериментировали, так что в принципе, это штука рабочая. Я думаю, что фуллтайм С-программисты однозначно должны заценить.
Для тех, кому интересно, как эта шняшка устроена внутри, ссылочка на [гитхаб](https://github.com/orangeduck/Cello). Помимо всего прочего, я также хотел бы сделать небольшой опрос по теме поста. Прошу отвечать на него только разработчиков, которые реально работают с языком С, остальных хочу попросить воздержаться. | https://habr.com/ru/post/262471/ | null | ru | null |
# Как появилась на свет программа youtube-dl
Как известно, в данный момент [репозиторий youtube-dl на GitHub](https://github.com/ytdl-org/youtube-dl) заблокирован по [DMCA-запросу](https://github.com/github/dmca/blob/master/2020/10/2020-10-23-RIAA.md) от RIAA. Хотя я не могу комментировать текущие планы мейнтейнеров или текущие дискуссии, но после сделанных обвинений RIAA я подумал, что мне как создателю программы и первому мейнтейнеру будет полезно рассказать о первых годах youtube-dl.
### Сборщики меди
В любой хорошей истории должен быть злодей, и в качестве такого персонажа я решил выбрать сборщиков меди — воришек, которые собирали цветные металлы в округе. Именно они подтолкнули к созданию youtube-dl. В далёком 2006 году мой посёлок находился в 5-10 километрах от небольшого города [Авилес](https://en.wikipedia.org/wiki/Avil%C3%A9s) на севере Испании. Жители Авилеса наслаждались хорошей инфраструктурой и услугами, включая кабельное телевидение и ADSL-доступ в интернет. В моём районе ничего такого не было: слишком далеко от телефонной станции с ADSL, а сборщики меди годами воровали медные провода по пути к ней, время от времени вызывая перебои в телефонной связи и заставляя телефонную компанию заменять эти провода более слабыми и тонкими, потому что их тоже, скорее всего, украдут. Это продолжалось несколько лет.
Единственным вариантом выхода в интернет из дома был [модем 56k V.90](https://en.wikipedia.org/wiki/Modem#Standardized_56k_(V.90/V.92)). На самом деле качество связи было настолько плохим, что приходилось для стабильности снижать скорость до 33,6 Кбит/с. Фактическая скорость загрузки редко превышала 4 КБ/с. В то же время в интернете появился интересный видеосервис YouTube, он быстро набирал популярность, а в конце того же года его купила компания Google.
### Не спать всю ночь, чтобы посмотреть кусочек
Просмотр любого видео на YouTube по соединению 33,6 Кбит/с был мучительным опытом. Практически любое видео загружалось целую вечность. Например, загрузка короткого 10-мегабайтного видео, если посчитать, занимает 40 минут, что делает потоковую передачу невозможной. Более длинное и качественное видео требует несколько часов и полностью занимает канал, не говоря уже о том, что соединение может в любой момент прерваться — и загрузку придётся начинать заново! А представьте, что вам очень понравилось конкретное видео и вы хотите посмотреть его во второй или третий раз. Повторение этого процесса становилось практически актом мазохизма.
В такой ситуации я начал думать о возможностях загрузки видеофайлов: если видео было интересным, наличие копии позволяет пересмотреть его впоследствии несколько раз. А если программа загрузки действительно хороша, то после прерванного соединения сможет возобновлять загрузку с того же места!
В то время существовали и другие решения для загрузки видео с YouTube, в том числе довольно популярный скрипт [Greasemonkey](https://addons.mozilla.org/en-US/firefox/addon/greasemonkey/). По чистой случайности я не смог настроить для работы ни одно из существующих решений, поэтому решил написать собственный инструмент. Примерно так появилась программа youtube-dl. Мне было удобнее и быстрее запускать её из консоли, поэтому графический интерфейс не предусмотрен. Выбор Python обусловлен наличием обширной стандартной библиотеки, с приятным побочным эффектом, что она будет работать на любой платформе.
### Запуск Ethereal
Первая версия работала только на YouTube. У программы практически не было никакой нормальной архитектуры, потому что она была не нужна. Написанная как простой скрипт, она шла прямо к сути. Размер программы 223 строки, причём только 143 фактически кода, 44 строки комментариев и 36 пустые. Название выбрано из чистого удобства: youtube-dl очевидно, понятно, трудно забыть и можно интуитивно ввести как “Y-O-U-TAB” в консоли.
Поскольку я уже несколько лет пользовался Linux, то решил опубликовать программу под свободной лицензией (MIT в первых версиях) на случай, если кто-то найдёт её полезной. Тогда GitHub ещё не появился и нам приходилось обходиться [SourceForge](https://en.wikipedia.org/wiki/SourceForge). Но там при создании нового проекта следовало заполнять утомительную форму. Поэтому вместо SourceForge я по-быстрому выложил код на [личной страничке](https://web.archive.org/web/20060812055952/http://www.arrakis.es/~rggi3/youtube-dl/), которую давал интернет-провайдер. Хотя сегодня это кажется необычным, но в то время провайдеры обычно выдавали пользователям адрес электронной почты и немного хостинга, куда можно было загрузить файлы по FTP. Таким образом, вы могли поднять собственный личный сайт в сети. Первая версия программы опубликована 08.08.2006, хотя к тому времени я уже несколько недель использовал её.
В процессе разработки нужно было понять операции браузера Firefox при просмотре видео на YouTube. Если я правильно помню, в Firefox ещё не встроили инструменты разработки для анализа сетевой активности. Соединения шли в основном по HTTP, так что неоценимым инструментом для анализа сетевого трафика стала программа Wireshark, известная в то время как Ethereal. Я написал youtube-dl с конкретной целью сделать то же самое, что делал веб-браузер при извлечении видео. Программа даже отправляла такую же строку user-agent, дословно скопированную из Firefox для Linux, чтобы убедиться, что сайт отправит программе те же веб-страницы, что и браузеру.
Кроме того, тогда YouTube использовал плеер [Adobe Flash](https://en.wikipedia.org/wiki/Adobe_Flash). Видео подавались в виде флэш-видеофайлов (FLV), поэтому для просмотра в браузере требовался проприетарный плагин (многие вспомнят страшную библиотеку libflashplayer.so), поэтому любые инструменты разработки в браузере были бесполезными. Этот проприетарный плагин являлся постоянным источником уязвимостей безопасности и проблем. У меня стояло расширение Firefox под названием Flashblock, которое не позволяло контенту загружаться по умолчанию и заменяло его элементами-заполнителями с кликабельным значком, поэтому контент загружался только по запросу, а библиотека плагинов не использовалась, если пользователь её не запрашивал.
Кроме повышения безопасности, у Flashblock было ещё два преимущества. Во-первых, он удалял много шумных и неприятных баннеров, которые тоже могли стать источником проблем безопасности. Во-вторых, облегчал анализ процесса загрузки видео в плеер. Я ждал, пока страница полностью загрузится, а затем уже запускал Wireshark непосредственно перед тем, как нажать на значок Flashblock, запуская загрузку видео. Таким образом, единственный трафик для анализа был связан с плагином, загружающим приложение видеоплеера, и самим приложением, загружающим видео.
Стоит также отметить, что плагин Flash Player в то время [уже загружал копию видео на жёсткий диск](https://www.nirsoft.net/articles/copy_flash_flv_temp_file.html) (под Linux они хранились в `/tmp`), и многие пользователи полагались на эту функциональность, чтобы сделать копию без дополнительных инструментов. Так что youtube-dl был удобнее только потому, что извлекал название видео и присваивал его файлу в автоматическом режиме, например.
### О, свежее мясо!
В конечном итоге Flash Player [изменили, так что видео стало труднее извлекать](https://www.omgubuntu.co.uk/2010/09/saving-flash-videos-in-linux-tmp-no-longer-works). Одной из первых мер было разорвать связь с видеофайлом после его создания, чтобы i-node всё ещё существовал и был доступен использующему его процессу (до тех пор, пока не будет закрыт), сохраняя файл невидимым с точки зрения файловой системы. По-прежнему можно было захватить файл с помощью файловой системы `/proc` для изучения файловых дескрипторов, используемых процессом браузера, но с каждым из этих небольших шагов youtube-dl становился всё более и более удобным.
Как и многие энтузиасты опенсорса в то время, я использовал Freshmeat для подписки на новые выпуски проектов, которые меня интересовали. Когда я создавал youtube-dl, я также создал запись проекта на этом веб-сайте, чтобы пользователи могли получать уведомления о новых выпусках и журнал изменений с перечислением новых функций, исправлений и улучшений. В каталоге Freshmeat можно было искать новые и интересные проекты, на первой странице публиковались последние обновления, обычно несколько десятков в день. Предполагаю, что именно таким способом [Джо Барр](https://en.wikipedia.org/wiki/Joe_Barr) (покойся с миром), редактор [linux.com](https://en.wikipedia.org/wiki/Linux.com), узнал о программе и решил написать о ней [статью](https://www.linux.com/news/cli-magic-enhance-your-youtube-viewing-pleasure/) ещё в 2006 году. В то время Linux.com был одним из самых популярных ресурсов для энтузиастов Linux вместе с другими классическими сайтами, такими как Slashdot или Linux Weekly News. По крайней мере, для меня.
С этого момента популярность youtube-dl начала расти, а мне время от времени стали приходить письма с благодарностями за создание и поддержку программы.
### Подсчёт трафика
Перенесёмся в 2008 год. Популярность youtube-dl продолжала медленно расти, и пользователи часто просили сделать подобные программы для загрузки с других сайтов, и я несколько раз уступал этой просьбе. Именно в этот момент я решил переписать программу с нуля, чтобы внедрить изначальную поддержку нескольких видеосайтов. У меня имелось несколько простых идей, как разделить внутренности программы на несколько частей, чтобы упростить наиболее важные части: отдельно загрузчик файлов, общий для всех веб-сайтов, а отдельно — экстракторы информации: объекты (классы), которые содержат код, специфичный для конкретного видеосайта. Когда задаётся URL или псевдо-URL, запрашиваются экстракторы, чтобы узнать, какой из них может обработать этот тип URL, а затем запрашивается извлечение информации об этом видео или списке видео, с основной целью получения URL видео или списка URL-адресов с доступными форматами, а также некоторых других метаданных, таких как заголовки, например.
Я также воспользовался возможностью сменить систему контроля версий и перенести проект на другой хостинг. В тот момент Git выигрывал войну распределённых систем управления версиями, но у Mercurial тоже было много пользователей. Я протестировал оба и решил, что Mercurial нравится немного больше, чем Git. Я начал использовать его для youtube-dl и разместил проект на [Bitbucket](https://en.wikipedia.org/wiki/Bitbucket), что было естественным выбором. В то время на Bitbucket размещались только репозитории Mercurial, а на GitHub — только Git. Оба запустились в 2008 году и стали глотком свежего воздуха по сравнению с SourceForge. Разные пространства имён проектов для каждого пользователя (то есть имя вашего проекта не обязательно должно быть глобально уникальным, а уникальным только для ваших проектов) с распределёнными системами управления версиями означало, что вы можете публиковать свои личные проекты в течение нескольких минут на любом из двух сайтов. В любом случае, перенос истории проекта в Git и перенос проекта на GitHub [последовали через пару лет](https://rg3.name/201011061013.html).
При переписывании проекта мне, без сомнения, следовало воспользоваться возможностью и переименовать его, но я не хотел смущать существующих пользователей и оставил название в попытке сохранить небольшую популярность программы.
Технологический контекст также немного изменился в тот год. Начали набирать обороты мобильные планы с передачей данных, и в конце того же года я купил себе 3G-модем и тарифный план, который впервые позволил мне просматривать веб-страницы на приличной скорости. В любом случае, это не заставило меня прекратить использовать youtube-dl. Я платил 45 евро в месяц, но ежемесячный лимит данных был ограничен 5 ГБ, то есть я мог использовать в среднем только около 150 МБ в день. А скорость позволяла скачать гораздо больше, так что приходилось следить за трафиком и избирательно выбирать контент, избегая больших загрузок, если это возможно. Поэтому youtube-dl очень помог предотвратить многократную загрузку больших видеофайлов и не выйти за пределы тарифного плана.
### Эпизод: новый дом
Некоторое время спустя, в конце 2009 года, я переехал и, наконец, начал жить со своей девушкой (теперь моей женой и матерью двоих детей) в Авилесе. Впервые у меня появился высокоскоростной интернет, который был стандартом для многих моих друзей и семьи в течение многих лет. Помню, что это было кабельное соединение 100/10 Мбит/с (скачивание/отдача) без ограничения трафика. Это определённо знаменовало поворотный момент в том, как часто я использовал youtube-dl и сколько внимания уделял проекту.
Чуть позже я, наконец, перенёс код в Git и GitHub. В то время YouTube начал экспериментировать с видео HTML5, которое станет вариантом по умолчанию примерно в 2015 году. В 2011 году я уже несколько лет как работал полный рабочий день в качестве инженера-программиста, и в целом по возвращении с работы мне не очень хотелось программировать и настраивать youtube-dl или реализовывать по просьбе пользователей функции, который я сам не собирался использовать лично.
Во второй половине 2011 года в разгаре другого важного проекта я решил уйти с поста мейнтейнера youtube-dl, поскольку уже несколько месяцев не справлялся с задачей. [Филипп Хагемейстер](https://phihag.de/) показал себя как отличный программист, и он прислал несколько пул-реквестов на GitHub с исправлениями, которые интересовали многих людей. Я дал ему доступ на коммиты к моему репозиторию youtube-dl, и по сути это был конец истории с моей стороны. Логи основной ветки показывают у меня непрерывный поток коммитов до марта 2011 года, а затем скачок на август 2011 года с мерджем от Филиппа. С тех пор я сделал единственный коммит в 2013 году для изменения в исходном коде *rg3.github.com* на *rg3.github.io*, когда GitHub перемещал пользовательские страницы с *USERNAME.github.com* на *USERNAME.github.io*, чтобы избежать проблем безопасности с вредоносным кодом на собственном домене, если я правильно помню.
Хотя я не участвовал в разработке youtube-dl, в течение многих лет официальная страница проекта по-прежнему лежала под моим аккаунтом на `https://github.com/rg3/youtube-dl` и `https://rg3.github.io/youtube-dl/`. Мне нужно было появляться, когда Филипп или другие мейнтейнеры просили дать доступ на коммиты дополнительным разработчикам, таким как [Филиппо Вальсорда](https://filippo.io/) или [Сергей М.](https://qna.habr.com/user/dstftw), один из нынешних мейнтейнеров. К сожалению, в 2019 году случилась небольшая проблема с троллями в трекере, а блокировать пользователей разрешено только владельцам проектов. Это заставило нас наконец перенести проект в организацию GitHub, куда были приглашены все, кто имел доступ на коммиты (хотя и не все присоединились). Организация GitHub позволила мейнтейнерам действовать более свободно, не дёргая меня по малейшему поводу.
Хочу ещё раз выразить самую искреннюю благодарность различным мейнтейнерам проекта в течение этих лет, которые значительно улучшили код, смогли создать вокруг реальное сообщество и которые сделали проект гораздо более популярным, чем он был, когда я ушёл почти 10 лет назад.
### Офлайн и бесплатно
Хотел бы ещё раз отметить, что назначение youtube-dl как инструмента практически не изменилось за 14 лет его существования. До и после получения письма DMCA от RIAA многие рассказывали, как они используют youtube-dl для [разных](https://freedom.press/news/riaa-github-youtube-dl-journalist-tool/) [целей](https://twitter.com/xor/status/1319744343549317128).
Для меня это всегда был офлайн-доступ к видео, которые уже доступны широкой публике в интернете. В мире мобильных сетей и постоянного подключения вы можете спросить, действительно ли это необходимо. Я думаю, что да, если Netflix, Amazon, Disney и HBO реализовали подобную функциональность в своих чрезвычайно популярных стриминговых приложениях. Для длительных автомобильных поездок или поездок за границу, особенно с детьми, или под землёй, или в самолёте, или в месте с плохой связью или ограниченными соединениями — невероятно удобно иметь автономный доступ к подкасту, лекции, обзору, новости или произведению искусства.
Дополнительным побочным эффектом youtube-dl является доступ к контенту, когда онлайн-интерфейс не справляется с задачей. Старый проприетарный флэш-плагин работал не для каждой платформы и архитектуры. В настоящее время браузеры могут воспроизводить видео, но иногда не способны воспользоваться преимуществами эффективного декодирования GPU, тратя при этом большой заряд батареи. Youtube-dl можно использовать с собственным плеером, чтобы сделать воспроизведение некоторых видео возможным и/или эффективным. Например, плеер [mpv](https://github.com/mpv-player/mpv) включает встроенную поддержку youtube-dl. Вам нужно только передать ему URL, и он использует youtube-dl для доступа к видеопотоку и воспроизведения, ничего не сохраняя на вашем жёстком диске.
В дефолтном онлайн-интерфейсе может не быть специальных возможностей, которые необходимы для навигации некоторым людям, или цветовых фильтров для дальтоников, опять же, доступных из собственного приложения видеоплеера.
И последнее, но не менее важное: такие инструменты, как youtube-dl, позволяют получать доступ к онлайн-видео, используя только свободное программное обеспечение. Я понимаю, что в мире не так уж много сторонников строго свободного и открытого ПО. Я даже себя не считаю таковым, по большому счёту. Проприетарный софт постоянно присутствует в нашей современной жизни и поставляется нам каждый день в виде огромного количества строк Javascript в браузере, с множеством различных целей и не всегда в лучших интересах пользователей. Доказательством является появление [GDPR](https://en.wikipedia.org/wiki/General_Data_Protection_Regulation), со всеми его недостатками и проблемами. Доступ к онлайн-видео с помощью youtube-dl гарантирует вам полное душевное спокойствие в режиме инкогнито там, где uBlock Origin или Privacy Badger только едва успокаивают. | https://habr.com/ru/post/527880/ | null | ru | null |
# Разбор заданий конкурса на взлом NFT “The Standoff Digital Art”
15-16 ноября в Москве проводилась ежегодная кибербитва [The Standoff](https://standoff365.com/), которая собрала лучшие команды защитников и атакующих. В рамках глобальной конференции по информационной безопасности проводился конкурс на взлом NFT под названием [The Standoff Digital Art](https://nft.standoff365.com/). Мы пригласили известных цифровых художников для использования их NFT-работ в качестве целей для взлома. Для конкурса мы подготовили смарт-контракт стандарта ERC1155 для нашей коллекции. Владельцем каждой из NFT в коллекции (всего их было 6) был специально подготовленный уязвимый смарт-контракт. При успешной эксплуатации каждого из смарт-контрактов атакующий получал во владение NFT (в тестовой сети). Также за каждый успешный взлом полагался денежный приз. Итак, какие же были уязвимости?
---
Инкубатор
---------
🎨 Автор: [Артем Ткач](https://www.instagram.com/tkach_tem/)
В [смарт-контракте](https://rinkeby.etherscan.io/address/0x3222310f6FC2da7a29b86293af740Bed994bb739#code) мы видим три внешние функции: mint(), allowMinting() и addToWailist(). Цель - заставить смарт-контракт сделать передачу NFT через функцию mint(), однако в конструкторе переменная canMint объявляется как false. Чтобы разблокировать функцию mint(), присутствует функция allowMinting(), однако она доступна только владельцу смарт-контракта. Что же делать? Если внимательно изучить третью функцию addToWailist(), то мы увидим, что в ней объявляется неинициализированный динамический список адресов. В языке Solidity, если при инициализации не присвоить сложным типам данных типа array, mapping или struct какое-либо значение, то при использовании ключевого слова “storage” переменная просто перезапишет первый слот стораджа смарт-контракта. Правда, разработчики Solidity не оставили такую “возможность” языка без внимания и еще 4 года назад исправили компилятор таким образом, чтобы при подобных случаях возвращалась ошибка. Однако компилятор не всегда видит перезапись стораджа. Подробнее об этом можно узнать здесь:
Таким образом, если вызвать addToWaitlist(), то перезапишется первый элемент стораджа, в котором хранится значение переменной canMint. После чего, вызвав функцию mint(), атакующий получает NFT.
Mine
----
🎨 Автор: [Meta Rite](https://taplink.cc/meta_rite)
В этом задании смарт-контракт [StandoffNFT\_2](https://rinkeby.etherscan.io/address/0xD1802259E2Eb09CA8861A6B89f446770F4645a9d#code) наследует контракт Ownable, что является распространенным шаблоном. Можно заметить, что в конструкторе основного смарт-контракта переменной owner присваивается адрес отправителя. У функции withdraw(), которая передает владение NFT, имеется модификатор onlyOwner, разрешающий вызов только владельцу смарт-контракта. Сам код onlyOwner тоже стандартный:
```
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
```
Однако чему будет равен owner при вызове onlyOwner()? Правильно, он будет равен 0, так как присваивание произошло в контракте StandoffNFT\_2, а не в Ownable. При наследовании значение owner в Ownable останется нетронутым. Иначе говоря, нам ничего не мешает позвать setOwner() и затем успешно выполнить withdraw().
Matter
------
🎨 Автор: [Desinfo](https://linktr.ee/desinfo)
В исходном коде [смарт-контракта](https://rinkeby.etherscan.io/address/0x5c95b14A411a5E2A1c2fc181c3A05318997DeD5A#code) мы видим функцию unlock(), которая передает владение NFT при выполнении условия:
```
require(
bytes32(
0x8d8056f94c32675006872f854a6757279eb9a1070660e871535fc7231dc18b30) ==
keccak256(preimage), "invalid preimage"
);
```
Также замечаем комментарий “*we have very secure metadata*”, что недвусмысленно дает понять, где искать preimage. Обратившись к [смарт-контракту коллекции](https://rinkeby.etherscan.io/address/0x1EBDe1D447752Ef17625c13940bf0218220bED3b#code), получаем адрес, где хранятся метаданные:
```
constructor() ERC1155("https://standoff-nft.vercel.app/api/{}.json") {
```
Адрес, который передается в функцию ERC1155, является token URI, т.е. это тот адрес, куда NFT маркетплейсы вроде [OpenSea](https://docs.opensea.io/docs/metadata-standards), будут ходить за метаданными каждого токена коллекции. Кажется, что дело в шляпе, нужно лишь подставить вместо {} идентификатор токена. Однако при обращении к /api/3.json, получаем 404 ошибку. В чем же дело?
Ответ может дать [документация стандарта ERC1155](https://eips.ethereum.org/EIPS/eip-1155#metadata):
> The string format of the substituted hexadecimal ID MUST be lowercase alphanumeric: [0-9a-f] with no 0x prefix.
>
> The string format of the substituted hexadecimal ID MUST be leading zero padded to 64 hex characters length if necessary.
>
>
Иными словами, TOKEN\_ID необходимо перевести в шестнадцатеричную форму и привести к длине из 64 символов с нулями. Т.е. вместо /api/3.json мы должны запрашивать /api/0000000000000000000000000000000000000000000000000000000000000002.json:
Отправив значение preimage в функцию unlock(), получаем NFT.
Raven
-----
🎨 Автор: [volv\_victory](https://linktr.ee/volv_victory)
В исходном коде [смарт-контракта](https://rinkeby.etherscan.io/address/0x810976E5D20d2d9e704dd75b09BE73D9d9d4BA8c#code) видим два маппинга blacklisted и whitelisted с адресами коллекций. Также имеется функция addCollections, которая принимает на вход упомянутые маппинги, а также подпись, по которой проверяется, что маппинги подписал владелец смарт-контракта. Глядя на историю транзакций на EtherScan, обнаруживаем [вызов addCollections](https://rinkeby.etherscan.io/tx/0x08443771ed957d8b3aef063cb3a3afe3785d802aaab2ff844ba9a780335b6aa1) с корректной подписью.
В \_blacklisted адрес коллекции The Standoff Digital Art. Это означает, что мы не можем вызвать функцию transfer(), которая отправляет NFT, так как она имеет следующее условие:
```
require(whitelisted[_collection], "collection is not allowed");
```
Но это не проблема, если внимательно изучить, как проверяется подпись в addCollections():
```
bytes32 hash = keccak256(abi.encodePacked(_whitelisted, _blacklisted));
address signer = hash.toEthSignedMessageHash().recover(_signature);
require(signer == owner, "only owner can add NFT collections");
```
Два маппинга “склеиваются“ с помощью функции abi.encodePacked(), от полученного маппинга считается keccak-хэш и от этого хэша считается подпись. Здесь ошибка заключается в том, что используется abi.encodePacked() вместо abi.encode(). Между ними есть существенная разница: abi.encodePacked() не сохраняет информацию о количестве элементов при сериализации. Это означает, что выражения abi.encodePacked([1,2,3], [4]) и abi.encodePacked([1,2], [3,4]) будут возвращать один и тот же результат и, соответственно, один и тот же keccak-хэш. Более подробно о подобных хэш-коллизиях из-за abi.encodePacked() можно ознакомиться [в этой статье](https://medium.com/swlh/new-smart-contract-weakness-hash-collisions-with-multiple-variable-length-arguments-dc7b9c84e493).
Таким образом, атакующий может переиспользовать подпись владельца смарт-контракта, чтобы изменить расположение адресов коллекций в переменных blacklisted и whitelisted. Иначе говоря, вместо вызова:
```
addCollections(
[0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB
0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D
0x1A92f7381B9F03921564a437210bB9396471050C],
[0x1EBDe1D447752Ef17625c13940bf0218220bED3b], // адрес standoff в blacklisted
signature
)
```
мы делаем следующий вызов:
```
addCollections(
[0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB
0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D
0x1A92f7381B9F03921564a437210bB9396471050C,
0x1EBDe1D447752Ef17625c13940bf0218220bED3b],
[], // blacklisted теперь пустой
signature
)
```
Подпись будет одинаковой и теперь мы сможем успешно выполнить transfer()!
Transformation
--------------
🎨 Автор: [Anomalit Kate](https://anomalitkate.com/ru/)
В [смарт-контракте](https://rinkeby.etherscan.io/address/0x13874C3906394Dc6824a48ed53cfB4485E576cDd#code) имеется лишь единственная внешняя функция transfer(), которая переводит NFT отправителю транзакции, однако вызвать ее может только владелец смарт-контракта, который устанавливается в конструкторе. Game over? Как бы ни так, обращаем внимание на старую версию компилятора Solidity - 0.4.25. В этой версии все еще была возможность допустить ошибку при объявлении конструктора, а именно сделать конструктор обычной функцией.
✅ правильный синтаксис: constructor(IERC1155 \_collection) {}
🛑 неправильный синтаксис: function constructor(IERC1155 \_collection) {}
Все, что оставалось сделать самому быстрому и внимательному участнику, это отправить транзакцию с вызовом функции constructor() с адресом коллекции, а затем сделать transfer().
Recharge
--------
🎨 Автор: [Loit](https://lynkfire.com/loiterkiddd)
Пройдя по [адресу NFT](https://rinkeby.etherscan.io/address/0xda7288a9E54F788A27A8C278408466EbC9b1f64D), мы не увидим исходного кода смарт-контракта, но в истории транзакций есть любопытное сообщение:
По [указанному адресу](https://rinkeby.etherscan.io/address/0xB2c1d1bF0A197fd46bCe75A30D51f8e37C66d60D#code) расположено задание. Оно каким-то образом должно позволить завладеть адресом, которому принадлежит NFT. Читая исходный код, видим функцию deploy(), которая на вход принимает параметр “salt” длиной 4 байта. В ней вызывается одноименная функция из модуля Create2 от OpenZeppelin:
```
address addr = Create2.deploy(0, salt, getInitCode());
```
Данный вызов публикует в сеть новый смарт-контракт с помощью опкода CREATE2, который не так давно появился в EVM (Ethereum Virtual Machine) в рамках хард-форка Constantinople. Ранее существовал лишь опкод CREATE; разница между ними состоит в том, что адрес нового смарт-контракта, созданного с помощью обычного CREATE, зависит от nonce - это число, которое увеличивается при каждом новом вызове CREATE, а адреса смарт-контрактов, созданных с помощью CREATE2, зависят от контролируемого пользователем значения salt, что делает адреса новых смарт-контрактов заранее известными.
Смарт-контракт, который можно таким образом задеплоить, называется NFTOwner. Он имеет конструктор, в котором владельцем становится tx.origin, т.е. изначальный отправитель транзакции, и функцию transfer(), передающая NFT. Все это дает понять, что нам нужно угадать salt и разместить контракт именно по тому адресу, который владеет NFT. Задача несложная, так как перебрать нужно всего 4 байта. В результате брутфорса получаем значение “aZy5”. Вызвав функцию deploy() с этим значением забираем NFT.
Итоги
-----
Целых 5 NFT удалось взломать [Алексею Быхуну](https://twitter.com/caffeinum) [@caffeinum](/users/caffeinum)в первые часы после начала конкурса. Последний NFT достался Алексею Егорову, который решил задание на перебор соли. Победители получат денежные призы от организаторов The Standoff, поздравляем!
Until next time! | https://habr.com/ru/post/590301/ | null | ru | null |
# Манипуляция мешами в реальном времени на Unity
Одно из преимуществ Unity в качестве платформы для разработки игр — её мощный 3D-движок. В этом туториале вы познакомитесь с миром 3D-объектов и манипуляций мешами.
В связи с ростом технологий виртуальной и дополненной реальности (VR/AR) большинство разработчиков сталкивается со сложными концепциями 3D-графики. Пусть этот туториал будет для них отправной точкой. Не волнуйтесь, здесь не будет сложной 3D-математики — только сердца, рисунки, стрелки и куча интересного!
> *Примечание:* этот туториал предназначен для пользователей, знакомых с IDE Unity и имеющих определённый опыт программирования на C#. Если у вас нет таких знаний, то изучите сначала туториалы [Introduction to Unity UI](https://www.raywenderlich.com/149464/introduction-to-unity-ui-part-1) и [Introduction to Unity Scripting](https://www.raywenderlich.com/127672/introduction-unity-scripting).
>
>
>
> Вам понадобится версия Unity не ниже 2017.3.1. Последнюю версию Unity можно скачать [здесь](https://unity3d.com/get-unity/download). В этом туториале используются custom editor, подробнее о них можно узнать из туториала [Extending the Unity Editor](https://www.raywenderlich.com/130721/extend-unity3d-editor).
Приступаем к работе
-------------------
Для начала познакомьтесь с основными терминами 3D-графики, которые позволят вам лучше понять туториал.
Базовые технические термины 3D-графики:
* *Вершины (Vertices)*: каждая вершина — это точка в 3D-пространстве.
* *Меш (Mesh)*: содержит все вершины, рёбра, треугольники, нормали и UV-данные модели.
* *Mesh Filter*: хранит данные меша модели.
* *Mesh Renderer*: рендерит данные меша в сцене.
* *Нормали (Normals)*: вектор вершины или поверхности. Он направлен наружу, перпендикулярно поверхности меша.
* *Линии/рёбра (Lines/Edges)*: невидимые линии, соединяющие вершины друг с другом.
* *Треугольники (Triangles)*: формируются при соединении трёх вершин.
* *UV-развёртка (UV Map)*: привязывает материал к объекту, создавая для него текстуру и цвет.
Анатомия 3D-объекта начинается с его меша. Создание этого меша начинается с его вершин. Невидимые линии, соединяющие эти вершины, образуют треугольники, которые определяют базовую форму объекта.
Затем нормали и UV-данные задают затенение, цвет и текстуру. Данные меша хранятся в mesh filter, а mesh renderer использует эти данные для отрисовки объекта в сцене.
То есть псевдокод создания 3D-модели выглядит так:
* Создаём новый меш под названием «myMesh».
* Добавляем данные в свойства вершин и треугольников myMesh.
* Создаём новый mesh filter под названием «myMeshFilter».
* Присваиваем свойству меша myMeshFilter значение myMesh.
Разобравшись с основами, скачайте [проект](https://koenig-media.raywenderlich.com/uploads/2018/05/HeartShaper-2.zip), распакуйте файлы и запустите заготовку проекта в Unity. Посмотрите на структуру папок в окне *Project*:
Описание папок:
* *Prefabs*: содержит префаб Sphere, который будет использоваться для сохранения 3D-меша в процессе выполнения приложения.
* *Scenes*: содержит три сцены, которые мы используем в этом туториале.
* *Editor*: скрипты внутри этой папки дают нам в редакторе сверхвозможности, которые мы используем в разработке.
* *Scripts*: здесь находятся скрипты времени выполнения, которые прикрепляются к GameObject и выполняются при нажатии на *Play*.
* *Materials*: в этой папке хранится материал для меша.
В следующем разделе мы создадим custom editor, чтобы визуализировать создание 3D-меша.
Изменение мешей с помощью Custom Editor
---------------------------------------
Откройте *01 Mesh Study Demo*, находящееся в папке *Scenes*. В окне *Scene* вы увидите 3D-куб:
Прежде чем приступать к мешу, давайте взглянем на скрипт custom editor.
### Изменение скрипта редактора
Выберите папку *Editor* в окне *Project*. Скрипты в этой папке добавляют функционал к редактору (Editor) во время разработки и недоступны в режиме Build.
Откройте *MeshInspector.cs* и просмотрите исходный код. Все скрипты Editor должны реализовывать класс `Editor`, его атрибут `CustomEditor` сообщает классу `Editor`, для какого типа объекта он является редактором. `OnSceneGUI()` — это метод события, позволяющий выполнять отрисовку в окне Scene; `OnInspectorGUI()` позволяет добавить в Inspector дополнительные элементы GUI.
В *MeshInspector.cs* перед началом класса `MeshInspector` добавим следующее:
```
[CustomEditor(typeof(MeshStudy))]
```
Объяснение кода: атрибут `CustomEditor` сообщает Unity, какой тип объекта может изменять класс custom editor.
В `OnSceneGUI()` перед `EditMesh()` добавим следующее:
```
mesh = target as MeshStudy;
Debug.Log("Custom editor is running");
```
Объяснение кода: класс `Editor` имеет стандартную переменную `target`. Здесь `target` является преобразованием в `MeshStudy`. Теперь custom editor будет отрисовывать в окне Scene все GameObject и прикреплёнными к ним *MeshStudy.cs*. Добавление отладочных сообщений позволяет убедиться в консоли, что custom editor действительно выполняется.
Сохраним (*Save*) файл и вернёмся в Unity. Перейдите в папку *Scripts* и перетащите *MeshStudy.cs* на GameObject *Cube* в *Hierarchy*, чтобы прикрепить его.
Теперь в консоли должно выводиться сообщение «Custom editor is running», и это означает, что мы всё сделали верно! Можете удалить отладочное сообщение, чтобы оно не мешало нам в консоли.
### Клонирование и сброс меша
При работе с 3D-мешем в режиме Edit при помощи custom editor будьте аккуратны, чтобы не перезаписать меш Unity по умолчанию. Если это произойдёт, то придётся перезапускать Unity.
Чтобы безопасно клонировать меш без перезаписи исходной формы, создадим копию меша из свойства `MeshFilter.sharedmesh` и присвоим его снова mesh filter.
Для этого дважды щёлкните на *MeshStudy.cs* в папке *Scripts*, чтобы открыть файл в редакторе кода. Этот скрипт наследует от класса `MonoBehaviour`, и его функция `Start()` не выполняется в режиме Edit.
В *MeshStudy.cs* перед началом класса `MeshStudy` добавим следующее:
```
[ExecuteInEditMode]
```
Объяснение кода: после добавления этого атрибута функция `Start()` будет выполняться и в режиме Play, и в режиме Edit. Теперь мы сначала можем создать экземпляр объекта меша и клонировать его.
В `InitMesh()` добавим следующий код:
```
oMeshFilter = GetComponent();
oMesh = oMeshFilter.sharedMesh; //1
cMesh = new Mesh(); //2
cMesh.name = "clone";
cMesh.vertices = oMesh.vertices;
cMesh.triangles = oMesh.triangles;
cMesh.normals = oMesh.normals;
cMesh.uv = oMesh.uv;
oMeshFilter.mesh = cMesh; //3
vertices = cMesh.vertices; //4
triangles = cMesh.triangles;
isCloned = true;
Debug.Log("Init & Cloned");
```
Объяснение кода:
1. Получает исходный меш `oMesh` из компонента `MeshFilter`.
2. Копирует в новый экземпляр меша `cMesh`.
3. Присваивает скопированный меш снова mesh filter.
4. Обновляет локальные переменные.
Сохраните файл и вернитесь в Unity. В консоли отладки должно отображаться сообщение «Init & Cloned». Выберите GameObject `Cube` в *Hierarchy* и проверьте его свойства в *Inspector*. В *Mesh Filter* должен отображаться ассет меша под названием *clone*. Отлично! Это означает, что мы успешно клонировали меш.
В папке Editor перейдите к *MeshInspector.cs*. В `OnInspectorGUI()`, после второй строки кода добавьте следующее:
```
if (GUILayout.Button("Reset")) //1
{
mesh.Reset(); //2
}
```
Объяснение кода:
1. Этот код отрисовывает в *Inspector* кнопку Reset.
2. При нажатии он вызывает в *MeshStudy.cs* функцию `Reset()`.
Сохраните файл, откройте *MeshStudy.cs* и добавьте в функцию `Reset()` следующий код:
```
if (cMesh != null && oMesh != null) //1
{
cMesh.vertices = oMesh.vertices; //2
cMesh.triangles = oMesh.triangles;
cMesh.normals = oMesh.normals;
cMesh.uv = oMesh.uv;
oMeshFilter.mesh = cMesh; //3
vertices = cMesh.vertices; //4
triangles = cMesh.triangles;
}
```
Объяснение кода:
1. Проверка существования исходного и клонированного меша.
2. Сброс `cMesh` на исходный меш.
3. Присвоение `cMesh` `oMeshFilter`.
4. Обновление локальных переменных.
Сохраните файл и вернитесь в Unity. В *Inspector* нажмите на кнопку *Test Edit*, чтобы исказить меш куба. Далее нажмите кнопку *Reset*; куб должен вернуться к исходной форме.
### Объяснение вершин и треугольников в Unity
Меш состоит из вершин, соединённых рёбрами в треугольники. Треугольники задают базовую форму объекта.
> *Класс Mesh:*
>
>
>
> * Вершины хранятся как массив значений `Vector3`.
> * Треугольники хранятся как массив integer, соответствующих индексам массива вершин.
>
>
>
> То есть в простом меше Quad, состоящем из четырёх вершин и двух треугольников, данные меша будут выглядеть так:
>
>
>
> 
### Отображение вершин
Здесь мы хотим отобразить вершины куба в виде голубых точек.
В *MeshInspector.cs* зайдём в функцию `EditMesh()` и добавим следующее:
```
handleTransform = mesh.transform; //1
handleRotation = Tools.pivotRotation == PivotRotation.Local ? handleTransform.rotation : Quaternion.identity; //2
for (int i = 0; i < mesh.vertices.Length; i++) //3
{
ShowPoint(i);
}
```
Объяснение кода:
1. `handleTransform` получает из `mesh` значения Transform.
2. `handleRotation` получает режим Rotation текущего шарнира.
3. Обходим вершины меша и отрисовываем точки с помощью `ShowPoint()`.
В функции `ShowPoint()`, сразу после комментария `//draw dot` добавим следующее:
```
Vector3 point = handleTransform.TransformPoint(mesh.vertices[index]);
```
Объяснение кода: эта строка преобразует локальную позицию вершины в координату в мировом пространстве.
В той же функции, в блоке `if` сразу после только что добавленной строки кода добавим следующее:
```
Handles.color = Color.blue;
point = Handles.FreeMoveHandle(point, handleRotation, mesh.handleSize, Vector3.zero, Handles.DotHandleCap);
```
Объяснение кода:
1. Задаёт цвет, размер и позицию точки с помощью вспомогательного класса `Handles`.
2. `Handles.FreeMoveHandle()` создаёт манипулятор неограниченного движения, упрощающий операцию перетаскивания, которая пригодится нам в следующем разделе.
Сохраните файл и вернитесь в Unity. Проверьте свойство куба в *Inspector* и убедитесь, что опция *Move Vertex Point* включена. Теперь вы должны увидеть, что меш на экране помечен несколькими голубыми точками. Вот и они — вершины меша куба! Попробуйте проделать это с другими 3D-объектами и понаблюдайте за результатами.
### Перемещение отдельной вершины
Начнём с самого простого шага манипуляций с мешем — перемещения отдельной вершины.
Перейдите в *MeshInspector.cs*. Внутри функции `ShowPoint()`, сразу после комментария `//drag` и прямо перед закрывающими скобками блока `if` добавьте следующее:
```
if (GUI.changed) //1
{
mesh.DoAction(index, handleTransform.InverseTransformPoint(point)); //2
}
```
Объяснение кода:
1. `GUI.changed` отслеживает все изменения, происходящие с точками, и хорошо работает вместе с `Handles.FreeMoveHandle()` для распознавания операции перетаскивания.
2. Для перетаскиваемой вершины функция `mesh.DoAction()` получает в качестве параметров её индекс и значения Transform. Так как значения Transform вершины находятся в мировом пространстве, мы преобразуем их в локальное пространство с помощью `InverseTransformPoint()`.
Сохраните файл скрипта и перейдите в *MeshStudy.cs*. В `DoAction()`, после открывающих скобок добавим следующее:
```
PullOneVertex(index, localPos);
```
Затем добавим в функцию `PullOneVertex()` следующее:
```
vertices[index] = newPos; //1
cMesh.vertices = vertices; //2
cMesh.RecalculateNormals(); //3
```
Объяснение кода:
1. Мы обновляем целевую вершину значением `newPos`.
2. Присваиваем значения обновлённых вершин обратно `cMesh.vertices`.
3. В `RecalculateNormals()` пересчитываем и перерисовываем меш, чтобы он соответствовал изменениям.
Сохраняем файл и возвращаемся в Unity. Попробуйте перетаскивать точки на кубе; увидели ли вы сломанный меш?
Похоже, что некоторые из вершин имеют одинаковую позицию, поэтому когда мы перетаскиваем только одну, остальные вершины остаются за ней, и меш ломается. В следующем разделе мы устраним эту проблему.
### Нахождение всех похожих вершин
Визуально меш куба состоит из восьми вершин, шести сторон и 12 треугольников. Давайте проверим, так ли это.
Откроем *MeshStudy.cs*, взглянем в место перед функцией `Start()` и найдём переменную `vertices`. Мы увидим следующее:
```
[HideInInspector]
public Vector3[] vertices;
```
Объяснение кода: `[HideInInspector]` скрывает общую переменную от окна *Inspector*.
Закомментируем этот атрибут:
```
//[HideInInspector]
public Vector3[] vertices;
```
> *Примечание:* сокрытие значений вершин помогает `[HideInInspector]` в случае более сложных 3D-мешей. Так как размер массива вершин может достигать тысяч элементов, то это может приводить к торможению Unity при попытке просмотра значения массива в Inspector.
Сохраните файл и вернитесь в Unity. Перейдите в *Inspector*. Теперь под компонентом скрипта *Mesh Study* появилось свойство *vertices*. Нажмите на значок стрелки рядом с ним; так вы развернёте массив элементов `Vector3`.
Можно увидеть, что размер массива равен 24, то есть существуют вершины, имеющие одинаковую позицию! Перед тем, как продолжать работу, не забудьте раскомментировать `[HideInInspector]`.
**Почему вершин 24?**На этот счёт есть много теорий. Но простейший ответ таков: у куба шесть сторон, и каждая сторона составлена из четырёх вершин, образующих плоскость.
Поэтому расчёт таков: 6 x 4 = 24 вершины.
Можете поискать и другие ответы. Но пока достаточно просто знать, что у некоторых мешей будут вершины, имеющие одинаковую позицию.
В *MeshStudy.cs* заменим *весь* код внутри функции `DoAction()` на следующий:
```
PullSimilarVertices(index, localPos);
```
Перейдём в функцию `PullSimilarVertices()` и добавим следующее:
```
Vector3 targetVertexPos = vertices[index]; //1
List relatedVertices = FindRelatedVertices(targetVertexPos, false); //2
foreach (int i in relatedVertices) //3
{
vertices[i] = newPos;
}
cMesh.vertices = vertices; //4
cMesh.RecalculateNormals();
```
Объяснение кода:
1. получаем позицию целевой вершины, которая будет использоваться в качестве аргумента метода `FindRelatedVertices()`.
2. Этот метод возвращает список индексов (соответствующих вершинам), имеющих ту же позицию, что и целевая вершина.
3. Цикл обходит весь список и присваивает соответствующим вершинам значение `newPos`.
4. Присваиваем обновлённый `vertices` обратно `cMesh.vertices`. Затем вызываем `RecalculateNormals()` для перерисовки меша с новыми значениями.
Сохраните файл и вернитесь в Unity. Перетащите любую из вершин; теперь меш должен сохранять форму и не разрушаться.
Теперь, когда мы выполнили первый шаг в манипуляции мешами, сохраним сцену и перейдём к следующему разделу.
Манипулирование мешами
----------------------
В этом разделе вы узнаете о манипулировании мешами в реальном времени. Существует множество способов, но в этом туториале мы рассмотрим наиболее простой вид манипуляций мешами, а именно перемещение заранее созданных вершин меша.
### Сбор выбранных индексов
Начнём с выбора вершин, которые будем перемещать в реальном времени.
Откройте сцену *02 Create Heart Mesh* из папки *Scenes*. В окне Scene вы увидите красную сферу. Выберите *Sphere* в *Hierarchy* и перейдите в *Inspector*. Вы увидите, что к объекту прикреплён компонент скрипта *Heart Mesh*.
Теперь нам нужно, чтобы скрипт Editor для этого объекта отображал вершины меша в окне Scene. Перейдите в папку *Editor* и дважды щёлкните на *HeartMeshInspector.cs*.
В функции `ShowHandle()`, внутри блока `if` добавьте следующее:
```
Handles.color = Color.blue;
if (Handles.Button(point, handleRotation, mesh.pickSize, mesh.pickSize, Handles.DotHandleCap)) //1
{
mesh.selectedIndices.Add(index); //2
}
```
Объяснение кода:
1. Задаёт и отображает вершины меша как тип `Handles.Button`.
2. При нажатии он добавляет выбранный индекс в список pressed, `mesh.selectedIndices`.
В `OnInspectorGUI()`, перед закрывающей скобкой, добавим следующее:
```
if (GUILayout.Button("Clear Selected Vertices"))
{
mesh.ClearAllData();
}
```
Объяснение кода: так мы добавляем в *Inspector* кнопку Reset для вызова `mesh.ClearAllData()`.
Сохраните файл и откройте *HeartMesh.cs* из папки *Scripts*. В функцию `ClearAllData()` добавьте следующее:
```
selectedIndices = new List();
targetIndex = 0;
targetVertex = Vector3.zero;
```
Объяснение кода: код очищает значения в `selectedIndices` и `targetIndex`. Также он обнуляет `targetVertex`.
Сохраните файл и вернитесь в Unity. Выберите *Sphere* и перейдите в *Inspector* к компоненту скрипта *HeartMesh*. Разверните *Selected Indices*, нажав на значок стрелки рядом с ним. Это позволит нам отслеживать каждую вершину, добавляемую в список.
Включите *Is Edit Mode* с помощью флажка рядом с ним. Благодаря этому в окне Scene будут отрисовываться вершины меша. При нажатии на синие точки в *Selected Indices* должны соответствующим образом меняться значения. Также протестируйте кнопку *Clear Selected Vertices*, чтобы убедиться, что она очищает все значения.
*Примечание:* в изменённом custom *Inspector* у нас есть опция для отображения/скрытия манипулятора transform с помощью *Show Transform Handle*. Так что не паникуйте, если не найдёте в других сценах манипулятор Transform! Перед выходом включайте его.
### Превращение сферы в сердце
Изменение вершин меша в реальном времени по сути состоит из трёх этапов:
1. Копируем текущие вершины меша (до анимации) в `mVertices`.
2. Выполняем вычисления и изменяем значения в `mVertices`.
3. Обновляем текущие вершины меша с помощью `mVertices` при изменении на каждом этапе и позволяем Unity автоматически вычислять нормали.
Откройте *HeartMesh.cs* и перед функцией `Start()` следующие переменные:
```
public float radiusofeffect = 0.3f; //1
public float pullvalue = 0.3f; //2
public float duration = 1.2f; //3
int currentIndex = 0; //4
bool isAnimate = false;
float starttime = 0f;
float runtime = 0f;
```
Объяснение кода:
1. Радиус области, на которую влияет целевая вершина.
2. Сила перетаскивания.
3. Длительность анимации.
4. Текущий индекс списка `selectedIndices`.
В функции `Init()` перед блоком `if` добавим следующее:
```
currentIndex = 0;
```
Объяснение кода: в начале игры `currentIndex` присваивается значение 0 — первый индекс списка `selectedIndices`.
В той же функции `Init()` перед закрывающей скобкой блока `else` добавим следующее:
```
StartDisplacement();
```
Объяснение кода: запускаем функцию `StartDisplacement()`, если `isEditMode` имеет значение false.
Внутрь функции `StartDisplacement()` добавим следующее:
```
targetVertex = oVertices[selectedIndices[currentIndex]]; //1
starttime = Time.time; //2
isAnimate = true;
```
Объяснение кода:
1. Выделяем `targetVertex`, чтобы начать анимацию.
2. Задаём время начала и изменяем значение `isAnimate` на true.
После функции `StartDisplacement()` создадим функцию `FixedUpdate()` со следующим кодом:
```
void FixedUpdate() //1
{
if (!isAnimate) //2
{
return;
}
runtime = Time.time - starttime; //3
if (runtime < duration) //4
{
Vector3 targetVertexPos = oFilter.transform.InverseTransformPoint(targetVertex);
DisplaceVertices(targetVertexPos, pullvalue, radiusofeffect);
}
else //5
{
currentIndex++;
if (currentIndex < selectedIndices.Count) //6
{
StartDisplacement();
}
else //7
{
oMesh = GetComponent().mesh;
isAnimate = false;
isMeshReady = true;
}
}
}
```
Объяснение кода:
1. Функция `FixedUpdate()` выполняется в цикле с фиксированным FPS.
2. Если `isAnimate` имеет значение false, то пропускаем следующий код.
3. Изменяем `runtime` анимации.
4. Если `runtime` находится в пределах `duration`, то получаем мировые координаты `targetVertex` и `DisplaceVertices()`, охватывая целевую вершину параметрами `pullvalue` и `radiusofeffect`.
5. В противном случае время закончилось. Прибавляем к `currentIndex` единицу.
6. Проверяем, находится ли `currentIndex` среди `selectedIndices`. Переходим к следующей вершине в списке с помощью `StartDisplacement()`.
7. В противном случае в конце списка изменяем данные `oMesh` на текущий меш и присваиваем `isAnimate` значение false, чтобы остановить анимацию.
В `DisplaceVertices()` добавим следующее:
```
Vector3 currentVertexPos = Vector3.zero;
float sqrRadius = radius * radius; //1
for (int i = 0; i < mVertices.Length; i++) //2
{
currentVertexPos = mVertices[i];
float sqrMagnitute = (currentVertexPos - targetVertexPos).sqrMagnitude; //3
if (sqrMagnitute > sqrRadius)
{
continue; //4
}
float distance = Mathf.Sqrt(sqrMagnitute); //5
float falloff = GaussFalloff(distance, radius);
Vector3 translate = (currentVertexPos * force) * falloff; //6
translate.z = 0f;
Quaternion rotation = Quaternion.Euler(translate);
Matrix4x4 m = Matrix4x4.TRS(translate, rotation, Vector3.one);
mVertices[i] = m.MultiplyPoint3x4(currentVertexPos);
}
oMesh.vertices = mVertices; //7
oMesh.RecalculateNormals();
```
Объяснение кода:
1. Квадрат радиуса.
2. Обходим в цикле каждую вершину меша.
3. Получаем `sqrMagnitude` между `currentVertexPos` и `targetVertexPos`.
4. Если `sqrMagnitude` превышает `sqrRadius`, то переходим к следующей вершине.
5. В противном случае продолжаем, определяя значение `falloff`, зависящее от расстояния `distance` текущей вершины от центральной точки области действия.
6. Получаем новую позицию `Vector3` и применяем её Transform к текущей вершине.
7. При выходе из цикла присваиваем данным `oMesh` изменённые значения `mVertices`, и заставляем Unity пересчитать нормали.
> *Источник техники Falloff*
>
> Исходная формула взята из файла пакета ассетов [Procedural Examples](https://assetstore.unity.com/packages/essentials/tutorial-projects/procedural-examples-5141), который можно бесплатно скачать из Unity Asset Store.
Сохраните файл и вернитесь в Unity. Выберите *Sphere*, перейдите к компоненту *HeartMesh* и попробуйте добавить несколько вершин в свойство *Selected Indices*. Отключите *Is Edit mode* и нажмите *Play*, чтобы посмотреть на результат своей работы.
Поэкспериментируйте со значениями *Radiusofeffect*, *Pullvalue* и *Duration*, чтобы получить разные результаты. Когда будете готовы, измените настройки в соответствии с показанным ниже скриншотом.
Нажмите на *Play*. Превратилась ли ваша сфера в сердце?
Поздравляю! В следующем разделе мы сохраним меш в префаб для дальнейшего использования.
### Сохранение меша в реальном времени
Для сохранения процедурного меша в форме сердца в режиме Play необходимо подготовить префаб, дочерним элементом которого будет 3D-объект, а затем заменить его ассет меша новым с помощью скрипта.
В окне *Project* найдите *CustomHeart* в папке *Prefabs*. Нажмите на значок стрелки, чтобы развернуть его содержимое и выберите *Child*. Теперь вы видите в окне превью *Inspector* объект Sphere. Это префаб, который будет хранить данные нового меша.
Откройте *HeartMeshInspector.cs*. Внутри функции `OnInspectorGUI()`, перед закрывающей скобкой добавьте следующее:
```
if (!mesh.isEditMode && mesh.isMeshReady)
{
string path = "Assets/Prefabs/CustomHeart.prefab"; //1
if (GUILayout.Button("Save Mesh"))
{
mesh.isMeshReady = false;
Object pfObj = AssetDatabase.LoadAssetAtPath(path, typeof(GameObject)); //2
Object pfRef = AssetDatabase.LoadAssetAtPath (path, typeof(GameObject));
GameObject gameObj = (GameObject)PrefabUtility.InstantiatePrefab(pfObj);
Mesh pfMesh = (Mesh)AssetDatabase.LoadAssetAtPath(path, typeof(Mesh)); //3
if (!pfMesh)
{
pfMesh = new Mesh();
}
else
{
pfMesh.Clear();
}
pfMesh = mesh.SaveMesh(); //4
AssetDatabase.AddObjectToAsset(pfMesh, path);
gameObj.GetComponentInChildren().mesh = pfMesh; //5
PrefabUtility.ReplacePrefab(gameObj, pfRef, ReplacePrefabOptions.Default); //6
Object.DestroyImmediate(gameObj); //7
}
}
```
Объяснение кода:
1. Задаёт `path` значение пути к объекту префаба *CustomHeart*.
2. Создаёт два объекта из префаба *CustomHeart*, один для создания экземпляра как GameObject (`pfObj`), второй — как ссылки (`pfRef`).
3. Создаёт из *CustomHeart* экземпляр ассета меша `pfMesh`. Если он не найден, создаёт новый меш, в противном случае очищает имеющиеся данные.
4. Заполняет `pfMesh` новыми данными меша, а затем добавляет его как ассет в *CustomHeart*.
5. Заполняет ассет меша в `gameObj` значением `pfMesh`.
6. Заменяет *CustomHeart* на `gameObj` сопоставляя ранее существовавшие соединения.
7. Мгновенно уничтожает `gameObj`.
Сохраните файл и перейдите в *HeartMesh.cs*. В общем методе `SaveMesh()`, после создания экземпляра `nMesh` добавьте следующее:
```
nMesh.name = "HeartMesh";
nMesh.vertices = oMesh.vertices;
nMesh.triangles = oMesh.triangles;
nMesh.normals = oMesh.normals;
```
Объяснение кода: возвращает ассет меша со значениями из меша в форме сердца.
Сохраните файл и вернитесь в Unity. Нажмите *Play*. После завершения анимации в *Inspector* появится кнопка *Save Mesh*. Нажмите на кнопку, чтобы сохранить новый меш, а затем остановите проигрыватель.
Перейдите в папку *Prefabs* и посмотрите на префаб *CustomHeart*. Вы должны увидеть, что теперь в объекте префаба *CustomHeart* есть совершенно новый меш в форме сердца.
*Отличная работа!*
Соединяем всё вместе
--------------------
В предыдущей сцене функция `DisplaceVertices()` использовала формулу Falloff для определения силы перетаскивания, которая прикладывалась к каждой вершине в пределах заданного радиуса. Точка «затухания» (fall off), в которой сила перетаскивания начинает снижаться, зависит от использованного типа Falloff: Linear, Gaussian или Needle. Каждый тип создаёт в меше разные результаты.
В этом разделе мы рассмотрим другой способ манипулирования вершинами: с помощью заданной кривой. Взяв правило, что скорость равна расстоянию, поделённому на время (d=(v/t)), мы можем определить позицию вектора, ссылаясь на его расстояние, поделённое на время.
### Использование способа с кривой
Сохраните текущую сцену и откройте *03 Customize Heart Mesh* из папки *Scenes*. Вы увидите в *Hierarchy* экземпляр префаба *CustomHeart*. Нажмите на значок стрелки рядом с ним, чтобы развернуть его содержимое и выберите *Child*.
Просмотрите его свойства в *Inspector*. Вы увидите компонент *Mesh Filter* с ассетом *Heart Mesh*. Прикрепите к *Child* в качестве компонента скрипт *Custom Heart*. Теперь ассет должен смениться с *HeartMesh* на *clone*.
Далее откройте *CustomHeart.cs* из папки *Scripts*. Перед функцией `Start()` добавьте следующее:
```
public enum CurveType
{
Curve1, Curve2
}
public CurveType curveType;
Curve curve;
```
Объяснение кода: здесь создаётся общее перечисление (enum) под названием `CurveType`, после чего оно делается доступным из *Inspector*.
Перейдите в `CurveType1()` и добавьте следующее:
```
Vector3[] curvepoints = new Vector3[3]; //1
curvepoints[0] = new Vector3(0, 1, 0);
curvepoints[1] = new Vector3(0.5f, 0.5f, 0);
curvepoints[2] = new Vector3(1, 0, 0);
curve = new Curve(curvepoints[0], curvepoints[1], curvepoints[2], false); //2
```
Объяснение кода:
1. Простая кривая состоит из трёх точек. Задаём точки для первой кривой.
2. Генерируем первую кривую с помощью `Curve()` и присваиваем её значения `curve`. Рисуемая кривая может отображаться в превью, если в качестве последнего параметра указать true.
Перейдите в `CurveType2()` и добавьте следующее:
```
Vector3[] curvepoints = new Vector3[3]; //1
curvepoints[0] = new Vector3(0, 0, 0);
curvepoints[1] = new Vector3(0.5f, 1, 0);
curvepoints[2] = new Vector3(1, 0, 0);
curve = new Curve(curvepoints[0], curvepoints[1], curvepoints[2], false); //2
```
Объяснение кода:
1. Задаём точки для второй кривой.
2. Генерируем вторую кривую с помощью `Curve()` и присваиваем её значения `curve`. Рисуемая кривая может отображаться в превью, если в качестве последнего параметра указать true.
В `StartDisplacement()`, перед закрывающей скобкой добавим следующее:
```
if (curveType == CurveType.Curve1)
{
CurveType1();
}
else if (curveType == CurveType.Curve2)
{
CurveType2();
}
```
Объяснение кода: здесь мы проверяем выбранную пользователем опцию `curveType` и соответствующим образом генерируем `curve`.
В `DisplaceVertices()`, внутри оператора цикла `for` перед закрывающими скобками добавим следующее:
```
float increment = curve.GetPoint(distance).y * force; //1
Vector3 translate = (vert * increment) * Time.deltaTime; //2
Quaternion rotation = Quaternion.Euler(translate);
Matrix4x4 m = Matrix4x4.TRS(translate, rotation, Vector3.one);
mVertices[i] = m.MultiplyPoint3x4(mVertices[i]);
```
Объяснение кода:
1. Получаем позицию кривой на заданной `distance` и умножаем её значение `y` на `force`, чтобы получить `increment`.
2. Создаём новый тип данных `Vector3` для хранения новой позиции текущей вершины и соответствующим образом применяем её Transform.
Сохраните файл и вернитесь в Unity. Проверьте свойства в компоненте *CustomHeart* игрового объекта *Child*. Вы увидите раскрывающийся список, в котором можно выбрать *Curve Type*. В раскрывающемся списке *Edit Type* выберите *Add Indices* или *Remove Indices*, чтобы обновить список вершин и поэкспериментировать с разными настройками.
Чтобы увидеть подробные результаты для разных типов кривых, введите значения в соответствии со скриншотом:
Для списка *Curve Type* выберите значение *Curve1*, убедитесь, что для *Edit Type* выбрано *None* и нажмите *Play*. Вы должны увидеть, что меш расходится в паттерн. Покрутите модель, чтобы увидеть её в виде сбоку, и сравните результаты для обоих типов кривых. Здесь вы видите, как выбранный *Curve Type* влияет на смещение меша.
Вот и всё! Можете нажать на *Clear Selected Vertices*, чтобы сбросить *Selected Indices* и поэкспериментировать с собственными паттернами. Но не забывайте, что есть и другие факторы, которые будут влиять на конечный результат меша, а именно:
* Величина радиуса.
* Распределение вершин по области.
* Позиция паттерна выбранных вершин.
* Способ, выбранный для смещения.
Куда двигаться дальше?
----------------------
Файлы готового проекта находятся в [архиве проекта](https://koenig-media.raywenderlich.com/uploads/2018/05/HeartShaper-2.zip) туториала.
Не останавливайтесь на этом! Попробуйте использовать более сложные техники, применяемые в туториале [«Процедурная генерация лабиринтов в Unity»](https://habr.com/post/353104/).
Надеюсь, вам понравился этот туториал, а информация оказалась полезной. Особую благодарность я выражаю [Джасперу Флику](http://catlikecoding.com/about/) из [Catlike Coding](http://catlikecoding.com/) за его отличные туториалы, которые помогли мне собрать демо для моего проекта.
 | https://habr.com/ru/post/428796/ | null | ru | null |
# Бесплатная GPU Tesla K80 для ваших экспериментов с нейросетями
Около месяца назад Google сервис Colaboratory, предоставляющий доступ к Jupyter ноутбукам, включил возможность бесплатно использовать GPU Tesla K80 с 13 Гб видеопамяти на борту. Если до сих пор единственным препятствием для погружения в мир нейросетей могло быть отсутствие доступа к GPU, теперь Вы можете смело сказать, “Держись Deep Learning, я иду!”.
Я попробовал использовать Colaboratory для работы над kaggle задачами. Мне больше всего не хватало возможности удобно сохранять натренированные tensorflow модели и использовать tensorboard. В данном посте, я хочу поделиться опытом и рассказать, как эти возможности добавить в colab. А напоследок покажу, как можно получить доступ к контейнеру по ssh и пользоваться привычными удобными инструментами bash, screen, rsync.
Для начала, почему это интересно
--------------------------------
Наличие GPU ускорителя является критическим фактором для скорости обучения deep learning моделей. Без GPU обучение нейросети займет многие часы/дни и не позволит полноценно экспериментировать со структурой сети. Объем видеопамяти так же важен. Больше памяти — можно установить больший размер батча и использовать более сложные модели. На сегодняшний день 13G это хороший объем, если захотите получить примерно столько же у себя на столе, придется покупать GPU уровня GTX 1080 Ti.
Что такое Colaboratory
----------------------
Это форк популярной среды [Jupyter notebook](http://jupyter.org/). Ваши ноутбуки доступны через google drive в .ipynb формате и вы можете их запускать у себя локально. Поддерживается Python 2.7 и 3.6. Код исполняется на сервере в docker контейнере. Можно закрыть браузер, все процессы на сервере продолжат работать, позже можно подключиться к серверу снова. Docker контейнер выдается вам во временное пользование на 12 часов. Вы имеете root привилегии, и можете устанавливать и запускать любые программы внутри контейнера. Colaboratory (далее colab) также поддерживает совместную работу над ноутбуком, по типу google docs. Это отличная платформа для начала изучения deep learning, machine learning. Многие бесплатные курсы, например [Открытый курс машинного обучения](https://habrahabr.ru/company/ods/blog/322626/) используют Jupyter notebook формат для своих учебных материалов.
Запускаем обучение
------------------
Для создания нового ноутбука перейдите [по ссылке](https://colab.research.google.com/notebook#create=true&language=python3). После успешного логина и создания ноутбука в меню выберете Runtime -> Change Runtime Type, в открывшемся диалоге в опции Hardware acceleration установите GPU, далее save.
После этого можно удостовериться, что tensorflow использует GPU. Просто скопируйте этот код в первую ячейку ноутбука и выполните, нажав *shift+Enter*:
```
import tensorflow as tf
tf.test.gpu_device_name()
```
Теперь попробуем запустить простую модель tensorflow из примеров, для этого клонируем github репозиторий и запустим скрипт.
```
! git clone https://github.com/tensorflow/models.git
%run models/samples/core/get_started/premade_estimator.py
```
После выполнения это команды мы увидим как сеть обучиться и сделает первые предсказания. Существует достаточно [много материалов](https://habrahabr.ru/search/?q=Jupyter#h) описывающих возможности Jupyter, поэтому я не буду подробно на этом останавливаться.
Монтируем google drive
----------------------
Всё работает отлично, но через 12 часов виртуальную машину у вас заберут и все данные внутри контейнера будут потеряны. Хорошо бы позаботиться о постоянном хранилище. В colab есть примеры как использовать импортировать данные из cloud storage, google sheets. Это предполагает явный вызов операции копирования, а мне бы хотелось иметь возможность примонтировать внешний диск к файловой системе внутри контейнера, тут на помощь приходит google drive и FUSE драйвер для него. Подключить google drive можно выполнив код, [по рецепту из статьи](https://medium.com/deep-learning-turkey/google-colab-free-gpu-tutorial-e113627b9f5d)
**Код для монтирования google drive**
```
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools
!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null
!apt-get update -qq 2>&1 > /dev/null
!apt-get -y install -qq google-drive-ocamlfuse fuse
from google.colab import auth
auth.authenticate_user()
from oauth2client.client import GoogleCredentials
creds = GoogleCredentials.get_application_default()
import getpass
!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL
vcode = getpass.getpass()
!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
```
После этого вам будет доступна директория куда вы можете записывать данные, без опаски их потерять после остановки контейнера. Вы можете определить параметр model\_dir в конфигурации модели, tensorflow будет автоматически восстанавливать состояние модели из последнего checkpoint. Таким образом, вы можете продолжить обучение модели или запустить inference в любой момент.
Tensorboard
-----------
Я люблю использовать tensorboard в процессе экспериментов со структурой и параметрами нейросети. Если вы хотите узнать больше об этом инструменте рекомендую посмотреть [презентацию](https://www.youtube.com/watch?v=eBbEDRsCmv4). Поэтому, я искал возможность, как можно запустить tensorboard в colab. Ответ [нашелся на SO](https://stackoverflow.com/a/48468512/1334157). Через переменную LOG\_DIR вам необходимо задать путь к model\_dir из конфигурации tensorflow модели, либо к корневой директории внутри которой содержиться множество сохраненных моделей.
**Код для запуска tensorboard.**
```
LOG_DIR = '/tmp'
get_ipython().system_raw(
'tensorboard --logdir {} --host 0.0.0.0 --port 6006 &'
.format(LOG_DIR)
)
! wget -c -nc https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip
! unzip -o ngrok-stable-linux-amd64.zip
get_ipython().system_raw('./ngrok http 6006 &')
! curl -s http://localhost:4040/api/tunnels | python3 -c \
"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])"
```
После выполнения в последней строчке будет выведен URL, открыв который в браузере, мы увидим привычный нам tensorboard.
Доступ по ssh
-------------
Если у вас есть опыт использования Jupyter. То вы вероятно знаете, что выйдя за рамки игрушечных моделей, некоторые преимущества формата jupyter ноутбука становятся его недостатками. Ноутбук превращается в сложно читаемую кашу, результаты вычислений становится трудно воспроизвести. Jupyter ноутбуки остаются отличным инструментом для обучения, визуализации и небольших экспериментов. Однако, в средних по величине проектах, я предпочитаю структурировать python код классическим способом, используя разбиение на модули и классы. Работать на серьезным проектом удобнее в PyCharm / Vim и т.д… Постоянно синхронизировать код через репозиторий, запускать .py файлы не очень удобно через jupyter, использовать для этого привычные инструменты намного комфортнее.
Основываясь на примере запуска tensorboard, я написал код, который открывает ssh туннель в контейнер.
```
#Generate root password
import secrets, string
password = ''.join(secrets.choice(string.ascii_letters + string.digits) for i in range(20))
#Download ngrok
! wget -q -c -nc https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip
! unzip -qq -n ngrok-stable-linux-amd64.zip
#Setup sshd
! apt-get install -qq -o=Dpkg::Use-Pty=0 openssh-server pwgen > /dev/null
#Set root password
! echo root:$password | chpasswd
! mkdir -p /var/run/sshd
! echo "PermitRootLogin yes" >> /etc/ssh/sshd_config
! echo "PasswordAuthentication yes" >> /etc/ssh/sshd_config
! echo "LD_LIBRARY_PATH=/usr/lib64-nvidia" >> /root/.bashrc
! echo "export LD_LIBRARY_PATH" >> /root/.bashrc
#Run sshd
get_ipython().system_raw('/usr/sbin/sshd -D &')
#Ask token
print("Copy authtoken from https://dashboard.ngrok.com/auth")
import getpass
authtoken = getpass.getpass()
#Create tunnel
get_ipython().system_raw('./ngrok authtoken $authtoken && ./ngrok tcp 22 &')
#Print root password
print("Root password: {}".format(password))
#Get public address
! curl -s http://localhost:4040/api/tunnels | python3 -c \
"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])"
```
Для создания TCP туннеля вам потребуется создать аккаунт на сайте [ngrok.com](https://ngrok.com) и скопировать authtoken оттуда. В бесплатной версии ngrok два тунеля не поддерживаются, поэтому если http тунель на tensorboard всё еще работает, вам надо его отключить, можно это сделать например перезапустив контейнер, нажав *Ctrl+M затем "."*.
После запуска тунеля вы увидите в ноутбуке, примерно следующее
```
Root password: 3KTyBVjtD6zPZX4Helkj
tcp://0.tcp.ngrok.io:15223
```
Теперь с рабочего компьютера вы сможете залогиниться в colab контейнер используя любой ssh клиент и в данном примере хост 0.tcp.ngrok.io, порт 15223. Пример для linux
```
ssh root@0.tcp.ngrok.io -p15223
```
Бонус для каглеров, для импортирования данных из [kaggle](https://kaggle.com) и отсылки submit прямо из colaboratory вы можете использовать официальный API [клиент](https://github.com/Kaggle/kaggle-api), устанавливается командой *pip install kaggle*. | https://habr.com/ru/post/348058/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.